@obsfx/trekker 0.1.7 → 0.1.9

package/webapp-dist/vendor/next/dist/server/request/search-params.js

@@ -0,0 +1,432 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createPrerenderSearchParamsForClientPage: null,
+    createSearchParamsFromClient: null,
+    createServerSearchParamsForMetadata: null,
+    createServerSearchParamsForServerPage: null,
+    makeErroringSearchParamsForUseCache: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createPrerenderSearchParamsForClientPage: function() {
+        return createPrerenderSearchParamsForClientPage;
+    },
+    createSearchParamsFromClient: function() {
+        return createSearchParamsFromClient;
+    },
+    createServerSearchParamsForMetadata: function() {
+        return createServerSearchParamsForMetadata;
+    },
+    createServerSearchParamsForServerPage: function() {
+        return createServerSearchParamsForServerPage;
+    },
+    makeErroringSearchParamsForUseCache: function() {
+        return makeErroringSearchParamsForUseCache;
+    }
+});
+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 _dynamicrenderingutils = require("../dynamic-rendering-utils");
+const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-callsite-server-error-logger");
+const _reflectutils = require("../../shared/lib/utils/reflect-utils");
+const _utils = require("./utils");
+const _stagedrendering = require("../app-render/staged-rendering");
+function createSearchParamsFromClient(underlyingSearchParams, workStore) {
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-client':
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+                return createStaticPrerenderSearchParams(workStore, workUnitStore);
+            case 'prerender-runtime':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
+                    value: "E769",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'cache':
+            case 'private-cache':
+            case 'unstable-cache':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
+                    value: "E739",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'request':
+                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore);
+            default:
+                workUnitStore;
+        }
+    }
+    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
+}
+const createServerSearchParamsForMetadata = createServerSearchParamsForServerPage;
+function createServerSearchParamsForServerPage(underlyingSearchParams, workStore) {
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-client':
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+                return createStaticPrerenderSearchParams(workStore, workUnitStore);
+            case 'cache':
+            case 'private-cache':
+            case 'unstable-cache':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createServerSearchParamsForServerPage should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
+                    value: "E747",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'prerender-runtime':
+                return createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore);
+            case 'request':
+                return createRenderSearchParams(underlyingSearchParams, workStore, workUnitStore);
+            default:
+                workUnitStore;
+        }
+    }
+    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
+}
+function createPrerenderSearchParamsForClientPage(workStore) {
+    if (workStore.forceStatic) {
+        // When using forceStatic we override all other logic and always just return an empty
+        // dictionary object.
+        return Promise.resolve({});
+    }
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-client':
+                // We're prerendering in a mode that aborts (cacheComponents) and should stall
+                // the promise to ensure the RSC side is considered dynamic
+                return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`searchParams`');
+            case 'prerender-runtime':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
+                    value: "E768",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'cache':
+            case 'private-cache':
+            case 'unstable-cache':
+                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
+                    value: "E746",
+                    enumerable: false,
+                    configurable: true
+                });
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+            case 'request':
+                return Promise.resolve({});
+            default:
+                workUnitStore;
+        }
+    }
+    (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
+}
+function createStaticPrerenderSearchParams(workStore, prerenderStore) {
+    if (workStore.forceStatic) {
+        // When using forceStatic we override all other logic and always just return an empty
+        // dictionary object.
+        return Promise.resolve({});
+    }
+    switch(prerenderStore.type){
+        case 'prerender':
+        case 'prerender-client':
+            // We are in a cacheComponents (PPR or otherwise) prerender
+            return makeHangingSearchParams(workStore, prerenderStore);
+        case 'prerender-ppr':
+        case 'prerender-legacy':
+            // We are in a legacy static generation and need to interrupt the
+            // prerender when search params are accessed.
+            return makeErroringSearchParams(workStore, prerenderStore);
+        default:
+            return prerenderStore;
+    }
+}
+function createRuntimePrerenderSearchParams(underlyingSearchParams, workUnitStore) {
+    return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedSearchParams(underlyingSearchParams));
+}
+function createRenderSearchParams(underlyingSearchParams, workStore, requestStore) {
+    if (workStore.forceStatic) {
+        // When using forceStatic we override all other logic and always just return an empty
+        // dictionary object.
+        return Promise.resolve({});
+    } else {
+        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 makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore);
+        } else {
+            return makeUntrackedSearchParams(underlyingSearchParams);
+        }
+    }
+}
+const CachedSearchParams = new WeakMap();
+const CachedSearchParamsForUseCache = new WeakMap();
+function makeHangingSearchParams(workStore, prerenderStore) {
+    const cachedSearchParams = CachedSearchParams.get(prerenderStore);
+    if (cachedSearchParams) {
+        return cachedSearchParams;
+    }
+    const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`searchParams`');
+    const proxiedPromise = new Proxy(promise, {
+        get (target, prop, receiver) {
+            if (Object.hasOwn(promise, prop)) {
+                // The promise has this property directly. we must return it.
+                // We know it isn't a dynamic access because it can only be something
+                // that was previously written to the promise and thus not an underlying searchParam value
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+            switch(prop){
+                case 'then':
+                    {
+                        const expression = '`await searchParams`, `searchParams.then`, or similar';
+                        (0, _dynamicrendering.annotateDynamicAccess)(expression, prerenderStore);
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                    }
+                case 'status':
+                    {
+                        const expression = '`use(searchParams)`, `searchParams.status`, or similar';
+                        (0, _dynamicrendering.annotateDynamicAccess)(expression, prerenderStore);
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                    }
+                default:
+                    {
+                        return _reflect.ReflectAdapter.get(target, prop, receiver);
+                    }
+            }
+        }
+    });
+    CachedSearchParams.set(prerenderStore, proxiedPromise);
+    return proxiedPromise;
+}
+function makeErroringSearchParams(workStore, prerenderStore) {
+    const cachedSearchParams = CachedSearchParams.get(workStore);
+    if (cachedSearchParams) {
+        return cachedSearchParams;
+    }
+    const underlyingSearchParams = {};
+    // For search params we don't construct a ReactPromise because we want to interrupt
+    // rendering on any property access that was not set from outside and so we only want
+    // to have properties like value and status if React sets them.
+    const promise = Promise.resolve(underlyingSearchParams);
+    const proxiedPromise = new Proxy(promise, {
+        get (target, prop, receiver) {
+            if (Object.hasOwn(promise, prop)) {
+                // The promise has this property directly. we must return it.
+                // We know it isn't a dynamic access because it can only be something
+                // that was previously written to the promise and thus not an underlying searchParam value
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+            if (typeof prop === 'string' && prop === 'then') {
+                const expression = '`await searchParams`, `searchParams.then`, or similar';
+                if (workStore.dynamicShouldError) {
+                    (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
+                } else 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);
+                }
+            }
+            return _reflect.ReflectAdapter.get(target, prop, receiver);
+        }
+    });
+    CachedSearchParams.set(workStore, proxiedPromise);
+    return proxiedPromise;
+}
+function makeErroringSearchParamsForUseCache(workStore) {
+    const cachedSearchParams = CachedSearchParamsForUseCache.get(workStore);
+    if (cachedSearchParams) {
+        return cachedSearchParams;
+    }
+    const promise = Promise.resolve({});
+    const proxiedPromise = new Proxy(promise, {
+        get: function get(target, prop, receiver) {
+            if (Object.hasOwn(promise, prop)) {
+                // The promise has this property directly. we must return it. We know it
+                // isn't a dynamic access because it can only be something that was
+                // previously written to the promise and thus not an underlying
+                // searchParam value
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+            if (typeof prop === 'string' && (prop === 'then' || !_reflectutils.wellKnownProperties.has(prop))) {
+                (0, _utils.throwForSearchParamsAccessInUseCache)(workStore, get);
+            }
+            return _reflect.ReflectAdapter.get(target, prop, receiver);
+        }
+    });
+    CachedSearchParamsForUseCache.set(workStore, proxiedPromise);
+    return proxiedPromise;
+}
+function makeUntrackedSearchParams(underlyingSearchParams) {
+    const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
+    if (cachedSearchParams) {
+        return cachedSearchParams;
+    }
+    const promise = Promise.resolve(underlyingSearchParams);
+    CachedSearchParams.set(underlyingSearchParams, promise);
+    return promise;
+}
+function makeUntrackedSearchParamsWithDevWarnings(underlyingSearchParams, workStore, requestStore) {
+    if (requestStore.asyncApiPromises) {
+        // Do not cache the resulting promise. If we do, we'll only show the first "awaited at"
+        // across all segments that receive searchParams.
+        return makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore);
+    } else {
+        const cachedSearchParams = CachedSearchParams.get(underlyingSearchParams);
+        if (cachedSearchParams) {
+            return cachedSearchParams;
+        }
+        const promise = makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore);
+        CachedSearchParams.set(requestStore, promise);
+        return promise;
+    }
+}
+function makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, workStore, requestStore) {
+    const promiseInitialized = {
+        current: false
+    };
+    const proxiedUnderlying = instrumentSearchParamsObjectWithDevWarnings(underlyingSearchParams, workStore, promiseInitialized);
+    let promise;
+    if (requestStore.asyncApiPromises) {
+        // We wrap each instance of searchParams in a `new Promise()`.
+        // This is important when all awaits are in third party which would otherwise
+        // track all the way to the internal params.
+        const sharedSearchParamsParent = requestStore.asyncApiPromises.sharedSearchParamsParent;
+        promise = new Promise((resolve, reject)=>{
+            sharedSearchParamsParent.then(()=>resolve(proxiedUnderlying), reject);
+        });
+        // @ts-expect-error
+        promise.displayName = 'searchParams';
+    } else {
+        promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(proxiedUnderlying, requestStore, _stagedrendering.RenderStage.Runtime);
+    }
+    promise.then(()=>{
+        promiseInitialized.current = true;
+    }, // If we're in staged rendering, this promise will reject if the render
+    // is aborted before it can reach the runtime stage.
+    // In that case, we have to prevent an unhandled rejection from the promise
+    // created by this `.then()` call.
+    // This does not affect the `promiseInitialized` logic above,
+    // because `proxiedUnderlying` will not be used to resolve the promise,
+    // so there's no risk of any of its properties being accessed and triggering
+    // an undesireable warning.
+    ignoreReject);
+    return instrumentSearchParamsPromiseWithDevWarnings(underlyingSearchParams, promise, workStore);
+}
+function ignoreReject() {}
+function instrumentSearchParamsObjectWithDevWarnings(underlyingSearchParams, workStore, promiseInitialized) {
+    // We have an unfortunate sequence of events that requires this initialization logic. We want to instrument the underlying
+    // searchParams object to detect if you are accessing values in dev. This is used for warnings and for things like the static prerender
+    // indicator. However when we pass this proxy to our Promise.resolve() below the VM checks if the resolved value is a promise by looking
+    // at the `.then` property. To our dynamic tracking logic this is indistinguishable from a `then` searchParam and so we would normally trigger
+    // dynamic tracking. However we know that this .then is not real dynamic access, it's just how thenables resolve in sequence. So we introduce
+    // this initialization concept so we omit the dynamic check until after we've constructed our resolved promise.
+    return new Proxy(underlyingSearchParams, {
+        get (target, prop, receiver) {
+            if (typeof prop === 'string' && promiseInitialized.current) {
+                if (workStore.dynamicShouldError) {
+                    const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', prop);
+                    (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
+                }
+            }
+            return _reflect.ReflectAdapter.get(target, prop, receiver);
+        },
+        has (target, prop) {
+            if (typeof prop === 'string') {
+                if (workStore.dynamicShouldError) {
+                    const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
+                    (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
+                }
+            }
+            return Reflect.has(target, prop);
+        },
+        ownKeys (target) {
+            if (workStore.dynamicShouldError) {
+                const expression = '`{...searchParams}`, `Object.keys(searchParams)`, or similar';
+                (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
+            }
+            return Reflect.ownKeys(target);
+        }
+    });
+}
+function instrumentSearchParamsPromiseWithDevWarnings(underlyingSearchParams, promise, workStore) {
+    // Track which properties we should warn for.
+    const proxiedProperties = new Set();
+    Object.keys(underlyingSearchParams).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 (prop === 'then' && workStore.dynamicShouldError) {
+                const expression = '`searchParams.then`';
+                (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
+            }
+            if (typeof prop === 'string') {
+                if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
+                // the underlying searchParams.
+                Reflect.has(target, prop) === false)) {
+                    const expression = (0, _reflectutils.describeStringPropertyAccess)('searchParams', 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.set(target, prop, value, receiver);
+        },
+        has (target, prop) {
+            if (typeof prop === 'string') {
+                if (!_reflectutils.wellKnownProperties.has(prop) && (proxiedProperties.has(prop) || // We are accessing a property that doesn't exist on the promise nor
+                // the underlying searchParams.
+                Reflect.has(target, prop) === false)) {
+                    const expression = (0, _reflectutils.describeHasCheckingStringProperty)('searchParams', prop);
+                    warnForSyncAccess(workStore.route, expression);
+                }
+            }
+            return Reflect.has(target, prop);
+        },
+        ownKeys (target) {
+            const expression = '`Object.keys(searchParams)` or similar';
+            warnForSyncAccess(workStore.route, expression);
+            return Reflect.ownKeys(target);
+        }
+    });
+}
+const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createSearchAccessError);
+function createSearchAccessError(route, expression) {
+    const prefix = route ? `Route "${route}" ` : 'This route ';
+    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`searchParams\` is a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E848",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=search-params.js.map

package/webapp-dist/vendor/next/dist/server/request/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isRequestAPICallableInsideAfter: null,
+    throwForSearchParamsAccessInUseCache: null,
+    throwWithStaticGenerationBailoutErrorWithDynamicError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isRequestAPICallableInsideAfter: function() {
+        return isRequestAPICallableInsideAfter;
+    },
+    throwForSearchParamsAccessInUseCache: function() {
+        return throwForSearchParamsAccessInUseCache;
+    },
+    throwWithStaticGenerationBailoutErrorWithDynamicError: function() {
+        return throwWithStaticGenerationBailoutErrorWithDynamicError;
+    }
+});
+const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
+const _aftertaskasyncstorageexternal = require("../app-render/after-task-async-storage.external");
+function throwWithStaticGenerationBailoutErrorWithDynamicError(route, expression) {
+    throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} with \`dynamic = "error"\` couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+        value: "E543",
+        enumerable: false,
+        configurable: true
+    });
+}
+function throwForSearchParamsAccessInUseCache(workStore, constructorOpt) {
+    const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`searchParams\` inside "use cache". Accessing dynamic request data inside a cache scope is not supported. If you need some search params inside a cached function await \`searchParams\` outside of the cached function and pass only the required search params as arguments to the cached function. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+        value: "E842",
+        enumerable: false,
+        configurable: true
+    });
+    Error.captureStackTrace(error, constructorOpt);
+    workStore.invalidDynamicUsageError ??= error;
+    throw error;
+}
+function isRequestAPICallableInsideAfter() {
+    const afterTaskStore = _aftertaskasyncstorageexternal.afterTaskAsyncStorage.getStore();
+    return (afterTaskStore == null ? void 0 : afterTaskStore.rootTaskSpawnPhase) === 'action';
+}
+
+//# sourceMappingURL=utils.js.map

package/webapp-dist/vendor/next/dist/server/request-meta.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NEXT_REQUEST_META: null,
+    addRequestMeta: null,
+    getRequestMeta: null,
+    removeRequestMeta: null,
+    setRequestMeta: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NEXT_REQUEST_META: function() {
+        return NEXT_REQUEST_META;
+    },
+    addRequestMeta: function() {
+        return addRequestMeta;
+    },
+    getRequestMeta: function() {
+        return getRequestMeta;
+    },
+    removeRequestMeta: function() {
+        return removeRequestMeta;
+    },
+    setRequestMeta: function() {
+        return setRequestMeta;
+    }
+});
+const NEXT_REQUEST_META = Symbol.for('NextInternalRequestMeta');
+function getRequestMeta(req, key) {
+    const meta = req[NEXT_REQUEST_META] || {};
+    return typeof key === 'string' ? meta[key] : meta;
+}
+function setRequestMeta(req, meta) {
+    req[NEXT_REQUEST_META] = meta;
+    return meta;
+}
+function addRequestMeta(request, key, value) {
+    const meta = getRequestMeta(request);
+    meta[key] = value;
+    return setRequestMeta(request, meta);
+}
+function removeRequestMeta(request, key) {
+    const meta = getRequestMeta(request);
+    delete meta[key];
+    return setRequestMeta(request, meta);
+}
+
+//# sourceMappingURL=request-meta.js.map

package/webapp-dist/vendor/next/dist/server/require-hook.js

@@ -0,0 +1,71 @@
+// Synchronously inject a require hook for webpack and webpack/. It's required to use the internal ncc webpack version.
+// This is needed for userland plugins to attach to the same webpack instance as Next.js'.
+// Individually compiled modules are as defined for the compilation in bundles/webpack/packages/*.
+// This module will only be loaded once per process.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    addHookAliases: null,
+    defaultOverrides: null,
+    hookPropertyMap: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    addHookAliases: function() {
+        return addHookAliases;
+    },
+    defaultOverrides: function() {
+        return defaultOverrides;
+    },
+    hookPropertyMap: function() {
+        return hookPropertyMap;
+    }
+});
+const path = require('path');
+const mod = require('module');
+const originalRequire = mod.prototype.require;
+const resolveFilename = // @ts-expect-error
+mod._resolveFilename;
+let resolve = process.env.NEXT_MINIMAL ? __non_webpack_require__.resolve : require.resolve;
+const hookPropertyMap = new Map();
+const defaultOverrides = {
+    'styled-jsx': path.dirname(resolve('styled-jsx/package.json')),
+    'styled-jsx/style': resolve('styled-jsx/style'),
+    'styled-jsx/style.js': resolve('styled-jsx/style')
+};
+const toResolveMap = (map)=>Object.entries(map).map(([key, value])=>[
+            key,
+            resolve(value)
+        ]);
+function addHookAliases(aliases = []) {
+    for (const [key, value] of aliases){
+        hookPropertyMap.set(key, value);
+    }
+}
+addHookAliases(toResolveMap(defaultOverrides));
+// @ts-expect-error
+mod._resolveFilename = (function(originalResolveFilename, requestMap, request, parent, isMain, options) {
+    const hookResolved = requestMap.get(request);
+    if (hookResolved) request = hookResolved;
+    return originalResolveFilename.call(mod, request, parent, isMain, options);
+// We use `bind` here to avoid referencing outside variables to create potential memory leaks.
+}).bind(null, resolveFilename, hookPropertyMap);
+// @ts-expect-error
+// This is a hack to make sure that if a user requires a Next.js module that wasn't bundled
+// that needs to point to the rendering runtime version, it will point to the correct one.
+// This can happen on `pages` when a user requires a dependency that uses next/image for example.
+mod.prototype.require = function(request) {
+    if (request.endsWith('.shared-runtime')) {
+        return originalRequire.call(this, `next/dist/server/route-modules/pages/vendored/contexts/${path.basename(request, '.shared-runtime')}`);
+    }
+    return originalRequire.call(this, request);
+};
+
+//# sourceMappingURL=require-hook.js.map