@ank1015/llm 0.0.1 → 0.0.3

package/vendor/web/standalone/node_modules/next/dist/server/request/params.js

@@ -0,0 +1,527 @@
+"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 _varyparams = require("../app-render/vary-params");
+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) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
+            value: "E1068",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-client':
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+                // Client params don't need additional vary tracking because by the
+                // time they reach the client, the access would have already been
+                // tracked by the server.
+                const varyParamsAccumulator = null;
+                return createStaticPrerenderParams(underlyingParams, null, workStore, workUnitStore, varyParamsAccumulator);
+            case 'validation-client':
+                return createClientParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples);
+            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 'generate-static-params':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createParamsFromClient should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
+                    value: "E1122",
+                    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 fallbackParams = workUnitStore.fallbackParams;
+                    // Client params are not runtime prefetchable
+                    const isRuntimePrefetchable = false;
+                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
+                } else if (workUnitStore.validationSamples) {
+                    return createClientParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples);
+                } else {
+                    return createRenderParamsInProd(underlyingParams);
+                }
+            default:
+                workUnitStore;
+        }
+    }
+    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
+}
+function createServerParamsForMetadata(underlyingParams, optionalCatchAllParamName, isRuntimePrefetchable) {
+    const metadataVaryParamsAccumulator = (0, _varyparams.getMetadataVaryParamsAccumulator)();
+    return createServerParamsForServerSegment(underlyingParams, optionalCatchAllParamName, metadataVaryParamsAccumulator, isRuntimePrefetchable);
+}
+function createServerParamsForRoute(underlyingParams, varyParamsAccumulator = null) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
+            value: "E1068",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+                return createStaticPrerenderParams(underlyingParams, null, workStore, workUnitStore, varyParamsAccumulator);
+            case 'prerender-client':
+            case 'validation-client':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called in client contexts.'), "__NEXT_ERROR_CODE", {
+                    value: "E1064",
+                    enumerable: false,
+                    configurable: true
+                });
+            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 'generate-static-params':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
+                    value: "E1131",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'prerender-runtime':
+                {
+                    // Route params are not runtime prefetchable
+                    const isRuntimePrefetchable = false;
+                    return createRuntimePrerenderParams(underlyingParams, null, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
+                }
+            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 fallbackParams = workUnitStore.fallbackParams;
+                    // Route params are not runtime prefetchable
+                    const isRuntimePrefetchable = false;
+                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
+                } else {
+                    return createRenderParamsInProd(underlyingParams);
+                }
+            default:
+                workUnitStore;
+        }
+    }
+    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
+}
+function createServerParamsForServerSegment(underlyingParams, optionalCatchAllParamName, varyParamsAccumulator, isRuntimePrefetchable) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
+            value: "E1068",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-client':
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+                return createStaticPrerenderParams(underlyingParams, optionalCatchAllParamName, workStore, workUnitStore, varyParamsAccumulator);
+            case 'validation-client':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForServerSegment should not be called in client contexts.'), "__NEXT_ERROR_CODE", {
+                    value: "E1101",
+                    enumerable: false,
+                    configurable: true
+                });
+            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 'generate-static-params':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForServerSegment should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
+                    value: "E1120",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'prerender-runtime':
+                return createRuntimePrerenderParams(underlyingParams, optionalCatchAllParamName, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
+            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 fallbackParams = workUnitStore.fallbackParams;
+                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
+                } else if (workUnitStore.asyncApiPromises && workUnitStore.validationSamples) {
+                    return createServerParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples, workUnitStore.asyncApiPromises, isRuntimePrefetchable);
+                } else if (workUnitStore.asyncApiPromises && hasFallbackRouteParams(underlyingParams, workUnitStore.fallbackParams)) {
+                    return (isRuntimePrefetchable ? workUnitStore.asyncApiPromises.earlySharedParamsParent : workUnitStore.asyncApiPromises.sharedParamsParent).then(()=>underlyingParams);
+                } 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 'validation-client':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderParamsForClientSegment should not be called in validation contexts.'), "__NEXT_ERROR_CODE", {
+                    value: "E1099",
+                    enumerable: false,
+                    configurable: true
+                });
+                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 'generate-static-params':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderParamsForClientSegment should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
+                    value: "E1126",
+                    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, optionalCatchAllParamName, workStore, prerenderStore, varyParamsAccumulator) {
+    const underlyingParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName) : underlyingParams;
+    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(underlyingParamsWithVarying, workStore, prerenderStore);
+                        }
+                    }
+                }
+                break;
+            }
+        case 'prerender-ppr':
+            {
+                const fallbackParams = prerenderStore.fallbackRouteParams;
+                if (fallbackParams) {
+                    for(const key in underlyingParams){
+                        if (fallbackParams.has(key)) {
+                            return makeErroringParams(underlyingParamsWithVarying, fallbackParams, workStore, prerenderStore);
+                        }
+                    }
+                }
+                break;
+            }
+        case 'prerender-legacy':
+            break;
+        default:
+            prerenderStore;
+    }
+    return makeUntrackedParams(underlyingParamsWithVarying);
+}
+function createRuntimePrerenderParams(underlyingParams, optionalCatchAllParamName, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable) {
+    const underlyingParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName) : underlyingParams;
+    const result = makeUntrackedParams(underlyingParamsWithVarying);
+    const { stagedRendering } = workUnitStore;
+    if (!stagedRendering) {
+        return result;
+    }
+    const stage = isRuntimePrefetchable ? _stagedrendering.RenderStage.EarlyRuntime : _stagedrendering.RenderStage.Runtime;
+    return stagedRendering.waitForStage(stage).then(()=>result);
+}
+function hasFallbackRouteParams(underlyingParams, fallbackParams) {
+    if (fallbackParams) {
+        for(let key in underlyingParams){
+            if (fallbackParams.has(key)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function createServerParamsInInstantValidation(underlyingParams, workStore, validationSamples, asyncApiPromises, isRuntimePrefetchable) {
+    const { createExhaustiveParamsProxy } = require('../app-render/instant-validation/instant-samples');
+    const declaredParams = new Set(Object.keys(validationSamples.params ?? {}));
+    const proxiedUnderlying = createExhaustiveParamsProxy(underlyingParams, declaredParams, workStore.route);
+    return (isRuntimePrefetchable ? asyncApiPromises.earlySharedParamsParent : asyncApiPromises.sharedParamsParent).then(()=>proxiedUnderlying);
+}
+function createClientParamsInInstantValidation(underlyingParams, workStore, validationSamples) {
+    const { createExhaustiveParamsProxy } = require('../app-render/instant-validation/instant-samples');
+    const declaredParams = new Set(Object.keys((validationSamples == null ? void 0 : validationSamples.params) ?? {}));
+    const proxiedUnderlying = createExhaustiveParamsProxy(underlyingParams, declaredParams, workStore.route);
+    return Promise.resolve(proxiedUnderlying);
+}
+function createRenderParamsInProd(underlyingParams) {
+    return makeUntrackedParams(underlyingParams);
+}
+function createRenderParamsInDev(underlyingParams, fallbackParams, workStore, requestStore, isRuntimePrefetchable) {
+    return makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackRouteParams(underlyingParams, fallbackParams), workStore, requestStore, isRuntimePrefetchable);
+}
+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, isRuntimePrefetchable) {
+    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 = isRuntimePrefetchable ? requestStore.asyncApiPromises.earlySharedParamsParent : 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

package/vendor/web/standalone/node_modules/next/dist/server/request/pathname.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createServerPathnameForMetadata", {
+    enumerable: true,
+    get: function() {
+        return createServerPathnameForMetadata;
+    }
+});
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _dynamicrendering = require("../app-render/dynamic-rendering");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _dynamicrenderingutils = require("../dynamic-rendering-utils");
+const _invarianterror = require("../../shared/lib/invariant-error");
+function createServerPathnameForMetadata(underlyingPathname) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
+            value: "E1068",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+                {
+                    return createPrerenderPathname(underlyingPathname, workStore, workUnitStore);
+                }
+            case 'prerender-client':
+            case 'validation-client':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerPathnameForMetadata should not be called in client contexts.'), "__NEXT_ERROR_CODE", {
+                    value: "E1065",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'cache':
+            case 'private-cache':
+            case 'unstable-cache':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerPathnameForMetadata should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
+                    value: "E740",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'generate-static-params':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerPathnameForMetadata should not be called inside generateStaticParams.'), "__NEXT_ERROR_CODE", {
+                    value: "E1129",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'prerender-runtime':
+                return (0, _dynamicrenderingutils.delayUntilRuntimeStage)(workUnitStore, createRenderPathname(underlyingPathname));
+            case 'request':
+                return createRenderPathname(underlyingPathname);
+            default:
+                workUnitStore;
+        }
+    }
+    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
+}
+function createPrerenderPathname(underlyingPathname, workStore, prerenderStore) {
+    switch(prerenderStore.type){
+        case 'prerender':
+            {
+                const fallbackParams = prerenderStore.fallbackRouteParams;
+                if (fallbackParams && fallbackParams.size > 0) {
+                    return (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`pathname`');
+                }
+                break;
+            }
+        case 'prerender-ppr':
+            {
+                const fallbackParams = prerenderStore.fallbackRouteParams;
+                if (fallbackParams && fallbackParams.size > 0) {
+                    return makeErroringPathname(workStore, prerenderStore.dynamicTracking);
+                }
+                break;
+            }
+        case 'prerender-legacy':
+            break;
+        default:
+            prerenderStore;
+    }
+    // We don't have any fallback params so we have an entirely static safe params object
+    return Promise.resolve(underlyingPathname);
+}
+function makeErroringPathname(workStore, dynamicTracking) {
+    let reject = null;
+    const promise = new Promise((_, re)=>{
+        reject = re;
+    });
+    const originalThen = promise.then.bind(promise);
+    // We instrument .then so that we can generate a tracking event only if you actually
+    // await this promise, not just that it is created.
+    promise.then = (onfulfilled, onrejected)=>{
+        if (reject) {
+            try {
+                (0, _dynamicrendering.postponeWithTracking)(workStore.route, 'metadata relative url resolving', dynamicTracking);
+            } catch (error) {
+                reject(error);
+                reject = null;
+            }
+        }
+        return originalThen(onfulfilled, onrejected);
+    };
+    // We wrap in a noop proxy to trick the runtime into thinking it
+    // isn't a native promise (it's not really). This is so that awaiting
+    // the promise will call the `then` property triggering the lazy postpone
+    return new Proxy(promise, {});
+}
+function createRenderPathname(underlyingPathname) {
+    return Promise.resolve(underlyingPathname);
+}
+
+//# sourceMappingURL=pathname.js.map