0r_m_next_dist_0r39plp._.js

js iamrye.com collected 2026-10-05 07:10:15 UTC 223,059 bytes, 4,548 lines download raw bytes

1(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
2"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/router/utils/disable-smooth-scroll.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
3"use strict";
4
5var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$2$2e$2_$40$babel$2b$core$40$7$2e$29$2e$0_react$2d$dom$40$19$2e$2$2e$4_react$40$19$2e$2$2e$4_$5f$react$40$19$2e$2$2e$4$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
6"use strict";
7Object.defineProperty(exports, "__esModule", {
8    value: true
9});
10Object.defineProperty(exports, "disableSmoothScrollDuringRouteTransition", {
11    enumerable: true,
12    get: function() {
13        return disableSmoothScrollDuringRouteTransition;
14    }
15});
16const _warnonce = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/utils/warn-once.js [app-client] (ecmascript)");
17function disableSmoothScrollDuringRouteTransition(fn, options = {}) {
18    // if only the hash is changed, we don't need to disable smooth scrolling
19    // we only care to prevent smooth scrolling when navigating to a new page to avoid jarring UX
20    if (options.onlyHashChange) {
21        fn();
22        return;
23    }
24    const htmlElement = document.documentElement;
25    const hasDataAttribute = htmlElement.dataset.scrollBehavior === 'smooth';
26    if (!hasDataAttribute) {
27        // Warn if smooth scrolling is detected but no data attribute is present
28        if (("TURBOPACK compile-time value", "development") === 'development' && getComputedStyle(htmlElement).scrollBehavior === 'smooth') {
29            (0, _warnonce.warnOnce)('Detected `scroll-behavior: smooth` on the `<html>` element. To disable smooth scrolling during route transitions, ' + 'add `data-scroll-behavior="smooth"` to your <html> element. ' + 'Learn more: https://nextjs.org/docs/messages/missing-data-scroll-behavior');
30        }
31        // No smooth scrolling configured, run directly without style manipulation
32        fn();
33        return;
34    }
35    // Proceed with temporarily disabling smooth scrolling
36    const existing = htmlElement.style.scrollBehavior;
37    htmlElement.style.scrollBehavior = 'auto';
38    if (!options.dontForceLayout) {
39        // In Chrome-based browsers we need to force reflow before calling `scrollTo`.
40        // Otherwise it will not pickup the change in scrollBehavior
41        // More info here: https://github.com/vercel/next.js/issues/40719#issuecomment-1336248042
42        htmlElement.getClientRects();
43    }
44    fn();
45    htmlElement.style.scrollBehavior = existing;
46}
47}),
48"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/bfcache-state-manager.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
49"use strict";
50
51var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$2$2e$2_$40$babel$2b$core$40$7$2e$29$2e$0_react$2d$dom$40$19$2e$2$2e$4_react$40$19$2e$2$2e$4_$5f$react$40$19$2e$2$2e$4$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
52"use strict";
53Object.defineProperty(exports, "__esModule", {
54    value: true
55});
56Object.defineProperty(exports, "useRouterBFCache", {
57    enumerable: true,
58    get: function() {
59        return useRouterBFCache;
60    }
61});
62const _react = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)");
63// When the flag is disabled, only track the currently active tree
64const MAX_BF_CACHE_ENTRIES = ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : 1;
65function useRouterBFCache(activeTree, activeCacheNode, activeStateKey) {
66    // The currently active entry. The entries form a linked list, sorted in
67    // order of most recently active. This allows us to reuse parts of the list
68    // without cloning, unless there's a reordering or removal.
69    // TODO: Once we start tracking back/forward history at each route level,
70    // we should use the history order instead. In other words, when traversing
71    // to an existing entry as a result of a popstate event, we should maintain
72    // the existing order instead of moving it to the front of the list. I think
73    // an initial implementation of this could be to pass an incrementing id
74    // to history.pushState/replaceState, then use that here for ordering.
75    const [prevActiveEntry, setPrevActiveEntry] = (0, _react.useState)(()=>{
76        const initialEntry = {
77            tree: activeTree,
78            cacheNode: activeCacheNode,
79            stateKey: activeStateKey,
80            next: null
81        };
82        return initialEntry;
83    });
84    if (prevActiveEntry.tree === activeTree) {
85        // Fast path. The active tree hasn't changed, so we can reuse the
86        // existing state.
87        return prevActiveEntry;
88    }
89    // The route tree changed. Note that this doesn't mean that the tree changed
90    // *at this level* â the change may be due to a child route. Either way, we
91    // need to either add or update the router tree in the bfcache.
92    //
93    // The rest of the code looks more complicated than it actually is because we
94    // can't mutate the state in place; we have to copy-on-write.
95    // Create a new entry for the active cache key. This is the head of the new
96    // linked list.
97    const newActiveEntry = {
98        tree: activeTree,
99        cacheNode: activeCacheNode,
100        stateKey: activeStateKey,
101        next: null
102    };
103    // We need to append the old list onto the new list. If the head of the new
104    // list was already present in the cache, then we'll need to clone everything
105    // that came before it. Then we can reuse the rest.
106    let n = 1;
107    let oldEntry = prevActiveEntry;

108    let clonedEntry = newActiveEntry;
109    while(oldEntry !== null && n < MAX_BF_CACHE_ENTRIES){
110        if (oldEntry.stateKey === activeStateKey) {
111            // Fast path. This entry in the old list that corresponds to the key that
112            // is now active. We've already placed a clone of this entry at the front
113            // of the new list. We can reuse the rest of the old list without cloning.
114            // NOTE: We don't need to worry about eviction in this case because we
115            // haven't increased the size of the cache, and we assume the max size
116            // is constant across renders. If we were to change it to a dynamic limit,
117            // then the implementation would need to account for that.
118            clonedEntry.next = oldEntry.next;
119            break;
120        } else {
121            // Clone the entry and append it to the list.
122            n++;
123            const entry = {
124                tree: oldEntry.tree,
125                cacheNode: oldEntry.cacheNode,
126                stateKey: oldEntry.stateKey,
127                next: null
128            };
129            clonedEntry.next = entry;
130            clonedEntry = entry;
131        }
132        oldEntry = oldEntry.next;
133    }
134    setPrevActiveEntry(newActiveEntry);
135    return newActiveEntry;
136}
137if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
138    Object.defineProperty(exports.default, '__esModule', {
139        value: true
140    });
141    Object.assign(exports.default, exports);
142    module.exports = exports.default;
143}
144}),
145"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/layout-router.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
146"use strict";
147
148var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$2$2e$2_$40$babel$2b$core$40$7$2e$29$2e$0_react$2d$dom$40$19$2e$2$2e$4_react$40$19$2e$2$2e$4_$5f$react$40$19$2e$2$2e$4$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
149'use client';
150"use strict";
151Object.defineProperty(exports, "__esModule", {
152    value: true
153});
1540 && (module.exports = {
155    LoadingBoundaryProvider: null,
156    default: null
157});
158function _export(target, all) {
159    for(var name in all)Object.defineProperty(target, name, {
160        enumerable: true,
161        get: all[name]
162    });
163}
164_export(exports, {
165    LoadingBoundaryProvider: function() {
166        return LoadingBoundaryProvider;
167    },
168    /**
169 * OuterLayoutRouter handles the current segment as well as <Offscreen> rendering of other segments.
170 * It can be rendered next to each other with a different `parallelRouterKey`, allowing for Parallel routes.
171 */ default: function() {
172        return OuterLayoutRouter;
173    }
174});
175const _interop_require_default = __turbopack_context__.r("[project]/node_modules/.pnpm/@[email protected]/node_modules/@swc/helpers/cjs/_interop_require_default.cjs [app-client] (ecmascript)");
176const _interop_require_wildcard = __turbopack_context__.r("[project]/node_modules/.pnpm/@[email protected]/node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs [app-client] (ecmascript)");
177const _jsxruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
178const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
179const _reactdom = /*#__PURE__*/ _interop_require_default._(__turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react-dom/index.js [app-client] (ecmascript)"));
180const _approutercontextsharedruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js [app-client] (ecmascript)");
181const _unresolvedthenable = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/unresolved-thenable.js [a

181pp-client] (ecmascript)");
182const _errorboundary = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/error-boundary.js [app-client] (ecmascript)");
183const _disablesmoothscroll = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/router/utils/disable-smooth-scroll.js [app-client] (ecmascript)");
184const _redirectboundary = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/redirect-boundary.js [app-client] (ecmascript)");
185const _errorboundary1 = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/http-access-fallback/error-boundary.js [app-client] (ecmascript)");
186const _createroutercachekey = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/router-reducer/create-router-cache-key.js [app-client] (ecmascript)");
187const _bfcachestatemanager = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/bfcache-state-manager.js [app-client] (ecmascript)");
188const _apppaths = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/router/utils/app-paths.js [app-client] (ecmascript)");
189const _hooksclientcontextsharedruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.js [app-client] (ecmascript)");
190const _routeparams = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/route-params.js [app-client] (ecmascript)");
191const _pprnavigations = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/router-reducer/ppr-navigations.js [app-client] (ecmascript)");
192const enableNewScrollHandler = ("TURBOPACK compile-time value", false);
193const __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = _reactdom.default.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
194// TODO-APP: Replace with new React API for finding dom nodes without a `ref` when available
195/**
196 * Wraps ReactDOM.findDOMNode with additional logic to hide React Strict Mode warning
197 */ function findDOMNode(instance) {
198    // Tree-shake for server bundle
199    if (typeof window === 'undefined') return null;
200    // __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE.findDOMNode is null during module init.
201    // We need to lazily reference it.
202    const internal_reactDOMfindDOMNode = __DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE.findDOMNode;
203    return internal_reactDOMfindDOMNode(instance);
204}
205const rectProperties = [
206    'bottom',
207    'height',
208    'left',
209    'right',
210    'top',
211    'width',
212    'x',
213    'y'
214];
215/**
216 * Check if a HTMLElement is hidden or fixed/sticky position
217 */ function shouldSkipElement(element) {
218    // we ignore fixed or sticky positioned elements since they'll likely pass the "in-viewport" check
219    // and will result in a situation we bail on scroll because of something like a fixed nav,
220    // even though the actual page content is offscreen
221    if ([
222        'sticky',
223        'fixed'
224    ].includes(getComputedStyle(element).position)) {
225        return true;
226    }
227    // Uses `getBoundingClientRect` to check if the element is hidden instead of `offsetParent`
228    // because `offsetParent` doesn't consider document/body
229    const rect = element.getBoundingClientRect();
230    return rectProperties.every((item)=>rect[item] === 0);
231}
232/**
233 * Check if the top corner of the HTMLElement is in the viewport.

234 */ function topOfElementInViewport(instance, viewportHeight) {
235    const rects = instance.getClientRects();
236    if (rects.length === 0) {
237        // Just to be explicit.
238        return false;
239    }
240    let elementTop = Number.POSITIVE_INFINITY;
241    for(let i = 0; i < rects.length; i++){
242        const rect = rects[i];
243        if (rect.top < elementTop) {
244            elementTop = rect.top;
245        }
246    }
247    return elementTop >= 0 && elementTop <= viewportHeight;
248}
249/**
250 * Find the DOM node for a hash fragment.
251 * If `top` the page has to scroll to the top of the page. This mirrors the browser's behavior.
252 * If the hash fragment is an id, the page has to scroll to the element with that id.
253 * If the hash fragment is a name, the page has to scroll to the first element with that name.
254 */ function getHashFragmentDomNode(hashFragment) {
255    // If the hash fragment is `top` the page has to scroll to the top of the page.
256    if (hashFragment === 'top') {
257        return document.body;
258    }
259    // If the hash fragment is an id, the page has to scroll to the element with that id.
260    return document.getElementById(hashFragment) ?? // If the hash fragment is a name, the page has to scroll to the first element with that name.
261    document.getElementsByName(hashFragment)[0];
262}
263class InnerScrollAndFocusHandlerOld extends _react.default.Component {
264    componentDidMount() {
265        this.handlePotentialScroll();
266    }
267    componentDidUpdate() {
268        this.handlePotentialScroll();
269    }
270    render() {
271        return this.props.children;
272    }
273    constructor(...args){
274        super(...args), this.handlePotentialScroll = ()=>{
275            // Handle scroll and focus, it's only applied once.
276            const { focusAndScrollRef, cacheNode } = this.props;
277            const scrollRef = focusAndScrollRef.forceScroll ? focusAndScrollRef.scrollRef : cacheNode.scrollRef;
278            if (scrollRef === null || !scrollRef.current) return;
279            let domNode = null;
280            const hashFragment = focusAndScrollRef.hashFragment;
281            if (hashFragment) {
282                domNode = getHashFragmentDomNode(hashFragment);
283            }
284            // `findDOMNode` is tricky because it returns just the first child if the component is a fragment.
285            // This already caused a bug where the first child was a <link/> in head.
286            if (!domNode) {
287                domNode = findDOMNode(this);
288            }
289            // If there is no DOM node this layout-router level is skipped. It'll be handled higher-up in the tree.
290            if (!(domNode instanceof Element)) {
291                return;
292            }
293            // Verify if the element is a HTMLElement and if we want to consider it for scroll behavior.
294            // If the element is skipped, try to select the next sibling and try again.
295            while(!(domNode instanceof HTMLElement) || shouldSkipElement(domNode)){
296                if ("TURBOPACK compile-time truthy", 1) {
297                    if (domNode.parentElement?.localName === 'head') {
298                    // We enter this state when metadata was rendered as part of the page or via Next.js.
299                    // This is always a bug in Next.js and caused by React hoisting metadata.
300                    // Fixed with `experimental.appNewScrollHandler`
301                    }
302                }
303                // No siblings found that match the criteria are found, so handle scroll higher up in the tree instead.
304                if (domNode.nextElementSibling === null) {
305                    return;
306                }
307                domNode = domNode.nextElementSibling;
308            }
309            // Mark as scrolled so no other segment scrolls for this navigation.
310            scrollRef.current = false;
311            (0, _disablesmoothscroll.disableSmoothScrollDuringRouteTransition)(()=>{
312                // In case of hash scroll, we only need to scroll the element into view
313                if (hashFragment) {
314                    domNode.scrollIntoView();
315                    return;
316                }
317                // Store the current viewport height because reading `clientHeight` causes a reflow,

318                // and it won't change during this function.
319                const htmlElement = document.documentElement;
320                const viewportHeight = htmlElement.clientHeight;
321                // If the element's top edge is already in the viewport, exit early.
322                if (topOfElementInViewport(domNode, viewportHeight)) {
323                    return;
324                }
325                // Otherwise, try scrolling go the top of the document to be backward compatible with pages
326                // scrollIntoView() called on `<html/>` element scrolls horizontally on chrome and firefox (that shouldn't happen)
327                // We could use it to scroll horizontally following RTL but that also seems to be broken - it will always scroll left
328                // scrollLeft = 0 also seems to ignore RTL and manually checking for RTL is too much hassle so we will scroll just vertically
329                htmlElement.scrollTop = 0;
330                // Scroll to domNode if domNode is not in viewport when scrolled to top of document
331                if (!topOfElementInViewport(domNode, viewportHeight)) {
332                    // Scroll into view doesn't scroll horizontally by default when not needed
333                    domNode.scrollIntoView();
334                }
335            }, {
336                // We will force layout by querying domNode position
337                dontForceLayout: true,
338                onlyHashChange: focusAndScrollRef.onlyHashChange
339            });
340            // Mutate after scrolling so that it can be read by `disableSmoothScrollDuringRouteTransition`
341            focusAndScrollRef.onlyHashChange = false;
342            focusAndScrollRef.hashFragment = null;
343            // Set focus on the element
344            domNode.focus();
345        };
346    }
347}
348/**
349 * Fork of InnerScrollAndFocusHandlerOld using Fragment refs for scrolling.
350 * No longer focuses the first host descendant.
351 */ function InnerScrollHandlerNew(props) {
352    const childrenRef = _react.default.useRef(null);
353    (0, _react.useLayoutEffect)(()=>{
354        const { focusAndScrollRef, cacheNode } = props;
355        const scrollRef = focusAndScrollRef.forceScroll ? focusAndScrollRef.scrollRef : cacheNode.scrollRef;
356        if (scrollRef === null || !scrollRef.current) return;
357        let instance = null;
358        const hashFragment = focusAndScrollRef.hashFragment;
359        if (hashFragment) {
360            instance = getHashFragmentDomNode(hashFragment);
361        }
362        if (!instance) {
363            instance = childrenRef.current;
364        }
365        // If there is no DOM node this layout-router level is skipped. It'll be handled higher-up in the tree.
366        if (instance === null) {
367            return;
368        }
369        // Mark as scrolled so no other segment scrolls for this navigation.
370        scrollRef.current = false;
371        const activeElement = document.activeElement;
372        if (activeElement !== null && 'blur' in activeElement && typeof activeElement.blur === 'function') {
373            // Trying to match hard navigations.
374            // Ideally we'd move the internal focus cursor either to the top
375            // or at least before the segment. But there's no DOM API to do that,
376            // so we just blur.
377            // We could workaround this by moving focus to a temporary element in
378            // the body. But adding elements might trigger layout or other effects
379            // so it should be well motivated.
380            activeElement.blur();
381        }
382        (0, _disablesmoothscroll.disableSmoothScrollDuringRouteTransition)(()=>{
383            // In case of hash scroll, we only need to scroll the element into view
384            if (hashFragment) {
385                instance.scrollIntoView();
386                return;
387            }
388            // Store the current viewport height because reading `clientHeight` causes a reflow,
389            // and it won't change during this function.
390            const htmlElement = document.documentElement;
391            const viewportHeight = htmlElement.clientHeight;
392            // If the element's top edge is already in the viewport, exit early.

393            if (topOfElementInViewport(instance, viewportHeight)) {
394                return;
395            }
396            // Otherwise, try scrolling go the top of the document to be backward compatible with pages
397            // scrollIntoView() called on `<html/>` element scrolls horizontally on chrome and firefox (that shouldn't happen)
398            // We could use it to scroll horizontally following RTL but that also seems to be broken - it will always scroll left
399            // scrollLeft = 0 also seems to ignore RTL and manually checking for RTL is too much hassle so we will scroll just vertically
400            htmlElement.scrollTop = 0;
401            // Scroll to domNode if domNode is not in viewport when scrolled to top of document
402            if (!topOfElementInViewport(instance, viewportHeight)) {
403                // Scroll into view doesn't scroll horizontally by default when not needed
404                instance.scrollIntoView();
405            }
406        }, {
407            // We will force layout by querying domNode position
408            dontForceLayout: true,
409            onlyHashChange: focusAndScrollRef.onlyHashChange
410        });
411        // Mutate after scrolling so that it can be read by `disableSmoothScrollDuringRouteTransition`
412        focusAndScrollRef.onlyHashChange = false;
413        focusAndScrollRef.hashFragment = null;
414    }, // but be prepared for lots of manual testing.
415    undefined);
416    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Fragment, {
417        ref: childrenRef,
418        children: props.children
419    });
420}
421const InnerScrollAndMaybeFocusHandler = ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : InnerScrollAndFocusHandlerOld;
422function ScrollAndMaybeFocusHandler({ children, cacheNode }) {
423    const context = (0, _react.useContext)(_approutercontextsharedruntime.GlobalLayoutRouterContext);
424    if (!context) {
425        throw Object.defineProperty(new Error('invariant global layout router not mounted'), "__NEXT_ERROR_CODE", {
426            value: "E473",
427            enumerable: false,
428            configurable: true
429        });
430    }
431    return /*#__PURE__*/ (0, _jsxruntime.jsx)(InnerScrollAndMaybeFocusHandler, {
432        focusAndScrollRef: context.focusAndScrollRef,
433        cacheNode: cacheNode,
434        children: children
435    });
436}
437/**
438 * InnerLayoutRouter handles rendering the provided segment based on the cache.
439 */ function InnerLayoutRouter({ tree, segmentPath, debugNameContext, cacheNode: maybeCacheNode, params, url, isActive }) {
440    const context = (0, _react.useContext)(_approutercontextsharedruntime.GlobalLayoutRouterContext);
441    const parentNavPromises = (0, _react.useContext)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
442    if (!context) {
443        throw Object.defineProperty(new Error('invariant global layout router not mounted'), "__NEXT_ERROR_CODE", {
444            value: "E473",
445            enumerable: false,
446            configurable: true
447        });
448    }
449    const cacheNode = maybeCacheNode !== null ? maybeCacheNode : // This should only be reachable for inactive/hidden segments, during
450    // prerendering The active segment should always be consistent with the
451    // CacheNode tree. Regardless, if we don't have a matching CacheNode, we
452    // must suspend rather than render nothing, to prevent showing an
453    // inconsistent route.
454    (0, _react.use)(_unresolvedthenable.unresolvedThenable);
455    // `rsc` represents the renderable node for this segment.
456    // If this segment has a `prefetchRsc`, it's the statically prefetched data.
457    // We should use that on initial render instead of `rsc`. Then we'll switch
458    // to `rsc` when the dynamic response streams in.
459    //
460    // If no prefetch data is available, then we go straight to rendering `rsc`.
461    const resolvedPrefetchRsc = cacheNode.prefetchRsc !== null ? cacheNode.prefetchRsc : cacheNode.rsc;
462    // We use `useDeferredValue` to handle switching between the prefetched and
463    // final values. The second argument is returned on initial render, then it
464    // re-renders with the first argument.

465    const rsc = (0, _react.useDeferredValue)(cacheNode.rsc, resolvedPrefetchRsc);
466    // `rsc` is either a React node or a promise for a React node, except we
467    // special case `null` to represent that this segment's data is missing. If
468    // it's a promise, we need to unwrap it so we can determine whether or not the
469    // data is missing.
470    let resolvedRsc;
471    if ((0, _pprnavigations.isDeferredRsc)(rsc)) {
472        const unwrappedRsc = (0, _react.use)(rsc);
473        if (unwrappedRsc === null) {
474            // If the promise was resolved to `null`, it means the data for this
475            // segment was not returned by the server. Suspend indefinitely. When this
476            // happens, the router is responsible for triggering a new state update to
477            // un-suspend this segment.
478            (0, _react.use)(_unresolvedthenable.unresolvedThenable);
479        }
480        resolvedRsc = unwrappedRsc;
481    } else {
482        // This is not a deferred RSC promise. Don't need to unwrap it.
483        if (rsc === null) {
484            (0, _react.use)(_unresolvedthenable.unresolvedThenable);
485        }
486        resolvedRsc = rsc;
487    }
488    // In dev, we create a NavigationPromisesContext containing the instrumented promises that provide
489    // `useSelectedLayoutSegment` and `useSelectedLayoutSegments`.
490    // Promises are cached outside of render to survive suspense retries.
491    let navigationPromises = null;
492    if ("TURBOPACK compile-time truthy", 1) {
493        const { createNestedLayoutNavigationPromises } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/navigation-devtools.js [app-client] (ecmascript)");
494        navigationPromises = createNestedLayoutNavigationPromises(tree, parentNavPromises);
495    }
496    let children = resolvedRsc;
497    if (navigationPromises) {
498        children = /*#__PURE__*/ (0, _jsxruntime.jsx)(_hooksclientcontextsharedruntime.NavigationPromisesContext.Provider, {
499            value: navigationPromises,
500            children: resolvedRsc
501        });
502    }
503    children = /*#__PURE__*/ (0, _jsxruntime.jsx)(_approutercontextsharedruntime.LayoutRouterContext.Provider, {
504        value: {
505            parentTree: tree,
506            parentCacheNode: cacheNode,
507            parentSegmentPath: segmentPath,
508            parentParams: params,
509            // This is always set to null as we enter a child segment. It's
510            // populated by LoadingBoundaryProvider the next time we reach a
511            // loading boundary.
512            parentLoadingData: null,
513            debugNameContext: debugNameContext,
514            // TODO-APP: overriding of url for parallel routes
515            url: url,
516            isActive: isActive
517        },
518        children: children
519    });
520    return children;
521}
522function LoadingBoundaryProvider({ loading, children }) {
523    // Provides the data needed to render a loading.tsx boundary, via context.
524    //
525    // loading.tsx creates a Suspense boundary around each of a layout's child
526    // slots. (Might be bit confusing to think about the data flow, but: if
527    // loading.tsx and layout.tsx are in the same directory, they are assigned
528    // to the same CacheNode.)
529    //
530    // This provider component does not render the Suspense boundary directly;
531    // that's handled by LoadingBoundary.
532    //
533    // TODO: For simplicity, we should combine this provider with LoadingBoundary
534    // and render the Suspense boundary directly. The only real benefit of doing
535    // it separately is so that when there are multiple parallel routes, we only
536    // send the boundary data once, rather than once per child. But that's a
537    // negligible benefit and can be achieved via caching instead.
538    const parentContext = (0, _react.use)(_approutercontextsharedruntime.LayoutRouterContext);
539    if (parentContext === null) {
540        return children;
541    }
542    // All values except for parentLoadingData are the same as the parent context.
543    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_approutercontextsharedruntime.LayoutRouterContext.Provider, {
544        value: {
545            parentTree: parentContext.parentTree,
546            parentCacheNode: parentContext.parentCacheNode,
547            parentSegmentPath: parentContext.parentSegmentPath,

548            parentParams: parentContext.parentParams,
549            parentLoadingData: loading,
550            debugNameContext: parentContext.debugNameContext,
551            url: parentContext.url,
552            isActive: parentContext.isActive
553        },
554        children: children
555    });
556}
557/**
558 * Renders suspense boundary with the provided "loading" property as the fallback.
559 * If no loading property is provided it renders the children without a suspense boundary.
560 */ function LoadingBoundary({ name, loading, children }) {
561    // TODO: For LoadingBoundary, and the other built-in boundary types, don't
562    // wrap in an extra function component if no user-defined boundary is
563    // provided. In other words, inline this conditional wrapping logic into
564    // the parent component. More efficient and keeps unnecessary junk out of
565    // the component stack.
566    if (loading !== null) {
567        const loadingRsc = loading[0];
568        const loadingStyles = loading[1];
569        const loadingScripts = loading[2];
570        return /*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Suspense, {
571            name: name,
572            fallback: /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
573                children: [
574                    loadingStyles,
575                    loadingScripts,
576                    loadingRsc
577                ]
578            }),
579            children: children
580        });
581    }
582    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
583        children: children
584    });
585}
586function OuterLayoutRouter({ parallelRouterKey, error, errorStyles, errorScripts, templateStyles, templateScripts, template, notFound, forbidden, unauthorized, segmentViewBoundaries }) {
587    const context = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
588    if (!context) {
589        throw Object.defineProperty(new Error('invariant expected layout router to be mounted'), "__NEXT_ERROR_CODE", {
590            value: "E56",
591            enumerable: false,
592            configurable: true
593        });
594    }
595    const { parentTree, parentCacheNode, parentSegmentPath, parentParams, parentLoadingData, url, isActive, debugNameContext } = context;
596    // Get the CacheNode for this segment by reading it from the parent segment's
597    // child map.
598    const parentTreeSegment = parentTree[0];
599    const segmentPath = parentSegmentPath === null ? // the code. We should clean this up.
600    [
601        parallelRouterKey
602    ] : parentSegmentPath.concat([
603        parentTreeSegment,
604        parallelRouterKey
605    ]);
606    // The "state" key of a segment is the one passed to React â it represents the
607    // identity of the UI tree. Whenever the state key changes, the tree is
608    // recreated and the state is reset. In the App Router model, search params do
609    // not cause state to be lost, so two segments with the same segment path but
610    // different search params should have the same state key.
611    //
612    // The "cache" key of a segment, however, *does* include the search params, if
613    // it's possible that the segment accessed the search params on the server.
614    // (This only applies to page segments; layout segments cannot access search
615    // params on the server.)
616    const activeTree = parentTree[1][parallelRouterKey];
617    const maybeParentSlots = parentCacheNode.slots;
618    if (activeTree === undefined || maybeParentSlots === null) {
619        // Could not find a matching segment. The client tree is inconsistent with
620        // the server tree. Suspend indefinitely; the router will have already
621        // detected the inconsistency when handling the server response, and
622        // triggered a refresh of the page to recover.
623        (0, _react.use)(_unresolvedthenable.unresolvedThenable);
624    }
625    let maybeValidationBoundaryId = null;
626    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
627    ;
628    const activeSegment = activeTree[0];
629    const activeCacheNode = maybeParentSlots[parallelRouterKey] ?? null;
630    const activeStateKey = (0, _createroutercachekey.createRouterCacheKey)(activeSegment, true) // no search params
631    ;
632    // At each level of the route tree, not only do we render the currently
633    // active segment â we also render the last N segments that were active at
634    // this level inside a hidden <Activity> boundary, to preserve their state
635    // if or when the user navigates to them again.
636    //
637    // bfcacheEntry is a linked list of FlightRouterStates.
638    let bfcacheEntry = (0, _bfcachestatemanager.useRouterBFCache)(activeTree, activeCacheNode, activeStateKey);

639    let children = [];
640    do {
641        const tree = bfcacheEntry.tree;
642        const cacheNode = bfcacheEntry.cacheNode;
643        const stateKey = bfcacheEntry.stateKey;
644        const segment = tree[0];
645        /*
646    - Error boundary
647      - Only renders error boundary if error component is provided.
648      - Rendered for each segment to ensure they have their own error state.
649      - When gracefully degrade for bots, skip rendering error boundary.
650    - Loading boundary
651      - Only renders suspense boundary if loading components is provided.
652      - Rendered for each segment to ensure they have their own loading state.
653      - Passed to the router during rendering to ensure it can be immediately rendered when suspending on a Flight fetch.
654  */ let segmentBoundaryTriggerNode = null;
655        let segmentViewStateNode = null;
656        if ("TURBOPACK compile-time truthy", 1) {
657            const { SegmentBoundaryTriggerNode, SegmentViewStateNode } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/next-devtools/userspace/app/segment-explorer-node.js [app-client] (ecmascript)");
658            const pagePrefix = (0, _apppaths.normalizeAppPath)(url);
659            segmentViewStateNode = /*#__PURE__*/ (0, _jsxruntime.jsx)(SegmentViewStateNode, {
660                page: pagePrefix
661            }, pagePrefix);
662            segmentBoundaryTriggerNode = /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
663                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(SegmentBoundaryTriggerNode, {})
664            });
665        }
666        let params = parentParams;
667        if (Array.isArray(segment)) {
668            // This segment contains a route param. Accumulate these as we traverse
669            // down the router tree. The result represents the set of params that
670            // the layout/page components are permitted to access below this point.
671            const paramName = segment[0];
672            const paramCacheKey = segment[1];
673            const paramType = segment[2];
674            const paramValue = (0, _routeparams.getParamValueFromCacheKey)(paramCacheKey, paramType);
675            if (paramValue !== null) {
676                params = {
677                    ...parentParams,
678                    [paramName]: paramValue
679                };
680            }
681        }
682        const debugName = getBoundaryDebugNameFromSegment(segment);
683        // `debugNameContext` represents the nearest non-"virtual" parent segment.
684        // `getBoundaryDebugNameFromSegment` returns undefined for virtual segments.
685        // So if `debugName` is undefined, the context is passed through unchanged.
686        const childDebugNameContext = debugName ?? debugNameContext;
687        // In practical terms, clicking this name in the Suspense DevTools
688        // should select the child slots of that layout.
689        //
690        // So the name we apply to the Activity boundary is actually based on
691        // the nearest parent segments.
692        //
693        // We skip over "virtual" parents, i.e. ones inserted by Next.js that
694        // don't correspond to application-defined code.
695        const isVirtual = debugName === undefined;
696        const debugNameToDisplay = isVirtual ? undefined : debugNameContext;
697        let templateValue = /*#__PURE__*/ (0, _jsxruntime.jsxs)(ScrollAndMaybeFocusHandler, {
698            cacheNode: cacheNode,
699            children: [
700                /*#__PURE__*/ (0, _jsxruntime.jsx)(_errorboundary.ErrorBoundary, {
701                    errorComponent: error,
702                    errorStyles: errorStyles,
703                    errorScripts: errorScripts,
704                    children: /*#__PURE__*/ (0, _jsxruntime.jsx)(LoadingBoundary, {
705                        name: debugNameToDisplay,
706                        // TODO: The loading module data for a segment is stored on the
707                        // parent, then applied to each of that parent segment's
708                        // parallel route slots. In the simple case where there's only
709                        // one parallel route (the `children` slot), this is no
710                        // different from if the loading module data were stored on the
711                        // child directly. But I'm not sure this actually makes sense
712                        // when there are multiple parallel routes. It's not a huge
713                        // issue because you always have the option to define a narrower
714                        // loading boundary for a particular slot. But this sort of
715                        // smells like an implementation accident to me.
716                        loading: parentLoadingData,
717                        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_errorboundary1.HTTPAccessFallbackBoundary, {
718                            notFound: notFound,
719                            forbidden: forbidden,
720                            unauthorized: unauthorized,
721                            children: /*#__PURE__*/ (0, _jsxruntime.jsxs)(_redirectboundary.RedirectBoundary, {
722                                children: [
723                                    /*#__PURE__*/ (0, _jsxruntime.jsx)(InnerLayoutRouter, {
724                                        url: url,
725                                        tree: tree,
726                                        params: params,
727                                        cacheNode: cacheNode,
728                                        segmentPath: segmentPath,
729                                        debugNameContext: childDebugNameContext,
730                                        isActive: isActive && stateKey === activeStateKey
731                                    }),
732                                    segmentBoundaryTriggerNode
733                                ]
734                            })
735                        })
736                    })
737                }),
738                segmentViewStateNode
739            ]
740        });
741        if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
742        ;
743        let child = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_approutercontextsharedruntime.TemplateContext.Provider, {
744            value: templateValue,
745            children: [
746                templateStyles,
747                templateScripts,
748                template
749            ]
750        }, stateKey);
751        if ("TURBOPACK compile-time truthy", 1) {
752            const { SegmentStateProvider } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/next-devtools/userspace/app/segment-explorer-node.js [app-client] (ecmascript)");
753            child = /*#__PURE__*/ (0, _jsxruntime.jsxs)(SegmentStateProvider, {
754                children: [
755                    child,
756                    segmentViewBoundaries
757                ]
758            }, stateKey);
759        }
760        if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
761        ;
762        children.push(child);
763        bfcacheEntry = bfcacheEntry.next;
764    }while (bfcacheEntry !== null)
765    return children;
766}
767function getBoundaryDebugNameFromSegment(segment) {
768    if (segment === '/') {
769        // Reached the root
770        return '/';
771    }
772    if (typeof segment === 'string') {
773        if (isVirtualLayout(segment)) {
774            return undefined;
775        } else {
776            return segment + '/';
777        }
778    }
779    const paramCacheKey = segment[1];
780    return paramCacheKey + '/';
781}
782function isVirtualLayout(segment) {
783    return(// (like __PAGE__ and __DEFAULT__) to avoid collisions with
784    // user-defined route groups.
785    segment === '(__SLOT__)');
786}
787if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
788    Object.defineProperty(exports.default, '__esModule', {
789        value: true
790    });

791    Object.assign(exports.default, exports);
792    module.exports = exports.default;
793}
794}),
795"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/render-from-template-context.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
796"use strict";
797
798Object.defineProperty(exports, "__esModule", {
799    value: true
800});
801Object.defineProperty(exports, "default", {
802    enumerable: true,
803    get: function() {
804        return RenderFromTemplateContext;
805    }
806});
807const _interop_require_wildcard = __turbopack_context__.r("[project]/node_modules/.pnpm/@[email protected]/node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs [app-client] (ecmascript)");
808const _jsxruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
809const _react = /*#__PURE__*/ _interop_require_wildcard._(__turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
810const _approutercontextsharedruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js [app-client] (ecmascript)");
811function RenderFromTemplateContext() {
812    const children = (0, _react.useContext)(_approutercontextsharedruntime.TemplateContext);
813    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
814        children: children
815    });
816}
817if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
818    Object.defineProperty(exports.default, '__esModule', {
819        value: true
820    });
821    Object.assign(exports.default, exports);
822    module.exports = exports.default;
823}
824}),
825"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
826"use strict";
827
828Object.defineProperty(exports, "__esModule", {
829    value: true
830});
831Object.defineProperty(exports, "ReflectAdapter", {
832    enumerable: true,
833    get: function() {
834        return ReflectAdapter;
835    }
836});
837class ReflectAdapter {
838    static get(target, prop, receiver) {
839        const value = Reflect.get(target, prop, receiver);
840        if (typeof value === 'function') {
841            return value.bind(target);
842        }
843        return value;
844    }
845    static set(target, prop, value, receiver) {
846        return Reflect.set(target, prop, value, receiver);
847    }
848    static has(target, prop) {
849        return Reflect.has(target, prop);
850    }
851    static deleteProperty(target, prop) {
852        return Reflect.deleteProperty(target, prop);
853    }
854}
855}),
856"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
857"use strict";
858
859// This regex will have fast negatives meaning valid identifiers may not pass
860// this test. However this is only used during static generation to provide hints
861// about why a page bailed out of some or all prerendering and we can use bracket notation
862// for example while `à² _à² ` is a valid identifier it's ok to print `searchParams['à² _à² ']`
863// even if this would have been fine too `searchParams.à² _à² `
864Object.defineProperty(exports, "__esModule", {
865    value: true
866});
8670 && (module.exports = {
868    describeHasCheckingStringProperty: null,
869    describeStringPropertyAccess: null,
870    wellKnownProperties: null
871});
872function _export(target, all) {
873    for(var name in all)Object.defineProperty(target, name, {
874        enumerable: true,
875        get: all[name]
876    });
877}
878_export(exports, {
879    describeHasCheckingStringProperty: function() {
880        return describeHasCheckingStringProperty;
881    },
882    describeStringPropertyAccess: function() {
883        return describeStringPropertyAccess;
884    },
885    wellKnownProperties: function() {
886        return wellKnownProperties;
887    }
888});
889const isDefinitelyAValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
890function describeStringPropertyAccess(target, prop) {
891    if (isDefinitelyAValidIdentifier.test(prop)) {
892        return `\`${target}.${prop}\``;
893    }
894    return `\`${target}[${JSON.stringify(prop)}]\``;
895}
896function describeHasCheckingStringProperty(target, prop) {
897    const stringifiedProp = JSON.stringify(prop);
898    return `\`Reflect.has(${target}, ${stringifiedProp})\`, \`${stringifiedProp} in ${target}\`, or similar`;
899}
900const wellKnownProperties = new Set([
901    'hasOwnProperty',
902    'isPrototypeOf',
903    'propertyIsEnumerable',
904    'toString',
905    'valueOf',

906    'toLocaleString',
907    // Promise prototype
908    'then',
909    'catch',
910    'finally',
911    // React Promise extension
912    'status',
913    // 'value',
914    // 'error',
915    // React introspection
916    'displayName',
917    '_debugInfo',
918    // Common tested properties
919    'toJSON',
920    '$$typeof',
921    '__esModule',
922    // Tested by flight when checking for iterables
923    '@@iterator'
924]);
925}),
926"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/request/search-params.browser.dev.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
927"use strict";
928
929Object.defineProperty(exports, "__esModule", {
930    value: true
931});
932Object.defineProperty(exports, "createRenderSearchParamsFromClient", {
933    enumerable: true,
934    get: function() {
935        return createRenderSearchParamsFromClient;
936    }
937});
938const _reflect = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)");
939const _reflectutils = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)");
940const CachedSearchParams = new WeakMap();
941function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams) {
942    const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
943    if (cachedSearchParams) {
944        return cachedSearchParams;
945    }
946    const proxiedProperties = new Set();
947    const promise = Promise.resolve(underlyingSearchParams);
948    Object.keys(underlyingSearchParams).forEach((prop)=>{
949        if (_reflectutils.wellKnownProperties.has(prop)) {
950        // These properties cannot be shadowed because they need to be the
951        // true underlying value for Promises to work correctly at runtime
952        } else {
953            proxiedProperties.add(prop);
954        }
955    });
956    const proxiedPromise = new Proxy(promise, {
957        get (target, prop, receiver) {
958            if (typeof prop === 'string') {
959                if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
960                // the underlying searchParams.
961                Reflect.has(target, prop) === false)) {
962                    const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
963                    warnForSyncAccess(expression);
964                }
965            }
966            return _reflect.ReflectAdapter.get(target, prop, receiver);
967        },
968        set (target, prop, value, receiver) {
969            if (typeof prop === 'string') {
970                proxiedProperties.delete(prop);
971            }
972            return Reflect.set(target, prop, value, receiver);
973        },
974        has (target, prop) {
975            if (typeof prop === 'string') {
976                if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
977                // the underlying searchParams.
978                Reflect.has(target, prop) === false)) {
979                    const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
980                    warnForSyncAccess(expression);
981                }
982            }
983            return Reflect.has(target, prop);
984        },
985        ownKeys (target) {
986            warnForSyncSpread();
987            return Reflect.ownKeys(target);
988        }
989    });
990    CachedSearchParams.set(underlyingSearchParams, proxiedPromise);
991    return proxiedPromise;
992}
993function warnForSyncAccess(expression) {
994    console.error(`A searchParam property was accessed directly with ${expression}. ` + `\`searchParams\` is a Promise and must be unwrapped with \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
995}
996function warnForSyncSpread() {
997    console.error(`The keys of \`searchParams\` were accessed directly. ` + `\`searchParams\` is a Promise and must be unwrapped with \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
998}
999function createRenderSearchParamsFromClient(underlyingSearchParams) {
1000    return makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams);
1001}
1002if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
1003    Object.defineProperty(exports.default, '__esModule', {
1004        value: true
1005    });

1006    Object.assign(exports.default, exports);
1007    module.exports = exports.default;
1008}
1009}),
1010"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/request/search-params.browser.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
1011"use strict";
1012
1013var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$2$2e$2_$40$babel$2b$core$40$7$2e$29$2e$0_react$2d$dom$40$19$2e$2$2e$4_react$40$19$2e$2$2e$4_$5f$react$40$19$2e$2$2e$4$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
1014"use strict";
1015Object.defineProperty(exports, "__esModule", {
1016    value: true
1017});
1018Object.defineProperty(exports, "createRenderSearchParamsFromClient", {
1019    enumerable: true,
1020    get: function() {
1021        return createRenderSearchParamsFromClient;
1022    }
1023});
1024const createRenderSearchParamsFromClient = ("TURBOPACK compile-time truthy", 1) ? __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/request/search-params.browser.dev.js [app-client] (ecmascript)").createRenderSearchParamsFromClient : "TURBOPACK unreachable";
1025if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
1026    Object.defineProperty(exports.default, '__esModule', {
1027        value: true
1028    });
1029    Object.assign(exports.default, exports);
1030    module.exports = exports.default;
1031}
1032}),
1033"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/request/params.browser.dev.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
1034"use strict";
1035
1036Object.defineProperty(exports, "__esModule", {
1037    value: true
1038});
1039Object.defineProperty(exports, "createRenderParamsFromClient", {
1040    enumerable: true,
1041    get: function() {
1042        return createRenderParamsFromClient;
1043    }
1044});
1045const _reflect = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)");
1046const _reflectutils = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)");
1047const CachedParams = new WeakMap();
1048function makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams) {
1049    const cachedParams = CachedParams.get(underlyingParams);
1050    if (cachedParams) {
1051        return cachedParams;
1052    }
1053    // We don't use makeResolvedReactPromise here because params
1054    // supports copying with spread and we don't want to unnecessarily
1055    // instrument the promise with spreadable properties of ReactPromise.
1056    const promise = Promise.resolve(underlyingParams);
1057    const proxiedProperties = new Set();
1058    Object.keys(underlyingParams).forEach((prop)=>{
1059        if (_reflectutils.wellKnownProperties.has(prop)) {
1060        // These properties cannot be shadowed because they need to be the
1061        // true underlying value for Promises to work correctly at runtime
1062        } else {
1063            proxiedProperties.add(prop);
1064        }
1065    });
1066    const proxiedPromise = new Proxy(promise, {
1067        get (target, prop, receiver) {
1068            if (typeof prop === 'string') {
1069                if (proxiedProperties.has(prop)) {
1070                    const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
1071                    warnForSyncAccess(expression);
1072                }
1073            }
1074            return _reflect.ReflectAdapter.get(target, prop, receiver);
1075        },
1076        set (target, prop, value, receiver) {
1077            if (typeof prop === 'string') {
1078                proxiedProperties.delete(prop);
1079            }
1080            return _reflect.ReflectAdapter.set(target, prop, value, receiver);
1081        },
1082        ownKeys (target) {
1083            warnForEnumeration();
1084            return Reflect.ownKeys(target);
1085        }
1086    });
1087    CachedParams.set(underlyingParams, proxiedPromise);
1088    return proxiedPromise;
1089}
1090function warnForSyncAccess(expression) {
1091    console.error(`A param property was accessed directly with ${expression}. ` + `\`params\` is a Promise and must be unwrapped with \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
1092}
1093function warnForEnumeration() {
1094    console.error(`params are being enumerated. ` + `\`params\` is a Promise and must be unwrapped with \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
1095}
1096function createRenderParamsFromClient(clientParams) {
1097    return makeDynamicallyTrackedParamsWithDevWarnings(clientParams);
1098}
1099if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
1100    Object.defineProperty(exports.default, '__esModule', {
1101        value: true
1102    });

1103    Object.assign(exports.default, exports);
1104    module.exports = exports.default;
1105}
1106}),
1107"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/request/params.browser.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
1108"use strict";
1109
1110var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$2$2e$2_$40$babel$2b$core$40$7$2e$29$2e$0_react$2d$dom$40$19$2e$2$2e$4_react$40$19$2e$2$2e$4_$5f$react$40$19$2e$2$2e$4$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
1111"use strict";
1112Object.defineProperty(exports, "__esModule", {
1113    value: true
1114});
1115Object.defineProperty(exports, "createRenderParamsFromClient", {
1116    enumerable: true,
1117    get: function() {
1118        return createRenderParamsFromClient;
1119    }
1120});
1121const createRenderParamsFromClient = ("TURBOPACK compile-time truthy", 1) ? __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/request/params.browser.dev.js [app-client] (ecmascript)").createRenderParamsFromClient : "TURBOPACK unreachable";
1122if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
1123    Object.defineProperty(exports.default, '__esModule', {
1124        value: true
1125    });
1126    Object.assign(exports.default, exports);
1127    module.exports = exports.default;
1128}
1129}),
1130"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/vary-params.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
1131"use strict";
1132
1133Object.defineProperty(exports, "__esModule", {
1134    value: true
1135});
11360 && (module.exports = {
1137    accumulateRootVaryParam: null,
1138    accumulateVaryParam: null,
1139    createResponseVaryParamsAccumulator: null,
1140    createVaryParamsAccumulator: null,
1141    createVaryingParams: null,
1142    createVaryingSearchParams: null,
1143    emptyVaryParamsAccumulator: null,
1144    finishAccumulatingVaryParams: null,
1145    getMetadataVaryParamsAccumulator: null,
1146    getMetadataVaryParamsThenable: null,
1147    getRootParamsVaryParamsAccumulator: null,
1148    getVaryParamsThenable: null,
1149    getViewportVaryParamsAccumulator: null
1150});
1151function _export(target, all) {
1152    for(var name in all)Object.defineProperty(target, name, {
1153        enumerable: true,
1154        get: all[name]
1155    });
1156}
1157_export(exports, {
1158    accumulateRootVaryParam: function() {
1159        return accumulateRootVaryParam;
1160    },
1161    accumulateVaryParam: function() {
1162        return accumulateVaryParam;
1163    },
1164    createResponseVaryParamsAccumulator: function() {
1165        return createResponseVaryParamsAccumulator;
1166    },
1167    createVaryParamsAccumulator: function() {
1168        return createVaryParamsAccumulator;
1169    },
1170    createVaryingParams: function() {
1171        return createVaryingParams;
1172    },
1173    createVaryingSearchParams: function() {
1174        return createVaryingSearchParams;
1175    },
1176    emptyVaryParamsAccumulator: function() {
1177        return emptyVaryParamsAccumulator;
1178    },
1179    finishAccumulatingVaryParams: function() {
1180        return finishAccumulatingVaryParams;
1181    },
1182    getMetadataVaryParamsAccumulator: function() {
1183        return getMetadataVaryParamsAccumulator;
1184    },
1185    getMetadataVaryParamsThenable: function() {
1186        return getMetadataVaryParamsThenable;
1187    },
1188    getRootParamsVaryParamsAccumulator: function() {
1189        return getRootParamsVaryParamsAccumulator;
1190    },
1191    getVaryParamsThenable: function() {
1192        return getVaryParamsThenable;
1193    },
1194    getViewportVaryParamsAccumulator: function() {
1195        return getViewportVaryParamsAccumulator;
1196    }
1197});
1198const _workunitasyncstorageexternal = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/wor

1198k-unit-async-storage.external.js [app-client] (ecmascript)");
1199function createSegmentVaryParamsAccumulator() {
1200    const accumulator = {
1201        varyParams: new Set(),
1202        status: 'pending',
1203        value: new Set(),
1204        then (onfulfilled) {
1205            if (onfulfilled) {
1206                if (accumulator.status === 'pending') {
1207                    accumulator.resolvers.push(onfulfilled);
1208                } else {
1209                    onfulfilled(accumulator.value);
1210                }
1211            }
1212        },
1213        resolvers: []
1214    };
1215    return accumulator;
1216}
1217/**
1218 * A singleton accumulator that's already resolved to an empty Set. Use this for
1219 * segments where we know upfront that no params will be accessed, such as
1220 * client components or segments without user code.
1221 *
1222 * Benefits:
1223 * - No need to accumulate or resolve later
1224 * - Resilient: resolves correctly even if other tracking fails
1225 * - Memory efficient: reuses the same object
1226 */ const emptySet = new Set();
1227const emptyVaryParamsAccumulator = {
1228    varyParams: emptySet,
1229    status: 'fulfilled',
1230    value: emptySet,
1231    then (onfulfilled) {
1232        if (onfulfilled) {
1233            onfulfilled(emptySet);
1234        }
1235    },
1236    resolvers: []
1237};
1238function createResponseVaryParamsAccumulator() {
1239    // Create the head and rootParams accumulators as top-level fields.
1240    // Segment accumulators are added to the segments set as they are created.
1241    const head = createSegmentVaryParamsAccumulator();
1242    const rootParams = createSegmentVaryParamsAccumulator();
1243    const segments = new Set();
1244    return {
1245        head,
1246        rootParams,
1247        segments
1248    };
1249}
1250function createVaryParamsAccumulator() {
1251    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
1252    if (workUnitStore) {
1253        switch(workUnitStore.type){
1254            case 'prerender':
1255            case 'prerender-runtime':
1256                {
1257                    const responseAccumulator = workUnitStore.varyParamsAccumulator;
1258                    if (responseAccumulator !== null) {
1259                        const accumulator = createSegmentVaryParamsAccumulator();
1260                        responseAccumulator.segments.add(accumulator);
1261                        return accumulator;
1262                    }
1263                    return null;
1264                }
1265            case 'prerender-ppr':
1266            case 'prerender-legacy':
1267            case 'request':
1268            case 'cache':
1269            case 'private-cache':
1270            case 'prerender-client':
1271            case 'validation-client':
1272            case 'unstable-cache':
1273            case 'generate-static-params':
1274                break;
1275            default:
1276                workUnitStore;
1277        }
1278    }
1279    return null;
1280}
1281function getMetadataVaryParamsAccumulator() {
1282    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
1283    if (workUnitStore) {
1284        switch(workUnitStore.type){
1285            case 'prerender':
1286            case 'prerender-runtime':
1287                {
1288                    const responseAccumulator = workUnitStore.varyParamsAccumulator;
1289                    if (responseAccumulator !== null) {
1290                        return responseAccumulator.head;
1291                    }
1292                    return null;
1293                }
1294            case 'prerender-ppr':
1295            case 'prerender-legacy':
1296            case 'request':
1297            case 'cache':
1298            case 'private-cache':
1299            case 'prerender-client':
1300            case 'validation-client':
1301            case 'unstable-cache':
1302            case 'generate-static-params':
1303                return null;
1304            default:
1305                workUnitStore;
1306        }
1307    }
1308    return null;
1309}
1310function getVaryParamsThenable(accumulator) {
1311    return accumulator;
1312}
1313function getMetadataVaryParamsThenable() {
1314    const accumulator = getMetadataVaryParamsAccumulator();
1315    if (accumulator !== null) {
1316        return getVaryParamsThenable(accumulator);
1317    }
1318    return null;
1319}
1320const getViewportVaryParamsAccumulator = getMetadataVaryParamsAccumulator;
1321function getRootParamsVaryParamsAccumulator() {
1322    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
1323    if (workUnitStore) {
1324        switch(workUnitStore.type){
1325            case 'prerender':
1326            case 'prerender-runtime':
1327                {
1328                    const responseAccumulator = workUnitStore.varyParamsAccumulator;
1329                    if (responseAccumulator !== null) {

1330                        return responseAccumulator.rootParams;
1331                    }
1332                    return null;
1333                }
1334            case 'prerender-ppr':
1335            case 'prerender-legacy':
1336            case 'request':
1337            case 'cache':
1338            case 'private-cache':
1339            case 'prerender-client':
1340            case 'validation-client':
1341            case 'unstable-cache':
1342            case 'generate-static-params':
1343                return null;
1344            default:
1345                workUnitStore;
1346        }
1347    }
1348    return null;
1349}
1350function accumulateVaryParam(accumulator, paramName) {
1351    accumulator.varyParams.add(paramName);
1352}
1353function accumulateRootVaryParam(paramName) {
1354    const rootParamsAccumulator = getRootParamsVaryParamsAccumulator();
1355    if (rootParamsAccumulator !== null) {
1356        accumulateVaryParam(rootParamsAccumulator, paramName);
1357    }
1358}
1359function createVaryingParams(accumulator, originalParamsObject, optionalCatchAllParamName) {
1360    if (optionalCatchAllParamName !== null) {
1361        // When there's an optional catch-all param with no value (e.g.,
1362        // [[...slug]] at /), the param doesn't exist as a property on the params
1363        // object. Use a Proxy to track all param access â both existing params
1364        // and the missing optional param â including enumeration patterns like
1365        // Object.keys(), spread, for...in, and `in` checks.
1366        return new Proxy(originalParamsObject, {
1367            get (target, prop, receiver) {
1368                if (typeof prop === 'string') {
1369                    if (prop === optionalCatchAllParamName || Object.prototype.hasOwnProperty.call(target, prop)) {
1370                        accumulateVaryParam(accumulator, prop);
1371                    }
1372                }
1373                return Reflect.get(target, prop, receiver);
1374            },
1375            has (target, prop) {
1376                if (prop === optionalCatchAllParamName) {
1377                    accumulateVaryParam(accumulator, optionalCatchAllParamName);
1378                }
1379                return Reflect.has(target, prop);
1380            },
1381            ownKeys (target) {
1382                // Enumerating the params object means the user's code may depend on
1383                // which params are present, so conservatively track the optional
1384                // param as accessed.
1385                accumulateVaryParam(accumulator, optionalCatchAllParamName);
1386                return Reflect.ownKeys(target);
1387            }
1388        });
1389    }
1390    // When there's no optional catch-all, all params exist as properties on the
1391    // object, so we can use defineProperty getters instead of a Proxy. This is
1392    // faster because the engine can optimize property access on regular objects
1393    // more aggressively than Proxy trap calls.
1394    const underlyingParamsWithVarying = {};
1395    for(const paramName in originalParamsObject){
1396        Object.defineProperty(underlyingParamsWithVarying, paramName, {
1397            get () {
1398                accumulateVaryParam(accumulator, paramName);
1399                return originalParamsObject[paramName];
1400            },
1401            enumerable: true
1402        });
1403    }
1404    return underlyingParamsWithVarying;
1405}
1406function createVaryingSearchParams(accumulator, originalSearchParamsObject) {
1407    const underlyingSearchParamsWithVarying = {};
1408    for(const searchParamName in originalSearchParamsObject){
1409        Object.defineProperty(underlyingSearchParamsWithVarying, searchParamName, {
1410            get () {
1411                // TODO: Unlike path params, we don't vary track each search param
1412                // individually. The entire search string is treated as a single param.
1413                // This may change in the future.
1414                accumulateVaryParam(accumulator, '?');
1415                return originalSearchParamsObject[searchParamName];
1416            },
1417            enumerable: true
1418        });
1419    }
1420    return underlyingSearchParamsWithVarying;
1421}
1422async function finishAccumulatingVaryParams(responseAccumulator) {
1423    const rootVaryParams = responseAccumulator.rootParams.varyParams;
1424    // Resolve head
1425    finishSegmentAccumulator(responseAccumulator.head, rootVaryParams);
1426    // Resolve each segment
1427    for (const segmentAccumulator of responseAccumulator.segments){
1428        finishSegmentAccumulator(segmentAccumulator, rootVaryParams);
1429    }
1430    // Now that the thenables are resolved, Flight should be able to flush the
1431    // vary params into the response stream. This work gets scheduled internally
1432    // by Flight using a microtask as soon as we notify the thenable listeners.
1433    //
1434    // We need to ensure that Flight's pending queues are emptied before this
1435    // function returns; the caller will abort the prerender immediately after.
1436    // We can't use a macrotask, because that would allow dynamic IO to sneak
1437    // into the response. So we use microtasks instead.
1438    //
1439    // The exact number of awaits here isn't important (indeed, one seems to be
1440    // sufficient, at the time of writing), as long as we wait enough ticks for
1441    // Flight to finish writing the response.
1442    //
1443    // Anything that remains in Flight's internal queue after these awaits must
1444    // be actual dynamic IO, not caused by pending vary params tasks. In other
1445    // words, failing to do this would cause us to treat a fully static prerender
1446    // as if it were partially dynamic.
1447    await Promise.resolve();
1448    await Promise.resolve();
1449    await Promise.resolve();
1450}
1451function finishSegmentAccumulator(accumulator, rootVaryParams) {
1452    if (accumulator.status !== 'pending') {
1453        return;
1454    }
1455    const merged = new Set(accumulator.varyParams);
1456    for (const param of rootVaryParams){
1457        merged.add(param);
1458    }
1459    accumulator.value = merged;
1460    accumulator.status = 'fulfilled';
1461    for (const resolver of accumulator.resolvers){
1462        resolver(merged);
1463    }
1464    accumulator.resolvers = [];
1465}
1466}),
1467"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports

1467) => {
1468"use strict";
1469
1470var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$2$2e$2_$40$babel$2b$core$40$7$2e$29$2e$0_react$2d$dom$40$19$2e$2$2e$4_react$40$19$2e$2$2e$4_$5f$react$40$19$2e$2$2e$4$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
1471"use strict";
1472Object.defineProperty(exports, "__esModule", {
1473    value: true
1474});
1475Object.defineProperty(exports, "createDedupedByCallsiteServerErrorLoggerDev", {
1476    enumerable: true,
1477    get: function() {
1478        return createDedupedByCallsiteServerErrorLoggerDev;
1479    }
1480});
1481const _react = /*#__PURE__*/ _interop_require_wildcard(__turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)"));
1482function _getRequireWildcardCache(nodeInterop) {
1483    if (typeof WeakMap !== "function") return null;
1484    var cacheBabelInterop = new WeakMap();
1485    var cacheNodeInterop = new WeakMap();
1486    return (_getRequireWildcardCache = function(nodeInterop) {
1487        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
1488    })(nodeInterop);
1489}
1490function _interop_require_wildcard(obj, nodeInterop) {
1491    if (!nodeInterop && obj && obj.__esModule) {
1492        return obj;
1493    }
1494    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
1495        return {
1496            default: obj
1497        };
1498    }
1499    var cache = _getRequireWildcardCache(nodeInterop);
1500    if (cache && cache.has(obj)) {
1501        return cache.get(obj);
1502    }
1503    var newObj = {
1504        __proto__: null
1505    };
1506    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
1507    for(var key in obj){
1508        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
1509            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
1510            if (desc && (desc.get || desc.set)) {
1511                Object.defineProperty(newObj, key, desc);
1512            } else {
1513                newObj[key] = obj[key];
1514            }
1515        }
1516    }
1517    newObj.default = obj;
1518    if (cache) {
1519        cache.set(obj, newObj);
1520    }
1521    return newObj;
1522}
1523const errorRef = {
1524    current: null
1525};
1526// React.cache is currently only available in canary/experimental React channels.
1527const cache = typeof _react.cache === 'function' ? _react.cache : (fn)=>fn;
1528// When Cache Components is enabled, we record these as errors so that they
1529// are captured by the dev overlay as it's more critical to fix these
1530// when enabled.
1531const logErrorOrWarn = ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : console.warn;
1532// We don't want to dedupe across requests.
1533// The developer might've just attempted to fix the warning so we should warn again if it still happens.
1534const flushCurrentErrorIfNew = cache((key)=>{
1535    try {
1536        logErrorOrWarn(errorRef.current);
1537    } finally{
1538        errorRef.current = null;
1539    }
1540});
1541function createDedupedByCallsiteServerErrorLoggerDev(getMessage) {
1542    return function logDedupedError(...args) {
1543        const message = getMessage(...args);
1544        if ("TURBOPACK compile-time truthy", 1) {
1545            var _stack;
1546            const callStackFrames = (_stack = new Error().stack) == null ? void 0 : _stack.split('\n');
1547            if (callStackFrames === undefined || callStackFrames.length < 4) {
1548                logErrorOrWarn(message);
1549            } else {
1550                // Error:
1551                //   logDedupedError
1552                //   asyncApiBeingAccessedSynchronously
1553                //   <userland callsite>
1554                // TODO: This breaks if sourcemaps with ignore lists are enabled.
1555                const key = callStackFrames[4];
1556                errorRef.current = message;
1557                flushCurrentErrorIfNew(key);
1558            }
1559        } else //TURBOPACK unreachable
1560        ;
1561    };
1562}
1563}),
1564"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/after-task-async-storage-instance.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports

1564) => {
1565"use strict";
1566
1567Object.defineProperty(exports, "__esModule", {
1568    value: true
1569});
1570Object.defineProperty(exports, "afterTaskAsyncStorageInstance", {
1571    enumerable: true,
1572    get: function() {
1573        return afterTaskAsyncStorageInstance;
1574    }
1575});
1576const _asynclocalstorage = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/async-local-storage.js [app-client] (ecmascript)");
1577const afterTaskAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
1578}),
1579"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/after-task-async-storage.external.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
1580"use strict";
1581
1582Object.defineProperty(exports, "__esModule", {
1583    value: true
1584});
1585Object.defineProperty(exports, "afterTaskAsyncStorage", {
1586    enumerable: true,
1587    get: function() {
1588        return _aftertaskasyncstorageinstance.afterTaskAsyncStorageInstance;
1589    }
1590});
1591const _aftertaskasyncstorageinstance = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/after-task-async-storage-instance.js [app-client] (ecmascript)");
1592}),
1593"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/request/utils.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
1594"use strict";
1595
1596Object.defineProperty(exports, "__esModule", {
1597    value: true
1598});
15990 && (module.exports = {
1600    isRequestAPICallableInsideAfter: null,
1601    throwForSearchParamsAccessInUseCache: null,
1602    throwWithStaticGenerationBailoutErrorWithDynamicError: null
1603});
1604function _export(target, all) {
1605    for(var name in all)Object.defineProperty(target, name, {
1606        enumerable: true,
1607        get: all[name]
1608    });
1609}
1610_export(exports, {
1611    isRequestAPICallableInsideAfter: function() {
1612        return isRequestAPICallableInsideAfter;
1613    },
1614    throwForSearchParamsAccessInUseCache: function() {
1615        return throwForSearchParamsAccessInUseCache;
1616    },
1617    throwWithStaticGenerationBailoutErrorWithDynamicError: function() {
1618        return throwWithStaticGenerationBailoutErrorWithDynamicError;
1619    }
1620});
1621const _staticgenerationbailout = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/static-generation-bailout.js [app-client] (ecmascript)");
1622const _aftertaskasyncstorageexternal = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/after-task-async-storage.external.js [app-client] (ecmascript)");
1623function throwWithStaticGenerationBailoutErrorWithDynamicError(route, expression) {
1624    throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} with \`dynamic = "error"\` couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
1625        value: "E543",
1626        enumerable: false,
1627        configurable: true
1628    });
1629}
1630function throwForSearchParamsAccessInUseCache(workStore, constructorOpt) {
1631    const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`searchParams\` inside "use cache". Accessing dynamic request data inside a cache scope is not supported. If you need some search params inside a cached function await \`searchParams\` outside of the cached function and pass only the required search params as arguments to the cached function. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
1632        value: "E842",
1633        enumerable: false,
1634        configurable: true
1635    });
1636    Error.captureStackTrace(error, constructorOpt);

1637    workStore.invalidDynamicUsageError ??= error;
1638    throw error;
1639}
1640function isRequestAPICallableInsideAfter() {
1641    const afterTaskStore = _aftertaskasyncstorageexternal.afterTaskAsyncStorage.getStore();
1642    return (afterTaskStore == null ? void 0 : afterTaskStore.rootTaskSpawnPhase) === 'action';
1643}
1644}),
1645"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/@edge-runtime/cookies/index.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
1646"use strict";
1647
1648var __defProp = Object.defineProperty;
1649var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
1650var __getOwnPropNames = Object.getOwnPropertyNames;
1651var __hasOwnProp = Object.prototype.hasOwnProperty;
1652var __export = (target, all)=>{
1653    for(var name in all)__defProp(target, name, {
1654        get: all[name],
1655        enumerable: true
1656    });
1657};
1658var __copyProps = (to, from, except, desc)=>{
1659    if (from && typeof from === "object" || typeof from === "function") {
1660        for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
1661            get: ()=>from[key],
1662            enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
1663        });
1664    }
1665    return to;
1666};
1667var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
1668        value: true
1669    }), mod);

1670// src/index.ts
1671var src_exports = {};
1672__export(src_exports, {
1673    RequestCookies: ()=>RequestCookies,
1674    ResponseCookies: ()=>ResponseCookies,
1675    parseCookie: ()=>parseCookie,
1676    parseSetCookie: ()=>parseSetCookie,
1677    stringifyCookie: ()=>stringifyCookie
1678});
1679module.exports = __toCommonJS(src_exports);

1680// src/serialize.ts
1681function stringifyCookie(c) {
1682    var _a;
1683    const attrs = [
1684        "path" in c && c.path && `Path=${c.path}`,
1685        "expires" in c && (c.expires || c.expires === 0) && `Expires=${(typeof c.expires === "number" ? new Date(c.expires) : c.expires).toUTCString()}`,
1686        "maxAge" in c && typeof c.maxAge === "number" && `Max-Age=${c.maxAge}`,
1687        "domain" in c && c.domain && `Domain=${c.domain}`,
1688        "secure" in c && c.secure && "Secure",
1689        "httpOnly" in c && c.httpOnly && "HttpOnly",
1690        "sameSite" in c && c.sameSite && `SameSite=${c.sameSite}`,
1691        "partitioned" in c && c.partitioned && "Partitioned",
1692        "priority" in c && c.priority && `Priority=${c.priority}`
1693    ].filter(Boolean);
1694    const stringified = `${c.name}=${encodeURIComponent((_a = c.value) != null ? _a : "")}`;
1695    return attrs.length === 0 ? stringified : `${stringified}; ${attrs.join("; ")}`;
1696}
1697function parseCookie(cookie) {
1698    const map = /* @__PURE__ */ new Map();
1699    for (const pair of cookie.split(/; */)){
1700        if (!pair) continue;
1701        const splitAt = pair.indexOf("=");
1702        if (splitAt === -1) {
1703            map.set(pair, "true");
1704            continue;
1705        }
1706        const [key, value] = [
1707            pair.slice(0, splitAt),
1708            pair.slice(splitAt + 1)
1709        ];
1710        try {
1711            map.set(key, decodeURIComponent(value != null ? value : "true"));
1712        } catch  {}
1713    }
1714    return map;
1715}
1716function parseSetCookie(setCookie) {
1717    if (!setCookie) {
1718        return void 0;
1719    }
1720    const [[name, value], ...attributes] = parseCookie(setCookie);
1721    const { domain, expires, httponly, maxage, path, samesite, secure, partitioned, priority } = Object.fromEntries(attributes.map(([key, value2])=>[
1722            key.toLowerCase().replace(/-/g, ""),
1723            value2
1724        ]));
1725    const cookie = {
1726        name,
1727        value: decodeURIComponent(value),
1728        domain,
1729        ...expires && {
1730            expires: new Date(expires)
1731        },
1732        ...httponly && {
1733            httpOnly: true
1734        },
1735        ...typeof maxage === "string" && {
1736            maxAge: Number(maxage)
1737        },
1738        path,
1739        ...samesite && {
1740            sameSite: parseSameSite(samesite)
1741        },
1742        ...secure && {
1743            secure: true
1744        },
1745        ...priority && {
1746            priority: parsePriority(priority)
1747        },
1748        ...partitioned && {
1749            partitioned: true
1750        }
1751    };
1752    return compact(cookie);
1753}
1754function compact(t) {
1755    const newT = {};
1756    for(const key in t){
1757        if (t[key]) {
1758            newT[key] = t[key];
1759        }
1760    }
1761    return newT;
1762}
1763var SAME_SITE = [
1764    "strict",
1765    "lax",
1766    "none"
1767];
1768function parseSameSite(string) {
1769    string = string.toLowerCase();
1770    return SAME_SITE.includes(string) ? string : void 0;
1771}
1772var PRIORITY = [
1773    "low",
1774    "medium",
1775    "high"
1776];
1777function parsePriority(string) {
1778    string = string.toLowerCase();
1779    return PRIORITY.includes(string) ? string : void 0;
1780}
1781function splitCookiesString(cookiesString) {
1782    if (!cookiesString) return [];
1783    var cookiesStrings = [];
1784    var pos = 0;
1785    var start;
1786    var ch;
1787    var lastComma;
1788    var nextStart;
1789    var cookiesSeparatorFound;
1790    function skipWhitespace() {
1791        while(pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))){
1792            pos += 1;
1793        }
1794        return pos < cookiesString.length;
1795    }
1796    function notSpecialChar() {
1797        ch = cookiesString.charAt(pos);
1798        return ch !== "=" && ch !== ";" && ch !== ",";
1799    }
1800    while(pos < cookiesString.length){
1801        start = pos;
1802        cookiesSeparatorFound = false;
1803        while(skipWhitespace()){
1804            ch = cookiesString.charAt(pos);
1805            if (ch === ",") {
1806                lastComma = pos;
1807                pos += 1;
1808                skipWhitespace();
1809                nextStart = pos;
1810                while(pos < cookiesString.length && notSpecialChar()){
1811                    pos += 1;
1812                }
1813                if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
1814                    cookiesSeparatorFound = true;
1815                    pos = nextStart;
1816                    cookiesStrings.push(cookiesString.substring(start, lastComma));
1817                    start = pos;
1818                } else {
1819                    pos = lastComma + 1;
1820                }
1821            } else {
1822                pos += 1;
1823            }
1824        }
1825        if (!cookiesSeparatorFound || pos >= cookiesString.length) {
1826            cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
1827        }
1828    }
1829    return cookiesStrings;
1830}

1831// src/request-cookies.ts
1832var RequestCookies = class {
1833    constructor(requestHeaders){
1834        /** @internal */ this._parsed = /* @__PURE__ */ new Map();
1835        this._headers = requestHeaders;
1836        const header = requestHeaders.get("cookie");
1837        if (header) {
1838            const parsed = parseCookie(header);
1839            for (const [name, value] of parsed){
1840                this._parsed.set(name, {
1841                    name,
1842                    value
1843                });
1844            }
1845        }
1846    }
1847    [Symbol.iterator]() {
1848        return this._parsed[Symbol.iterator]();
1849    }
1850    /**
1851   * The amount of cookies received from the client
1852   */ get size() {
1853        return this._parsed.size;
1854    }
1855    get(...args) {
1856        const name = typeof args[0] === "string" ? args[0] : args[0].name;
1857        return this._parsed.get(name);
1858    }
1859    getAll(...args) {
1860        var _a;
1861        const all = Array.from(this._parsed);
1862        if (!args.length) {
1863            return all.map(([_, value])=>value);
1864        }
1865        const name = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
1866        return all.filter(([n])=>n === name).map(([_, value])=>value);
1867    }
1868    has(name) {
1869        return this._parsed.has(name);
1870    }
1871    set(...args) {
1872        const [name, value] = args.length === 1 ? [
1873            args[0].name,
1874            args[0].value
1875        ] : args;
1876        const map = this._parsed;
1877        map.set(name, {
1878            name,
1879            value
1880        });
1881        this._headers.set("cookie", Array.from(map).map(([_, value2])=>stringifyCookie(value2)).join("; "));
1882        return this;
1883    }
1884    /**
1885   * Delete the cookies matching the passed name or names in the request.
1886   */ delete(names) {
1887        const map = this._parsed;
1888        const result = !Array.isArray(names) ? map.delete(names) : names.map((name)=>map.delete(name));
1889        this._headers.set("cookie", Array.from(map).map(([_, value])=>stringifyCookie(value)).join("; "));
1890        return result;
1891    }
1892    /**
1893   * Delete all the cookies in the cookies in the request.
1894   */ clear() {
1895        this.delete(Array.from(this._parsed.keys()));
1896        return this;
1897    }
1898    /**
1899   * Format the cookies in the request as a string for logging
1900   */ [Symbol.for("edge-runtime.inspect.custom")]() {
1901        return `RequestCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
1902    }
1903    toString() {
1904        return [
1905            ...this._parsed.values()
1906        ].map((v)=>`${v.name}=${encodeURIComponent(v.value)}`).join("; ");
1907    }
1908};

1909// src/response-cookies.ts
1910var ResponseCookies = class {
1911    constructor(responseHeaders){
1912        /** @internal */ this._parsed = /* @__PURE__ */ new Map();
1913        var _a, _b, _c;
1914        this._headers = responseHeaders;
1915        const setCookie = (_c = (_b = (_a = responseHeaders.getSetCookie) == null ? void 0 : _a.call(responseHeaders)) != null ? _b : responseHeaders.get("set-cookie")) != null ? _c : [];
1916        const cookieStrings = Array.isArray(setCookie) ? setCookie : splitCookiesString(setCookie);
1917        for (const cookieString of cookieStrings){
1918            const parsed = parseSetCookie(cookieString);
1919            if (parsed) this._parsed.set(parsed.name, parsed);
1920        }
1921    }
1922    /**
1923   * {@link https://wicg.github.io/cookie-store/#CookieStore-get CookieStore#get} without the Promise.
1924   */ get(...args) {
1925        const key = typeof args[0] === "string" ? args[0] : args[0].name;
1926        return this._parsed.get(key);
1927    }
1928    /**
1929   * {@link https://wicg.github.io/cookie-store/#CookieStore-getAll CookieStore#getAll} without the Promise.
1930   */ getAll(...args) {
1931        var _a;
1932        const all = Array.from(this._parsed.values());
1933        if (!args.length) {
1934            return all;
1935        }
1936        const key = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
1937        return all.filter((c)=>c.name === key);
1938    }
1939    has(name) {
1940        return this._parsed.has(name);
1941    }
1942    /**
1943   * {@link https://wicg.github.io/cookie-store/#CookieStore-set CookieStore#set} without the Promise.
1944   */ set(...args) {
1945        const [name, value, cookie] = args.length === 1 ? [
1946            args[0].name,
1947            args[0].value,
1948            args[0]
1949        ] : args;
1950        const map = this._parsed;
1951        map.set(name, normalizeCookie({
1952            name,
1953            value,
1954            ...cookie
1955        }));
1956        replace(map, this._headers);
1957        return this;
1958    }
1959    /**
1960   * {@link https://wicg.github.io/cookie-store/#CookieStore-delete CookieStore#delete} without the Promise.
1961   */ delete(...args) {
1962        const [name, options] = typeof args[0] === "string" ? [
1963            args[0]
1964        ] : [
1965            args[0].name,
1966            args[0]
1967        ];
1968        return this.set({
1969            ...options,
1970            name,
1971            value: "",
1972            expires: /* @__PURE__ */ new Date(0)
1973        });
1974    }
1975    [Symbol.for("edge-runtime.inspect.custom")]() {
1976        return `ResponseCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
1977    }
1978    toString() {
1979        return [
1980            ...this._parsed.values()
1981        ].map(stringifyCookie).join("; ");
1982    }
1983};
1984function replace(bag, headers) {
1985    headers.delete("set-cookie");
1986    for (const [, value] of bag){
1987        const serialized = stringifyCookie(value);
1988        headers.append("set-cookie", serialized);
1989    }
1990}
1991function normalizeCookie(cookie = {
1992    name: "",
1993    value: ""
1994}) {
1995    if (typeof cookie.expires === "number") {
1996        cookie.expires = new Date(cookie.expires);
1997    }
1998    if (cookie.maxAge) {
1999        cookie.expires = new Date(Date.now() + cookie.maxAge * 1e3);
2000    }
2001    if (cookie.path === null || cookie.path === void 0) {
2002        cookie.path = "/";
2003    }
2004    return cookie;
2005}
2006// Annotate the CommonJS export names for ESM import in node:
20070 && (module.exports = {
2008    RequestCookies,
2009    ResponseCookies,
2010    parseCookie,
2011    parseSetCookie,
2012    stringifyCookie
2013});
2014}),
2015"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/cookies.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
2016"use strict";
2017
2018Object.defineProperty(exports, "__esModule", {
2019    value: true
2020});
20210 && (module.exports = {
2022    RequestCookies: null,
2023    ResponseCookies: null,
2024    stringifyCookie: null
2025});
2026function _export(target, all) {
2027    for(var name in all)Object.defineProperty(target, name, {
2028        enumerable: true,
2029        get: all[name]
2030    });
2031}
2032_export(exports, {
2033    RequestCookies: function() {
2034        return _cookies.RequestCookies;
2035    },
2036    ResponseCookies: function() {
2037        return _cookies.ResponseCookies;
2038    },
2039    stringifyCookie: function() {

2040        return _cookies.stringifyCookie;
2041    }
2042});
2043const _cookies = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/@edge-runtime/cookies/index.js [app-client] (ecmascript)");
2044}),
2045"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
2046"use strict";
2047
2048Object.defineProperty(exports, "__esModule", {
2049    value: true
2050});
20510 && (module.exports = {
2052    MutableRequestCookiesAdapter: null,
2053    ReadonlyRequestCookiesError: null,
2054    RequestCookiesAdapter: null,
2055    appendMutableCookies: null,
2056    areCookiesMutableInCurrentPhase: null,
2057    createCookiesWithMutableAccessCheck: null,
2058    getModifiedCookieValues: null,
2059    responseCookiesToRequestCookies: null
2060});
2061function _export(target, all) {
2062    for(var name in all)Object.defineProperty(target, name, {
2063        enumerable: true,
2064        get: all[name]
2065    });
2066}
2067_export(exports, {
2068    MutableRequestCookiesAdapter: function() {
2069        return MutableRequestCookiesAdapter;
2070    },
2071    ReadonlyRequestCookiesError: function() {
2072        return ReadonlyRequestCookiesError;
2073    },
2074    RequestCookiesAdapter: function() {
2075        return RequestCookiesAdapter;
2076    },
2077    appendMutableCookies: function() {
2078        return appendMutableCookies;
2079    },
2080    areCookiesMutableInCurrentPhase: function() {
2081        return areCookiesMutableInCurrentPhase;
2082    },
2083    createCookiesWithMutableAccessCheck: function() {
2084        return createCookiesWithMutableAccessCheck;
2085    },
2086    getModifiedCookieValues: function() {
2087        return getModifiedCookieValues;
2088    },
2089    responseCookiesToRequestCookies: function() {
2090        return responseCookiesToRequestCookies;
2091    }
2092});
2093const _cookies = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/cookies.js [app-client] (ecmascript)");
2094const _reflect = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)");
2095const _workasyncstorageexternal = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/work-async-storage.external.js [app-client] (ecmascript)");
2096const _actionrevalidationkind = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/action-revalidation-kind.js [app-client] (ecmascript)");
2097class ReadonlyRequestCookiesError extends Error {
2098    constructor(){
2099        super('Cookies can only be modified in a Server Action or Route Handler. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options');
2100    }
2101    static callable() {
2102        throw new ReadonlyRequestCookiesError();
2103    }
2104}
2105class RequestCookiesAdapter {
2106    static seal(cookies) {
2107        return new Proxy(cookies, {
2108            get (target, prop, receiver) {
2109                switch(prop){
2110                    case 'clear':
2111                    case 'delete':
2112                    case 'set':
2113                        return ReadonlyRequestCookiesError.callable;
2114                    default:
2115                        return _reflect.ReflectAdapter.get(target, prop, receiver);
2116                }
2117            }
2118        });
2119    }
2120}
2121const SYMBOL_MODIFY_COOKIE_VALUES = Symbol.for('next.mutated.cookies');
2122function getModifiedCookieValues(cookies) {
2123    const modified = cookies[SYMBOL_MODIFY_COOKIE_VALUES];
2124    if (!modified || !Array.isArray(modified) || modified.length === 0) {
2125        return [];
2126    }
2127    return modified;
2128}
2129function appendMutableCookies(headers, mutableCookies) {
2130    const modifiedCookieValues = getModifiedCookieValues(mutableCookies);
2131    if (modifiedCookieValues.length === 0) {
2132        return false;

2133    }
2134    // Return a new response that extends the response with
2135    // the modified cookies as fallbacks. `res` cookies
2136    // will still take precedence.
2137    const resCookies = new _cookies.ResponseCookies(headers);
2138    const returnedCookies = resCookies.getAll();
2139    // Set the modified cookies as fallbacks.
2140    for (const cookie of modifiedCookieValues){
2141        resCookies.set(cookie);
2142    }
2143    // Set the original cookies as the final values.
2144    for (const cookie of returnedCookies){
2145        resCookies.set(cookie);
2146    }
2147    return true;
2148}
2149class MutableRequestCookiesAdapter {
2150    static wrap(cookies, onUpdateCookies) {
2151        const responseCookies = new _cookies.ResponseCookies(new Headers());
2152        for (const cookie of cookies.getAll()){
2153            responseCookies.set(cookie);
2154        }
2155        let modifiedValues = [];
2156        const modifiedCookies = new Set();
2157        const updateResponseCookies = ()=>{
2158            // TODO-APP: change method of getting workStore
2159            const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
2160            if (workStore) {
2161                workStore.pathWasRevalidated = _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic;
2162            }
2163            const allCookies = responseCookies.getAll();
2164            modifiedValues = allCookies.filter((c)=>modifiedCookies.has(c.name));
2165            if (onUpdateCookies) {
2166                const serializedCookies = [];
2167                for (const cookie of modifiedValues){
2168                    const tempCookies = new _cookies.ResponseCookies(new Headers());
2169                    tempCookies.set(cookie);
2170                    serializedCookies.push(tempCookies.toString());
2171                }
2172                onUpdateCookies(serializedCookies);
2173            }
2174        };
2175        const wrappedCookies = new Proxy(responseCookies, {
2176            get (target, prop, receiver) {
2177                switch(prop){
2178                    // A special symbol to get the modified cookie values
2179                    case SYMBOL_MODIFY_COOKIE_VALUES:
2180                        return modifiedValues;
2181                    // TODO: Throw error if trying to set a cookie after the response
2182                    // headers have been set.
2183                    case 'delete':
2184                        return function(...args) {
2185                            modifiedCookies.add(typeof args[0] === 'string' ? args[0] : args[0].name);
2186                            try {
2187                                target.delete(...args);
2188                                return wrappedCookies;
2189                            } finally{
2190                                updateResponseCookies();
2191                            }
2192                        };
2193                    case 'set':
2194                        return function(...args) {
2195                            modifiedCookies.add(typeof args[0] === 'string' ? args[0] : args[0].name);
2196                            try {
2197                                target.set(...args);
2198                                return wrappedCookies;
2199                            } finally{
2200                                updateResponseCookies();
2201                            }
2202                        };
2203                    default:
2204                        return _reflect.ReflectAdapter.get(target, prop, receiver);
2205                }
2206            }
2207        });
2208        return wrappedCookies;
2209    }
2210}
2211function createCookiesWithMutableAccessCheck(requestStore) {
2212    const wrappedCookies = new Proxy(requestStore.mutableCookies, {
2213        get (target, prop, receiver) {
2214            switch(prop){
2215                case 'delete':
2216                    return function(...args) {
2217                        ensureCookiesAreStillMutable(requestStore, 'cookies().delete');
2218                        target.delete(...args);
2219                        return wrappedCookies;
2220                    };
2221                case 'set':
2222                    return function(...args) {
2223                        ensureCookiesAreStillMutable(requestStore, 'cookies().set');
2224                        target.set(...args);
2225                        return wrappedCookies;
2226                    };
2227                default:
2228                    return _reflect.ReflectAdapter.get(target, prop, receiver);
2229            }
2230        }
2231    });
2232    return wrappedCookies;
2233}
2234function areCookiesMutableInCurrentPhase(requestStore) {
2235    return requestStore.phase === 'action';
2236}
2237/** Ensure that cookies() starts throwing on mutation
2238 * if we changed phases and can no longer mutate.
2239 *
2240 * This can happen when going:
2241 *   'render' -> 'after'
2242 *   'action' -> 'render'
2243 * */ function ensureCookiesAreStillMutable(requestStore, _callingExpression) {
2244    if (!areCookiesMutableInCurrentPhase(requestStore)) {
2245        // TODO: maybe we can give a more precise error message based on callingExpression?
2246        throw new ReadonlyRequestCookiesError();
2247    }
2248}
2249function responseCookiesToRequestCookies(responseCookies) {
2250    const requestCookies = new _cookies.RequestCookies(new Headers());
2251    for (const cookie of responseCookies.getAll()){
2252        requestCookies.set(cookie);
2253    }
2254    return requestCookies;
2255}
2256}),
2257"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapter

2257s/headers.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
2258"use strict";
2259
2260Object.defineProperty(exports, "__esModule", {
2261    value: true
2262});
22630 && (module.exports = {
2264    HeadersAdapter: null,
2265    ReadonlyHeadersError: null
2266});
2267function _export(target, all) {
2268    for(var name in all)Object.defineProperty(target, name, {
2269        enumerable: true,
2270        get: all[name]
2271    });
2272}
2273_export(exports, {
2274    HeadersAdapter: function() {
2275        return HeadersAdapter;
2276    },
2277    ReadonlyHeadersError: function() {
2278        return ReadonlyHeadersError;
2279    }
2280});
2281const _reflect = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)");
2282class ReadonlyHeadersError extends Error {
2283    constructor(){
2284        super('Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers');
2285    }
2286    static callable() {
2287        throw new ReadonlyHeadersError();
2288    }
2289}
2290class HeadersAdapter extends Headers {
2291    constructor(headers){
2292        // We've already overridden the methods that would be called, so we're just
2293        // calling the super constructor to ensure that the instanceof check works.
2294        super();
2295        this.headers = new Proxy(headers, {
2296            get (target, prop, receiver) {
2297                // Because this is just an object, we expect that all "get" operations
2298                // are for properties. If it's a "get" for a symbol, we'll just return
2299                // the symbol.
2300                if (typeof prop === 'symbol') {
2301                    return _reflect.ReflectAdapter.get(target, prop, receiver);
2302                }
2303                const lowercased = prop.toLowerCase();
2304                // Let's find the original casing of the key. This assumes that there is
2305                // no mixed case keys (e.g. "Content-Type" and "content-type") in the
2306                // headers object.
2307                const original = Object.keys(headers).find((o)=>o.toLowerCase() === lowercased);
2308                // If the original casing doesn't exist, return undefined.
2309                if (typeof original === 'undefined') return;
2310                // If the original casing exists, return the value.
2311                return _reflect.ReflectAdapter.get(target, original, receiver);
2312            },
2313            set (target, prop, value, receiver) {
2314                if (typeof prop === 'symbol') {
2315                    return _reflect.ReflectAdapter.set(target, prop, value, receiver);
2316                }
2317                const lowercased = prop.toLowerCase();
2318                // Let's find the original casing of the key. This assumes that there is
2319                // no mixed case keys (e.g. "Content-Type" and "content-type") in the
2320                // headers object.
2321                const original = Object.keys(headers).find((o)=>o.toLowerCase() === lowercased);
2322                // If the original casing doesn't exist, use the prop as the key.
2323                return _reflect.ReflectAdapter.set(target, original ?? prop, value, receiver);
2324            },
2325            has (target, prop) {
2326                if (typeof prop === 'symbol') return _reflect.ReflectAdapter.has(target, prop);
2327                const lowercased = prop.toLowerCase();
2328                // Let's find the original casing of the key. This assumes that there is
2329                // no mixed case keys (e.g. "Content-Type" and "content-type") in the
2330                // headers object.
2331                const original = Object.keys(headers).find((o)=>o.toLowerCase() === lowercased);
2332                // If the original casing doesn't exist, return false.
2333                if (typeof original === 'undefined') return false;
2334                // If the original casing exists, return true.
2335                return _reflect.ReflectAdapter.has(target, original);
2336            },
2337            deleteProperty (target, prop) {
2338                if (typeof prop === 'symbol') return _reflect.ReflectAdapter.deleteProperty(target, prop);

2339                const lowercased = prop.toLowerCase();
2340                // Let's find the original casing of the key. This assumes that there is
2341                // no mixed case keys (e.g. "Content-Type" and "content-type") in the
2342                // headers object.
2343                const original = Object.keys(headers).find((o)=>o.toLowerCase() === lowercased);
2344                // If the original casing doesn't exist, return true.
2345                if (typeof original === 'undefined') return true;
2346                // If the original casing exists, delete the property.
2347                return _reflect.ReflectAdapter.deleteProperty(target, original);
2348            }
2349        });
2350    }
2351    /**
2352   * Seals a Headers instance to prevent modification by throwing an error when
2353   * any mutating method is called.
2354   */ static seal(headers) {
2355        return new Proxy(headers, {
2356            get (target, prop, receiver) {
2357                switch(prop){
2358                    case 'append':
2359                    case 'delete':
2360                    case 'set':
2361                        return ReadonlyHeadersError.callable;
2362                    default:
2363                        return _reflect.ReflectAdapter.get(target, prop, receiver);
2364                }
2365            }
2366        });
2367    }
2368    /**
2369   * Merges a header value into a string. This stores multiple values as an
2370   * array, so we need to merge them into a string.
2371   *
2372   * @param value a header value
2373   * @returns a merged header value (a string)
2374   */ merge(value) {
2375        if (Array.isArray(value)) return value.join(', ');
2376        return value;
2377    }
2378    /**
2379   * Creates a Headers instance from a plain object or a Headers instance.
2380   *
2381   * @param headers a plain object or a Headers instance
2382   * @returns a headers instance
2383   */ static from(headers) {
2384        if (headers instanceof Headers) return headers;
2385        return new HeadersAdapter(headers);
2386    }
2387    append(name, value) {
2388        const existing = this.headers[name];
2389        if (typeof existing === 'string') {
2390            this.headers[name] = [
2391                existing,
2392                value
2393            ];
2394        } else if (Array.isArray(existing)) {
2395            existing.push(value);
2396        } else {
2397            this.headers[name] = value;
2398        }
2399    }
2400    delete(name) {
2401        delete this.headers[name];
2402    }
2403    get(name) {
2404        const value = this.headers[name];
2405        if (typeof value !== 'undefined') return this.merge(value);
2406        return null;
2407    }
2408    has(name) {
2409        return typeof this.headers[name] !== 'undefined';
2410    }
2411    set(name, value) {
2412        this.headers[name] = value;
2413    }
2414    forEach(callbackfn, thisArg) {
2415        for (const [name, value] of this.entries()){
2416            callbackfn.call(thisArg, value, name, this);
2417        }
2418    }
2419    *entries() {
2420        for (const key of Object.keys(this.headers)){
2421            const name = key.toLowerCase();
2422            // We assert here that this is a string because we got it from the
2423            // Object.keys() call above.
2424            const value = this.get(name);
2425            yield [
2426                name,
2427                value
2428            ];
2429        }
2430    }
2431    *keys() {
2432        for (const key of Object.keys(this.headers)){
2433            const name = key.toLowerCase();
2434            yield name;
2435        }
2436    }
2437    *values() {
2438        for (const key of Object.keys(this.headers)){
2439            // We assert here that this is a string because we got it from the
2440            // Object.keys() call above.
2441            const value = this.get(key);
2442            yield value;
2443        }
2444    }
2445    [Symbol.iterator]() {
2446        return this.entries();
2447    }
2448}
2449}),
2450"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/router/utils/get-segment-param.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
2451"use strict";
2452
2453Object.defineProperty(exports, "__esModule", {
2454    value: true
2455});
24560 && (module.exports = {
2457    getParamProperties: null,
2458    getSegmentParam: null,
2459    isCatchAll: null
2460});
2461function _export(target, all) {
2462    for(var name in all)Object.defineProperty(target, name, {
2463        enumerable: true,
2464        get: all[name]
2465    });
2466}
2467_export(exports, {
2468    getParamProperties: function() {
2469        return getParamProperties;
2470    },
2471    getSegmentParam: function() {
2472        return getSegmentParam;
2473    },
2474    isCatchAll: function() {
2475        return isCatchAll;
2476    }
2477});
2478const _interceptionroutes = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/router/utils/interception-routes.js [app-client] (ecmascript)");
2479function getSegmentParam(segment) {
2480    const interceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((marker)=>segment.startsWith(marker));
2481    // if an interception marker is part of the path segment, we need to jump ahead
2482    // to the relevant portion for param parsing
2483    if (interceptionMarker) {
2484        segment = segment.slice(interceptionMarker.length);
2485    }
2486    if (segment.startsWith('[[...') && segment.endsWith(']]')) {
2487        return {
2488            // TODO-APP: Optional catchall does not currently work with parallel routes,
2489            // so for now aren't handling a potential interception marker.
2490            paramType: 'optional-catchall',
2491            paramName: segment.slice(5, -2)
2492        };
2493    }
2494    if (segment.startsWith('[...') && segment.endsWith(']')) {
2495        return {
2496            paramType: interceptionMarker ? `catchall-intercepted-${interceptionMarker}` : 'catchall',
2497            paramName: segment.slice(4, -1)
2498        };
2499    }
2500    if (segment.startsWith('[') && segment.endsWith(']')) {
2501        return {
2502            paramType: interceptionMarker ? `dynamic-intercepted-${interceptionMarker}` : 'dynamic',
2503            paramName: segment.slice(1, -1)
2504        };
2505    }
2506    return null;
2507}
2508function isCatchAll(type) {
2509    return type === 'catchall' || type === 'catchall-intercepted-(..)(..)' || type === 'catchall-intercepted-(.)' || type === 'catchall-intercepted-(..)' || type === 'catchall-intercepted-(...)' || type === 'optional-catchall';
2510}
2511function getParamProperties(paramType) {
2512    let repeat = false;

2513    let optional = false;
2514    switch(paramType){
2515        case 'catchall':
2516        case 'catchall-intercepted-(..)(..)':
2517        case 'catchall-intercepted-(.)':
2518        case 'catchall-intercepted-(..)':
2519        case 'catchall-intercepted-(...)':
2520            repeat = true;
2521            break;
2522        case 'optional-catchall':
2523            repeat = true;
2524            optional = true;
2525            break;
2526        case 'dynamic':
2527        case 'dynamic-intercepted-(..)(..)':
2528        case 'dynamic-intercepted-(.)':
2529        case 'dynamic-intercepted-(..)':
2530        case 'dynamic-intercepted-(...)':
2531            break;
2532        default:
2533            paramType;
2534    }
2535    return {
2536        repeat,
2537        optional
2538    };
2539}
2540}),
2541"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/utils.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
2542"use strict";
2543
2544var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$2$2e$2_$40$babel$2b$core$40$7$2e$29$2e$0_react$2d$dom$40$19$2e$2$2e$4_react$40$19$2e$2$2e$4_$5f$react$40$19$2e$2$2e$4$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
2545"use strict";
2546Object.defineProperty(exports, "__esModule", {
2547    value: true
2548});
25490 && (module.exports = {
2550    DecodeError: null,
2551    MiddlewareNotFoundError: null,
2552    MissingStaticPage: null,
2553    NormalizeError: null,
2554    PageNotFoundError: null,
2555    SP: null,
2556    ST: null,
2557    WEB_VITALS: null,
2558    execOnce: null,
2559    getDisplayName: null,
2560    getLocationOrigin: null,
2561    getURL: null,
2562    isAbsoluteUrl: null,
2563    isResSent: null,
2564    loadGetInitialProps: null,
2565    normalizeRepeatedSlashes: null,
2566    stringifyError: null
2567});
2568function _export(target, all) {
2569    for(var name in all)Object.defineProperty(target, name, {
2570        enumerable: true,
2571        get: all[name]
2572    });
2573}
2574_export(exports, {
2575    DecodeError: function() {
2576        return DecodeError;
2577    },
2578    MiddlewareNotFoundError: function() {
2579        return MiddlewareNotFoundError;
2580    },
2581    MissingStaticPage: function() {
2582        return MissingStaticPage;
2583    },
2584    NormalizeError: function() {
2585        return NormalizeError;
2586    },
2587    PageNotFoundError: function() {
2588        return PageNotFoundError;
2589    },
2590    SP: function() {
2591        return SP;
2592    },
2593    ST: function() {
2594        return ST;
2595    },
2596    WEB_VITALS: function() {
2597        return WEB_VITALS;
2598    },
2599    execOnce: function() {
2600        return execOnce;
2601    },
2602    getDisplayName: function() {
2603        return getDisplayName;
2604    },
2605    getLocationOrigin: function() {
2606        return getLocationOrigin;
2607    },
2608    getURL: function() {
2609        return getURL;
2610    },
2611    isAbsoluteUrl: function() {
2612        return isAbsoluteUrl;
2613    },
2614    isResSent: function() {
2615        return isResSent;
2616    },
2617    loadGetInitialProps: function() {
2618        return loadGetInitialProps;
2619    },
2620    normalizeRepeatedSlashes: function() {
2621        return normalizeRepeatedSlashes;
2622    },
2623    stringifyError: function() {
2624        return stringifyError;
2625    }
2626});
2627const WEB_VITALS = [
2628    'CLS',
2629    'FCP',
2630    'FID',
2631    'INP',
2632    'LCP',
2633    'TTFB'
2634];
2635function execOnce(fn) {
2636    let used = false;
2637    let result;
2638    return (...args)=>{
2639        if (!used) {
2640            used = true;
2641            result = fn(...args);
2642        }
2643        return result;
2644    };
2645}
2646// Scheme: https://tools.ietf.org/html/rfc3986#section-3.1
2647// Absolute URL: https://tools.ietf.org/html/rfc3986#section-4.3
2648const ABSOLUTE_URL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/;
2649const isAbsoluteUrl = (url)=>ABSOLUTE_URL_REGEX.test(url);
2650function getLocationOrigin() {
2651    const { protocol, hostname, port } = window.location;
2652    return `${protocol}//${hostname}${port ? ':' + port : ''}`;
2653}
2654function getURL() {
2655    const { href } = window.location;
2656    const origin = getLocationOrigin();
2657    return href.substring(origin.length);
2658}
2659function getDisplayName(Component) {
2660    return typeof Component === 'string' ? Component : Component.displayName || Component.name || 'Unknown';
2661}
2662function isResSent(res) {
2663    return res.finished || res.headersSent;
2664}

2665function normalizeRepeatedSlashes(url) {
2666    const urlParts = url.split('?');
2667    const urlNoQuery = urlParts[0];
2668    return urlNoQuery // first we replace any non-encoded backslashes with forward
2669    // then normalize repeated forward slashes
2670    .replace(/\\/g, '/').replace(/\/\/+/g, '/') + (urlParts[1] ? `?${urlParts.slice(1).join('?')}` : '');
2671}
2672async function loadGetInitialProps(App, ctx) {
2673    if ("TURBOPACK compile-time truthy", 1) {
2674        if (App.prototype?.getInitialProps) {
2675            const message = `"${getDisplayName(App)}.getInitialProps()" is defined as an instance method - visit https://nextjs.org/docs/messages/get-initial-props-as-an-instance-method for more information.`;
2676            throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2677                value: "E1035",
2678                enumerable: false,
2679                configurable: true
2680            });
2681        }
2682    }
2683    // when called from _app `ctx` is nested in `ctx`
2684    const res = ctx.res || ctx.ctx && ctx.ctx.res;
2685    if (!App.getInitialProps) {
2686        if (ctx.ctx && ctx.Component) {
2687            // @ts-ignore pageProps default
2688            return {
2689                pageProps: await loadGetInitialProps(ctx.Component, ctx.ctx)
2690            };
2691        }
2692        return {};
2693    }
2694    const props = await App.getInitialProps(ctx);
2695    if (res && isResSent(res)) {
2696        return props;
2697    }
2698    if (!props) {
2699        const message = `"${getDisplayName(App)}.getInitialProps()" should resolve to an object. But found "${props}" instead.`;
2700        throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
2701            value: "E1025",
2702            enumerable: false,
2703            configurable: true
2704        });
2705    }
2706    if ("TURBOPACK compile-time truthy", 1) {
2707        if (Object.keys(props).length === 0 && !ctx.ctx) {
2708            console.warn(`${getDisplayName(App)} returned an empty object from \`getInitialProps\`. This de-optimizes and prevents automatic static optimization. https://nextjs.org/docs/messages/empty-object-getInitialProps`);
2709        }
2710    }
2711    return props;
2712}
2713const SP = typeof performance !== 'undefined';
2714const ST = SP && [
2715    'mark',
2716    'measure',
2717    'getEntriesByName'
2718].every((method)=>typeof performance[method] === 'function');
2719class DecodeError extends Error {
2720}
2721class NormalizeError extends Error {
2722}
2723class PageNotFoundError extends Error {
2724    constructor(page){
2725        super();
2726        this.code = 'ENOENT';
2727        this.name = 'PageNotFoundError';
2728        this.message = `Cannot find module for page: ${page}`;
2729    }
2730}
2731class MissingStaticPage extends Error {
2732    constructor(page, message){
2733        super();
2734        this.message = `Failed to load static file for page: ${page} ${message}`;
2735    }
2736}
2737class MiddlewareNotFoundError extends Error {
2738    constructor(){
2739        super();
2740        this.code = 'ENOENT';
2741        this.message = `Cannot find the middleware module`;
2742    }
2743}
2744function stringifyError(error) {
2745    return JSON.stringify({
2746        message: error.message,
2747        stack: error.stack
2748    });
2749}
2750}),
2751"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/router/utils/querystring.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
2752"use strict";
2753
2754Object.defineProperty(exports, "__esModule", {
2755    value: true
2756});
27570 && (module.exports = {
2758    assign: null,
2759    searchParamsToUrlQuery: null,
2760    urlQueryToSearchParams: null
2761});
2762function _export(target, all) {
2763    for(var name in all)Object.defineProperty(target, name, {
2764        enumerable: true,
2765        get: all[name]
2766    });
2767}
2768_export(exports, {
2769    assign: function() {
2770        return assign;
2771    },
2772    searchParamsToUrlQuery: function() {
2773        return searchParamsToUrlQuery;
2774    },
2775    urlQueryToSearchParams: function() {
2776        return urlQueryToSearchParams;
2777    }
2778});
2779function searchParamsToUrlQuery(searchParams) {
2780    const query = {};
2781    for (const [key, value] of searchParams.entries()){
2782        const existing = query[key];
2783        if (typeof existing === 'undefined') {
2784            query[key] = value;
2785        } else if (Array.isArray(existing)) {
2786            existing.push(value);
2787        } else {
2788            query[key] = [
2789                existing,
2790                value
2791            ];
2792        }
2793    }
2794    return query;
2795}
2796function stringifyUrlQueryParam(param) {
2797    if (typeof param === 'string') {
2798        return param;
2799    }
2800    if (typeof param === 'number' && !isNaN(param) || typeof param === 'boolean') {
2801        return String(param);
2802    } else {
2803        return '';
2804    }
2805}
2806function urlQueryToSearchParams(query) {
2807    const searchParams = new URLSearchParams();
2808    for (const [key, value] of Object.entries(query)){
2809        if (Array.isArray(value)) {
2810            for (const item of value){
2811                searchParams.append(key, stringifyUrlQueryParam(item));
2812            }
2813        } else {
2814            searchParams.set(key, stringifyUrlQueryParam(value));
2815        }
2816    }
2817    return searchParams;
2818}
2819function assign(target, ...searchParamsList) {
2820    for (const searchParams of searchParamsList){
2821        for (const key of searchParams.keys()){
2822            target.delete(key);
2823        }

2824        for (const [key, value] of searchParams.entries()){
2825            target.append(key, value);
2826        }
2827    }
2828    return target;
2829}
2830}),
2831"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/router/utils/parse-relative-url.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
2832"use strict";
2833
2834Object.defineProperty(exports, "__esModule", {
2835    value: true
2836});
2837Object.defineProperty(exports, "parseRelativeUrl", {
2838    enumerable: true,
2839    get: function() {
2840        return parseRelativeUrl;
2841    }
2842});
2843const _utils = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/utils.js [app-client] (ecmascript)");
2844const _querystring = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/router/utils/querystring.js [app-client] (ecmascript)");
2845function parseRelativeUrl(url, base, parseQuery = true) {
2846    const globalBase = new URL(typeof window === 'undefined' ? 'http://n' : (0, _utils.getLocationOrigin)());
2847    const resolvedBase = base ? new URL(base, globalBase) : url.startsWith('.') ? new URL(typeof window === 'undefined' ? 'http://n' : window.location.href) : globalBase;
2848    const { pathname, searchParams, search, hash, href, origin } = url.startsWith('/') ? // Not using `origin` to support other protocols
2849    new URL(`${resolvedBase.protocol}//${resolvedBase.host}${url}`) : new URL(url, resolvedBase);
2850    if (origin !== globalBase.origin) {
2851        throw Object.defineProperty(new Error(`invariant: invalid relative URL, router received ${url}`), "__NEXT_ERROR_CODE", {
2852            value: "E159",
2853            enumerable: false,
2854            configurable: true
2855        });
2856    }
2857    return {
2858        auth: null,
2859        host: null,
2860        hostname: null,
2861        pathname,
2862        port: null,
2863        protocol: null,
2864        query: parseQuery ? (0, _querystring.searchParamsToUrlQuery)(searchParams) : undefined,
2865        search,
2866        hash,
2867        href: href.slice(origin.length),
2868        // We don't know for relative URLs at this point since we set a custom, internal
2869        // base that isn't surfaced to users.
2870        slashes: null
2871    };
2872}
2873}),
2874"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/instant-validation/instant-validation-error.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
2875"use strict";
2876
2877Object.defineProperty(exports, "__esModule", {
2878    value: true
2879});
28800 && (module.exports = {
2881    InstantValidationError: null,
2882    isInstantValidationError: null
2883});
2884function _export(target, all) {
2885    for(var name in all)Object.defineProperty(target, name, {
2886        enumerable: true,
2887        get: all[name]
2888    });
2889}
2890_export(exports, {
2891    InstantValidationError: function() {
2892        return InstantValidationError;
2893    },
2894    isInstantValidationError: function() {
2895        return isInstantValidationError;
2896    }
2897});
2898const INSTANT_VALIDATION_ERROR_DIGEST = 'INSTANT_VALIDATION_ERROR';
2899function isInstantValidationError(err) {
2900    return !!(err && typeof err === 'object' && err instanceof Error && err.digest === INSTANT_VALIDATION_ERROR_DIGEST);
2901}
2902class InstantValidationError extends Error {
2903    constructor(...args){
2904        super(...args), this.digest = INSTANT_VALIDATION_ERROR_DIGEST;
2905    }
2906}
2907}),
2908"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/instant-validation/instant-samples.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
2909"use strict";
2910
2911Object.defineProperty(exports, "__esModule", {
2912    value: true
2913});
29140 && (module.exports = {
2915    assertRootParamInSamples: null,
2916    createCookiesFromSample: null,
2917    createDraftModeForValidation: null,
2918    createExhaustiveParamsProxy: null,
2919    createExhaustiveSearchParamsProxy: null,
2920    createExhaustiveURLSearchParamsProxy: null,

2921    createHeadersFromSample: null,
2922    createRelativeURLFromSamples: null,
2923    createValidationSampleTracking: null,
2924    trackMissingSampleError: null,
2925    trackMissingSampleErrorAndThrow: null
2926});
2927function _export(target, all) {
2928    for(var name in all)Object.defineProperty(target, name, {
2929        enumerable: true,
2930        get: all[name]
2931    });
2932}
2933_export(exports, {
2934    assertRootParamInSamples: function() {
2935        return assertRootParamInSamples;
2936    },
2937    createCookiesFromSample: function() {
2938        return createCookiesFromSample;
2939    },
2940    createDraftModeForValidation: function() {
2941        return createDraftModeForValidation;
2942    },
2943    createExhaustiveParamsProxy: function() {
2944        return createExhaustiveParamsProxy;
2945    },
2946    createExhaustiveSearchParamsProxy: function() {
2947        return createExhaustiveSearchParamsProxy;
2948    },
2949    createExhaustiveURLSearchParamsProxy: function() {
2950        return createExhaustiveURLSearchParamsProxy;
2951    },
2952    createHeadersFromSample: function() {
2953        return createHeadersFromSample;
2954    },
2955    createRelativeURLFromSamples: function() {
2956        return createRelativeURLFromSamples;
2957    },
2958    createValidationSampleTracking: function() {
2959        return createValidationSampleTracking;
2960    },
2961    trackMissingSampleError: function() {
2962        return trackMissingSampleError;
2963    },
2964    trackMissingSampleErrorAndThrow: function() {
2965        return trackMissingSampleErrorAndThrow;
2966    }
2967});
2968const _cookies = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/cookies.js [app-client] (ecmascript)");
2969const _requestcookies = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js [app-client] (ecmascript)");
2970const _headers = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapters/headers.js [app-client] (ecmascript)");
2971const _getsegmentparam = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/router/utils/get-segment-param.js [app-client] (ecmascript)");
2972const _parserelativeurl = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/router/utils/parse-relative-url.js [app-client] (ecmascript)");
2973const _invarianterror = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/invariant-error.js [app-client] (ecmascript)");
2974const _instantvalidationerror = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/instant-validation/instant-validation-error.js [app-client] (ecmascript)");
2975const _workunitasyncstorageexternal = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/work-unit-async-storage.external.js [app-client] (ecmascript)");
2976const _reflectutils = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)");
2977function createValidationSampleTracking() {
2978    return {
2979        missingSampleErrors: []
2980    };
2981}
2982function getExpectedSampleTracking() {
2983    let validationSampleTracking = null;
2984    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
2985    if (workUnitStore) {
2986        switch(workUnitStore.type){
2987            case 'request':
2988            case 'validation-client':
2989                // TODO(instant-validation-build): do we need any special handling for caches?
2990                validationSampleTracking = workUnitStore.validationSampleTracking ?? null;
2991                break;
2992            case 'cache':
2993            case 'private-cache':
2994            case 'unstable-cache':
2995            case 'prerender-legacy':
2996            case 'prerender-ppr':
2997            case 'prerender-client':
2998            case 'prerender':
2999            case 'prerender-runtime':
3000            case 'generate-static-params':
3001                break;
3002            default:
3003                workUnitStore;
3004        }
3005    }
3006    if (!validationSampleTracking) {
3007        throw Object.defineProperty(new _invarianterror.InvariantError('Expected to have a workUnitStore that provides validationSampleTracking'), "__NEXT_ERROR_CODE", {
3008            value: "E1110",
3009            enumerable: false,
3010            configurable: true
3011        });
3012    }
3013    return validationSampleTracking;
3014}
3015function trackMissingSampleError(error) {
3016    const validationSampleTracking = getExpectedSampleTracking();
3017    validationSampleTracking.missingSampleErrors.push(error);
3018}
3019function trackMissingSampleErrorAndThrow(error) {
3020    // TODO(instant-validation-build): this should abort the render
3021    trackMissingSampleError(error);
3022    throw error;
3023}
3024function createCookiesFromSample(sampleCookies, route) {
3025    const declaredNames = new Set();
3026    const cookies = new _cookies.RequestCookies(new Headers());
3027    if (sampleCookies) {
3028        for (const cookie of sampleCookies){
3029            declaredNames.add(cookie.name);
3030            if (cookie.value !== null) {
3031                cookies.set(cookie.name, cookie.value);
3032            }
3033        }
3034    }
3035    const sealed = _requestcookies.RequestCookiesAdapter.seal(cookies);
3036    return new Proxy(sealed, {
3037        get (target, prop, receiver) {
3038            if (prop === 'has') {
3039                const originalMethod = Reflect.get(target, prop, receiver);
3040                const wrappedMethod = function(name) {
3041                    if (!declaredNames.has(name)) {
3042                        trackMissingSampleErrorAndThrow(createMissingCookieSampleError(route, name));
3043                    }
3044                    return originalMethod.call(target, name);
3045                };
3046                return wrappedMethod;
3047            }
3048            if (prop === 'get') {
3049                const originalMethod = Reflect.get(target, prop, receiver);
3050                const wrappedMethod = function(nameOrCookie) {
3051                    let name;
3052                    if (typeof nameOrCookie === 'string') {
3053                        name = nameOrCookie;
3054                    } else if (nameOrCookie && typeof nameOrCookie === 'object' && typeof nameOrCookie.name === 'string') {
3055                        name = nameOrCookie.name;
3056                    } else {

3057                        // This is an invalid input. Pass it through to the original method so it can error.
3058                        return originalMethod.call(target, nameOrCookie);
3059                    }
3060                    if (!declaredNames.has(name)) {
3061                        trackMissingSampleErrorAndThrow(createMissingCookieSampleError(route, name));
3062                    }
3063                    return originalMethod.call(target, name);
3064                };
3065                return wrappedMethod;
3066            }
3067            // TODO(instant-validation-build): what should getAll do?
3068            // Maybe we should only allow it if there's an array (possibly empty?)
3069            return Reflect.get(target, prop, receiver);
3070        }
3071    });
3072}
3073function createMissingCookieSampleError(route, name) {
3074    return Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed cookie "${name}" which is not defined in the \`samples\` ` + `of \`unstable_instant\`. Add it to the sample's \`cookies\` array, ` + `or \`{ name: "${name}", value: null }\` if it should be absent.`), "__NEXT_ERROR_CODE", {
3075        value: "E1115",
3076        enumerable: false,
3077        configurable: true
3078    });
3079}
3080function createHeadersFromSample(rawSampleHeaders, sampleCookies, route) {
3081    // If we have cookie samples, add a `cookie` header to match.
3082    // Accessing it will be implicitly allowed by the proxy --
3083    // if the user defined some cookies, accessing the "cookie" header is also fine.
3084    const sampleHeaders = rawSampleHeaders ? [
3085        ...rawSampleHeaders
3086    ] : [];
3087    if (sampleHeaders.find(([name])=>name.toLowerCase() === 'cookie')) {

3088        throw Object.defineProperty(new _instantvalidationerror.InstantValidationError('Invalid sample: Defining cookies via a "cookie" header is not supported. Use `cookies: [{ name: ..., value: ... }]` instead.'), "__NEXT_ERROR_CODE", {
3089            value: "E1111",
3090            enumerable: false,
3091            configurable: true
3092        });
3093    }
3094    if (sampleCookies) {
3095        const cookieHeaderValue = sampleCookies.toString();
3096        sampleHeaders.push([
3097            'cookie',
3098            // if the `cookies` samples were empty, or they were all `null`, then we have no cookies,
3099            // and the header isn't present, but should remains readable, so we set it to null.
3100            cookieHeaderValue !== '' ? cookieHeaderValue : null
3101        ]);
3102    }
3103    const declaredNames = new Set();
3104    const headersInit = {};
3105    for (const [name, value] of sampleHeaders){
3106        declaredNames.add(name.toLowerCase());
3107        if (value !== null) {
3108            headersInit[name.toLowerCase()] = value;
3109        }
3110    }
3111    const sealed = _headers.HeadersAdapter.seal(_headers.HeadersAdapter.from(headersInit));
3112    return new Proxy(sealed, {
3113        get (target, prop, receiver) {
3114            if (prop === 'get' || prop === 'has') {
3115                const originalMethod = Reflect.get(target, prop, receiver);
3116                const patchedMethod = function(rawName) {
3117                    const name = rawName.toLowerCase();
3118                    if (!declaredNames.has(name)) {
3119                        trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantval

3119idationerror.InstantValidationError(`Route "${route}" accessed header "${name}" which is not defined in the \`samples\` ` + `of \`unstable_instant\`. Add it to the sample's \`headers\` array, ` + `or \`["${name}", null]\` if it should be absent.`), "__NEXT_ERROR_CODE", {
3120                            value: "E1116",
3121                            enumerable: false,
3122                            configurable: true
3123                        }));
3124                    }
3125                    // typescript can't reconcile a union of functions with a union of return types,
3126                    // so we have to cast the original return type away
3127                    return originalMethod.call(target, name);
3128                };
3129                return patchedMethod;
3130            }
3131            return Reflect.get(target, prop, receiver);
3132        }
3133    });
3134}
3135function createDraftModeForValidation() {
3136    // Create a minimal DraftModeProvider-compatible object
3137    // that always reports draft mode as disabled.
3138    //
3139    // private properties that can't be set from outside the class.
3140    return {
3141        get isEnabled () {
3142            return false;
3143        },
3144        enable () {
3145            throw Object.defineProperty(new Error('Draft mode cannot be enabled during build-time instant validation.'), "__NEXT_ERROR_CODE", {
3146                value: "E1092",
3147                enumerable: false,
3148                configurable: true
3149            });
3150        },
3151        disable () {
3152            throw Object.defineProperty(new Error('Draft mode cannot be disabled during build-time instant validation.'), "__NEXT_ERROR_CODE", {
3153                value: "E1094",
3154                enumerable: false,
3155                configurable: true
3156            });
3157        }
3158    };
3159}
3160function createExhaustiveParamsProxy(underlyingParams, declaredParamNames, route) {
3161    return new Proxy(underlyingParams, {
3162        get (target, prop, receiver) {
3163            if (typeof prop === 'string' && !_reflectutils.wellKnownProperties.has(prop) && // Only error when accessing a param that is part of the route but wasn't provided.
3164            // accessing properties that aren't expected to be a valid param value is fine.
3165            prop in underlyingParams && !declaredParamNames.has(prop)) {
3166                trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantval

3166idationerror.InstantValidationError(`Route "${route}" accessed param "${prop}" which is not defined in the \`samples\` ` + `of \`unstable_instant\`. Add it to the sample's \`params\` object.`), "__NEXT_ERROR_CODE", {
3167                    value: "E1095",
3168                    enumerable: false,
3169                    configurable: true
3170                }));
3171            }
3172            return Reflect.get(target, prop, receiver);
3173        }
3174    });
3175}
3176function createExhaustiveSearchParamsProxy(searchParams, declaredSearchParamNames, route) {
3177    return new Proxy(searchParams, {
3178        get (target, prop, receiver) {
3179            if (typeof prop === 'string' && !_reflectutils.wellKnownProperties.has(prop) && !declaredSearchParamNames.has(prop)) {
3180                trackMissingSampleErrorAndThrow(createMissingSearchParamSampleError(route, prop));
3181            }
3182            return Reflect.get(target, prop, receiver);
3183        },
3184        has (target, prop) {
3185            if (typeof prop === 'string' && !_reflectutils.wellKnownProperties.has(prop) && !declaredSearchParamNames.has(prop)) {
3186                trackMissingSampleErrorAndThrow(createMissingSearchParamSampleError(route, prop));
3187            }
3188            return Reflect.has(target, prop);
3189        }
3190    });
3191}
3192function createExhaustiveURLSearchParamsProxy(searchParams, declaredSearchParamNames, route) {
3193    return new Proxy(searchParams, {
3194        get (target, prop, receiver) {
3195            // Intercept method calls that access specific param names
3196            if (prop === 'get' || prop === 'getAll' || prop === 'has') {
3197                const originalMathod = Reflect.get(target, prop, receiver);
3198                return (name)=>{
3199                    if (typeof name === 'string' && !declaredSearchParamNames.has(name)) {
3200                        trackMissingSampleErrorAndThrow(createMissingSearchParamSampleError(route, name));
3201                    }
3202                    return originalMathod.call(target, name);
3203                };
3204            }
3205            const value = Reflect.get(target, prop, receiver);
3206            // Prevent `TypeError: Value of "this" must be of type URLSearchParams` for methods
3207            if (typeof value === 'function' && !Object.hasOwn(target, prop)) {
3208                return value.bind(target);
3209            }
3210            return value;
3211        }
3212    });
3213}
3214function createMissingSearchParamSampleError(route, name) {

3215    return Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed searchParam "${name}" which is not defined in the \`samples\` ` + `of \`unstable_instant\`. Add it to the sample's \`searchParams\` object, ` + `or \`{ "${name}": null }\` if it should be absent.`), "__NEXT_ERROR_CODE", {
3216        value: "E1098",
3217        enumerable: false,
3218        configurable: true
3219    });
3220}
3221function createRelativeURLFromSamples(route, sampleParams, sampleSearchParams) {
3222    // Build searchParams query object and URL search string from sample
3223    const pathname = createPathnameFromRouteAndSampleParams(route, sampleParams ?? {});
3224    let search = '';
3225    if (sampleSearchParams) {
3226        const qs = createURLSearchParamsFromSample(sampleSearchParams).toString();
3227        if (qs) {
3228            search = '?' + qs;
3229        }
3230    }
3231    return (0, _parserelativeurl.parseRelativeUrl)(pathname + search, undefined, true);
3232}
3233function createURLSearchParamsFromSample(sampleSearchParams) {
3234    const result = new URLSearchParams();
3235    if (sampleSearchParams) {
3236        for (const [key, value] of Object.entries(sampleSearchParams)){
3237            if (value === null || value === undefined) continue;
3238            if (Array.isArray(value)) {
3239                for (const v of value){
3240                    result.append(key, v);
3241                }
3242            } else {
3243                result.set(key, value);
3244            }
3245        }
3246    }
3247    return result;
3248}
3249/**
3250 * Substitute sample params into `workStore.route` to create a plausible pathname.
3251 * TODO(instant-validation-build): this logic is somewhat hacky and likely incomplete,
3252 * but it should be good enough for some initial testing.
3253 */ function createPathnameFromRouteAndSampleParams(route, params) {
3254    let interpolatedSegments = [];
3255    const rawSegments = route.split('/');
3256    for (const rawSegment of rawSegments){
3257        const param = (0, _getsegmentparam.getSegmentParam)(rawSegment);
3258        if (param) {
3259            switch(param.paramType){
3260                case 'catchall':
3261                case 'optional-catchall':
3262                    {
3263                        let paramValue = params[param.paramName];
3264                        if (paramValue === undefined) {
3265                            // The value for the param was not provided. `usePathname` will detect this and throw
3266                            // before this can surface to userspace. Use `[...NAME]` as a placeholder for the param value
3267                            // in case it pops up somewhere unexpectedly.
3268                            paramValue = [
3269                                rawSegment
3270                            ];
3271                        } else if (!Array.isArray(paramValue)) {
3272                            // NOTE: this happens outside of render, so we don't need `trackMissingSampleErrorAndThrow`
3273                            throw Object.defineProperty(new _instantval

3273idationerror.InstantValidationError(`Expected sample param value for segment '${rawSegment}' to be an array of strings, got ${typeof paramValue}`), "__NEXT_ERROR_CODE", {
3274                                value: "E1104",
3275                                enumerable: false,
3276                                configurable: true
3277                            });
3278                        }
3279                        interpolatedSegments.push(...paramValue.map((v)=>encodeURIComponent(v)));
3280                        break;
3281                    }
3282                case 'dynamic':
3283                    {
3284                        let paramValue = params[param.paramName];
3285                        if (paramValue === undefined) {
3286                            // The value for the param was not provided. `usePathname` will detect this and throw
3287                            // before this can surface to userspace. Use `[NAME]` as a placeholder for the param value
3288                            // in case it pops up somewhere unexpectedly.
3289                            paramValue = rawSegment;
3290                        } else if (typeof paramValue !== 'string') {
3291                            // NOTE: this happens outside of render, so we don't need `trackMissingSampleErrorAndThrow`
3292                            throw Object.defineProperty(new _instantval

3292idationerror.InstantValidationError(`Expected sample param value for segment '${rawSegment}' to be a string, got ${typeof paramValue}`), "__NEXT_ERROR_CODE", {
3293                                value: "E1108",
3294                                enumerable: false,
3295                                configurable: true
3296                            });
3297                        }
3298                        interpolatedSegments.push(encodeURIComponent(paramValue));
3299                        break;
3300                    }
3301                case 'catchall-intercepted-(..)(..)':
3302                case 'catchall-intercepted-(.)':
3303                case 'catchall-intercepted-(..)':
3304                case 'catchall-intercepted-(...)':
3305                case 'dynamic-intercepted-(..)(..)':
3306                case 'dynamic-intercepted-(.)':
3307                case 'dynamic-intercepted-(..)':
3308                case 'dynamic-intercepted-(...)':
3309                    {
3310                        // TODO(instant-validation-build): i don't know how these are supposed to work, or if we can even get them here
3311                        throw Object.defineProperty(new _invarianterror.InvariantError('Not implemented: Validation of interception routes'), "__NEXT_ERROR_CODE", {
3312                            value: "E1106",
3313                            enumerable: false,
3314                            configurable: true
3315                        });
3316                    }
3317                default:
3318                    {
3319                        param.paramType;
3320                    }
3321            }
3322        } else {
3323            interpolatedSegments.push(rawSegment);
3324        }
3325    }
3326    return interpolatedSegments.join('/');
3327}
3328function assertRootParamInSamples(workStore, sampleParams, paramName) {
3329    if (sampleParams && paramName in sampleParams) {
3330    // The param is defined in the samples.
3331    } else {
3332        const route = workStore.route;
3333        trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantval

3333idationerror.InstantValidationError(`Route "${route}" accessed root param "${paramName}" which is not defined in the \`samples\` ` + `of \`unstable_instant\`. Add it to the sample's \`params\` object.`), "__NEXT_ERROR_CODE", {
3334            value: "E1114",
3335            enumerable: false,
3336            configurable: true
3337        }));
3338    }
3339}
3340}),
3341"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/request/search-params.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
3342"use strict";
3343
3344var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$2$2e$2_$40$babel$2b$core$40$7$2e$29$2e$0_react$2d$dom$40$19$2e$2$2e$4_react$40$19$2e$2$2e$4_$5f$react$40$19$2e$2$2e$4$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
3345"use strict";
3346Object.defineProperty(exports, "__esModule", {
3347    value: true
3348});
33490 && (module.exports = {
3350    createPrerenderSearchParamsForClientPage: null,
3351    createSearchParamsFromClient: null,
3352    createServerSearchParamsForMetadata: null,
3353    createServerSearchParamsForServerPage: null,
3354    makeErroringSearchParamsForUseCache: null
3355});
3356function _export(target, all) {
3357    for(var name in all)Object.defineProperty(target, name, {
3358        enumerable: true,
3359        get: all[name]
3360    });
3361}
3362_export(exports, {
3363    createPrerenderSearchParamsForClientPage: function() {
3364        return createPrerenderSearchParamsForClientPage;
3365    },
3366    createSearchParamsFromClient: function() {
3367        return createSearchParamsFromClient;
3368    },
3369    createServerSearchParamsForMetadata: function() {
3370        return createServerSearchParamsForMetadata;
3371    },
3372    createServerSearchParamsForServerPage: function() {
3373        return createServerSearchParamsForServerPage;
3374    },
3375    makeErroringSearchParamsForUseCache: function() {
3376        return makeErroringSearchParamsForUseCache;
3377    }
3378});
3379const _workasyncstorageexternal = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/work-async-storage.external.js [app-client] (ecmascript)");
3380const _varyparams = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/vary-params.js [app-client] (ecmascript)");
3381const _reflect = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)");
3382const _dynamicrendering = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/dynamic-rendering.js [app-client] (ecmascript)");
3383const _workunitasyncstorageexternal = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/work-unit-async-storage.external.js [app-client] (ecmascript)");
3384const _invarianterror = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/invariant-error.js [app-client] (ecmascript)");
3385const _dynamicrenderingutils = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/dynamic-rendering-utils.js [app-client] (ecmascript)");
3386const _creatededupedbycallsiteservererrorlogger = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js [app-client] (ecmascript)");
3387const _reflectutils = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)");
3388const _utils = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/request/utils.js [app-client] (ecmascript)");
3389const _stagedrendering = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/staged-rendering.js [a

3389pp-client] (ecmascript)");
3390function createSearchParamsFromClient(underlyingSearchParams) {
3391    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
3392    if (!workStore) {
3393        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
3394            value: "E1068",
3395            enumerable: false,
3396            configurable: true
3397        });
3398    }
3399    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
3400    if (workUnitStore) {
3401        switch(workUnitStore.type){
3402            case 'prerender':
3403            case 'prerender-client':
3404            case 'prerender-ppr':
3405            case 'prerender-legacy':
3406                return createStaticPrerenderSearchParams(workStore, workUnitStore);
3407            case 'validation-client':
3408                {
3409                    return createClientSearchParamsInValidation(underlyingSearchParams, workStore, workUnitStore);
3410                }
3411            case 'prerender-runtime':
3412                throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
3413                    value: "E769",
3414                    enumerable: false,
3415                    configurable: true
3416                });
3417            case 'cache':
3418            case 'private-cache':
3419            case 'unstable-cache':
3420                throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
3421                    value: "E739",
3422                    enumerable: false,
3423                    configurable: true
3424                });
3425            case 'generate-static-params':
3426                throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
3427                    value: "E1133",
3428                    enumerable: false,
3429                    configurable: true
3430                });
3431            case 'request':
3432                // Client searchParams are not runtime prefetchable
3433                const isRuntimePrefetchable = false;
3434                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore, isRuntimePrefetchable);
3435            default:
3436                workUnitStore;
3437        }
3438    }
3439    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
3440}
3441function createServerSearchParamsForMetadata(underlyingSearchParams, isRuntimePrefetchable) {
3442    const metadataVaryParamsAccumulator = (0, _varyparams.getMetadataVaryParamsAccumulator)();
3443    return createServerSearchParamsForServerPage(underlyingSearchParams, metadataVaryParamsAccumulator, isRuntimePrefetchable);
3444}
3445function createServerSearchParamsForServerPage(underlyingSearchParams, varyParamsAccumulator, isRuntimePrefetchable) {
3446    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
3447    if (!workStore) {
3448        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
3449            value: "E1068",
3450            enumerable: false,
3451            configurable: true
3452        });
3453    }
3454    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
3455    if (workUnitStore) {
3456        switch(workUnitStore.type){
3457            case 'prerender':
3458            case 'prerender-client':
3459            case 'prerender-ppr':
3460            case 'prerender-legacy':
3461                return createStaticPrerenderSearchParams(workStore, workUnitStore);
3462            case 'validation-client':
3463                throw Object.defineProperty(new _invarianterror.InvariantError('createServerSearchParamsForServerPage should not be called in a client validation.'), "__NEXT_ERROR_CODE", {
3464                    value: "E1066",
3465                    enumerable: false,
3466                    configurable: true
3467                });
3468            case 'cache':
3469            case 'private-cache':
3470            case 'unstable-cache':
3471                throw Object.defineProperty(new _invarianterror.InvariantError('createServerSearchParamsForServerPage should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
3472                    value: "E747",
3473                    enumerable: false,
3474                    configurable: true
3475                });
3476            case 'generate-static-params':
3477                throw Object.defineProperty(new _invarianterror.InvariantError('createServerSearchParamsForServerPage should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
3478                    value: "E1128",
3479                    enumerable: false,
3480                    configurable: true
3481                });
3482            case 'prerender-runtime':

3483                return createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
3484            case 'request':
3485                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore, isRuntimePrefetchable);
3486            default:
3487                workUnitStore;
3488        }
3489    }
3490    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
3491}
3492function createPrerenderSearchParamsForClientPage() {
3493    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
3494    if (!workStore) {
3495        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
3496            value: "E1068",
3497            enumerable: false,
3498            configurable: true
3499        });
3500    }
3501    if (workStore.forceStatic) {
3502        // When using forceStatic we override all other logic and always just return an empty
3503        // dictionary object.
3504        return Promise.resolve({});
3505    }
3506    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
3507    if (workUnitStore) {
3508        switch(workUnitStore.type){
3509            case 'prerender':
3510            case 'prerender-client':
3511                // We're prerendering in a mode that aborts (cacheComponents) and should stall
3512                // the promise to ensure the RSC side is considered dynamic
3513                return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`searchParams`');
3514            case 'validation-client':
3515                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in a client validation.'), "__NEXT_ERROR_CODE", {
3516                    value: "E1061",
3517                    enumerable: false,
3518                    configurable: true
3519                });
3520            case 'prerender-runtime':
3521                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
3522                    value: "E768",
3523                    enumerable: false,
3524                    configurable: true
3525                });
3526            case 'cache':
3527            case 'private-cache':
3528            case 'unstable-cache':
3529                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
3530                    value: "E746",
3531                    enumerable: false,
3532                    configurable: true
3533                });
3534            case 'generate-static-params':
3535                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
3536                    value: "E1124",
3537                    enumerable: false,
3538                    configurable: true
3539                });
3540            case 'prerender-ppr':
3541            case 'prerender-legacy':
3542            case 'request':
3543                return Promise.resolve({});
3544            default:
3545                workUnitStore;
3546        }
3547    }
3548    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
3549}
3550function createStaticPrerenderSearchParams(workStore, prerenderStore) {
3551    if (workStore.forceStatic) {
3552        // When using forceStatic we override all other logic and always just return an empty
3553        // dictionary object.
3554        return Promise.resolve({});
3555    }
3556    switch(prerenderStore.type){
3557        case 'prerender':
3558        case 'prerender-client':
3559            // We are in a cacheComponents (PPR or otherwise) prerender
3560            return makeHangingSearchParams(workStore, prerenderStore);
3561        case 'prerender-ppr':
3562        case 'prerender-legacy':
3563            // We are in a legacy static generation and need to interrupt the
3564            // prerender when search params are accessed.
3565            return makeErroringSearchParams(workStore, prerenderStore);
3566        default:
3567            return prerenderStore;
3568    }
3569}

3570function createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable) {
3571    const underlyingSearchParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingSearchParams)(varyParamsAccumulator, underlyingSearchParams) : underlyingSearchParams;
3572    const result = makeUntrackedSearchParams(underlyingSearchParamsWithVarying);
3573    const { stagedRendering } = workUnitStore;
3574    if (!stagedRendering) {
3575        return result;
3576    }
3577    const stage = isRuntimePrefetchable ? _stagedrendering.RenderStage.EarlyRuntime : _stagedrendering.RenderStage.Runtime;
3578    return stagedRendering.waitForStage(stage).then(()=>result);
3579}
3580function createRenderSearchParams(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable) {
3581    if (workStore.forceStatic) {
3582        // When using forceStatic we override all other logic and always just return an empty
3583        // dictionary object.
3584        return Promise.resolve({});
3585    } else {
3586        if ("TURBOPACK compile-time truthy", 1) {
3587            // Semantically we only need the dev tracking when running in `next dev`
3588            // but since you would never use next dev with production NODE_ENV we use this
3589            // as a proxy so we can statically exclude this code from production builds.
3590            return makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable);
3591        } else //TURBOPACK unreachable
3592        ;
3593    }
3594}
3595const CachedSearchParams = new WeakMap();
3596const CachedSearchParamsForUseCache = new WeakMap();
3597function makeHangingSearchParams(workStore, prerenderStore) {
3598    const cachedSearchParams = CachedSearchParams.get(prerenderStore);
3599    if (cachedSearchParams) {
3600        return cachedSearchParams;
3601    }
3602    const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`searchParams`');
3603    const proxiedPromise = new Proxy(promise, {
3604        get (target, prop, receiver) {
3605            if (Object.hasOwn(promise, prop)) {
3606                // The promise has this property directly. we must return it.
3607                // We know it isn't a dynamic access because it can only be something
3608                // that was previously written to the promise and thus not an underlying searchParam value
3609                return _reflect.ReflectAdapter.get(target, prop, receiver);
3610            }
3611            switch(prop){
3612                case 'then':
3613                    {
3614                        const expression = '`await searchParams`, `searchParams.then`, or similar';
3615                        (0, _dynamicrendering.annotateDynamicAccess)(expression, prerenderStore);
3616                        return _reflect.ReflectAdapter.get(target, prop, receiver);
3617                    }
3618                case 'status':
3619                    {
3620                        const expression = '`use(searchParams)`, `searchParams.status`, or similar';
3621                        (0, _dynamicrendering.annotateDynamicAccess)(expression, prerenderStore);
3622                        return _reflect.ReflectAdapter.get(target, prop, receiver);
3623                    }
3624                default:
3625                    {
3626                        return _reflect.ReflectAdapter.get(target, prop, receiver);
3627                    }
3628            }
3629        }
3630    });
3631    CachedSearchParams.set(prerenderStore, proxiedPromise);
3632    return proxiedPromise;
3633}
3634function makeErroringSearchParams(workStore, prerenderStore) {
3635    const cachedSearchParams = CachedSearchParams.get(workStore);
3636    if (cachedSearchParams) {
3637        return cachedSearchParams;
3638    }
3639    const underlyingSearchParams = {};
3640    // For search params we don't construct a ReactPromise because we want to interrupt
3641    // rendering on any property access that was not set from outside and so we only want
3642    // to have properties like value and status if React sets them.
3643    const promise = Promise.resolve(underlyingSearchParams);
3644    const proxiedPromise = new Proxy(promise, {
3645        get (target, prop, receiver) {
3646            if (Object.hasOwn(promise, prop)) {
3647                // The promise has this property directly. we must return it.
3648                // We know it isn't a dynamic access because it can only be something
3649                // that was previously written to the promise and thus not an underlying searchParam value
3650                return _reflect.ReflectAdapter.get(target, prop, receiver);
3651            }
3652            if (typeof prop === 'string' && prop === 'then') {
3653                const expression = '`await searchParams`, `searchParams.then`, or similar';
3654                if (workStore.dynamicShouldError) {
3655                    (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
3656                } else if (prerenderStore.type === 'prerender-ppr') {
3657                    // PPR Prerender (no cacheComponents)
3658                    (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
3659                } else {
3660                    // Legacy Prerender
3661                    (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
3662                }
3663            }
3664            return _reflect.ReflectAdapter.get(target, prop, receiver);
3665        }
3666    });
3667    CachedSearchParams.set(workStore, proxiedPromise);
3668    return proxiedPromise;
3669}
3670function makeErroringSearchParamsForUseCache() {
3671    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
3672    if (!workStore) {
3673        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
3674            value: "E1068",
3675            enumerable: false,
3676            configurable: true
3677        });
3678    }
3679    const cachedSearchParams = CachedSearchParamsForUseCache.get(workStore);
3680    if (cachedSearchParams) {
3681        return cachedSearchParams;
3682    }
3683    const promise = Promise.resolve({});
3684    const proxiedPromise = new Proxy(promise, {
3685        get: function get(target, prop, receiver) {
3686            if (Object.hasOwn(promise, prop)) {
3687                // The promise has this property directly. we must return it. We know it
3688                // isn't a dynamic access because it can only be something that was
3689                // previously written to the promise and thus not an underlying
3690                // searchParam value
3691                return _reflect.ReflectAdapter.get(target, prop, receiver);
3692            }
3693            if (typeof prop === 'string' && (prop === 'then' || !_reflectutils.wellKnownProperties.has(prop))) {
3694                (0, _utils.throwForSearchParamsAccessInUseCache)(workStore, get);
3695            }
3696            return _reflect.ReflectAdapter.get(target, prop, receiver);
3697        }
3698    });
3699    CachedSearchParamsForUseCache.set(workStore, proxiedPromise);
3700    return proxiedPromise;
3701}
3702function makeUntrackedSearchParams(underlyingSearchParams) {
3703    const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
3704    if (cachedSearchParams) {
3705        return cachedSearchParams;
3706    }
3707    const promise = Promise.resolve(underlyingSearchParams);
3708    CachedSearchParams.set(underlyingSearchParams, promise);
3709    return promise;
3710}
3711function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable) {
3712    if (requestStore.asyncApiPromises) {

3713        // Do not cache the resulting promise. If we do, we'll only show the first "awaited at"
3714        // across all segments that receive searchParams.
3715        return makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable);
3716    } else {
3717        const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
3718        if (cachedSearchParams) {
3719            return cachedSearchParams;
3720        }
3721        const promise = makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable);
3722        CachedSearchParams.set(requestStore, promise);
3723        return promise;
3724    }
3725}
3726function makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore, isRuntimePrefetchable) {
3727    const promiseInitialized = {
3728        current: false
3729    };
3730    const proxiedUnderlying = instrumentSearchParamsObjectWithDevWarnings(underlyingSearchParams, workStore, promiseInitialized);
3731    let promise;
3732    if (requestStore.asyncApiPromises) {
3733        // We wrap each instance of searchParams in a `new Promise()`.
3734        // This is important when all awaits are in third party which would otherwise
3735        // track all the way to the internal params.
3736        const sharedSearchParamsParent = isRuntimePrefetchable ? requestStore.asyncApiPromises.earlySharedSearchParamsParent : requestStore.asyncApiPromises.sharedSearchParamsParent;
3737        promise = new Promise((resolve, reject)=>{
3738            sharedSearchParamsParent.then(()=>resolve(proxiedUnderlying), reject);
3739        });
3740        // @ts-expect-error
3741        promise.displayName = 'searchParams';
3742    } else {
3743        promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(proxiedUnderlying, requestStore, _stagedrendering.RenderStage.Runtime);
3744    }
3745    promise.then(()=>{
3746        promiseInitialized.current = true;
3747    }, // is aborted before it can reach the runtime stage.
3748    // In that case, we have to prevent an unhandled rejection from the promise
3749    // created by this `.then()` call.
3750    // This does not affect the `promiseInitialized` logic above,
3751    // because `proxiedUnderlying` will not be used to resolve the promise,
3752    // so there's no risk of any of its properties being accessed and triggering
3753    // an undesireable warning.
3754    ignoreReject);
3755    return instrumentSearchParamsPromiseWithDevWarnings(underlyingSearchParams, promise, workStore);
3756}
3757function ignoreReject() {}
3758function instrumentSearchParamsObjectWithDevWarnings(underlyingSearchParams, workStore, promiseInitialized) {
3759    // We have an unfortunate sequence of events that requires this initialization logic. We want to instrument the underlying
3760    // searchParams object to detect if you are accessing values in dev. This is used for warnings and for things like the static prerender
3761    // indicator. However when we pass this proxy to our Promise.resolve() below the VM checks if the resolved value is a promise by looking
3762    // at the `.then` property. To our dynamic tracking logic this is indistinguishable from a `then` searchParam and so we would normally trigger
3763    // dynamic tracking. However we know that this .then is not real dynamic access, it's just how thenables resolve in sequence. So we introduce
3764    // this initialization concept so we omit the dynamic check until after we've constructed our resolved promise.
3765    return new Proxy(underlyingSearchParams, {
3766        get (target, prop, receiver) {
3767            if (typeof prop === 'string' && promiseInitialized.current) {
3768                if (workStore.dynamicShouldError) {
3769                    const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
3770                    (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
3771                }
3772            }
3773            return _reflect.ReflectAdapter.get(target, prop, receiver);
3774        },
3775        has (target, prop) {
3776            if (typeof prop === 'string') {
3777                if (workStore.dynamicShouldError) {
3778                    const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
3779                    (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
3780                }
3781            }
3782            return Reflect.has(target, prop);
3783        },
3784        ownKeys (target) {
3785            if (workStore.dynamicShouldError) {
3786                const expression = '`{...searchParams}`, `Object.keys(searchParams)`, or similar';
3787                (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
3788            }
3789            return Reflect.ownKeys(target);
3790        }
3791    });
3792}
3793function instrumentSearchParamsPromiseWithDevWarnings(underlyingSearchParams, promise, workStore) {
3794    // Track which properties we should warn for.
3795    const proxiedProperties = new Set();

3796    Object.keys(underlyingSearchParams).forEach((prop)=>{
3797        if (_reflectutils.wellKnownProperties.has(prop)) {
3798        // These properties cannot be shadowed because they need to be the
3799        // true underlying value for Promises to work correctly at runtime
3800        } else {
3801            proxiedProperties.add(prop);
3802        }
3803    });
3804    return new Proxy(promise, {
3805        get (target, prop, receiver) {
3806            if (prop === 'then' && workStore.dynamicShouldError) {
3807                const expression = '`searchParams.then`';
3808                (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
3809            }
3810            if (typeof prop === 'string') {
3811                if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
3812                // the underlying searchParams.
3813                Reflect.has(target, prop) === false)) {
3814                    const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
3815                    warnForSyncAccess(workStore.route, expression);
3816                }
3817            }
3818            return _reflect.ReflectAdapter.get(target, prop, receiver);
3819        },
3820        set (target, prop, value, receiver) {
3821            if (typeof prop === 'string') {
3822                proxiedProperties.delete(prop);
3823            }
3824            return Reflect.set(target, prop, value, receiver);
3825        },
3826        has (target, prop) {
3827            if (typeof prop === 'string') {
3828                if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
3829                // the underlying searchParams.
3830                Reflect.has(target, prop) === false)) {
3831                    const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
3832                    warnForSyncAccess(workStore.route, expression);
3833                }
3834            }
3835            return Reflect.has(target, prop);
3836        },
3837        ownKeys (target) {
3838            const expression = '`Object.keys(searchParams)` or similar';
3839            warnForSyncAccess(workStore.route, expression);
3840            return Reflect.ownKeys(target);
3841        }
3842    });
3843}
3844const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createSearchAccessError);
3845function createSearchAccessError(route, expression) {
3846    const prefix = route ? `Route "${route}" ` : 'This route ';
3847    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`searchParams\` is a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
3848        value: "E848",
3849        enumerable: false,
3850        configurable: true
3851    });
3852}
3853function createClientSearchParamsInValidation(underlyingSearchParams, workStore, workUnitStore) {
3854    var _workUnitStore_validationSamples;
3855    const { createExhaustiveSearchParamsProxy } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/instant-validation/instant-samples.js [app-client] (ecmascript)");
3856    const declaredKeys = new Set(Object.keys(((_workUnitStore_validationSamples = workUnitStore.validationSamples) == null ? void 0 : _workUnitStore_validationSamples.searchParams) ?? {}));
3857    underlyingSearchParams = createExhaustiveSearchParamsProxy(underlyingSearchParams, declaredKeys, workStore.route);
3858    return Promise.resolve(underlyingSearchParams);
3859}
3860}),
3861"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/dynamic-access-async-storage-instance.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
3862"use strict";
3863
3864Object.defineProperty(exports, "__esModule", {
3865    value: true
3866});
3867Object.defineProperty(exports, "dynamicAccessAsyncStorageInstance", {
3868    enumerable: true,
3869    get: function() {
3870        return dynamicAccessAsyncStorageInstance;
3871    }
3872});
3873const _asynclocalstorage = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/async-local-storage.js [a

3873pp-client] (ecmascript)");
3874const dynamicAccessAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
3875}),
3876"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/dynamic-access-async-storage.external.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
3877"use strict";
3878
3879Object.defineProperty(exports, "__esModule", {
3880    value: true
3881});
3882Object.defineProperty(exports, "dynamicAccessAsyncStorage", {
3883    enumerable: true,
3884    get: function() {
3885        return _dynamicaccessasyncstorageinstance.dynamicAccessAsyncStorageInstance;
3886    }
3887});
3888const _dynamicaccessasyncstorageinstance = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/dynamic-access-async-storage-instance.js [app-client] (ecmascript)");
3889}),
3890"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/request/params.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
3891"use strict";
3892
3893var __TURBOPACK__imported__module__$5b$project$5d2f$node_modules$2f2e$pnpm$2f$next$40$16$2e$2$2e$2_$40$babel$2b$core$40$7$2e$29$2e$0_react$2d$dom$40$19$2e$2$2e$4_react$40$19$2e$2$2e$4_$5f$react$40$19$2e$2$2e$4$2f$node_modules$2f$next$2f$dist$2f$build$2f$polyfills$2f$process$2e$js__$5b$app$2d$client$5d$__$28$ecmascript$29$__ = /*#__PURE__*/ __turbopack_context__.i("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/build/polyfills/process.js [app-client] (ecmascript)");
3894"use strict";
3895Object.defineProperty(exports, "__esModule", {
3896    value: true
3897});
38980 && (module.exports = {
3899    createParamsFromClient: null,
3900    createPrerenderParamsForClientSegment: null,
3901    createServerParamsForMetadata: null,
3902    createServerParamsForRoute: null,
3903    createServerParamsForServerSegment: null
3904});
3905function _export(target, all) {
3906    for(var name in all)Object.defineProperty(target, name, {
3907        enumerable: true,
3908        get: all[name]
3909    });
3910}
3911_export(exports, {
3912    createParamsFromClient: function() {
3913        return createParamsFromClient;
3914    },
3915    createPrerenderParamsForClientSegment: function() {
3916        return createPrerenderParamsForClientSegment;
3917    },
3918    createServerParamsForMetadata: function() {
3919        return createServerParamsForMetadata;
3920    },
3921    createServerParamsForRoute: function() {
3922        return createServerParamsForRoute;
3923    },
3924    createServerParamsForServerSegment: function() {
3925        return createServerParamsForServerSegment;
3926    }
3927});
3928const _workasyncstorageexternal = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/work-async-storage.external.js [app-client] (ecmascript)");
3929const _varyparams = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/vary-params.js [app-client] (ecmascript)");
3930const _reflect = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/web/spec-extension/adapters/reflect.js [app-client] (ecmascript)");
3931const _dynamicrendering = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/dynamic-rendering.js [app-client] (ecmascript)");
3932const _workunitasyncstorageexternal = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/work-unit-async-storage.external.js [app-client] (ecmascript)");
3933const _invarianterror = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/invariant-error.js [app-client] (ecmascript)");
3934const _reflectutils = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/utils/reflect-utils.js [app-client] (ecmascript)");
3935const _dynamicrenderingutils = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/dynamic-rendering-utils.js [app-client] (ecmascript)");
3936const _creatededupedbycallsiteservererrorlogger = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js [app-client] (ecmascript)");
3937const _dynamicaccessasyncstorageexternal = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/dynamic-access-async-storage.external.js [app-client] (ecmascript)");
3938const _stagedrendering = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/staged-rendering.js [a

3938pp-client] (ecmascript)");
3939function createParamsFromClient(underlyingParams) {
3940    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
3941    if (!workStore) {
3942        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
3943            value: "E1068",
3944            enumerable: false,
3945            configurable: true
3946        });
3947    }
3948    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
3949    if (workUnitStore) {
3950        switch(workUnitStore.type){
3951            case 'prerender':
3952            case 'prerender-client':
3953            case 'prerender-ppr':
3954            case 'prerender-legacy':
3955                // Client params don't need additional vary tracking because by the
3956                // time they reach the client, the access would have already been
3957                // tracked by the server.
3958                const varyParamsAccumulator = null;
3959                return createStaticPrerenderParams(underlyingParams, null, workStore, workUnitStore, varyParamsAccumulator);
3960            case 'validation-client':
3961                return createClientParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples);
3962            case 'cache':
3963            case 'private-cache':
3964            case 'unstable-cache':
3965                throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
3966                    value: "E736",
3967                    enumerable: false,
3968                    configurable: true
3969                });
3970            case 'prerender-runtime':
3971                throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
3972                    value: "E770",
3973                    enumerable: false,
3974                    configurable: true
3975                });
3976            case 'generate-static-params':
3977                throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
3978                    value: "E1122",
3979                    enumerable: false,
3980                    configurable: true
3981                });
3982            case 'request':
3983                if ("TURBOPACK compile-time truthy", 1) {
3984                    // Semantically we only need the dev tracking when running in `next dev`
3985                    // but since you would never use next dev with production NODE_ENV we use this
3986                    // as a proxy so we can statically exclude this code from production builds.
3987                    const fallbackParams = workUnitStore.fallbackParams;
3988                    // Client params are not runtime prefetchable
3989                    const isRuntimePrefetchable = false;
3990                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
3991                } else //TURBOPACK unreachable
3992                ;
3993            default:
3994                workUnitStore;
3995        }
3996    }
3997    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
3998}
3999function createServerParamsForMetadata(underlyingParams, optionalCatchAllParamName, isRuntimePrefetchable) {
4000    const metadataVaryParamsAccumulator = (0, _varyparams.getMetadataVaryParamsAccumulator)();
4001    return createServerParamsForServerSegment(underlyingParams, optionalCatchAllParamName, metadataVaryParamsAccumulator, isRuntimePrefetchable);
4002}
4003function createServerParamsForRoute(underlyingParams, varyParamsAccumulator = null) {
4004    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
4005    if (!workStore) {
4006        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
4007            value: "E1068",
4008            enumerable: false,
4009            configurable: true
4010        });
4011    }
4012    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
4013    if (workUnitStore) {
4014        switch(workUnitStore.type){
4015            case 'prerender':
4016            case 'prerender-ppr':
4017            case 'prerender-legacy':
4018                return createStaticPrerenderParams(underlyingParams, null, workStore, workUnitStore, varyParamsAccumulator);
4019            case 'prerender-client':
4020            case 'validation-client':
4021                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called in client contexts.'), "__NEXT_ERROR_CODE", {
4022                    value: "E1064",
4023                    enumerable: false,
4024                    configurable: true
4025                });
4026            case 'cache':
4027            case 'private-cache':
4028            case 'unstable-cache':
4029                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
4030                    value: "E738",
4031                    enumerable: false,
4032                    configurable: true
4033                });
4034            case 'generate-static-params':
4035                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
4036                    value: "E1131",
4037                    enumerable: false,
4038                    configurable: true
4039                });
4040            case 'prerender-runtime':
4041                {
4042                    // Route params are not runtime prefetchable
4043                    const isRuntimePrefetchable = false;

4044                    return createRuntimePrerenderParams(underlyingParams, null, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
4045                }
4046            case 'request':
4047                if ("TURBOPACK compile-time truthy", 1) {
4048                    // Semantically we only need the dev tracking when running in `next dev`
4049                    // but since you would never use next dev with production NODE_ENV we use this
4050                    // as a proxy so we can statically exclude this code from production builds.
4051                    const fallbackParams = workUnitStore.fallbackParams;
4052                    // Route params are not runtime prefetchable
4053                    const isRuntimePrefetchable = false;
4054                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
4055                } else //TURBOPACK unreachable
4056                ;
4057            default:
4058                workUnitStore;
4059        }
4060    }
4061    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
4062}
4063function createServerParamsForServerSegment(underlyingParams, optionalCatchAllParamName, varyParamsAccumulator, isRuntimePrefetchable) {
4064    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
4065    if (!workStore) {
4066        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
4067            value: "E1068",
4068            enumerable: false,
4069            configurable: true
4070        });
4071    }
4072    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
4073    if (workUnitStore) {
4074        switch(workUnitStore.type){
4075            case 'prerender':
4076            case 'prerender-client':
4077            case 'prerender-ppr':
4078            case 'prerender-legacy':
4079                return createStaticPrerenderParams(underlyingParams, optionalCatchAllParamName, workStore, workUnitStore, varyParamsAccumulator);
4080            case 'validation-client':
4081                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForServerSegment should not be called in client contexts.'), "__NEXT_ERROR_CODE", {
4082                    value: "E1101",
4083                    enumerable: false,
4084                    configurable: true
4085                });
4086            case 'cache':
4087            case 'private-cache':
4088            case 'unstable-cache':
4089                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForServerSegment should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
4090                    value: "E743",
4091                    enumerable: false,
4092                    configurable: true
4093                });
4094            case 'generate-static-params':
4095                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForServerSegment should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
4096                    value: "E1120",
4097                    enumerable: false,
4098                    configurable: true
4099                });
4100            case 'prerender-runtime':
4101                return createRuntimePrerenderParams(underlyingParams, optionalCatchAllParamName, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
4102            case 'request':
4103                if ("TURBOPACK compile-time truthy", 1) {
4104                    // Semantically we only need the dev tracking when running in `next dev`
4105                    // but since you would never use next dev with production NODE_ENV we use this
4106                    // as a proxy so we can statically exclude this code from production builds.
4107                    const fallbackParams = workUnitStore.fallbackParams;
4108                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
4109                } else //TURBOPACK unreachable
4110                ;
4111            default:
4112                workUnitStore;
4113        }
4114    }
4115    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
4116}
4117function createPrerenderParamsForClientSegment(underlyingParams) {
4118    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
4119    if (!workStore) {
4120        throw Object.defineProperty(new _invarianterror.InvariantError('Missing workStore in createPrerenderParamsForClientSegment'), "__NEXT_ERROR_CODE", {
4121            value: "E773",
4122            enumerable: false,
4123            configurable: true
4124        });
4125    }
4126    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
4127    if (workUnitStore) {
4128        switch(workUnitStore.type){
4129            case 'prerender':
4130            case 'prerender-client':
4131                const fallbackParams = workUnitStore.fallbackRouteParam

4131s;
4132                if (fallbackParams) {
4133                    for(let key in underlyingParams){
4134                        if (fallbackParams.has(key)) {
4135                            // This params object has one or more fallback params, so we need
4136                            // to consider the awaiting of this params object "dynamic". Since
4137                            // we are in cacheComponents mode we encode this as a promise that never
4138                            // resolves.
4139                            return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`params`');
4140                        }
4141                    }
4142                }
4143                break;
4144            case 'validation-client':
4145                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderParamsForClientSegment should not be called in validation contexts.'), "__NEXT_ERROR_CODE", {
4146                    value: "E1099",
4147                    enumerable: false,
4148                    configurable: true
4149                });
4150                break;
4151            case 'cache':
4152            case 'private-cache':
4153            case 'unstable-cache':
4154                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderParamsForClientSegment should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
4155                    value: "E734",
4156                    enumerable: false,
4157                    configurable: true
4158                });
4159            case 'generate-static-params':
4160                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderParamsForClientSegment should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
4161                    value: "E1126",
4162                    enumerable: false,
4163                    configurable: true
4164                });
4165            case 'prerender-ppr':
4166            case 'prerender-legacy':
4167            case 'prerender-runtime':
4168            case 'request':
4169                break;
4170            default:
4171                workUnitStore;
4172        }
4173    }
4174    // We're prerendering in a mode that does not abort. We resolve the promise without
4175    // any tracking because we're just transporting a value from server to client where the tracking
4176    // will be applied.
4177    return Promise.resolve(underlyingParams);
4178}
4179function createStaticPrerenderParams(underlyingParams, optionalCatchAllParamName, workStore, prerenderStore, varyParamsAccumulator) {
4180    const underlyingParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName) : underlyingParams;
4181    switch(prerenderStore.type){
4182        case 'prerender':
4183        case 'prerender-client':
4184            {
4185                const fallbackParams = prerenderStore.fallbackRouteParams;
4186                if (fallbackParams) {
4187                    for(const key in underlyingParams){
4188                        if (fallbackParams.has(key)) {
4189                            // This params object has one or more fallback params, so we need
4190                            // to consider the awaiting of this params object "dynamic". Since
4191                            // we are in cacheComponents mode we encode this as a promise that never
4192                            // resolves.
4193                            return makeHangingParams(underlyingParamsWithVarying, workStore, prerenderStore);
4194                        }
4195                    }
4196                }
4197                break;
4198            }
4199        case 'prerender-ppr':
4200            {
4201                const fallbackParams = prerenderStore.fallbackRouteParams;
4202                if (fallbackParams) {
4203                    for(const key in underlyingParams){
4204                        if (fallbackParams.has(key)) {
4205                            return makeErroringParams(underlyingParamsWithVarying, fallbackParams, workStore, prerenderStore);
4206                        }
4207                    }
4208                }
4209                break;
4210            }
4211        case 'prerender-legacy':
4212            break;
4213        default:
4214            prerenderStore;
4215    }
4216    return makeUntrackedParams(underlyingParamsWithVarying);
4217}

4218function createRuntimePrerenderParams(underlyingParams, optionalCatchAllParamName, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable) {
4219    const underlyingParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName) : underlyingParams;
4220    const result = makeUntrackedParams(underlyingParamsWithVarying);
4221    const { stagedRendering } = workUnitStore;
4222    if (!stagedRendering) {
4223        return result;
4224    }
4225    const stage = isRuntimePrefetchable ? _stagedrendering.RenderStage.EarlyRuntime : _stagedrendering.RenderStage.Runtime;
4226    return stagedRendering.waitForStage(stage).then(()=>result);
4227}
4228function hasFallbackRouteParams(underlyingParams, fallbackParams) {
4229    if (fallbackParams) {
4230        for(let key in underlyingParams){
4231            if (fallbackParams.has(key)) {
4232                return true;
4233            }
4234        }
4235    }
4236    return false;
4237}
4238function createServerParamsInInstantValidation(underlyingParams, workStore, validationSamples, asyncApiPromises, isRuntimePrefetchable) {
4239    const { createExhaustiveParamsProxy } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/instant-validation/instant-samples.js [app-client] (ecmascript)");
4240    const declaredParams = new Set(Object.keys(validationSamples.params ?? {}));
4241    const proxiedUnderlying = createExhaustiveParamsProxy(underlyingParams, declaredParams, workStore.route);
4242    return (isRuntimePrefetchable ? asyncApiPromises.earlySharedParamsParent : asyncApiPromises.sharedParamsParent).then(()=>proxiedUnderlying);
4243}
4244function createClientParamsInInstantValidation(underlyingParams, workStore, validationSamples) {
4245    const { createExhaustiveParamsProxy } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/app-render/instant-validation/instant-samples.js [app-client] (ecmascript)");
4246    const declaredParams = new Set(Object.keys((validationSamples == null ? void 0 : validationSamples.params) ?? {}));
4247    const proxiedUnderlying = createExhaustiveParamsProxy(underlyingParams, declaredParams, workStore.route);
4248    return Promise.resolve(proxiedUnderlying);
4249}
4250function createRenderParamsInProd(underlyingParams) {
4251    return makeUntrackedParams(underlyingParams);
4252}
4253function createRenderParamsInDev(underlyingParams, fallbackParams, workStore, requestStore, isRuntimePrefetchable) {
4254    return makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackRouteParams(underlyingParams, fallbackParams), workStore, requestStore, isRuntimePrefetchable);
4255}
4256const CachedParams = new WeakMap();
4257const fallbackParamsProxyHandler = {
4258    get: function get(target, prop, receiver) {
4259        if (prop === 'then' || prop === 'catch' || prop === 'finally') {
4260            const originalMethod = _reflect.ReflectAdapter.get(target, prop, receiver);
4261            return ({
4262                [prop]: (...args)=>{
4263                    const store = _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.getStore();
4264                    if (store) {
4265                        store.abortController.abort(Object.defineProperty(new Error(`Accessed fallback \`params\` during prerendering.`), "__NEXT_ERROR_CODE", {
4266                            value: "E691",
4267                            enumerable: false,
4268                            configurable: true
4269                        }));
4270                    }
4271                    return new Proxy(originalMethod.apply(target, args), fallbackParamsProxyHandler);
4272                }
4273            })[prop];
4274        }
4275        return _reflect.ReflectAdapter.get(target, prop, receiver);
4276    }
4277};
4278function makeHangingParams(underlyingParams, workStore, prerenderStore) {
4279    const cachedParams = CachedParams.get(underlyingParams);
4280    if (cachedParams) {
4281        return cachedParams;
4282    }
4283    const promise = new Proxy((0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.render

4283Signal, workStore.route, '`params`'), fallbackParamsProxyHandler);
4284    CachedParams.set(underlyingParams, promise);
4285    return promise;
4286}
4287function makeErroringParams(underlyingParams, fallbackParams, workStore, prerenderStore) {
4288    const cachedParams = CachedParams.get(underlyingParams);
4289    if (cachedParams) {
4290        return cachedParams;
4291    }
4292    const augmentedUnderlying = {
4293        ...underlyingParams
4294    };
4295    // We don't use makeResolvedReactPromise here because params
4296    // supports copying with spread and we don't want to unnecessarily
4297    // instrument the promise with spreadable properties of ReactPromise.
4298    const promise = Promise.resolve(augmentedUnderlying);
4299    CachedParams.set(underlyingParams, promise);
4300    Object.keys(underlyingParams).forEach((prop)=>{
4301        if (_reflectutils.wellKnownProperties.has(prop)) {
4302        // These properties cannot be shadowed because they need to be the
4303        // true underlying value for Promises to work correctly at runtime
4304        } else {
4305            if (fallbackParams.has(prop)) {
4306                Object.defineProperty(augmentedUnderlying, prop, {
4307                    get () {
4308                        const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
4309                        // In most dynamic APIs we also throw if `dynamic = "error"` however
4310                        // for params is only dynamic when we're generating a fallback shell
4311                        // and even when `dynamic = "error"` we still support generating dynamic
4312                        // fallback shells
4313                        // TODO remove this comment when cacheComponents is the default since there
4314                        // will be no `dynamic = "error"`
4315                        if (prerenderStore.type === 'prerender-ppr') {
4316                            // PPR Prerender (no cacheComponents)
4317                            (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
4318                        } else {
4319                            // Legacy Prerender
4320                            (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
4321                        }
4322                    },
4323                    enumerable: true
4324                });
4325            }
4326        }
4327    });
4328    return promise;
4329}
4330function makeUntrackedParams(underlyingParams) {
4331    const cachedParams = CachedParams.get(underlyingParams);
4332    if (cachedParams) {
4333        return cachedParams;
4334    }
4335    const promise = Promise.resolve(underlyingParams);
4336    CachedParams.set(underlyingParams, promise);
4337    return promise;
4338}
4339function makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackParams, workStore, requestStore, isRuntimePrefetchable) {
4340    if (requestStore.asyncApiPromises && hasFallbackParams) {
4341        // We wrap each instance of params in a `new Promise()`, because deduping
4342        // them across requests doesn't work anyway and this let us show each
4343        // await a different set of values. This is important when all awaits
4344        // are in third party which would otherwise track all the way to the
4345        // internal params.
4346        const sharedParamsParent = isRuntimePrefetchable ? requestStore.asyncApiPromises.earlySharedParamsParent : requestStore.asyncApiPromises.sharedParamsParent;
4347        const promise = new Promise((resolve, reject)=>{
4348            sharedParamsParent.then(()=>resolve(underlyingParams), reject);
4349        });
4350        // @ts-expect-error
4351        promise.displayName = 'params';
4352        return instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
4353    }
4354    const cachedParams = CachedParams.get(underlyingParams);
4355    if (cachedParams) {
4356        return cachedParams;
4357    }
4358    // We don't use makeResolvedReactPromise here because params
4359    // supports copying with spread and we don't want to unnecessarily
4360    // instrument the promise with spreadable properties of ReactPromise.
4361    const promise = hasFallbackParams ? (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingParams, requestStore, _stagedrendering.RenderStage.Runtime) : Promise.resolve(underlyingParams);

4362    const proxiedPromise = instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
4363    CachedParams.set(underlyingParams, proxiedPromise);
4364    return proxiedPromise;
4365}
4366function instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore) {
4367    // Track which properties we should warn for.
4368    const proxiedProperties = new Set();
4369    Object.keys(underlyingParams).forEach((prop)=>{
4370        if (_reflectutils.wellKnownProperties.has(prop)) {
4371        // These properties cannot be shadowed because they need to be the
4372        // true underlying value for Promises to work correctly at runtime
4373        } else {
4374            proxiedProperties.add(prop);
4375        }
4376    });
4377    return new Proxy(promise, {
4378        get (target, prop, receiver) {
4379            if (typeof prop === 'string') {
4380                if (proxiedProperties.has(prop)) {
4381                    const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
4382                    warnForSyncAccess(workStore.route, expression);
4383                }
4384            }
4385            return _reflect.ReflectAdapter.get(target, prop, receiver);
4386        },
4387        set (target, prop, value, receiver) {
4388            if (typeof prop === 'string') {
4389                proxiedProperties.delete(prop);
4390            }
4391            return _reflect.ReflectAdapter.set(target, prop, value, receiver);
4392        },
4393        ownKeys (target) {
4394            const expression = '`...params` or similar expression';
4395            warnForSyncAccess(workStore.route, expression);
4396            return Reflect.ownKeys(target);
4397        }
4398    });
4399}
4400const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createParamsAccessError);
4401function createParamsAccessError(route, expression) {
4402    const prefix = route ? `Route "${route}" ` : 'This route ';
4403    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`params\` is a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
4404        value: "E834",
4405        enumerable: false,
4406        configurable: true
4407    });
4408}
4409}),
4410"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/client-page.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
4411"use strict";
4412
4413Object.defineProperty(exports, "__esModule", {
4414    value: true
4415});
4416Object.defineProperty(exports, "ClientPageRoot", {
4417    enumerable: true,
4418    get: function() {
4419        return ClientPageRoot;
4420    }
4421});
4422const _jsxruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
4423const _approutercontextsharedruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js [app-client] (ecmascript)");
4424const _react = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)");
4425const _routeparams = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/route-params.js [app-client] (ecmascript)");
4426const _hooksclientcontextsharedruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.js [app-client] (ecmascript)");
4427function ClientPageRoot({ Component, serverProvidedParams }) {
4428    let searchParams;
4429    let params;
4430    if (serverProvidedParams !== null) {
4431        searchParams = serverProvidedParams.searchParams;
4432        params = serverProvidedParams.params;
4433    } else {
4434        // When Cache Components is enabled, the server does not pass the params as
4435        // props; they are parsed on the client and passed via context.
4436        const layoutRouterContext = (0, _react.use)(_approutercontextsharedruntime.LayoutRouterContext);
4437        params = layoutRouterContext !== null ? layoutRouterContext.parentParam

4437s : {};
4438        // This is an intentional behavior change: when Cache Components is enabled,
4439        // client segments receive the "canonical" search params, not the
4440        // rewritten ones. Users should either call useSearchParams directly or pass
4441        // the rewritten ones in from a Server Component.
4442        // TODO: Log a deprecation error when this object is accessed
4443        searchParams = (0, _routeparams.urlSearchParamsToParsedUrlQuery)((0, _react.use)(_hooksclientcontextsharedruntime.SearchParamsContext));
4444    }
4445    if (typeof window === 'undefined') {
4446        let clientSearchParams;
4447        let clientParams;
4448        const { createSearchParamsFromClient } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/request/search-params.js [app-client] (ecmascript)");
4449        clientSearchParams = createSearchParamsFromClient(searchParams);
4450        const { createParamsFromClient } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/request/params.js [app-client] (ecmascript)");
4451        clientParams = createParamsFromClient(params);
4452        return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
4453            params: clientParams,
4454            searchParams: clientSearchParams
4455        });
4456    } else {
4457        const { createRenderSearchParamsFromClient } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/request/search-params.browser.js [app-client] (ecmascript)");
4458        const clientSearchParams = createRenderSearchParamsFromClient(searchParams);
4459        const { createRenderParamsFromClient } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/request/params.browser.js [app-client] (ecmascript)");
4460        const clientParams = createRenderParamsFromClient(params);
4461        return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
4462            params: clientParams,
4463            searchParams: clientSearchParams
4464        });
4465    }
4466}
4467if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
4468    Object.defineProperty(exports.default, '__esModule', {
4469        value: true
4470    });
4471    Object.assign(exports.default, exports);
4472    module.exports = exports.default;
4473}
4474}),
4475"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/components/client-segment.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
4476"use strict";
4477
4478Object.defineProperty(exports, "__esModule", {
4479    value: true
4480});
4481Object.defineProperty(exports, "ClientSegmentRoot", {
4482    enumerable: true,
4483    get: function() {
4484        return ClientSegmentRoot;
4485    }
4486});
4487const _jsxruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
4488const _approutercontextsharedruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js [app-client] (ecmascript)");
4489const _react = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/index.js [app-client] (ecmascript)");
4490function ClientSegmentRoot({ Component, slots, serverProvidedParams }) {
4491    let params;
4492    if (serverProvidedParams !== null) {
4493        params = serverProvidedParams.params;
4494    } else {
4495        // When Cache Components is enabled, the server does not pass the params
4496        // as props; they are parsed on the client and passed via context.
4497        const layoutRouterContext = (0, _react.use)(_approutercontextsharedruntime.LayoutRouterContext);
4498        params = layoutRouterContext !== null ? layoutRouterContext.parentParam

4498s : {};
4499    }
4500    if (typeof window === 'undefined') {
4501        const { createParamsFromClient } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/server/request/params.js [app-client] (ecmascript)");
4502        const clientParams = createParamsFromClient(params);
4503        return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
4504            ...slots,
4505            params: clientParams
4506        });
4507    } else {
4508        const { createRenderParamsFromClient } = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/client/request/params.browser.js [app-client] (ecmascript)");
4509        const clientParams = createRenderParamsFromClient(params);
4510        return /*#__PURE__*/ (0, _jsxruntime.jsx)(Component, {
4511            ...slots,
4512            params: clientParams
4513        });
4514    }
4515}
4516if ((typeof exports.default === 'function' || typeof exports.default === 'object' && exports.default !== null) && typeof exports.default.__esModule === 'undefined') {
4517    Object.defineProperty(exports.default, '__esModule', {
4518        value: true
4519    });
4520    Object.assign(exports.default, exports);
4521    module.exports = exports.default;
4522}
4523}),
4524"[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/lib/metadata/generate/icon-mark.js [app-client] (ecmascript)", ((__turbopack_context__, module, exports) => {
4525"use strict";
4526
4527Object.defineProperty(exports, "__esModule", {
4528    value: true
4529});
4530Object.defineProperty(exports, "IconMark", {
4531    enumerable: true,
4532    get: function() {
4533        return IconMark;
4534    }
4535});
4536const _jsxruntime = __turbopack_context__.r("[project]/node_modules/.pnpm/[email protected]_@[email protected][email protected][email protected][email protected]/node_modules/next/dist/compiled/react/jsx-runtime.js [app-client] (ecmascript)");
4537const IconMark = ()=>{
4538    if (typeof window !== 'undefined') {
4539        return null;
4540    }
4541    return /*#__PURE__*/ (0, _jsxruntime.jsx)("meta", {
4542        name: "\xabnxt-icon\xbb"
4543    });
4544};
4545}),
4546]);
4547
4548//# sourceMappingURL=0r_m_next_dist_0r39plp._.js.map

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