onvif-dashboard 0.1.0

package/.next/standalone/node_modules/next/dist/server/dev/use-cache-probe-pool.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "installUseCacheProbe", {
+    enumerable: true,
+    get: function() {
+        return installUseCacheProbe;
+    }
+});
+const _jestworker = require("next/dist/compiled/jest-worker");
+const _usecacheprobeglobals = require("../use-cache/use-cache-probe-globals");
+const _requirecache = require("./require-cache");
+const _utils = require("../lib/utils");
+const _needsexperimentalreact = require("../../lib/needs-experimental-react");
+/**
+ * Convert the `encodedArguments` that `use-cache-wrapper.ts` already holds into
+ * the worker-transport shape. Blob values are base64-encoded so the payload
+ * survives the child-process JSON-only fallback transport — the worker_threads
+ * path would handle Blobs via structured clone, but we need one shape that
+ * works for both.
+ */ async function toEncodedArgumentsForProbe(encoded) {
+    if (typeof encoded === 'string') {
+        return {
+            kind: 'string',
+            data: encoded
+        };
+    }
+    const entries = [];
+    for (const [key, value] of encoded.entries()){
+        if (typeof value === 'string') {
+            entries.push([
+                key,
+                value
+            ]);
+        } else {
+            const bytes = Buffer.from(await value.arrayBuffer()).toString('base64');
+            entries.push([
+                key,
+                {
+                    kind: 'blob',
+                    bytes,
+                    type: value.type
+                }
+            ]);
+        }
+    }
+    return {
+        kind: 'formdata',
+        entries
+    };
+}
+function installUseCacheProbe(options) {
+    const { distDir, buildId, deploymentId, nextConfig } = options;
+    // The deadlock pattern we're detecting requires the outer render's
+    // dynamic-stage semantics to produce a halted promise that a user-space
+    // `Map<string, Promise>` captures. A probe worker has no outer render, so its
+    // cache-scope fetches resolve normally — the shared module scope can never
+    // accumulate a halted promise that would poison a sibling probe. That's why
+    // reusing workers across probes is safe: isolation between main and probe is
+    // what matters, not between probe invocations.
+    //
+    // Torn down on HMR (stale user modules) and on worker crash. Hung probes
+    // don't trigger teardown — the worker is still able to handle further tasks
+    // (the hung promise just sits in its heap), and that leak is bounded by the
+    // next HMR clear.
+    let pool;
+    const getPool = ()=>{
+        if (pool) {
+            return pool;
+        }
+        // Strip `--inspect` from any inherited `NODE_OPTIONS` so the worker doesn't
+        // fight the parent for the same debug port.
+        const probeNodeOptions = (0, _utils.getFormattedNodeOptionsWithoutInspect)();
+        // The worker is shipped as four pre-bundled dev-only artifacts —
+        // {webpack,turbopack} × {stable,experimental} — so the bundler aliases and
+        // react-server layer resolve correctly at Next-build time. Pick the
+        // matching artifact from runtime env. `needsExperimentalReact` is the same
+        // predicate `define-env.ts` uses to wire `__NEXT_EXPERIMENTAL_REACT` for
+        // the user's bundle, so the worker stays in lockstep.
+        const turbo = process.env.TURBOPACK ? '-turbo' : '';
+        const channel = (0, _needsexperimentalreact.needsExperimentalReact)(nextConfig) ? '-experimental' : '';
+        const workerPath = require.resolve(`next/dist/compiled/next-server/use-cache-probe-worker${turbo}${channel}.runtime.dev.js`);
+        const worker = new _jestworker.Worker(workerPath, {
+            maxRetries: 0,
+            // jest-worker has no per-task scaling: once the pool is created, all
+            // `numWorkers` workers are alive until pool teardown. Set to absorb
+            // the realistic case of a single dev request fanning out into
+            // multiple concurrent `'use cache'` invocations that each hit the
+            // probe threshold.
+            // TODO: replace with on-demand scaling once
+            // https://github.com/vercel/next.js/pull/90532 lands — workers can
+            // then spawn lazily and shrink back when idle.
+            numWorkers: 4,
+            enableWorkerThreads: nextConfig.experimental.workerThreads,
+            // Listing the methods explicitly tells jest-worker to skip the discovery
+            // `require()` it would otherwise do in the parent process. The bundle has
+            // the full RSC pipeline embedded — loading it in the parent would eagerly
+            // initialize bindings that should only run in the isolated worker.
+            exposedMethods: [
+                'probeUseCache'
+            ],
+            forkOptions: {
+                env: {
+                    ...process.env,
+                    NODE_OPTIONS: probeNodeOptions
+                }
+            }
+        });
+        worker.getStdout().pipe(process.stdout);
+        worker.getStderr().pipe(process.stderr);
+        pool = worker;
+        return worker;
+    };
+    const tearDownPool = async ()=>{
+        const current = pool;
+        if (!current) {
+            return;
+        }
+        pool = undefined;
+        await current.end().catch(()=>{
+        // The worker process will exit on its own when nothing else holds it
+        // open; a failed `.end()` here just means we couldn't wait cleanly.
+        });
+    };
+    const runProbe = async (msg)=>{
+        let activePool;
+        try {
+            activePool = getPool();
+        } catch  {
+            return false;
+        }
+        try {
+            return await activePool.probeUseCache(msg);
+        } catch  {
+            // Worker crash or IPC error: tear down the pool so the next probe starts
+            // fresh.
+            await tearDownPool();
+            return false;
+        }
+    };
+    // The dev server can't reach into worker isolates to clear their
+    // `require.cache` or `loadManifest` `sharedCache`, so we drop the whole pool
+    // whenever the parent's caches are invalidated. The next probe lazy-spawns a
+    // fresh worker with empty caches. No path-level bookkeeping — cache
+    // invalidation in dev is infrequent and pool startup is cheap.
+    (0, _requirecache.onCacheInvalidation)(()=>{
+        void tearDownPool();
+    });
+    // Wire the probe hook that `use-cache-wrapper` calls when a cache fill has
+    // been idle long enough to suspect a hang. The forwarded request snapshot
+    // lets the worker rebuild a faithful request store so cache bodies that read
+    // cookies/headers/etc. behave as in a real fill.
+    (0, _usecacheprobeglobals.setUseCacheProbe)(async (args)=>{
+        const encodedArguments = await toEncodedArgumentsForProbe(args.encodedArguments);
+        return runProbe({
+            distDir,
+            page: args.page,
+            route: args.route,
+            id: args.id,
+            kind: args.kind,
+            encodedArguments,
+            request: args.request,
+            buildId,
+            deploymentId,
+            nextConfigSerializable: {
+                httpAgentOptions: nextConfig.httpAgentOptions,
+                cacheLifeProfiles: nextConfig.cacheLife,
+                useCacheTimeout: nextConfig.experimental.useCacheTimeout,
+                staticPageGenerationTimeout: nextConfig.staticPageGenerationTimeout
+            },
+            timeoutMs: args.timeoutMs
+        });
+    });
+}
+
+//# sourceMappingURL=use-cache-probe-pool.js.map

package/.next/standalone/node_modules/next/dist/server/dev/use-cache-probe-worker.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "probeUseCache", {
+    enumerable: true,
+    get: function() {
+        return probeUseCache;
+    }
+});
+require("../require-hook");
+require("../node-environment");
+const _aftercontext = require("../after/after-context");
+const _loadcomponents = require("../load-components");
+const _setuphttpagentenv = require("../setup-http-agent-env");
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _manifestssingleton = require("../app-render/manifests-singleton");
+const _asynclocalstorage = require("../app-render/async-local-storage");
+const _requeststore = require("../async-storage/request-store");
+const _server = require("react-server-dom-webpack/server");
+async function probeUseCache(msg) {
+    try {
+        (0, _setuphttpagentenv.setHttpClientAndAgentOptions)({
+            httpAgentOptions: msg.nextConfigSerializable.httpAgentOptions
+        });
+        // Populates the manifests singleton for the route via
+        // `setManifestsSingleton` inside the compiled app-page module — same
+        // mechanism a real request uses. The dev server tears the pool down
+        // whenever it invalidates its own require/manifest caches (HMR, route
+        // recompile) so the next probe lazy-spawns a worker with empty
+        // `require.cache` and `loadManifest` caches. Without that teardown, a
+        // second probe in the same worker would resolve user modules and manifests
+        // from the first probe's cached state.
+        //
+        // Narrowed to `AppPageModule` because the probe is only set up from the dev
+        // block in `generateCacheEntryImpl`, which is gated on
+        // `outerWorkUnitStore.cacheSignal` — currently only set for app pages.
+        // `'use cache'` in route handlers has no dev-mode hang protection at all
+        // today (no probe, no dev-fill timeout); when that gate is broadened, this
+        // loader will need to handle `AppRouteModule` and a different require
+        // mechanism (route handlers don't expose `__next_app__`).
+        const { ComponentMod } = await (0, _loadcomponents.loadComponents)({
+            distDir: msg.distDir,
+            page: msg.page,
+            isAppPath: true,
+            isDev: true,
+            sriEnabled: false,
+            needsManifestsForLegacyReasons: true
+        });
+        // Resolve the wrapped `'use cache'` function by its server reference
+        // id. Same path `action-handler.ts` takes for server actions: server
+        // module map → bundler module id → `__next_app__.require` → exported
+        // function keyed by the action id.
+        const serverModuleMap = (0, _manifestssingleton.getServerModuleMap)();
+        const entry = serverModuleMap[msg.id];
+        if (!entry) {
+            return false;
+        }
+        const actionMod = await ComponentMod.__next_app__.require(entry.id);
+        const wrappedFn = actionMod[msg.id];
+        if (typeof wrappedFn !== 'function') {
+            return false;
+        }
+        // Decode the args with the worker's own server module map. See the
+        // `EncodedArgumentsForProbe` comment for why we don't use the cache-map key
+        // string here.
+        const temporaryReferences = (0, _server.createTemporaryReferenceSet)();
+        let decoded;
+        if (msg.encodedArguments.kind === 'string') {
+            decoded = await (0, _server.decodeReply)(msg.encodedArguments.data, serverModuleMap, {
+                temporaryReferences
+            });
+        } else {
+            const entries = msg.encodedArguments.entries.map(([key, value])=>{
+                if (typeof value === 'string') {
+                    return [
+                        key,
+                        value
+                    ];
+                }
+                const bytes = Buffer.from(value.bytes, 'base64');
+                return [
+                    key,
+                    new File([
+                        bytes
+                    ], '', {
+                        type: value.type
+                    })
+                ];
+            });
+            decoded = await (0, _server.decodeReplyFromAsyncIterable)({
+                async *[Symbol.asyncIterator] () {
+                    for (const pair of entries){
+                        yield pair;
+                    }
+                }
+            }, serverModuleMap, {
+                temporaryReferences
+            });
+        }
+        const args = decoded[2];
+        const workStore = buildProbeWorkStore(msg);
+        // The outer store is `'request'`-typed and built from the forwarded
+        // snapshot so the cache body sees the same `headers` / `cookies` /
+        // `draftMode` it would in a real fill. `cacheSignal` defaults to undefined,
+        // which disables the dev-timeout/probe block in `generateCacheEntryImpl` —
+        // the primary guard against a probe inside the worker spawning another
+        // probe.
+        const workUnitStore = (0, _requeststore.createRequestStore)({
+            phase: 'render',
+            headers: new Headers(msg.request.headers),
+            onUpdateCookies: undefined,
+            url: {
+                pathname: msg.request.urlPathname,
+                search: msg.request.urlSearch
+            },
+            rootParams: msg.request.rootParams,
+            implicitTags: {
+                tags: [],
+                expirationsByCacheKind: new Map()
+            },
+            resumeDataCache: null,
+            previewProps: undefined,
+            isHmrRefresh: msg.request.isHmrRefresh,
+            serverComponentsHmrCache: undefined,
+            hmrRefreshHash: msg.request.hmrRefreshHash,
+            fallbackParams: null
+        });
+        await _workasyncstorageexternal.workAsyncStorage.run(workStore, ()=>_workunitasyncstorageexternal.workUnitAsyncStorage.run(workUnitStore, wrappedFn.bind(null, ...args)));
+        return true;
+    } catch  {
+        // Any error along the way — module resolution, decode, the actual run —
+        // collapses to "the probe didn't complete in isolation," so the main thread
+        // won't false-positive a deadlock.
+        return false;
+    }
+}
+function buildProbeWorkStore(msg) {
+    // `after()` callbacks would duplicate the real fill's side effects — the
+    // probe is a throwaway re-execution, not a second request. Same shape as the
+    // validation-render `AfterContext` in `app-render.tsx`.
+    const afterContext = new _aftercontext.AfterContext({
+        waitUntil (promise) {
+            promise.catch(()=>{});
+        },
+        onClose () {},
+        onTaskError () {}
+    });
+    return {
+        isStaticGeneration: false,
+        page: msg.page,
+        route: msg.route,
+        useCacheProbeMode: {
+            timeoutMs: msg.timeoutMs
+        },
+        isDraftMode: msg.request.isDraftMode,
+        useCacheTimeout: msg.nextConfigSerializable.useCacheTimeout,
+        staticPageGenerationTimeout: msg.nextConfigSerializable.staticPageGenerationTimeout,
+        cacheLifeProfiles: msg.nextConfigSerializable.cacheLifeProfiles,
+        buildId: msg.buildId,
+        deploymentId: msg.deploymentId,
+        requestStartTime: msg.request.requestStartTime,
+        // Empty values for cache-handler / RDC bookkeeping. The `useCacheProbeMode`
+        // branch in `cache()` returns before any code that reads or writes these
+        // fields, so the values can never be observed.
+        previouslyRevalidatedTags: [],
+        refreshTagsByCacheKind: new Map(),
+        runInCleanSnapshot: (0, _asynclocalstorage.createSnapshot)(),
+        shouldTrackFetchMetrics: false,
+        reactServerErrorsByDigest: new Map(),
+        afterContext,
+        cacheComponentsEnabled: true,
+        // In the probe the validation level is irrelevant because we do not perform validation
+        // in this context.
+        validationLevel: 'warning'
+    };
+}
+
+//# sourceMappingURL=use-cache-probe-worker.js.map

package/.next/standalone/node_modules/next/dist/server/dynamic-rendering-utils.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ClientHookDynamicError: null,
+    RENDER_STAGES_BY_DATA_KIND: null,
+    applyOwnerStack: null,
+    isClientHookDynamicError: null,
+    isHangingPromiseRejectionError: null,
+    makeClientHookHangingPromise: null,
+    makeDevtoolsIOAwarePromise: null,
+    makeDynamicHangingPromise: null,
+    makeFallbackParamsHangingPromise: null,
+    makePromiseFromTrigger: null,
+    makeRuntimeHangingPromise: null,
+    makeStageHangingPromise: null,
+    makeUntrackedHangingPromise: null,
+    trackFallbackParamsAccessed: null,
+    trackRuntimeDataAccessed: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ClientHookDynamicError: function() {
+        return ClientHookDynamicError;
+    },
+    RENDER_STAGES_BY_DATA_KIND: function() {
+        return RENDER_STAGES_BY_DATA_KIND;
+    },
+    applyOwnerStack: function() {
+        return applyOwnerStack;
+    },
+    isClientHookDynamicError: function() {
+        return isClientHookDynamicError;
+    },
+    isHangingPromiseRejectionError: function() {
+        return isHangingPromiseRejectionError;
+    },
+    makeClientHookHangingPromise: function() {
+        return makeClientHookHangingPromise;
+    },
+    makeDevtoolsIOAwarePromise: function() {
+        return makeDevtoolsIOAwarePromise;
+    },
+    makeDynamicHangingPromise: function() {
+        return makeDynamicHangingPromise;
+    },
+    makeFallbackParamsHangingPromise: function() {
+        return makeFallbackParamsHangingPromise;
+    },
+    makePromiseFromTrigger: function() {
+        return makePromiseFromTrigger;
+    },
+    makeRuntimeHangingPromise: function() {
+        return makeRuntimeHangingPromise;
+    },
+    makeStageHangingPromise: function() {
+        return makeStageHangingPromise;
+    },
+    makeUntrackedHangingPromise: function() {
+        return makeUntrackedHangingPromise;
+    },
+    trackFallbackParamsAccessed: function() {
+        return trackFallbackParamsAccessed;
+    },
+    trackRuntimeDataAccessed: function() {
+        return trackRuntimeDataAccessed;
+    }
+});
+const _stagedrendering = require("./app-render/staged-rendering");
+const _workunitasyncstorageexternal = require("./app-render/work-unit-async-storage.external");
+const _runtimereactsexternal = require("./runtime-reacts.external");
+function isHangingPromiseRejectionError(err) {
+    if (typeof err !== 'object' || err === null || !('digest' in err)) {
+        return false;
+    }
+    return err.digest === HANGING_PROMISE_REJECTION;
+}
+const HANGING_PROMISE_REJECTION = 'HANGING_PROMISE_REJECTION';
+class HangingPromiseRejectionError extends Error {
+    constructor(route, expression){
+        super(`During prerendering, ${expression} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${expression} to a different context by using \`setTimeout\`, \`after\`, or similar functions you may observe this error and you should handle it in that context. This occurred at route "${route}".`), this.route = route, this.expression = expression, this.digest = HANGING_PROMISE_REJECTION;
+    }
+}
+const CLIENT_HOOK_DYNAMIC = 'CLIENT_HOOK_DYNAMIC';
+class ClientHookDynamicError extends Error {
+    constructor(route, expression){
+        super(`Route "${route}": Next.js encountered URL data \`${expression}\` in a Client Component outside of \`<Suspense>\`.\n\n` + `This blocks prerendering because the value is only available at runtime.\n\n` + `Ways to fix this:\n` + `  - [stream] Wrap the component in \`<Suspense fallback={...}>\` so the hook value streams in after prerendering\n` + `  - [block] Set \`export const instant = false\` to allow a blocking route\n\n` + `Learn more: https://nextjs.org/docs/messages/blocking-prerender-client-hook`), this.digest = CLIENT_HOOK_DYNAMIC;
+        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
+            value: "E1433",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+function isClientHookDynamicError(err) {
+    if (typeof err !== 'object' || err === null || !('digest' in err)) {
+        return false;
+    }
+    return err.digest === CLIENT_HOOK_DYNAMIC;
+}
+const abortListenersBySignal = new WeakMap();
+function makeDynamicHangingPromise(signal, route, expression) {
+    return makeHangingPromiseWithError(signal, new HangingPromiseRejectionError(route, expression));
+}
+function makeUntrackedHangingPromise(signal, route, expression) {
+    return makeHangingPromiseWithError(signal, new HangingPromiseRejectionError(route, expression));
+}
+function makeRuntimeHangingPromise(signal, route, expression, workUnitStore) {
+    if (workUnitStore !== null) {
+        trackRuntimeDataAccessed(workUnitStore);
+    }
+    return makeHangingPromiseWithError(signal, new HangingPromiseRejectionError(route, expression));
+}
+function makeFallbackParamsHangingPromise(signal, route, expression, workUnitStore) {
+    if (workUnitStore !== null) {
+        trackFallbackParamsAccessed(workUnitStore);
+    }
+    return makeHangingPromiseWithError(signal, new HangingPromiseRejectionError(route, expression));
+}
+function makeStageHangingPromise(signal, route, expression, workUnitStore) {
+    trackRuntimeDataAccessed(workUnitStore);
+    return makeHangingPromiseWithError(signal, new HangingPromiseRejectionError(route, expression));
+}
+function trackRuntimeDataAccessed(workUnitStore) {
+    trackRuntimeDataAccessedImpl(workUnitStore, false);
+}
+function trackFallbackParamsAccessed(workUnitStore) {
+    trackRuntimeDataAccessedImpl(workUnitStore, true);
+}
+function trackRuntimeDataAccessedImpl(workUnitStore, isFallbackParamAccess) {
+    switch(workUnitStore.type){
+        case 'prerender':
+            {
+                var // Response-level flag (the payload's `u`, forwarded to segment
+                // responses as `needsRuntimeRequest`): resolved for every kind of
+                // access — a pre-upgrade fallback response must keep reporting that
+                // a runtime request would return more. The fulfillment row lands at
+                // the current position in the Flight stream, which is what makes the
+                // value rewindable per stage. Promise resolution is idempotent, so
+                // repeated accesses are free.
+                _workUnitStore_runtimeDataAccessed;
+                (_workUnitStore_runtimeDataAccessed = workUnitStore.runtimeDataAccessed) == null ? void 0 : _workUnitStore_runtimeDataAccessed.resolve(true);
+                // Hint cell (holds the build-constant
+                // PrefetchHint.ShouldAttemptStaticPrefetch value directly): a
+                // fallback-param access is transient when the route is
+                // fallback-upgradeable — ISR later produces the concrete prerender a
+                // static prefetch attempt would hit — so it leaves the hint intact.
+                // (Until that upgrade, the response-level flag above keeps directing
+                // the client to a runtime fallback; the hint only costs a wasted
+                // static attempt in the interim.) Every other access clears it.
+                const hintCell = workUnitStore.shouldAttemptStaticPrefetch;
+                if (hintCell !== null && (!isFallbackParamAccess || !workUnitStore.isFallbackUpgradeable)) {
+                    hintCell.current = false;
+                }
+                break;
+            }
+        case 'prerender-client':
+        case 'prerender-ppr':
+        case 'prerender-legacy':
+        case 'prerender-runtime':
+        case 'validation-client':
+        case 'request':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'generate-static-params':
+            break;
+        default:
+            workUnitStore;
+    }
+}
+function makeClientHookHangingPromise(signal, error) {
+    return makeHangingPromiseWithError(signal, error);
+}
+function makeHangingPromiseWithError(signal, error) {
+    if (signal.aborted) {
+        return Promise.reject(error);
+    } else {
+        const hangingPromise = new Promise((_, reject)=>{
+            const boundRejection = reject.bind(null, error);
+            let currentListeners = abortListenersBySignal.get(signal);
+            if (currentListeners) {
+                currentListeners.push(boundRejection);
+            } else {
+                const listeners = [
+                    boundRejection
+                ];
+                abortListenersBySignal.set(signal, listeners);
+                signal.addEventListener('abort', ()=>{
+                    for(let i = 0; i < listeners.length; i++){
+                        listeners[i]();
+                    }
+                }, {
+                    once: true
+                });
+            }
+        });
+        // We are fine if no one actually awaits this promise. We shouldn't consider this an unhandled rejection so
+        // we attach a noop catch handler here to suppress this warning. If you actually await somewhere or construct
+        // your own promise out of it you'll need to ensure you handle the error when it rejects.
+        hangingPromise.catch(ignoreReject);
+        return hangingPromise;
+    }
+}
+function ignoreReject() {}
+function makePromiseFromTrigger(trigger, value) {
+    const promise = trigger.then(()=>value);
+    promise.catch(ignoreReject);
+    return promise;
+}
+function makeDevtoolsIOAwarePromise(underlying, requestStore, stage) {
+    if (requestStore.stagedRendering) {
+        // We resolve each stage in a timeout, so React DevTools will pick this up as IO.
+        return requestStore.stagedRendering.delayUntilStage(stage, undefined, underlying);
+    }
+    // in React DevTools if we resolve in a setTimeout we will observe
+    // the promise resolution as something that can suspend a boundary or root.
+    return new Promise((resolve)=>{
+        // Must use setTimeout to be considered IO React DevTools. setImmediate will not work.
+        setTimeout(()=>{
+            resolve(underlying);
+        }, 0);
+    });
+}
+const RENDER_STAGES_BY_DATA_KIND = {
+    sessionData: _stagedrendering.RenderStage.ShellRuntime,
+    staticLinkData: _stagedrendering.RenderStage.Static,
+    runtimeLinkData: _stagedrendering.RenderStage.Runtime
+};
+function applyOwnerStack(error) {
+    if (process.env.NODE_ENV !== 'production') {
+        var _getClientReact_captureOwnerStack, _getClientReact, _getServerReact_captureOwnerStack, _getServerReact;
+        let ownerStack;
+        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+        // captureOwnerStack() returns the owner stack for the current React
+        // rendering context. Inside a cache scope this only includes the inner
+        // component tree. The outer owner stack (captured before entering the
+        // cache boundary in use-cache-wrapper.ts) is stored on the cache store.
+        // We concatenate both to get the full component tree.
+        const innerOwnerStack = ((_getClientReact = (0, _runtimereactsexternal.getClientReact)()) == null ? void 0 : (_getClientReact_captureOwnerStack = _getClientReact.captureOwnerStack) == null ? void 0 : _getClientReact_captureOwnerStack.call(_getClientReact)) ?? ((_getServerReact = (0, _runtimereactsexternal.getServerReact)()) == null ? void 0 : (_getServerReact_captureOwnerStack = _getServerReact.captureOwnerStack) == null ? void 0 : _getServerReact_captureOwnerStack.call(_getServerReact));
+        switch(workUnitStore == null ? void 0 : workUnitStore.type){
+            case 'cache':
+            case 'private-cache':
+                ownerStack = (innerOwnerStack || '') + (workUnitStore.outerOwnerStack || '') || undefined;
+                break;
+            case 'unstable-cache':
+            case 'request':
+            case 'prerender':
+            case 'prerender-ppr':
+            case 'prerender-legacy':
+            case 'prerender-runtime':
+            case 'prerender-client':
+            case 'validation-client':
+            case 'generate-static-params':
+            case undefined:
+                ownerStack = innerOwnerStack;
+                break;
+            default:
+                workUnitStore;
+        }
+        if (ownerStack) {
+            let stack = ownerStack;
+            if (error.stack) {
+                const frames = [];
+                for (const frame of error.stack.split('\n').slice(1)){
+                    if (frame.includes('react_stack_bottom_frame')) {
+                        break;
+                    }
+                    frames.push(frame);
+                }
+                stack = '\n' + frames.join('\n') + stack;
+            }
+            error.stack = error.name + ': ' + error.message + stack;
+        }
+    }
+    return error;
+}
+
+//# sourceMappingURL=dynamic-rendering-utils.js.map

package/.next/standalone/node_modules/next/dist/server/font-utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "calculateSizeAdjustValues", {
+    enumerable: true,
+    get: function() {
+        return calculateSizeAdjustValues;
+    }
+});
+const _constants = require("../shared/lib/constants");
+const capsizeFontsMetrics = require('next/dist/server/capsize-font-metrics.json');
+function formatName(str) {
+    return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
+        return index === 0 ? word.toLowerCase() : word.toUpperCase();
+    }).replace(/\s+/g, '');
+}
+function formatOverrideValue(val) {
+    return Math.abs(val * 100).toFixed(2);
+}
+function calculateSizeAdjustValues(fontName) {
+    const fontKey = formatName(fontName);
+    const fontMetrics = capsizeFontsMetrics[fontKey];
+    let { category, ascent, descent, lineGap, unitsPerEm, xWidthAvg } = fontMetrics;
+    const mainFontAvgWidth = xWidthAvg / unitsPerEm;
+    const fallbackFont = category === 'serif' ? _constants.DEFAULT_SERIF_FONT : _constants.DEFAULT_SANS_SERIF_FONT;
+    const fallbackFontName = formatName(fallbackFont.name);
+    const fallbackFontMetrics = capsizeFontsMetrics[fallbackFontName];
+    const fallbackFontAvgWidth = fallbackFontMetrics.xWidthAvg / fallbackFontMetrics.unitsPerEm;
+    let sizeAdjust = xWidthAvg ? mainFontAvgWidth / fallbackFontAvgWidth : 1;
+    ascent = formatOverrideValue(ascent / (unitsPerEm * sizeAdjust));
+    descent = formatOverrideValue(descent / (unitsPerEm * sizeAdjust));
+    lineGap = formatOverrideValue(lineGap / (unitsPerEm * sizeAdjust));
+    return {
+        ascent,
+        descent,
+        lineGap,
+        fallbackFont: fallbackFont.name,
+        sizeAdjust: formatOverrideValue(sizeAdjust)
+    };
+}
+
+//# sourceMappingURL=font-utils.js.map