shieldcortex 4.2.5 → 4.3.0

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/request/headers.js

@@ -1,219 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "headers", {
-    enumerable: true,
-    get: function() {
-        return headers;
-    }
-});
-const _headers = require("../web/spec-extension/adapters/headers");
-const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
-const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
-const _dynamicrendering = require("../app-render/dynamic-rendering");
-const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
-const _dynamicrenderingutils = require("../dynamic-rendering-utils");
-const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-callsite-server-error-logger");
-const _utils = require("./utils");
-const _invarianterror = require("../../shared/lib/invariant-error");
-const _stagedrendering = require("../app-render/staged-rendering");
-function headers() {
-    const callingExpression = 'headers';
-    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workStore) {
-        if (workUnitStore && workUnitStore.phase === 'after' && !(0, _utils.isRequestAPICallableInsideAfter)()) {
-            throw Object.defineProperty(new Error(`Route ${workStore.route} used \`headers()\` inside \`after()\`. This is not supported. If you need this data inside an \`after()\` callback, use \`headers()\` outside of the callback. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
-                value: "E839",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        if (workStore.forceStatic) {
-            // When using forceStatic we override all other logic and always just return an empty
-            // headers object without tracking
-            const underlyingHeaders = _headers.HeadersAdapter.seal(new Headers({}));
-            return makeUntrackedHeaders(underlyingHeaders);
-        }
-        if (workUnitStore) {
-            switch(workUnitStore.type){
-                case 'cache':
-                    {
-                        const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`headers()\` inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`headers()\` outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
-                            value: "E833",
-                            enumerable: false,
-                            configurable: true
-                        });
-                        Error.captureStackTrace(error, headers);
-                        workStore.invalidDynamicUsageError ??= error;
-                        throw error;
-                    }
-                case 'unstable-cache':
-                    throw Object.defineProperty(new Error(`Route ${workStore.route} used \`headers()\` inside a function cached with \`unstable_cache()\`. Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`headers()\` outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
-                        value: "E838",
-                        enumerable: false,
-                        configurable: true
-                    });
-                case 'prerender':
-                case 'prerender-client':
-                case 'private-cache':
-                case 'prerender-runtime':
-                case 'prerender-ppr':
-                case 'prerender-legacy':
-                case 'request':
-                    break;
-                default:
-                    workUnitStore;
-            }
-        }
-        if (workStore.dynamicShouldError) {
-            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`headers()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
-                value: "E828",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        if (workUnitStore) {
-            switch(workUnitStore.type){
-                case 'prerender':
-                    return makeHangingHeaders(workStore, workUnitStore);
-                case 'prerender-client':
-                    const exportName = '`headers`';
-                    throw Object.defineProperty(new _invarianterror.InvariantError(`${exportName} must not be used within a client component. Next.js should be preventing ${exportName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-                        value: "E693",
-                        enumerable: false,
-                        configurable: true
-                    });
-                case 'prerender-ppr':
-                    // PPR Prerender (no cacheComponents)
-                    // We are prerendering with PPR. We need track dynamic access here eagerly
-                    // to keep continuity with how headers has worked in PPR without cacheComponents.
-                    // TODO consider switching the semantic to throw on property access instead
-                    return (0, _dynamicrendering.postponeWithTracking)(workStore.route, callingExpression, workUnitStore.dynamicTracking);
-                case 'prerender-legacy':
-                    // Legacy Prerender
-                    // We are in a legacy static generation mode while prerendering
-                    // We track dynamic access here so we don't need to wrap the headers in
-                    // individual property access tracking.
-                    return (0, _dynamicrendering.throwToInterruptStaticGeneration)(callingExpression, workStore, workUnitStore);
-                case 'prerender-runtime':
-                    return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedHeaders(workUnitStore.headers));
-                case 'private-cache':
-                    // Private caches are delayed until the runtime stage in use-cache-wrapper,
-                    // so we don't need an additional delay here.
-                    return makeUntrackedHeaders(workUnitStore.headers);
-                case 'request':
-                    (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
-                    if (process.env.NODE_ENV === 'development') {
-                        // Semantically we only need the dev tracking when running in `next dev`
-                        // but since you would never use next dev with production NODE_ENV we use this
-                        // as a proxy so we can statically exclude this code from production builds.
-                        return makeUntrackedHeadersWithDevWarnings(workUnitStore.headers, workStore == null ? void 0 : workStore.route, workUnitStore);
-                    } else {
-                        return makeUntrackedHeaders(workUnitStore.headers);
-                    }
-                    break;
-                default:
-                    workUnitStore;
-            }
-        }
-    }
-    // If we end up here, there was no work store or work unit store present.
-    (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
-}
-const CachedHeaders = new WeakMap();
-function makeHangingHeaders(workStore, prerenderStore) {
-    const cachedHeaders = CachedHeaders.get(prerenderStore);
-    if (cachedHeaders) {
-        return cachedHeaders;
-    }
-    const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`headers()`');
-    CachedHeaders.set(prerenderStore, promise);
-    return promise;
-}
-function makeUntrackedHeaders(underlyingHeaders) {
-    const cachedHeaders = CachedHeaders.get(underlyingHeaders);
-    if (cachedHeaders) {
-        return cachedHeaders;
-    }
-    const promise = Promise.resolve(underlyingHeaders);
-    CachedHeaders.set(underlyingHeaders, promise);
-    return promise;
-}
-function makeUntrackedHeadersWithDevWarnings(underlyingHeaders, route, requestStore) {
-    if (requestStore.asyncApiPromises) {
-        const promise = requestStore.asyncApiPromises.headers;
-        return instrumentHeadersPromiseWithDevWarnings(promise, route);
-    }
-    const cachedHeaders = CachedHeaders.get(underlyingHeaders);
-    if (cachedHeaders) {
-        return cachedHeaders;
-    }
-    const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingHeaders, requestStore, _stagedrendering.RenderStage.Runtime);
-    const proxiedPromise = instrumentHeadersPromiseWithDevWarnings(promise, route);
-    CachedHeaders.set(underlyingHeaders, proxiedPromise);
-    return proxiedPromise;
-}
-const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createHeadersAccessError);
-function instrumentHeadersPromiseWithDevWarnings(promise, route) {
-    Object.defineProperties(promise, {
-        [Symbol.iterator]: replaceableWarningDescriptorForSymbolIterator(promise, route),
-        append: replaceableWarningDescriptor(promise, 'append', route),
-        delete: replaceableWarningDescriptor(promise, 'delete', route),
-        get: replaceableWarningDescriptor(promise, 'get', route),
-        has: replaceableWarningDescriptor(promise, 'has', route),
-        set: replaceableWarningDescriptor(promise, 'set', route),
-        getSetCookie: replaceableWarningDescriptor(promise, 'getSetCookie', route),
-        forEach: replaceableWarningDescriptor(promise, 'forEach', route),
-        keys: replaceableWarningDescriptor(promise, 'keys', route),
-        values: replaceableWarningDescriptor(promise, 'values', route),
-        entries: replaceableWarningDescriptor(promise, 'entries', route)
-    });
-    return promise;
-}
-function replaceableWarningDescriptor(target, prop, route) {
-    return {
-        enumerable: false,
-        get () {
-            warnForSyncAccess(route, `\`headers().${prop}\``);
-            return undefined;
-        },
-        set (value) {
-            Object.defineProperty(target, prop, {
-                value,
-                writable: true,
-                configurable: true
-            });
-        },
-        configurable: true
-    };
-}
-function replaceableWarningDescriptorForSymbolIterator(target, route) {
-    return {
-        enumerable: false,
-        get () {
-            warnForSyncAccess(route, '`...headers()` or similar iteration');
-            return undefined;
-        },
-        set (value) {
-            Object.defineProperty(target, Symbol.iterator, {
-                value,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
-        },
-        configurable: true
-    };
-}
-function createHeadersAccessError(route, expression) {
-    const prefix = route ? `Route "${route}" ` : 'This route ';
-    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`headers()\` returns 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", {
-        value: "E836",
-        enumerable: false,
-        configurable: true
-    });
-}
-
-//# sourceMappingURL=headers.js.map

package/dashboard/.next/standalone/dashboard/node_modules/next/dist/server/request/params.js

@@ -1,415 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    createParamsFromClient: null,
-    createPrerenderParamsForClientSegment: null,
-    createServerParamsForMetadata: null,
-    createServerParamsForRoute: null,
-    createServerParamsForServerSegment: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createParamsFromClient: function() {
-        return createParamsFromClient;
-    },
-    createPrerenderParamsForClientSegment: function() {
-        return createPrerenderParamsForClientSegment;
-    },
-    createServerParamsForMetadata: function() {
-        return createServerParamsForMetadata;
-    },
-    createServerParamsForRoute: function() {
-        return createServerParamsForRoute;
-    },
-    createServerParamsForServerSegment: function() {
-        return createServerParamsForServerSegment;
-    }
-});
-const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
-const _reflect = require("../web/spec-extension/adapters/reflect");
-const _dynamicrendering = require("../app-render/dynamic-rendering");
-const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
-const _invarianterror = require("../../shared/lib/invariant-error");
-const _reflectutils = require("../../shared/lib/utils/reflect-utils");
-const _dynamicrenderingutils = require("../dynamic-rendering-utils");
-const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-callsite-server-error-logger");
-const _dynamicaccessasyncstorageexternal = require("../app-render/dynamic-access-async-storage.external");
-const _stagedrendering = require("../app-render/staged-rendering");
-function createParamsFromClient(underlyingParams, workStore) {
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender':
-            case 'prerender-client':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-                return createStaticPrerenderParams(underlyingParams, workStore, workUnitStore);
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E736",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-runtime':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
-                    value: "E770",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'request':
-                if (process.env.NODE_ENV === 'development') {
-                    // Semantically we only need the dev tracking when running in `next dev`
-                    // but since you would never use next dev with production NODE_ENV we use this
-                    // as a proxy so we can statically exclude this code from production builds.
-                    const devFallbackParams = workUnitStore.devFallbackParams;
-                    return createRenderParamsInDev(underlyingParams, devFallbackParams, workStore, workUnitStore);
-                } else {
-                    return createRenderParamsInProd(underlyingParams);
-                }
-            default:
-                workUnitStore;
-        }
-    }
-    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
-}
-const createServerParamsForMetadata = createServerParamsForServerSegment;
-function createServerParamsForRoute(underlyingParams, workStore) {
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender':
-            case 'prerender-client':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-                return createStaticPrerenderParams(underlyingParams, workStore, workUnitStore);
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E738",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-runtime':
-                return createRuntimePrerenderParams(underlyingParams, workUnitStore);
-            case 'request':
-                if (process.env.NODE_ENV === 'development') {
-                    // Semantically we only need the dev tracking when running in `next dev`
-                    // but since you would never use next dev with production NODE_ENV we use this
-                    // as a proxy so we can statically exclude this code from production builds.
-                    const devFallbackParams = workUnitStore.devFallbackParams;
-                    return createRenderParamsInDev(underlyingParams, devFallbackParams, workStore, workUnitStore);
-                } else {
-                    return createRenderParamsInProd(underlyingParams);
-                }
-            default:
-                workUnitStore;
-        }
-    }
-    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
-}
-function createServerParamsForServerSegment(underlyingParams, workStore) {
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender':
-            case 'prerender-client':
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-                return createStaticPrerenderParams(underlyingParams, workStore, workUnitStore);
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForServerSegment should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E743",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-runtime':
-                return createRuntimePrerenderParams(underlyingParams, workUnitStore);
-            case 'request':
-                if (process.env.NODE_ENV === 'development') {
-                    // Semantically we only need the dev tracking when running in `next dev`
-                    // but since you would never use next dev with production NODE_ENV we use this
-                    // as a proxy so we can statically exclude this code from production builds.
-                    const devFallbackParams = workUnitStore.devFallbackParams;
-                    return createRenderParamsInDev(underlyingParams, devFallbackParams, workStore, workUnitStore);
-                } else {
-                    return createRenderParamsInProd(underlyingParams);
-                }
-            default:
-                workUnitStore;
-        }
-    }
-    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
-}
-function createPrerenderParamsForClientSegment(underlyingParams) {
-    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-    if (!workStore) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Missing workStore in createPrerenderParamsForClientSegment'), "__NEXT_ERROR_CODE", {
-            value: "E773",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-    if (workUnitStore) {
-        switch(workUnitStore.type){
-            case 'prerender':
-            case 'prerender-client':
-                const fallbackParams = workUnitStore.fallbackRouteParams;
-                if (fallbackParams) {
-                    for(let key in underlyingParams){
-                        if (fallbackParams.has(key)) {
-                            // This params object has one or more fallback params, so we need
-                            // to consider the awaiting of this params object "dynamic". Since
-                            // we are in cacheComponents mode we encode this as a promise that never
-                            // resolves.
-                            return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`params`');
-                        }
-                    }
-                }
-                break;
-            case 'cache':
-            case 'private-cache':
-            case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderParamsForClientSegment should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E734",
-                    enumerable: false,
-                    configurable: true
-                });
-            case 'prerender-ppr':
-            case 'prerender-legacy':
-            case 'prerender-runtime':
-            case 'request':
-                break;
-            default:
-                workUnitStore;
-        }
-    }
-    // We're prerendering in a mode that does not abort. We resolve the promise without
-    // any tracking because we're just transporting a value from server to client where the tracking
-    // will be applied.
-    return Promise.resolve(underlyingParams);
-}
-function createStaticPrerenderParams(underlyingParams, workStore, prerenderStore) {
-    switch(prerenderStore.type){
-        case 'prerender':
-        case 'prerender-client':
-            {
-                const fallbackParams = prerenderStore.fallbackRouteParams;
-                if (fallbackParams) {
-                    for(const key in underlyingParams){
-                        if (fallbackParams.has(key)) {
-                            // This params object has one or more fallback params, so we need
-                            // to consider the awaiting of this params object "dynamic". Since
-                            // we are in cacheComponents mode we encode this as a promise that never
-                            // resolves.
-                            return makeHangingParams(underlyingParams, workStore, prerenderStore);
-                        }
-                    }
-                }
-                break;
-            }
-        case 'prerender-ppr':
-            {
-                const fallbackParams = prerenderStore.fallbackRouteParams;
-                if (fallbackParams) {
-                    for(const key in underlyingParams){
-                        if (fallbackParams.has(key)) {
-                            return makeErroringParams(underlyingParams, fallbackParams, workStore, prerenderStore);
-                        }
-                    }
-                }
-                break;
-            }
-        case 'prerender-legacy':
-            break;
-        default:
-            prerenderStore;
-    }
-    return makeUntrackedParams(underlyingParams);
-}
-function createRuntimePrerenderParams(underlyingParams, workUnitStore) {
-    return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedParams(underlyingParams));
-}
-function createRenderParamsInProd(underlyingParams) {
-    return makeUntrackedParams(underlyingParams);
-}
-function createRenderParamsInDev(underlyingParams, devFallbackParams, workStore, requestStore) {
-    let hasFallbackParams = false;
-    if (devFallbackParams) {
-        for(let key in underlyingParams){
-            if (devFallbackParams.has(key)) {
-                hasFallbackParams = true;
-                break;
-            }
-        }
-    }
-    return makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackParams, workStore, requestStore);
-}
-const CachedParams = new WeakMap();
-const fallbackParamsProxyHandler = {
-    get: function get(target, prop, receiver) {
-        if (prop === 'then' || prop === 'catch' || prop === 'finally') {
-            const originalMethod = _reflect.ReflectAdapter.get(target, prop, receiver);
-            return ({
-                [prop]: (...args)=>{
-                    const store = _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.getStore();
-                    if (store) {
-                        store.abortController.abort(Object.defineProperty(new Error(`Accessed fallback \`params\` during prerendering.`), "__NEXT_ERROR_CODE", {
-                            value: "E691",
-                            enumerable: false,
-                            configurable: true
-                        }));
-                    }
-                    return new Proxy(originalMethod.apply(target, args), fallbackParamsProxyHandler);
-                }
-            })[prop];
-        }
-        return _reflect.ReflectAdapter.get(target, prop, receiver);
-    }
-};
-function makeHangingParams(underlyingParams, workStore, prerenderStore) {
-    const cachedParams = CachedParams.get(underlyingParams);
-    if (cachedParams) {
-        return cachedParams;
-    }
-    const promise = new Proxy((0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`params`'), fallbackParamsProxyHandler);
-    CachedParams.set(underlyingParams, promise);
-    return promise;
-}
-function makeErroringParams(underlyingParams, fallbackParams, workStore, prerenderStore) {
-    const cachedParams = CachedParams.get(underlyingParams);
-    if (cachedParams) {
-        return cachedParams;
-    }
-    const augmentedUnderlying = {
-        ...underlyingParams
-    };
-    // We don't use makeResolvedReactPromise here because params
-    // supports copying with spread and we don't want to unnecessarily
-    // instrument the promise with spreadable properties of ReactPromise.
-    const promise = Promise.resolve(augmentedUnderlying);
-    CachedParams.set(underlyingParams, promise);
-    Object.keys(underlyingParams).forEach((prop)=>{
-        if (_reflectutils.wellKnownProperties.has(prop)) {
-        // These properties cannot be shadowed because they need to be the
-        // true underlying value for Promises to work correctly at runtime
-        } else {
-            if (fallbackParams.has(prop)) {
-                Object.defineProperty(augmentedUnderlying, prop, {
-                    get () {
-                        const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
-                        // In most dynamic APIs we also throw if `dynamic = "error"` however
-                        // for params is only dynamic when we're generating a fallback shell
-                        // and even when `dynamic = "error"` we still support generating dynamic
-                        // fallback shells
-                        // TODO remove this comment when cacheComponents is the default since there
-                        // will be no `dynamic = "error"`
-                        if (prerenderStore.type === 'prerender-ppr') {
-                            // PPR Prerender (no cacheComponents)
-                            (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
-                        } else {
-                            // Legacy Prerender
-                            (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
-                        }
-                    },
-                    enumerable: true
-                });
-            }
-        }
-    });
-    return promise;
-}
-function makeUntrackedParams(underlyingParams) {
-    const cachedParams = CachedParams.get(underlyingParams);
-    if (cachedParams) {
-        return cachedParams;
-    }
-    const promise = Promise.resolve(underlyingParams);
-    CachedParams.set(underlyingParams, promise);
-    return promise;
-}
-function makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackParams, workStore, requestStore) {
-    if (requestStore.asyncApiPromises && hasFallbackParams) {
-        // We wrap each instance of params in a `new Promise()`, because deduping
-        // them across requests doesn't work anyway and this let us show each
-        // await a different set of values. This is important when all awaits
-        // are in third party which would otherwise track all the way to the
-        // internal params.
-        const sharedParamsParent = requestStore.asyncApiPromises.sharedParamsParent;
-        const promise = new Promise((resolve, reject)=>{
-            sharedParamsParent.then(()=>resolve(underlyingParams), reject);
-        });
-        // @ts-expect-error
-        promise.displayName = 'params';
-        return instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
-    }
-    const cachedParams = CachedParams.get(underlyingParams);
-    if (cachedParams) {
-        return cachedParams;
-    }
-    // We don't use makeResolvedReactPromise here because params
-    // supports copying with spread and we don't want to unnecessarily
-    // instrument the promise with spreadable properties of ReactPromise.
-    const promise = hasFallbackParams ? (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingParams, requestStore, _stagedrendering.RenderStage.Runtime) : Promise.resolve(underlyingParams);
-    const proxiedPromise = instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
-    CachedParams.set(underlyingParams, proxiedPromise);
-    return proxiedPromise;
-}
-function instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore) {
-    // Track which properties we should warn for.
-    const proxiedProperties = new Set();
-    Object.keys(underlyingParams).forEach((prop)=>{
-        if (_reflectutils.wellKnownProperties.has(prop)) {
-        // These properties cannot be shadowed because they need to be the
-        // true underlying value for Promises to work correctly at runtime
-        } else {
-            proxiedProperties.add(prop);
-        }
-    });
-    return new Proxy(promise, {
-        get (target, prop, receiver) {
-            if (typeof prop === 'string') {
-                if (// We are accessing a property that was proxied to the promise instance
-                proxiedProperties.has(prop)) {
-                    const expression = (0, _reflectutils.describeStringPropertyAccess)('params', prop);
-                    warnForSyncAccess(workStore.route, expression);
-                }
-            }
-            return _reflect.ReflectAdapter.get(target, prop, receiver);
-        },
-        set (target, prop, value, receiver) {
-            if (typeof prop === 'string') {
-                proxiedProperties.delete(prop);
-            }
-            return _reflect.ReflectAdapter.set(target, prop, value, receiver);
-        },
-        ownKeys (target) {
-            const expression = '`...params` or similar expression';
-            warnForSyncAccess(workStore.route, expression);
-            return Reflect.ownKeys(target);
-        }
-    });
-}
-const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createParamsAccessError);
-function createParamsAccessError(route, expression) {
-    const prefix = route ? `Route "${route}" ` : 'This route ';
-    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", {
-        value: "E834",
-        enumerable: false,
-        configurable: true
-    });
-}
-
-//# sourceMappingURL=params.js.map