@b4run/inspector 0.8.28

package/.next/standalone/node_modules/.pnpm/next@16.3.0_@babel+core@7.29.7_@opentelemetry+api@1.9.1_@playwright+test@1.62.1_@types+_dbc857abffbbe11b366888a920df3956/node_modules/next/dist/server/pipe-readable.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isAbortError: null,
+    pipeNodeReadableToNodeResponse: null,
+    pipeToNodeResponse: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isAbortError: function() {
+        return isAbortError;
+    },
+    pipeNodeReadableToNodeResponse: function() {
+        return pipeNodeReadableToNodeResponse;
+    },
+    pipeToNodeResponse: function() {
+        return pipeToNodeResponse;
+    }
+});
+const _nextrequest = require("./web/spec-extension/adapters/next-request");
+const _detachedpromise = require("../lib/detached-promise");
+const _tracer = require("./lib/trace/tracer");
+const _constants = require("./lib/trace/constants");
+const _clientcomponentrendererlogger = require("./client-component-renderer-logger");
+function isAbortError(e) {
+    return (e == null ? void 0 : e.name) === 'AbortError' || (e == null ? void 0 : e.name) === _nextrequest.ResponseAbortedName;
+}
+const HAS_CLIENT_COMPONENT_METRICS_ENABLED = 'performance' in globalThis && process.env.NEXT_OTEL_PERFORMANCE_PREFIX;
+function createWriterFromResponse(res, waitUntilForEnd) {
+    let started = false;
+    // Create a promise that will resolve once the response has drained. See
+    // https://nodejs.org/api/stream.html#stream_event_drain
+    let drained = new _detachedpromise.DetachedPromise();
+    function onDrain() {
+        drained.resolve();
+    }
+    res.on('drain', onDrain);
+    // If the finish event fires, it means we shouldn't block and wait for the
+    // drain event.
+    res.once('close', ()=>{
+        res.off('drain', onDrain);
+        drained.resolve();
+    });
+    // Create a promise that will resolve once the response has finished. See
+    // https://nodejs.org/api/http.html#event-finish_1
+    const finished = new _detachedpromise.DetachedPromise();
+    res.once('finish', ()=>{
+        finished.resolve();
+    });
+    // Create a writable stream that will write to the response.
+    return new WritableStream({
+        write: async (chunk)=>{
+            // You'd think we'd want to use `start` instead of placing this in `write`
+            // but this ensures that we don't actually flush the headers until we've
+            // started writing chunks.
+            if (!started) {
+                started = true;
+                if (HAS_CLIENT_COMPONENT_METRICS_ENABLED) {
+                    const metrics = (0, _clientcomponentrendererlogger.getClientComponentLoaderMetrics)();
+                    if (metrics) {
+                        performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`, {
+                            start: metrics.clientComponentLoadStart,
+                            end: metrics.clientComponentLoadStart + metrics.clientComponentLoadTimes
+                        });
+                    }
+                }
+                res.flushHeaders();
+                (0, _tracer.getTracer)().trace(_constants.NextNodeServerSpan.startResponse, {
+                    spanName: 'start response'
+                }, ()=>undefined);
+            }
+            try {
+                const ok = res.write(chunk);
+                // Added by the `compression` middleware, this is a function that will
+                // flush the partially-compressed response to the client.
+                if ('flush' in res && typeof res.flush === 'function') {
+                    res.flush();
+                }
+                // If the write returns false, it means there's some backpressure, so
+                // wait until it's streamed before continuing.
+                if (!ok) {
+                    await drained.promise;
+                    // Reset the drained promise so that we can wait for the next drain event.
+                    drained = new _detachedpromise.DetachedPromise();
+                }
+            } catch (err) {
+                res.end();
+                throw Object.defineProperty(new Error('failed to write chunk to response', {
+                    cause: err
+                }), "__NEXT_ERROR_CODE", {
+                    value: "E321",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        },
+        abort: (err)=>{
+            if (res.writableFinished) return;
+            res.destroy(err);
+        },
+        close: async ()=>{
+            // if a waitUntil promise was passed, wait for it to resolve before
+            // ending the response.
+            if (waitUntilForEnd) {
+                await waitUntilForEnd;
+            }
+            if (res.writableFinished) return;
+            res.end();
+            return finished.promise;
+        }
+    });
+}
+async function pipeToNodeResponse(readable, res, waitUntilForEnd) {
+    try {
+        // If the response has already errored, then just return now.
+        const { errored, destroyed } = res;
+        if (errored || destroyed) return;
+        // Create a new AbortController so that we can abort the readable if the
+        // client disconnects.
+        const controller = (0, _nextrequest.createAbortController)(res);
+        const writer = createWriterFromResponse(res, waitUntilForEnd);
+        await readable.pipeTo(writer, {
+            signal: controller.signal
+        });
+    } catch (err) {
+        // If this isn't related to an abort error, re-throw it.
+        if (isAbortError(err)) return;
+        throw Object.defineProperty(new Error('failed to pipe response', {
+            cause: err
+        }), "__NEXT_ERROR_CODE", {
+            value: "E180",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+async function pipeNodeReadableToNodeResponse(readable, res, waitUntilForEnd) {
+    try {
+        const { errored, destroyed } = res;
+        if (errored || destroyed) return;
+        let started = false;
+        const finished = new _detachedpromise.DetachedPromise();
+        res.once('close', ()=>{
+            readable.destroy();
+            finished.resolve();
+        });
+        readable.on('data', (chunk)=>{
+            if (!started) {
+                started = true;
+                if ('performance' in globalThis && process.env.NEXT_OTEL_PERFORMANCE_PREFIX) {
+                    const metrics = (0, _clientcomponentrendererlogger.getClientComponentLoaderMetrics)();
+                    if (metrics) {
+                        performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`, {
+                            start: metrics.clientComponentLoadStart,
+                            end: metrics.clientComponentLoadStart + metrics.clientComponentLoadTimes
+                        });
+                    }
+                }
+                res.flushHeaders();
+                (0, _tracer.getTracer)().trace(_constants.NextNodeServerSpan.startResponse, {
+                    spanName: 'start response'
+                }, ()=>undefined);
+            }
+            const ok = res.write(chunk);
+            if ('flush' in res && typeof res.flush === 'function') {
+                res.flush();
+            }
+            if (!ok) {
+                readable.pause();
+                res.once('drain', ()=>{
+                    readable.resume();
+                });
+            }
+        });
+        readable.on('end', async ()=>{
+            if (waitUntilForEnd) {
+                await waitUntilForEnd;
+            }
+            if (!res.writableFinished) {
+                res.end();
+            }
+            finished.resolve();
+        });
+        readable.on('error', (err)=>{
+            if (isAbortError(err)) {
+                finished.resolve();
+                return;
+            }
+            res.destroy(err);
+            finished.resolve();
+        });
+        await finished.promise;
+    } catch (err) {
+        if (isAbortError(err)) return;
+        throw Object.defineProperty(new Error('failed to pipe response', {
+            cause: err
+        }), "__NEXT_ERROR_CODE", {
+            value: "E180",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+
+//# sourceMappingURL=pipe-readable.js.map

package/.next/standalone/node_modules/.pnpm/next@16.3.0_@babel+core@7.29.7_@opentelemetry+api@1.9.1_@playwright+test@1.62.1_@types+_dbc857abffbbe11b366888a920df3956/node_modules/next/dist/server/post-process.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "postProcessHTML", {
+    enumerable: true,
+    get: function() {
+        return postProcessHTML;
+    }
+});
+const _nonnullable = require("../lib/non-nullable");
+async function postProcessHTML(content, renderOpts) {
+    const postProcessors = [
+        process.env.NEXT_RUNTIME !== 'edge' && renderOpts.optimizeCss ? async (html)=>{
+            // eslint-disable-next-line import/no-extraneous-dependencies
+            const Critters = require('critters');
+            // @ts-expect-error -- interopRequireDefault
+            const cssOptimizer = new Critters({
+                ssrMode: true,
+                reduceInlineStyles: false,
+                path: renderOpts.distDir,
+                publicPath: `${renderOpts.assetPrefix}/_next/`,
+                preload: 'media',
+                fonts: false,
+                logLevel: process.env.CRITTERS_LOG_LEVEL || (process.env.NODE_ENV === 'production' ? 'warn' : 'info'),
+                ...renderOpts.optimizeCss
+            });
+            return await cssOptimizer.process(html);
+        } : null
+    ].filter(_nonnullable.nonNullable);
+    for (const postProcessor of postProcessors){
+        if (postProcessor) {
+            content = await postProcessor(content);
+        }
+    }
+    return content;
+}
+
+//# sourceMappingURL=post-process.js.map

package/.next/standalone/node_modules/.pnpm/next@16.3.0_@babel+core@7.29.7_@opentelemetry+api@1.9.1_@playwright+test@1.62.1_@types+_dbc857abffbbe11b366888a920df3956/node_modules/next/dist/server/render-result.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return RenderResult;
+    }
+});
+const _nodewebstreamshelper = require("./stream-utils/node-web-streams-helper");
+const _pipereadable = require("./pipe-readable");
+const _invarianterror = require("../shared/lib/invariant-error");
+function isNodeReadable(value) {
+    return value !== null && typeof value === 'object' && typeof value.pipe === 'function' && typeof value.on === 'function' && !(value instanceof ReadableStream);
+}
+class RenderResult {
+    static #_ = /**
+   * A render result that represents an empty response. This is used to
+   * represent a response that was not found or was already sent.
+   */ this.EMPTY = new RenderResult(null, {
+        metadata: {},
+        contentType: null
+    });
+    /**
+   * Creates a new RenderResult instance from a static response.
+   *
+   * @param value the static response value
+   * @param contentType the content type of the response
+   * @returns a new RenderResult instance
+   */ static fromStatic(value, contentType) {
+        return new RenderResult(value, {
+            metadata: {},
+            contentType
+        });
+    }
+    constructor(response, { contentType, waitUntil, metadata }){
+        this.response = response;
+        this.contentType = contentType;
+        this.metadata = metadata;
+        this.waitUntil = waitUntil;
+    }
+    assignMetadata(metadata) {
+        Object.assign(this.metadata, metadata);
+    }
+    /**
+   * Returns true if the response is null. It can be null if the response was
+   * not found or was already sent.
+   */ get isNull() {
+        return this.response === null;
+    }
+    /**
+   * Returns false if the response is a string. It can be a string if the page
+   * was prerendered. If it's not, then it was generated dynamically.
+   */ get isDynamic() {
+        return typeof this.response !== 'string';
+    }
+    toUnchunkedString(stream = false) {
+        if (this.response === null) {
+            // If the response is null, return an empty string. This behavior is
+            // intentional as we're now providing the `RenderResult.EMPTY` value.
+            return '';
+        }
+        if (typeof this.response !== 'string') {
+            if (!stream) {
+                throw Object.defineProperty(new _invarianterror.InvariantError('dynamic responses cannot be unchunked. This is a bug in Next.js'), "__NEXT_ERROR_CODE", {
+                    value: "E732",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            return (0, _nodewebstreamshelper.streamToString)(this.readable);
+        }
+        return this.response;
+    }
+    /**
+   * Returns a readable stream of the response.
+   */ get readable() {
+        if (this.response === null) {
+            // If the response is null, return an empty stream. This behavior is
+            // intentional as we're now providing the `RenderResult.EMPTY` value.
+            return new ReadableStream({
+                start (controller) {
+                    controller.close();
+                }
+            });
+        }
+        if (typeof this.response === 'string') {
+            return (0, _nodewebstreamshelper.streamFromString)(this.response);
+        }
+        if (Buffer.isBuffer(this.response)) {
+            return (0, _nodewebstreamshelper.streamFromBuffer)(this.response);
+        }
+        // If the response is an array of streams, then chain them together.
+        if (Array.isArray(this.response)) {
+            return (0, _nodewebstreamshelper.chainStreams)(...this.response);
+        }
+        if (isNodeReadable(this.response)) {
+            if (process.env.NEXT_RUNTIME === 'edge') {
+                throw Object.defineProperty(new _invarianterror.InvariantError('Node.js Readable cannot be converted to a web stream in the edge runtime'), "__NEXT_ERROR_CODE", {
+                    value: "E1150",
+                    enumerable: false,
+                    configurable: true
+                });
+            } else {
+                let Readable;
+                if (process.env.TURBOPACK) {
+                    Readable = require('node:stream').Readable;
+                } else {
+                    Readable = __non_webpack_require__('node:stream').Readable;
+                }
+                return Readable.toWeb(this.response);
+            }
+        }
+        return this.response;
+    }
+    /**
+   * Coerces the response to an array of streams. This will convert the response
+   * to an array of streams if it is not already one.
+   *
+   * @returns An array of streams
+   */ coerce() {
+        if (this.response === null) {
+            // If the response is null, return an empty stream. This behavior is
+            // intentional as we're now providing the `RenderResult.EMPTY` value.
+            return [];
+        }
+        if (typeof this.response === 'string') {
+            return [
+                (0, _nodewebstreamshelper.streamFromString)(this.response)
+            ];
+        } else if (Array.isArray(this.response)) {
+            return this.response;
+        } else if (Buffer.isBuffer(this.response)) {
+            return [
+                (0, _nodewebstreamshelper.streamFromBuffer)(this.response)
+            ];
+        } else if (isNodeReadable(this.response)) {
+            if (process.env.NEXT_RUNTIME === 'edge') {
+                throw Object.defineProperty(new _invarianterror.InvariantError('Node.js Readable cannot be converted to a web stream in the edge runtime'), "__NEXT_ERROR_CODE", {
+                    value: "E1150",
+                    enumerable: false,
+                    configurable: true
+                });
+            } else {
+                let Readable;
+                if (process.env.TURBOPACK) {
+                    Readable = require('node:stream').Readable;
+                } else {
+                    Readable = __non_webpack_require__('node:stream').Readable;
+                }
+                return [
+                    Readable.toWeb(this.response)
+                ];
+            }
+        } else {
+            return [
+                this.response
+            ];
+        }
+    }
+    /**
+   * Pipes the response through a transform stream. This converts the response
+   * to a single readable stream (chaining if needed) and pipes it through the
+   * provided transform.
+   *
+   * @param transform The transform stream to pipe through
+   */ pipeThrough(transform) {
+        this.response = this.readable.pipeThrough(transform);
+    }
+    /**
+   * Unshifts a new stream to the response. This will convert the response to an
+   * array of streams if it is not already one and will add the new stream to
+   * the start of the array. When this response is piped, all of the streams
+   * will be piped one after the other.
+   *
+   * @param readable The new stream to unshift
+   */ unshift(readable) {
+        // Coerce the response to an array of streams.
+        this.response = this.coerce();
+        // Add the new stream to the start of the array.
+        this.response.unshift(readable);
+    }
+    /**
+   * Chains a new stream to the response. This will convert the response to an
+   * array of streams if it is not already one and will add the new stream to
+   * the end. When this response is piped, all of the streams will be piped
+   * one after the other.
+   *
+   * @param readable The new stream to chain
+   */ push(readable) {
+        // Coerce the response to an array of streams.
+        this.response = this.coerce();
+        // Add the new stream to the end of the array.
+        this.response.push(readable);
+    }
+    /**
+   * Pipes the response to a writable stream. This will close/cancel the
+   * writable stream if an error is encountered. If this doesn't throw, then
+   * the writable stream will be closed or aborted.
+   *
+   * @param writable Writable stream to pipe the response to
+   */ async pipeTo(writable) {
+        try {
+            await this.readable.pipeTo(writable, {
+                // We want to close the writable stream ourselves so that we can wait
+                // for the waitUntil promise to resolve before closing it. If an error
+                // is encountered, we'll abort the writable stream if we swallowed the
+                // error.
+                preventClose: true
+            });
+            // If there is a waitUntil promise, wait for it to resolve before
+            // closing the writable stream.
+            if (this.waitUntil) await this.waitUntil;
+            // Close the writable stream.
+            await writable.close();
+        } catch (err) {
+            // If this is an abort error, we should abort the writable stream (as we
+            // took ownership of it when we started piping). We don't need to re-throw
+            // because we handled the error.
+            if ((0, _pipereadable.isAbortError)(err)) {
+                // Abort the writable stream if an error is encountered.
+                await writable.abort(err);
+                return;
+            }
+            // We're not aborting the writer here as when this method throws it's not
+            // clear as to how so the caller should assume it's their responsibility
+            // to clean up the writer.
+            throw err;
+        }
+    }
+    /**
+   * Pipes the response to a node response. This will close/cancel the node
+   * response if an error is encountered.
+   *
+   * @param res
+   */ async pipeToNodeResponse(res) {
+        if (this.response !== null && typeof this.response !== 'string' && !Buffer.isBuffer(this.response) && !Array.isArray(this.response) && isNodeReadable(this.response)) {
+            await (0, _pipereadable.pipeNodeReadableToNodeResponse)(this.response, res, this.waitUntil);
+            return;
+        }
+        await (0, _pipereadable.pipeToNodeResponse)(this.readable, res, this.waitUntil);
+    }
+}
+
+//# sourceMappingURL=render-result.js.map