@kubb/agent 4.28.0 → 4.29.0

package/.output/server/node_modules/execa/lib/arguments/specific.js

@@ -1,111 +0,0 @@
-import {debuglog} from 'node:util';
-import isPlainObject from 'is-plain-obj';
-import {STANDARD_STREAMS_ALIASES} from '../utils/standard-stream.js';
-
-// Some options can have different values for `stdout`/`stderr`/`fd3`.
-// This normalizes those to array of values.
-// For example, `{verbose: {stdout: 'none', stderr: 'full'}}` becomes `{verbose: ['none', 'none', 'full']}`
-export const normalizeFdSpecificOptions = options => {
-	const optionsCopy = {...options};
-
-	for (const optionName of FD_SPECIFIC_OPTIONS) {
-		optionsCopy[optionName] = normalizeFdSpecificOption(options, optionName);
-	}
-
-	return optionsCopy;
-};
-
-export const normalizeFdSpecificOption = (options, optionName) => {
-	const optionBaseArray = Array.from({length: getStdioLength(options) + 1});
-	const optionArray = normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName);
-	return addDefaultValue(optionArray, optionName);
-};
-
-const getStdioLength = ({stdio}) => Array.isArray(stdio)
-	? Math.max(stdio.length, STANDARD_STREAMS_ALIASES.length)
-	: STANDARD_STREAMS_ALIASES.length;
-
-const normalizeFdSpecificValue = (optionValue, optionArray, optionName) => isPlainObject(optionValue)
-	? normalizeOptionObject(optionValue, optionArray, optionName)
-	: optionArray.fill(optionValue);
-
-const normalizeOptionObject = (optionValue, optionArray, optionName) => {
-	for (const fdName of Object.keys(optionValue).sort(compareFdName)) {
-		for (const fdNumber of parseFdName(fdName, optionName, optionArray)) {
-			optionArray[fdNumber] = optionValue[fdName];
-		}
-	}
-
-	return optionArray;
-};
-
-// Ensure priority order when setting both `stdout`/`stderr`, `fd1`/`fd2`, and `all`
-const compareFdName = (fdNameA, fdNameB) => getFdNameOrder(fdNameA) < getFdNameOrder(fdNameB) ? 1 : -1;
-
-const getFdNameOrder = fdName => {
-	if (fdName === 'stdout' || fdName === 'stderr') {
-		return 0;
-	}
-
-	return fdName === 'all' ? 2 : 1;
-};
-
-const parseFdName = (fdName, optionName, optionArray) => {
-	if (fdName === 'ipc') {
-		return [optionArray.length - 1];
-	}
-
-	const fdNumber = parseFd(fdName);
-	if (fdNumber === undefined || fdNumber === 0) {
-		throw new TypeError(`"${optionName}.${fdName}" is invalid.
-It must be "${optionName}.stdout", "${optionName}.stderr", "${optionName}.all", "${optionName}.ipc", or "${optionName}.fd3", "${optionName}.fd4" (and so on).`);
-	}
-
-	if (fdNumber >= optionArray.length) {
-		throw new TypeError(`"${optionName}.${fdName}" is invalid: that file descriptor does not exist.
-Please set the "stdio" option to ensure that file descriptor exists.`);
-	}
-
-	return fdNumber === 'all' ? [1, 2] : [fdNumber];
-};
-
-// Use the same syntax for fd-specific options and the `from`/`to` options
-export const parseFd = fdName => {
-	if (fdName === 'all') {
-		return fdName;
-	}
-
-	if (STANDARD_STREAMS_ALIASES.includes(fdName)) {
-		return STANDARD_STREAMS_ALIASES.indexOf(fdName);
-	}
-
-	const regexpResult = FD_REGEXP.exec(fdName);
-	if (regexpResult !== null) {
-		return Number(regexpResult[1]);
-	}
-};
-
-const FD_REGEXP = /^fd(\d+)$/;
-
-const addDefaultValue = (optionArray, optionName) => optionArray.map(optionValue => optionValue === undefined
-	? DEFAULT_OPTIONS[optionName]
-	: optionValue);
-
-// Default value for the `verbose` option
-const verboseDefault = debuglog('execa').enabled ? 'full' : 'none';
-
-const DEFAULT_OPTIONS = {
-	lines: false,
-	buffer: true,
-	maxBuffer: 1000 * 1000 * 100,
-	verbose: verboseDefault,
-	stripFinalNewline: true,
-};
-
-// List of options which can have different values for `stdout`/`stderr`
-export const FD_SPECIFIC_OPTIONS = ['lines', 'buffer', 'maxBuffer', 'verbose', 'stripFinalNewline'];
-
-// Retrieve fd-specific option
-export const getFdSpecificValue = (optionArray, fdNumber) => fdNumber === 'ipc'
-	? optionArray.at(-1)
-	: optionArray[fdNumber];

package/.output/server/node_modules/execa/lib/convert/add.js

@@ -1,15 +0,0 @@
-import {initializeConcurrentStreams} from './concurrent.js';
-import {createReadable} from './readable.js';
-import {createWritable} from './writable.js';
-import {createDuplex} from './duplex.js';
-import {createIterable} from './iterable.js';
-
-// Add methods to convert the subprocess to a stream or iterable
-export const addConvertedStreams = (subprocess, {encoding}) => {
-	const concurrentStreams = initializeConcurrentStreams();
-	subprocess.readable = createReadable.bind(undefined, {subprocess, concurrentStreams, encoding});
-	subprocess.writable = createWritable.bind(undefined, {subprocess, concurrentStreams});
-	subprocess.duplex = createDuplex.bind(undefined, {subprocess, concurrentStreams, encoding});
-	subprocess.iterable = createIterable.bind(undefined, subprocess, encoding);
-	subprocess[Symbol.asyncIterator] = createIterable.bind(undefined, subprocess, encoding, {});
-};

package/.output/server/node_modules/execa/lib/convert/concurrent.js

@@ -1,33 +0,0 @@
-import {createDeferred} from '../utils/deferred.js';
-
-// When using multiple `.readable()`/`.writable()`/`.duplex()`, `final` and `destroy` should wait for other streams
-export const initializeConcurrentStreams = () => ({
-	readableDestroy: new WeakMap(),
-	writableFinal: new WeakMap(),
-	writableDestroy: new WeakMap(),
-});
-
-// Each file descriptor + `waitName` has its own array of promises.
-// Each promise is a single `.readable()`/`.writable()`/`.duplex()` call.
-export const addConcurrentStream = (concurrentStreams, stream, waitName) => {
-	const weakMap = concurrentStreams[waitName];
-	if (!weakMap.has(stream)) {
-		weakMap.set(stream, []);
-	}
-
-	const promises = weakMap.get(stream);
-	const promise = createDeferred();
-	promises.push(promise);
-	const resolve = promise.resolve.bind(promise);
-	return {resolve, promises};
-};
-
-// Wait for other streams, but stop waiting when subprocess ends
-export const waitForConcurrentStreams = async ({resolve, promises}, subprocess) => {
-	resolve();
-	const [isSubprocessExit] = await Promise.race([
-		Promise.allSettled([true, subprocess]),
-		Promise.all([false, ...promises]),
-	]);
-	return !isSubprocessExit;
-};

package/.output/server/node_modules/execa/lib/convert/duplex.js

@@ -1,69 +0,0 @@
-import {Duplex} from 'node:stream';
-import {callbackify} from 'node:util';
-import {BINARY_ENCODINGS} from '../arguments/encoding-option.js';
-import {
-	getSubprocessStdout,
-	getReadableOptions,
-	getReadableMethods,
-	onStdoutFinished,
-	onReadableDestroy,
-} from './readable.js';
-import {
-	getSubprocessStdin,
-	getWritableMethods,
-	onStdinFinished,
-	onWritableDestroy,
-} from './writable.js';
-
-// Create a `Duplex` stream combining both `subprocess.readable()` and `subprocess.writable()`
-export const createDuplex = ({subprocess, concurrentStreams, encoding}, {from, to, binary: binaryOption = true, preserveNewlines = true} = {}) => {
-	const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
-	const {subprocessStdout, waitReadableDestroy} = getSubprocessStdout(subprocess, from, concurrentStreams);
-	const {subprocessStdin, waitWritableFinal, waitWritableDestroy} = getSubprocessStdin(subprocess, to, concurrentStreams);
-	const {readableEncoding, readableObjectMode, readableHighWaterMark} = getReadableOptions(subprocessStdout, binary);
-	const {read, onStdoutDataDone} = getReadableMethods({
-		subprocessStdout,
-		subprocess,
-		binary,
-		encoding,
-		preserveNewlines,
-	});
-	const duplex = new Duplex({
-		read,
-		...getWritableMethods(subprocessStdin, subprocess, waitWritableFinal),
-		destroy: callbackify(onDuplexDestroy.bind(undefined, {
-			subprocessStdout,
-			subprocessStdin,
-			subprocess,
-			waitReadableDestroy,
-			waitWritableFinal,
-			waitWritableDestroy,
-		})),
-		readableHighWaterMark,
-		writableHighWaterMark: subprocessStdin.writableHighWaterMark,
-		readableObjectMode,
-		writableObjectMode: subprocessStdin.writableObjectMode,
-		encoding: readableEncoding,
-	});
-	onStdoutFinished({
-		subprocessStdout,
-		onStdoutDataDone,
-		readable: duplex,
-		subprocess,
-		subprocessStdin,
-	});
-	onStdinFinished(subprocessStdin, duplex, subprocessStdout);
-	return duplex;
-};
-
-const onDuplexDestroy = async ({subprocessStdout, subprocessStdin, subprocess, waitReadableDestroy, waitWritableFinal, waitWritableDestroy}, error) => {
-	await Promise.all([
-		onReadableDestroy({subprocessStdout, subprocess, waitReadableDestroy}, error),
-		onWritableDestroy({
-			subprocessStdin,
-			subprocess,
-			waitWritableFinal,
-			waitWritableDestroy,
-		}, error),
-	]);
-};

package/.output/server/node_modules/execa/lib/convert/iterable.js

@@ -1,34 +0,0 @@
-import {BINARY_ENCODINGS} from '../arguments/encoding-option.js';
-import {getFromStream} from '../arguments/fd-options.js';
-import {iterateOnSubprocessStream} from '../io/iterate.js';
-
-// Convert the subprocess to an async iterable
-export const createIterable = (subprocess, encoding, {
-	from,
-	binary: binaryOption = false,
-	preserveNewlines = false,
-} = {}) => {
-	const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
-	const subprocessStdout = getFromStream(subprocess, from);
-	const onStdoutData = iterateOnSubprocessStream({
-		subprocessStdout,
-		subprocess,
-		binary,
-		shouldEncode: true,
-		encoding,
-		preserveNewlines,
-	});
-	return iterateOnStdoutData(onStdoutData, subprocessStdout, subprocess);
-};
-
-const iterateOnStdoutData = async function * (onStdoutData, subprocessStdout, subprocess) {
-	try {
-		yield * onStdoutData;
-	} finally {
-		if (subprocessStdout.readable) {
-			subprocessStdout.destroy();
-		}
-
-		await subprocess;
-	}
-};

package/.output/server/node_modules/execa/lib/convert/readable.js

@@ -1,113 +0,0 @@
-import {Readable} from 'node:stream';
-import {callbackify} from 'node:util';
-import {BINARY_ENCODINGS} from '../arguments/encoding-option.js';
-import {getFromStream} from '../arguments/fd-options.js';
-import {iterateOnSubprocessStream, DEFAULT_OBJECT_HIGH_WATER_MARK} from '../io/iterate.js';
-import {createDeferred} from '../utils/deferred.js';
-import {addConcurrentStream, waitForConcurrentStreams} from './concurrent.js';
-import {
-	safeWaitForSubprocessStdin,
-	waitForSubprocessStdout,
-	waitForSubprocess,
-	destroyOtherStream,
-} from './shared.js';
-
-// Create a `Readable` stream that forwards from `stdout` and awaits the subprocess
-export const createReadable = ({subprocess, concurrentStreams, encoding}, {from, binary: binaryOption = true, preserveNewlines = true} = {}) => {
-	const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
-	const {subprocessStdout, waitReadableDestroy} = getSubprocessStdout(subprocess, from, concurrentStreams);
-	const {readableEncoding, readableObjectMode, readableHighWaterMark} = getReadableOptions(subprocessStdout, binary);
-	const {read, onStdoutDataDone} = getReadableMethods({
-		subprocessStdout,
-		subprocess,
-		binary,
-		encoding,
-		preserveNewlines,
-	});
-	const readable = new Readable({
-		read,
-		destroy: callbackify(onReadableDestroy.bind(undefined, {subprocessStdout, subprocess, waitReadableDestroy})),
-		highWaterMark: readableHighWaterMark,
-		objectMode: readableObjectMode,
-		encoding: readableEncoding,
-	});
-	onStdoutFinished({
-		subprocessStdout,
-		onStdoutDataDone,
-		readable,
-		subprocess,
-	});
-	return readable;
-};
-
-// Retrieve `stdout` (or other stream depending on `from`)
-export const getSubprocessStdout = (subprocess, from, concurrentStreams) => {
-	const subprocessStdout = getFromStream(subprocess, from);
-	const waitReadableDestroy = addConcurrentStream(concurrentStreams, subprocessStdout, 'readableDestroy');
-	return {subprocessStdout, waitReadableDestroy};
-};
-
-export const getReadableOptions = ({readableEncoding, readableObjectMode, readableHighWaterMark}, binary) => binary
-	? {readableEncoding, readableObjectMode, readableHighWaterMark}
-	: {readableEncoding, readableObjectMode: true, readableHighWaterMark: DEFAULT_OBJECT_HIGH_WATER_MARK};
-
-export const getReadableMethods = ({subprocessStdout, subprocess, binary, encoding, preserveNewlines}) => {
-	const onStdoutDataDone = createDeferred();
-	const onStdoutData = iterateOnSubprocessStream({
-		subprocessStdout,
-		subprocess,
-		binary,
-		shouldEncode: !binary,
-		encoding,
-		preserveNewlines,
-	});
-
-	return {
-		read() {
-			onRead(this, onStdoutData, onStdoutDataDone);
-		},
-		onStdoutDataDone,
-	};
-};
-
-// Forwards data from `stdout` to `readable`
-const onRead = async (readable, onStdoutData, onStdoutDataDone) => {
-	try {
-		const {value, done} = await onStdoutData.next();
-		if (done) {
-			onStdoutDataDone.resolve();
-		} else {
-			readable.push(value);
-		}
-	} catch {}
-};
-
-// When `subprocess.stdout` ends/aborts/errors, do the same on `readable`.
-// Await the subprocess, for the same reason as above.
-export const onStdoutFinished = async ({subprocessStdout, onStdoutDataDone, readable, subprocess, subprocessStdin}) => {
-	try {
-		await waitForSubprocessStdout(subprocessStdout);
-		await subprocess;
-		await safeWaitForSubprocessStdin(subprocessStdin);
-		await onStdoutDataDone;
-
-		if (readable.readable) {
-			readable.push(null);
-		}
-	} catch (error) {
-		await safeWaitForSubprocessStdin(subprocessStdin);
-		destroyOtherReadable(readable, error);
-	}
-};
-
-// When `readable` aborts/errors, do the same on `subprocess.stdout`
-export const onReadableDestroy = async ({subprocessStdout, subprocess, waitReadableDestroy}, error) => {
-	if (await waitForConcurrentStreams(waitReadableDestroy, subprocess)) {
-		destroyOtherReadable(subprocessStdout, error);
-		await waitForSubprocess(subprocess, error);
-	}
-};
-
-const destroyOtherReadable = (stream, error) => {
-	destroyOtherStream(stream, stream.readable, error);
-};

package/.output/server/node_modules/execa/lib/convert/shared.js

@@ -1,46 +0,0 @@
-import {finished} from 'node:stream/promises';
-import {isStreamAbort} from '../resolve/wait-stream.js';
-
-export const safeWaitForSubprocessStdin = async subprocessStdin => {
-	if (subprocessStdin === undefined) {
-		return;
-	}
-
-	try {
-		await waitForSubprocessStdin(subprocessStdin);
-	} catch {}
-};
-
-export const safeWaitForSubprocessStdout = async subprocessStdout => {
-	if (subprocessStdout === undefined) {
-		return;
-	}
-
-	try {
-		await waitForSubprocessStdout(subprocessStdout);
-	} catch {}
-};
-
-export const waitForSubprocessStdin = async subprocessStdin => {
-	await finished(subprocessStdin, {cleanup: true, readable: false, writable: true});
-};
-
-export const waitForSubprocessStdout = async subprocessStdout => {
-	await finished(subprocessStdout, {cleanup: true, readable: true, writable: false});
-};
-
-// When `readable` or `writable` aborts/errors, awaits the subprocess, for the reason mentioned above
-export const waitForSubprocess = async (subprocess, error) => {
-	await subprocess;
-	if (error) {
-		throw error;
-	}
-};
-
-export const destroyOtherStream = (stream, isOpen, error) => {
-	if (error && !isStreamAbort(error)) {
-		stream.destroy(error);
-	} else if (isOpen) {
-		stream.destroy();
-	}
-};

package/.output/server/node_modules/execa/lib/convert/writable.js

@@ -1,90 +0,0 @@
-import {Writable} from 'node:stream';
-import {callbackify} from 'node:util';
-import {getToStream} from '../arguments/fd-options.js';
-import {addConcurrentStream, waitForConcurrentStreams} from './concurrent.js';
-import {
-	safeWaitForSubprocessStdout,
-	waitForSubprocessStdin,
-	waitForSubprocess,
-	destroyOtherStream,
-} from './shared.js';
-
-// Create a `Writable` stream that forwards to `stdin` and awaits the subprocess
-export const createWritable = ({subprocess, concurrentStreams}, {to} = {}) => {
-	const {subprocessStdin, waitWritableFinal, waitWritableDestroy} = getSubprocessStdin(subprocess, to, concurrentStreams);
-	const writable = new Writable({
-		...getWritableMethods(subprocessStdin, subprocess, waitWritableFinal),
-		destroy: callbackify(onWritableDestroy.bind(undefined, {
-			subprocessStdin,
-			subprocess,
-			waitWritableFinal,
-			waitWritableDestroy,
-		})),
-		highWaterMark: subprocessStdin.writableHighWaterMark,
-		objectMode: subprocessStdin.writableObjectMode,
-	});
-	onStdinFinished(subprocessStdin, writable);
-	return writable;
-};
-
-// Retrieve `stdin` (or other stream depending on `to`)
-export const getSubprocessStdin = (subprocess, to, concurrentStreams) => {
-	const subprocessStdin = getToStream(subprocess, to);
-	const waitWritableFinal = addConcurrentStream(concurrentStreams, subprocessStdin, 'writableFinal');
-	const waitWritableDestroy = addConcurrentStream(concurrentStreams, subprocessStdin, 'writableDestroy');
-	return {subprocessStdin, waitWritableFinal, waitWritableDestroy};
-};
-
-export const getWritableMethods = (subprocessStdin, subprocess, waitWritableFinal) => ({
-	write: onWrite.bind(undefined, subprocessStdin),
-	final: callbackify(onWritableFinal.bind(undefined, subprocessStdin, subprocess, waitWritableFinal)),
-});
-
-// Forwards data from `writable` to `stdin`
-const onWrite = (subprocessStdin, chunk, encoding, done) => {
-	if (subprocessStdin.write(chunk, encoding)) {
-		done();
-	} else {
-		subprocessStdin.once('drain', done);
-	}
-};
-
-// Ensures that the writable `final` and readable `end` events awaits the subprocess.
-// Like this, any subprocess failure is propagated as a stream `error` event, instead of being lost.
-// The user does not need to `await` the subprocess anymore, but now needs to await the stream completion or error.
-// When multiple writables are targeting the same stream, they wait for each other, unless the subprocess ends first.
-const onWritableFinal = async (subprocessStdin, subprocess, waitWritableFinal) => {
-	if (await waitForConcurrentStreams(waitWritableFinal, subprocess)) {
-		if (subprocessStdin.writable) {
-			subprocessStdin.end();
-		}
-
-		await subprocess;
-	}
-};
-
-// When `subprocess.stdin` ends/aborts/errors, do the same on `writable`.
-export const onStdinFinished = async (subprocessStdin, writable, subprocessStdout) => {
-	try {
-		await waitForSubprocessStdin(subprocessStdin);
-		if (writable.writable) {
-			writable.end();
-		}
-	} catch (error) {
-		await safeWaitForSubprocessStdout(subprocessStdout);
-		destroyOtherWritable(writable, error);
-	}
-};
-
-// When `writable` aborts/errors, do the same on `subprocess.stdin`
-export const onWritableDestroy = async ({subprocessStdin, subprocess, waitWritableFinal, waitWritableDestroy}, error) => {
-	await waitForConcurrentStreams(waitWritableFinal, subprocess);
-	if (await waitForConcurrentStreams(waitWritableDestroy, subprocess)) {
-		destroyOtherWritable(subprocessStdin, error);
-		await waitForSubprocess(subprocess, error);
-	}
-};
-
-const destroyOtherWritable = (stream, error) => {
-	destroyOtherStream(stream, stream.writable, error);
-};

package/.output/server/node_modules/execa/lib/io/contents.js

@@ -1,116 +0,0 @@
-import {setImmediate} from 'node:timers/promises';
-import getStream, {getStreamAsArrayBuffer, getStreamAsArray} from 'get-stream';
-import {isArrayBuffer} from '../utils/uint-array.js';
-import {shouldLogOutput, logLines} from '../verbose/output.js';
-import {iterateForResult} from './iterate.js';
-import {handleMaxBuffer} from './max-buffer.js';
-import {getStripFinalNewline} from './strip-newline.js';
-
-// Retrieve `result.stdout|stderr|all|stdio[*]`
-export const getStreamOutput = async ({stream, onStreamEnd, fdNumber, encoding, buffer, maxBuffer, lines, allMixed, stripFinalNewline, verboseInfo, streamInfo}) => {
-	const logPromise = logOutputAsync({
-		stream,
-		onStreamEnd,
-		fdNumber,
-		encoding,
-		allMixed,
-		verboseInfo,
-		streamInfo,
-	});
-
-	if (!buffer) {
-		await Promise.all([resumeStream(stream), logPromise]);
-		return;
-	}
-
-	const stripFinalNewlineValue = getStripFinalNewline(stripFinalNewline, fdNumber);
-	const iterable = iterateForResult({
-		stream,
-		onStreamEnd,
-		lines,
-		encoding,
-		stripFinalNewline: stripFinalNewlineValue,
-		allMixed,
-	});
-	const [output] = await Promise.all([
-		getStreamContents({
-			stream,
-			iterable,
-			fdNumber,
-			encoding,
-			maxBuffer,
-			lines,
-		}),
-		logPromise,
-	]);
-	return output;
-};
-
-const logOutputAsync = async ({stream, onStreamEnd, fdNumber, encoding, allMixed, verboseInfo, streamInfo: {fileDescriptors}}) => {
-	if (!shouldLogOutput({
-		stdioItems: fileDescriptors[fdNumber]?.stdioItems,
-		encoding,
-		verboseInfo,
-		fdNumber,
-	})) {
-		return;
-	}
-
-	const linesIterable = iterateForResult({
-		stream,
-		onStreamEnd,
-		lines: true,
-		encoding,
-		stripFinalNewline: true,
-		allMixed,
-	});
-	await logLines(linesIterable, stream, fdNumber, verboseInfo);
-};
-
-// When using `buffer: false`, users need to read `subprocess.stdout|stderr|all` right away
-// See https://github.com/sindresorhus/execa/issues/730 and https://github.com/sindresorhus/execa/pull/729#discussion_r1465496310
-const resumeStream = async stream => {
-	await setImmediate();
-	if (stream.readableFlowing === null) {
-		stream.resume();
-	}
-};
-
-const getStreamContents = async ({stream, stream: {readableObjectMode}, iterable, fdNumber, encoding, maxBuffer, lines}) => {
-	try {
-		if (readableObjectMode || lines) {
-			return await getStreamAsArray(iterable, {maxBuffer});
-		}
-
-		if (encoding === 'buffer') {
-			return new Uint8Array(await getStreamAsArrayBuffer(iterable, {maxBuffer}));
-		}
-
-		return await getStream(iterable, {maxBuffer});
-	} catch (error) {
-		return handleBufferedData(handleMaxBuffer({
-			error,
-			stream,
-			readableObjectMode,
-			lines,
-			encoding,
-			fdNumber,
-		}));
-	}
-};
-
-// On failure, `result.stdout|stderr|all` should contain the currently buffered stream
-// They are automatically closed and flushed by Node.js when the subprocess exits
-// When `buffer` is `false`, `streamPromise` is `undefined` and there is no buffered data to retrieve
-export const getBufferedData = async streamPromise => {
-	try {
-		return await streamPromise;
-	} catch (error) {
-		return handleBufferedData(error);
-	}
-};
-
-// Ensure we are returning Uint8Arrays when using `encoding: 'buffer'`
-const handleBufferedData = ({bufferedData}) => isArrayBuffer(bufferedData)
-	? new Uint8Array(bufferedData)
-	: bufferedData;

package/.output/server/node_modules/execa/lib/io/input-sync.js

@@ -1,44 +0,0 @@
-import {runGeneratorsSync} from '../transform/generator.js';
-import {joinToUint8Array, isUint8Array} from '../utils/uint-array.js';
-import {TYPE_TO_MESSAGE} from '../stdio/type.js';
-
-// Apply `stdin`/`input`/`inputFile` options, before spawning, in sync mode, by converting it to the `input` option
-export const addInputOptionsSync = (fileDescriptors, options) => {
-	for (const fdNumber of getInputFdNumbers(fileDescriptors)) {
-		addInputOptionSync(fileDescriptors, fdNumber, options);
-	}
-};
-
-const getInputFdNumbers = fileDescriptors => new Set(Object.entries(fileDescriptors)
-	.filter(([, {direction}]) => direction === 'input')
-	.map(([fdNumber]) => Number(fdNumber)));
-
-const addInputOptionSync = (fileDescriptors, fdNumber, options) => {
-	const {stdioItems} = fileDescriptors[fdNumber];
-	const allStdioItems = stdioItems.filter(({contents}) => contents !== undefined);
-	if (allStdioItems.length === 0) {
-		return;
-	}
-
-	if (fdNumber !== 0) {
-		const [{type, optionName}] = allStdioItems;
-		throw new TypeError(`Only the \`stdin\` option, not \`${optionName}\`, can be ${TYPE_TO_MESSAGE[type]} with synchronous methods.`);
-	}
-
-	const allContents = allStdioItems.map(({contents}) => contents);
-	const transformedContents = allContents.map(contents => applySingleInputGeneratorsSync(contents, stdioItems));
-	options.input = joinToUint8Array(transformedContents);
-};
-
-const applySingleInputGeneratorsSync = (contents, stdioItems) => {
-	const newContents = runGeneratorsSync(contents, stdioItems, 'utf8', true);
-	validateSerializable(newContents);
-	return joinToUint8Array(newContents);
-};
-
-const validateSerializable = newContents => {
-	const invalidItem = newContents.find(item => typeof item !== 'string' && !isUint8Array(item));
-	if (invalidItem !== undefined) {
-		throw new TypeError(`The \`stdin\` option is invalid: when passing objects as input, a transform must be used to serialize them to strings or Uint8Arrays: ${invalidItem}.`);
-	}
-};