react-easy-wall 1.0.19 → 1.0.21

package/dist/esm/node_modules/next/dist/server/app-render/dynamic-rendering.js

@@ -1,654 +0,0 @@
-import { __exports as dynamicRendering } from '../../../../../_virtual/dynamic-rendering.js';
-import React__default from 'react';
-import { __require as requireHooksServerContext } from '../../client/components/hooks-server-context.js';
-import { __require as requireStaticGenerationBailout } from '../../client/components/static-generation-bailout.js';
-import { __require as requireWorkUnitAsyncStorage_external } from './work-unit-async-storage.external.js';
-import { __require as requireWorkAsyncStorage_external } from './work-async-storage.external.js';
-import { __require as requireDynamicRenderingUtils } from '../dynamic-rendering-utils.js';
-import { __require as requireBoundaryConstants } from '../../lib/framework/boundary-constants.js';
-import { __require as requireScheduler } from '../../lib/scheduler.js';
-import { __require as requireBailoutToCsr } from '../../shared/lib/lazy-dynamic/bailout-to-csr.js';
-import { __require as requireInvariantError } from '../../shared/lib/invariant-error.js';
-
-/**
- * The functions provided by this module are used to communicate certain properties
- * about the currently running code so that Next.js can make decisions on how to handle
- * the current execution in different rendering modes such as pre-rendering, resuming, and SSR.
- *
- * Today Next.js treats all code as potentially static. Certain APIs may only make sense when dynamically rendering.
- * Traditionally this meant deopting the entire render to dynamic however with PPR we can now deopt parts
- * of a React tree as dynamic while still keeping other parts static. There are really two different kinds of
- * Dynamic indications.
- *
- * The first is simply an intention to be dynamic. unstable_noStore is an example of this where
- * the currently executing code simply declares that the current scope is dynamic but if you use it
- * inside unstable_cache it can still be cached. This type of indication can be removed if we ever
- * make the default dynamic to begin with because the only way you would ever be static is inside
- * a cache scope which this indication does not affect.
- *
- * The second is an indication that a dynamic data source was read. This is a stronger form of dynamic
- * because it means that it is inappropriate to cache this at all. using a dynamic data source inside
- * unstable_cache should error. If you want to use some dynamic data inside unstable_cache you should
- * read that data outside the cache and pass it in as an argument to the cached function.
- */
-
-var hasRequiredDynamicRendering;
-
-function requireDynamicRendering () {
-	if (hasRequiredDynamicRendering) return dynamicRendering;
-	hasRequiredDynamicRendering = 1;
-	(function (exports$1) {
-		Object.defineProperty(exports$1, "__esModule", {
-		    value: true
-		});
-		function _export(target, all) {
-		    for(var name in all)Object.defineProperty(target, name, {
-		        enumerable: true,
-		        get: all[name]
-		    });
-		}
-		_export(exports$1, {
-		    Postpone: function() {
-		        return Postpone;
-		    },
-		    PreludeState: function() {
-		        return PreludeState;
-		    },
-		    abortAndThrowOnSynchronousRequestDataAccess: function() {
-		        return abortAndThrowOnSynchronousRequestDataAccess;
-		    },
-		    abortOnSynchronousPlatformIOAccess: function() {
-		        return abortOnSynchronousPlatformIOAccess;
-		    },
-		    accessedDynamicData: function() {
-		        return accessedDynamicData;
-		    },
-		    annotateDynamicAccess: function() {
-		        return annotateDynamicAccess;
-		    },
-		    consumeDynamicAccess: function() {
-		        return consumeDynamicAccess;
-		    },
-		    createDynamicTrackingState: function() {
-		        return createDynamicTrackingState;
-		    },
-		    createDynamicValidationState: function() {
-		        return createDynamicValidationState;
-		    },
-		    createHangingInputAbortSignal: function() {
-		        return createHangingInputAbortSignal;
-		    },
-		    createRenderInBrowserAbortSignal: function() {
-		        return createRenderInBrowserAbortSignal;
-		    },
-		    delayUntilRuntimeStage: function() {
-		        return delayUntilRuntimeStage;
-		    },
-		    formatDynamicAPIAccesses: function() {
-		        return formatDynamicAPIAccesses;
-		    },
-		    getFirstDynamicReason: function() {
-		        return getFirstDynamicReason;
-		    },
-		    isDynamicPostpone: function() {
-		        return isDynamicPostpone;
-		    },
-		    isPrerenderInterruptedError: function() {
-		        return isPrerenderInterruptedError;
-		    },
-		    logDisallowedDynamicError: function() {
-		        return logDisallowedDynamicError;
-		    },
-		    markCurrentScopeAsDynamic: function() {
-		        return markCurrentScopeAsDynamic;
-		    },
-		    postponeWithTracking: function() {
-		        return postponeWithTracking;
-		    },
-		    throwIfDisallowedDynamic: function() {
-		        return throwIfDisallowedDynamic;
-		    },
-		    throwToInterruptStaticGeneration: function() {
-		        return throwToInterruptStaticGeneration;
-		    },
-		    trackAllowedDynamicAccess: function() {
-		        return trackAllowedDynamicAccess;
-		    },
-		    trackDynamicDataInDynamicRender: function() {
-		        return trackDynamicDataInDynamicRender;
-		    },
-		    trackSynchronousPlatformIOAccessInDev: function() {
-		        return trackSynchronousPlatformIOAccessInDev;
-		    },
-		    trackSynchronousRequestDataAccessInDev: function() {
-		        return trackSynchronousRequestDataAccessInDev;
-		    },
-		    useDynamicRouteParams: function() {
-		        return useDynamicRouteParams;
-		    },
-		    warnOnSyncDynamicError: function() {
-		        return warnOnSyncDynamicError;
-		    }
-		});
-		const _react = /*#__PURE__*/ _interop_require_default(React__default);
-		const _hooksservercontext = requireHooksServerContext();
-		const _staticgenerationbailout = requireStaticGenerationBailout();
-		const _workunitasyncstorageexternal = requireWorkUnitAsyncStorage_external();
-		const _workasyncstorageexternal = requireWorkAsyncStorage_external();
-		const _dynamicrenderingutils = requireDynamicRenderingUtils();
-		const _boundaryconstants = requireBoundaryConstants();
-		const _scheduler = requireScheduler();
-		const _bailouttocsr = requireBailoutToCsr();
-		const _invarianterror = requireInvariantError();
-		function _interop_require_default(obj) {
-		    return obj && obj.__esModule ? obj : {
-		        default: obj
-		    };
-		}
-		const hasPostpone = typeof _react.default.unstable_postpone === 'function';
-		function createDynamicTrackingState(isDebugDynamicAccesses) {
-		    return {
-		        isDebugDynamicAccesses,
-		        dynamicAccesses: [],
-		        syncDynamicErrorWithStack: null
-		    };
-		}
-		function createDynamicValidationState() {
-		    return {
-		        hasSuspenseAboveBody: false,
-		        hasDynamicMetadata: false,
-		        hasDynamicViewport: false,
-		        hasAllowedDynamic: false,
-		        dynamicErrors: []
-		    };
-		}
-		function getFirstDynamicReason(trackingState) {
-		    var _trackingState_dynamicAccesses_;
-		    return (_trackingState_dynamicAccesses_ = trackingState.dynamicAccesses[0]) == null ? void 0 : _trackingState_dynamicAccesses_.expression;
-		}
-		function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
-		    if (workUnitStore) {
-		        switch(workUnitStore.type){
-		            case 'cache':
-		            case 'unstable-cache':
-		                // Inside cache scopes, marking a scope as dynamic has no effect,
-		                // because the outer cache scope creates a cache boundary. This is
-		                // subtly different from reading a dynamic data source, which is
-		                // forbidden inside a cache scope.
-		                return;
-		            case 'private-cache':
-		                // A private cache scope is already dynamic by definition.
-		                return;
-		        }
-		    }
-		    // If we're forcing dynamic rendering or we're forcing static rendering, we
-		    // don't need to do anything here because the entire page is already dynamic
-		    // or it's static and it should not throw or postpone here.
-		    if (store.forceDynamic || store.forceStatic) return;
-		    if (store.dynamicShouldError) {
-		        throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${store.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
-		            value: "E553",
-		            enumerable: false,
-		            configurable: true
-		        });
-		    }
-		    if (workUnitStore) {
-		        switch(workUnitStore.type){
-		            case 'prerender-ppr':
-		                return postponeWithTracking(store.route, expression, workUnitStore.dynamicTracking);
-		            case 'prerender-legacy':
-		                workUnitStore.revalidate = 0;
-		                // We aren't prerendering, but we are generating a static page. We need
-		                // to bail out of static generation.
-		                const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
-		                    value: "E550",
-		                    enumerable: false,
-		                    configurable: true
-		                });
-		                store.dynamicUsageDescription = expression;
-		                store.dynamicUsageStack = err.stack;
-		                throw err;
-		            case 'request':
-		                if (process.env.NODE_ENV !== 'production') {
-		                    workUnitStore.usedDynamic = true;
-		                }
-		                break;
-		        }
-		    }
-		}
-		function throwToInterruptStaticGeneration(expression, store, prerenderStore) {
-		    // We aren't prerendering but we are generating a static page. We need to bail out of static generation
-		    const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
-		        value: "E558",
-		        enumerable: false,
-		        configurable: true
-		    });
-		    prerenderStore.revalidate = 0;
-		    store.dynamicUsageDescription = expression;
-		    store.dynamicUsageStack = err.stack;
-		    throw err;
-		}
-		function trackDynamicDataInDynamicRender(workUnitStore) {
-		    switch(workUnitStore.type){
-		        case 'cache':
-		        case 'unstable-cache':
-		            // Inside cache scopes, marking a scope as dynamic has no effect,
-		            // because the outer cache scope creates a cache boundary. This is
-		            // subtly different from reading a dynamic data source, which is
-		            // forbidden inside a cache scope.
-		            return;
-		        case 'private-cache':
-		            // A private cache scope is already dynamic by definition.
-		            return;
-		        case 'prerender':
-		        case 'prerender-runtime':
-		        case 'prerender-legacy':
-		        case 'prerender-ppr':
-		        case 'prerender-client':
-		            break;
-		        case 'request':
-		            if (process.env.NODE_ENV !== 'production') {
-		                workUnitStore.usedDynamic = true;
-		            }
-		            break;
-		    }
-		}
-		function abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore) {
-		    const reason = `Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`;
-		    const error = createPrerenderInterruptedError(reason);
-		    prerenderStore.controller.abort(error);
-		    const dynamicTracking = prerenderStore.dynamicTracking;
-		    if (dynamicTracking) {
-		        dynamicTracking.dynamicAccesses.push({
-		            // When we aren't debugging, we don't need to create another error for the
-		            // stack trace.
-		            stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : undefined,
-		            expression
-		        });
-		    }
-		}
-		function abortOnSynchronousPlatformIOAccess(route, expression, errorWithStack, prerenderStore) {
-		    const dynamicTracking = prerenderStore.dynamicTracking;
-		    abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
-		    // It is important that we set this tracking value after aborting. Aborts are executed
-		    // synchronously except for the case where you abort during render itself. By setting this
-		    // value late we can use it to determine if any of the aborted tasks are the task that
-		    // called the sync IO expression in the first place.
-		    if (dynamicTracking) {
-		        if (dynamicTracking.syncDynamicErrorWithStack === null) {
-		            dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
-		        }
-		    }
-		}
-		function trackSynchronousPlatformIOAccessInDev(requestStore) {
-		    // We don't actually have a controller to abort but we do the semantic equivalent by
-		    // advancing the request store out of prerender mode
-		    requestStore.prerenderPhase = false;
-		}
-		function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWithStack, prerenderStore) {
-		    const prerenderSignal = prerenderStore.controller.signal;
-		    if (prerenderSignal.aborted === false) {
-		        // TODO it would be better to move this aborted check into the callsite so we can avoid making
-		        // the error object when it isn't relevant to the aborting of the prerender however
-		        // since we need the throw semantics regardless of whether we abort it is easier to land
-		        // this way. See how this was handled with `abortOnSynchronousPlatformIOAccess` for a closer
-		        // to ideal implementation
-		        abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
-		        // It is important that we set this tracking value after aborting. Aborts are executed
-		        // synchronously except for the case where you abort during render itself. By setting this
-		        // value late we can use it to determine if any of the aborted tasks are the task that
-		        // called the sync IO expression in the first place.
-		        const dynamicTracking = prerenderStore.dynamicTracking;
-		        if (dynamicTracking) {
-		            if (dynamicTracking.syncDynamicErrorWithStack === null) {
-		                dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
-		            }
-		        }
-		    }
-		    throw createPrerenderInterruptedError(`Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`);
-		}
-		function warnOnSyncDynamicError(dynamicTracking) {
-		    if (dynamicTracking.syncDynamicErrorWithStack) {
-		        // the server did something sync dynamic, likely
-		        // leading to an early termination of the prerender.
-		        console.error(dynamicTracking.syncDynamicErrorWithStack);
-		    }
-		}
-		const trackSynchronousRequestDataAccessInDev = trackSynchronousPlatformIOAccessInDev;
-		function Postpone({ reason, route }) {
-		    const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-		    const dynamicTracking = prerenderStore && prerenderStore.type === 'prerender-ppr' ? prerenderStore.dynamicTracking : null;
-		    postponeWithTracking(route, reason, dynamicTracking);
-		}
-		function postponeWithTracking(route, expression, dynamicTracking) {
-		    assertPostpone();
-		    if (dynamicTracking) {
-		        dynamicTracking.dynamicAccesses.push({
-		            // When we aren't debugging, we don't need to create another error for the
-		            // stack trace.
-		            stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : undefined,
-		            expression
-		        });
-		    }
-		    _react.default.unstable_postpone(createPostponeReason(route, expression));
-		}
-		function createPostponeReason(route, expression) {
-		    return `Route ${route} needs to bail out of prerendering at this point because it used ${expression}. ` + `React throws this special object to indicate where. It should not be caught by ` + `your own try/catch. Learn more: https://nextjs.org/docs/messages/ppr-caught-error`;
-		}
-		function isDynamicPostpone(err) {
-		    if (typeof err === 'object' && err !== null && typeof err.message === 'string') {
-		        return isDynamicPostponeReason(err.message);
-		    }
-		    return false;
-		}
-		function isDynamicPostponeReason(reason) {
-		    return reason.includes('needs to bail out of prerendering at this point because it used') && reason.includes('Learn more: https://nextjs.org/docs/messages/ppr-caught-error');
-		}
-		if (isDynamicPostponeReason(createPostponeReason('%%%', '^^^')) === false) {
-		    throw Object.defineProperty(new Error('Invariant: isDynamicPostpone misidentified a postpone reason. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
-		        value: "E296",
-		        enumerable: false,
-		        configurable: true
-		    });
-		}
-		const NEXT_PRERENDER_INTERRUPTED = 'NEXT_PRERENDER_INTERRUPTED';
-		function createPrerenderInterruptedError(message) {
-		    const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-		        value: "E394",
-		        enumerable: false,
-		        configurable: true
-		    });
-		    error.digest = NEXT_PRERENDER_INTERRUPTED;
-		    return error;
-		}
-		function isPrerenderInterruptedError(error) {
-		    return typeof error === 'object' && error !== null && error.digest === NEXT_PRERENDER_INTERRUPTED && 'name' in error && 'message' in error && error instanceof Error;
-		}
-		function accessedDynamicData(dynamicAccesses) {
-		    return dynamicAccesses.length > 0;
-		}
-		function consumeDynamicAccess(serverDynamic, clientDynamic) {
-		    // We mutate because we only call this once we are no longer writing
-		    // to the dynamicTrackingState and it's more efficient than creating a new
-		    // array.
-		    serverDynamic.dynamicAccesses.push(...clientDynamic.dynamicAccesses);
-		    return serverDynamic.dynamicAccesses;
-		}
-		function formatDynamicAPIAccesses(dynamicAccesses) {
-		    return dynamicAccesses.filter((access)=>typeof access.stack === 'string' && access.stack.length > 0).map(({ expression, stack })=>{
-		        stack = stack.split('\n')// Remove the "Error: " prefix from the first line of the stack trace as
-		        // well as the first 4 lines of the stack trace which is the distance
-		        // from the user code and the `new Error().stack` call.
-		        .slice(4).filter((line)=>{
-		            // Exclude Next.js internals from the stack trace.
-		            if (line.includes('node_modules/next/')) {
-		                return false;
-		            }
-		            // Exclude anonymous functions from the stack trace.
-		            if (line.includes(' (<anonymous>)')) {
-		                return false;
-		            }
-		            // Exclude Node.js internals from the stack trace.
-		            if (line.includes(' (node:')) {
-		                return false;
-		            }
-		            return true;
-		        }).join('\n');
-		        return `Dynamic API Usage Debug - ${expression}:\n${stack}`;
-		    });
-		}
-		function assertPostpone() {
-		    if (!hasPostpone) {
-		        throw Object.defineProperty(new Error(`Invariant: React.unstable_postpone is not defined. This suggests the wrong version of React was loaded. This is a bug in Next.js`), "__NEXT_ERROR_CODE", {
-		            value: "E224",
-		            enumerable: false,
-		            configurable: true
-		        });
-		    }
-		}
-		function createRenderInBrowserAbortSignal() {
-		    const controller = new AbortController();
-		    controller.abort(Object.defineProperty(new _bailouttocsr.BailoutToCSRError('Render in Browser'), "__NEXT_ERROR_CODE", {
-		        value: "E721",
-		        enumerable: false,
-		        configurable: true
-		    }));
-		    return controller.signal;
-		}
-		function createHangingInputAbortSignal(workUnitStore) {
-		    switch(workUnitStore.type){
-		        case 'prerender':
-		        case 'prerender-runtime':
-		            const controller = new AbortController();
-		            if (workUnitStore.cacheSignal) {
-		                // If we have a cacheSignal it means we're in a prospective render. If
-		                // the input we're waiting on is coming from another cache, we do want
-		                // to wait for it so that we can resolve this cache entry too.
-		                workUnitStore.cacheSignal.inputReady().then(()=>{
-		                    controller.abort();
-		                });
-		            } else {
-		                // Otherwise we're in the final render and we should already have all
-		                // our caches filled.
-		                // If the prerender uses stages, we have wait until the runtime stage,
-		                // at which point all runtime inputs will be resolved.
-		                // (otherwise, a runtime prerender might consider `cookies()` hanging
-		                //  even though they'd resolve in the next task.)
-		                //
-		                // We might still be waiting on some microtasks so we
-		                // wait one tick before giving up. When we give up, we still want to
-		                // render the content of this cache as deeply as we can so that we can
-		                // suspend as deeply as possible in the tree or not at all if we don't
-		                // end up waiting for the input.
-		                const runtimeStagePromise = (0, _workunitasyncstorageexternal.getRuntimeStagePromise)(workUnitStore);
-		                if (runtimeStagePromise) {
-		                    runtimeStagePromise.then(()=>(0, _scheduler.scheduleOnNextTick)(()=>controller.abort()));
-		                } else {
-		                    (0, _scheduler.scheduleOnNextTick)(()=>controller.abort());
-		                }
-		            }
-		            return controller.signal;
-		        case 'prerender-client':
-		        case 'prerender-ppr':
-		        case 'prerender-legacy':
-		        case 'request':
-		        case 'cache':
-		        case 'private-cache':
-		        case 'unstable-cache':
-		            return undefined;
-		    }
-		}
-		function annotateDynamicAccess(expression, prerenderStore) {
-		    const dynamicTracking = prerenderStore.dynamicTracking;
-		    if (dynamicTracking) {
-		        dynamicTracking.dynamicAccesses.push({
-		            stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : undefined,
-		            expression
-		        });
-		    }
-		}
-		function useDynamicRouteParams(expression) {
-		    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-		    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-		    if (workStore && workUnitStore) {
-		        switch(workUnitStore.type){
-		            case 'prerender-client':
-		            case 'prerender':
-		                {
-		                    const fallbackParams = workUnitStore.fallbackRouteParams;
-		                    if (fallbackParams && fallbackParams.size > 0) {
-		                        // We are in a prerender with cacheComponents semantics. We are going to
-		                        // hang here and never resolve. This will cause the currently
-		                        // rendering component to effectively be a dynamic hole.
-		                        _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
-		                    }
-		                    break;
-		                }
-		            case 'prerender-ppr':
-		                {
-		                    const fallbackParams = workUnitStore.fallbackRouteParams;
-		                    if (fallbackParams && fallbackParams.size > 0) {
-		                        return postponeWithTracking(workStore.route, expression, workUnitStore.dynamicTracking);
-		                    }
-		                    break;
-		                }
-		            case 'prerender-runtime':
-		                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called during a runtime prerender. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-		                    value: "E771",
-		                    enumerable: false,
-		                    configurable: true
-		                });
-		            case 'cache':
-		            case 'private-cache':
-		                throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called inside a cache scope. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
-		                    value: "E745",
-		                    enumerable: false,
-		                    configurable: true
-		                });
-		        }
-		    }
-		}
-		const hasSuspenseRegex = /\n\s+at Suspense \(<anonymous>\)/;
-		// Common implicit body tags that React will treat as body when placed directly in html
-		const bodyAndImplicitTags = 'body|div|main|section|article|aside|header|footer|nav|form|p|span|h1|h2|h3|h4|h5|h6';
-		// Detects when RootLayoutBoundary (our framework marker component) appears
-		// after Suspense in the component stack, indicating the root layout is wrapped
-		// within a Suspense boundary. Ensures no body/html/implicit-body components are in between.
-		//
-		// Example matches:
-		//   at Suspense (<anonymous>)
-		//   at __next_root_layout_boundary__ (<anonymous>)
-		//
-		// Or with other components in between (but not body/html/implicit-body):
-		//   at Suspense (<anonymous>)
-		//   at SomeComponent (<anonymous>)
-		//   at __next_root_layout_boundary__ (<anonymous>)
-		const hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex = new RegExp(`\\n\\s+at Suspense \\(<anonymous>\\)(?:(?!\\n\\s+at (?:${bodyAndImplicitTags}) \\(<anonymous>\\))[\\s\\S])*?\\n\\s+at ${_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME} \\([^\\n]*\\)`);
-		const hasMetadataRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.METADATA_BOUNDARY_NAME}[\\n\\s]`);
-		const hasViewportRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
-		const hasOutletRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
-		function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation, clientDynamic) {
-		    if (hasOutletRegex.test(componentStack)) {
-		        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
-		        return;
-		    } else if (hasMetadataRegex.test(componentStack)) {
-		        dynamicValidation.hasDynamicMetadata = true;
-		        return;
-		    } else if (hasViewportRegex.test(componentStack)) {
-		        dynamicValidation.hasDynamicViewport = true;
-		        return;
-		    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
-		        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
-		        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
-		        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
-		        dynamicValidation.hasAllowedDynamic = true;
-		        dynamicValidation.hasSuspenseAboveBody = true;
-		        return;
-		    } else if (hasSuspenseRegex.test(componentStack)) {
-		        // this error had a Suspense boundary above it so we don't need to report it as a source
-		        // of disallowed
-		        dynamicValidation.hasAllowedDynamic = true;
-		        return;
-		    } else if (clientDynamic.syncDynamicErrorWithStack) {
-		        // This task was the task that called the sync error.
-		        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
-		        return;
-		    } else {
-		        const message = `Route "${workStore.route}": A component accessed data, headers, params, searchParams, or a short-lived cache without a Suspense boundary nor a "use cache" above it. See more info: https://nextjs.org/docs/messages/next-prerender-missing-suspense`;
-		        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
-		        dynamicValidation.dynamicErrors.push(error);
-		        return;
-		    }
-		}
-		/**
-		 * In dev mode, we prefer using the owner stack, otherwise the provided
-		 * component stack is used.
-		 */ function createErrorWithComponentOrOwnerStack(message, componentStack) {
-		    const ownerStack = process.env.NODE_ENV !== 'production' && _react.default.captureOwnerStack ? _react.default.captureOwnerStack() : null;
-		    const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-		        value: "E394",
-		        enumerable: false,
-		        configurable: true
-		    });
-		    error.stack = error.name + ': ' + message + (ownerStack ?? componentStack);
-		    return error;
-		}
-		var PreludeState = /*#__PURE__*/ function(PreludeState) {
-		    PreludeState[PreludeState["Full"] = 0] = "Full";
-		    PreludeState[PreludeState["Empty"] = 1] = "Empty";
-		    PreludeState[PreludeState["Errored"] = 2] = "Errored";
-		    return PreludeState;
-		}({});
-		function logDisallowedDynamicError(workStore, error) {
-		    console.error(error);
-		    if (!workStore.dev) {
-		        if (workStore.hasReadableErrorStacks) {
-		            console.error(`To get a more detailed stack trace and pinpoint the issue, start the app in development mode by running \`next dev\`, then open "${workStore.route}" in your browser to investigate the error.`);
-		        } else {
-		            console.error(`To get a more detailed stack trace and pinpoint the issue, try one of the following:
-  - Start the app in development mode by running \`next dev\`, then open "${workStore.route}" in your browser to investigate the error.
-  - Rerun the production build with \`next build --debug-prerender\` to generate better stack traces.`);
-		        }
-		    }
-		}
-		function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic) {
-		    if (prelude !== 0) {
-		        if (dynamicValidation.hasSuspenseAboveBody) {
-		            // This route has opted into allowing fully dynamic rendering
-		            // by including a Suspense boundary above the body. In this case
-		            // a lack of a shell is not considered disallowed so we simply return
-		            return;
-		        }
-		        if (serverDynamic.syncDynamicErrorWithStack) {
-		            // There is no shell and the server did something sync dynamic likely
-		            // leading to an early termination of the prerender before the shell
-		            // could be completed. We terminate the build/validating render.
-		            logDisallowedDynamicError(workStore, serverDynamic.syncDynamicErrorWithStack);
-		            throw new _staticgenerationbailout.StaticGenBailoutError();
-		        }
-		        // We didn't have any sync bailouts but there may be user code which
-		        // blocked the root. We would have captured these during the prerender
-		        // and can log them here and then terminate the build/validating render
-		        const dynamicErrors = dynamicValidation.dynamicErrors;
-		        if (dynamicErrors.length > 0) {
-		            for(let i = 0; i < dynamicErrors.length; i++){
-		                logDisallowedDynamicError(workStore, dynamicErrors[i]);
-		            }
-		            throw new _staticgenerationbailout.StaticGenBailoutError();
-		        }
-		        // If we got this far then the only other thing that could be blocking
-		        // the root is dynamic Viewport. If this is dynamic then
-		        // you need to opt into that by adding a Suspense boundary above the body
-		        // to indicate your are ok with fully dynamic rendering.
-		        if (dynamicValidation.hasDynamicViewport) {
-		            console.error(`Route "${workStore.route}" has a \`generateViewport\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) without explicitly allowing fully dynamic rendering. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`);
-		            throw new _staticgenerationbailout.StaticGenBailoutError();
-		        }
-		        if (prelude === 1) {
-		            // If we ever get this far then we messed up the tracking of invalid dynamic.
-		            // We still adhere to the constraint that you must produce a shell but invite the
-		            // user to report this as a bug in Next.js.
-		            console.error(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason. This is a bug in Next.js.`);
-		            throw new _staticgenerationbailout.StaticGenBailoutError();
-		        }
-		    } else {
-		        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.hasDynamicMetadata) {
-		            console.error(`Route "${workStore.route}" has a \`generateMetadata\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) when the rest of the route does not. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`);
-		            throw new _staticgenerationbailout.StaticGenBailoutError();
-		        }
-		    }
-		}
-		function delayUntilRuntimeStage(prerenderStore, result) {
-		    if (prerenderStore.runtimeStagePromise) {
-		        return prerenderStore.runtimeStagePromise.then(()=>result);
-		    }
-		    return result;
-		}
-
-		
-	} (dynamicRendering));
-	return dynamicRendering;
-}
-
-export { requireDynamicRendering as __require };
-//# sourceMappingURL=dynamic-rendering.js.map