@kubb/agent 4.28.1 → 4.29.1

package/.output/server/node_modules/execa/lib/return/result.js

@@ -1,186 +0,0 @@
-import {getSignalDescription} from '../terminate/signal.js';
-import {getDurationMs} from './duration.js';
-import {getFinalError} from './final-error.js';
-import {createMessages} from './message.js';
-
-// Object returned on subprocess success
-export const makeSuccessResult = ({
-	command,
-	escapedCommand,
-	stdio,
-	all,
-	ipcOutput,
-	options: {cwd},
-	startTime,
-}) => omitUndefinedProperties({
-	command,
-	escapedCommand,
-	cwd,
-	durationMs: getDurationMs(startTime),
-	failed: false,
-	timedOut: false,
-	isCanceled: false,
-	isGracefullyCanceled: false,
-	isTerminated: false,
-	isMaxBuffer: false,
-	isForcefullyTerminated: false,
-	exitCode: 0,
-	stdout: stdio[1],
-	stderr: stdio[2],
-	all,
-	stdio,
-	ipcOutput,
-	pipedFrom: [],
-});
-
-// Object returned on subprocess failure before spawning
-export const makeEarlyError = ({
-	error,
-	command,
-	escapedCommand,
-	fileDescriptors,
-	options,
-	startTime,
-	isSync,
-}) => makeError({
-	error,
-	command,
-	escapedCommand,
-	startTime,
-	timedOut: false,
-	isCanceled: false,
-	isGracefullyCanceled: false,
-	isMaxBuffer: false,
-	isForcefullyTerminated: false,
-	stdio: Array.from({length: fileDescriptors.length}),
-	ipcOutput: [],
-	options,
-	isSync,
-});
-
-// Object returned on subprocess failure
-export const makeError = ({
-	error: originalError,
-	command,
-	escapedCommand,
-	startTime,
-	timedOut,
-	isCanceled,
-	isGracefullyCanceled,
-	isMaxBuffer,
-	isForcefullyTerminated,
-	exitCode: rawExitCode,
-	signal: rawSignal,
-	stdio,
-	all,
-	ipcOutput,
-	options: {
-		timeoutDuration,
-		timeout = timeoutDuration,
-		forceKillAfterDelay,
-		killSignal,
-		cwd,
-		maxBuffer,
-	},
-	isSync,
-}) => {
-	const {exitCode, signal, signalDescription} = normalizeExitPayload(rawExitCode, rawSignal);
-	const {originalMessage, shortMessage, message} = createMessages({
-		stdio,
-		all,
-		ipcOutput,
-		originalError,
-		signal,
-		signalDescription,
-		exitCode,
-		escapedCommand,
-		timedOut,
-		isCanceled,
-		isGracefullyCanceled,
-		isMaxBuffer,
-		isForcefullyTerminated,
-		forceKillAfterDelay,
-		killSignal,
-		maxBuffer,
-		timeout,
-		cwd,
-	});
-	const error = getFinalError(originalError, message, isSync);
-	Object.assign(error, getErrorProperties({
-		error,
-		command,
-		escapedCommand,
-		startTime,
-		timedOut,
-		isCanceled,
-		isGracefullyCanceled,
-		isMaxBuffer,
-		isForcefullyTerminated,
-		exitCode,
-		signal,
-		signalDescription,
-		stdio,
-		all,
-		ipcOutput,
-		cwd,
-		originalMessage,
-		shortMessage,
-	}));
-	return error;
-};
-
-const getErrorProperties = ({
-	error,
-	command,
-	escapedCommand,
-	startTime,
-	timedOut,
-	isCanceled,
-	isGracefullyCanceled,
-	isMaxBuffer,
-	isForcefullyTerminated,
-	exitCode,
-	signal,
-	signalDescription,
-	stdio,
-	all,
-	ipcOutput,
-	cwd,
-	originalMessage,
-	shortMessage,
-}) => omitUndefinedProperties({
-	shortMessage,
-	originalMessage,
-	command,
-	escapedCommand,
-	cwd,
-	durationMs: getDurationMs(startTime),
-	failed: true,
-	timedOut,
-	isCanceled,
-	isGracefullyCanceled,
-	isTerminated: signal !== undefined,
-	isMaxBuffer,
-	isForcefullyTerminated,
-	exitCode,
-	signal,
-	signalDescription,
-	code: error.cause?.code,
-	stdout: stdio[1],
-	stderr: stdio[2],
-	all,
-	stdio,
-	ipcOutput,
-	pipedFrom: [],
-});
-
-const omitUndefinedProperties = result => Object.fromEntries(Object.entries(result).filter(([, value]) => value !== undefined));
-
-// `signal` and `exitCode` emitted on `subprocess.on('exit')` event can be `null`.
-// We normalize them to `undefined`
-const normalizeExitPayload = (rawExitCode, rawSignal) => {
-	const exitCode = rawExitCode === null ? undefined : rawExitCode;
-	const signal = rawSignal === null ? undefined : rawSignal;
-	const signalDescription = signal === undefined ? undefined : getSignalDescription(rawSignal);
-	return {exitCode, signal, signalDescription};
-};

package/.output/server/node_modules/execa/lib/stdio/direction.js

@@ -1,76 +0,0 @@
-import process from 'node:process';
-import {
-	isStream as isNodeStream,
-	isReadableStream as isNodeReadableStream,
-	isWritableStream as isNodeWritableStream,
-} from 'is-stream';
-import {isWritableStream} from './type.js';
-
-// For `stdio[fdNumber]` beyond stdin/stdout/stderr, we need to guess whether the value passed is intended for inputs or outputs.
-// This allows us to know whether to pipe _into_ or _from_ the stream.
-// When `stdio[fdNumber]` is a single value, this guess is fairly straightforward.
-// However, when it is an array instead, we also need to make sure the different values are not incompatible with each other.
-export const getStreamDirection = (stdioItems, fdNumber, optionName) => {
-	const directions = stdioItems.map(stdioItem => getStdioItemDirection(stdioItem, fdNumber));
-
-	if (directions.includes('input') && directions.includes('output')) {
-		throw new TypeError(`The \`${optionName}\` option must not be an array of both readable and writable values.`);
-	}
-
-	return directions.find(Boolean) ?? DEFAULT_DIRECTION;
-};
-
-const getStdioItemDirection = ({type, value}, fdNumber) => KNOWN_DIRECTIONS[fdNumber] ?? guessStreamDirection[type](value);
-
-// `stdin`/`stdout`/`stderr` have a known direction
-const KNOWN_DIRECTIONS = ['input', 'output', 'output'];
-
-const anyDirection = () => undefined;
-const alwaysInput = () => 'input';
-
-// `string` can only be added through the `input` option, i.e. does not need to be handled here
-const guessStreamDirection = {
-	generator: anyDirection,
-	asyncGenerator: anyDirection,
-	fileUrl: anyDirection,
-	filePath: anyDirection,
-	iterable: alwaysInput,
-	asyncIterable: alwaysInput,
-	uint8Array: alwaysInput,
-	webStream: value => isWritableStream(value) ? 'output' : 'input',
-	nodeStream(value) {
-		if (!isNodeReadableStream(value, {checkOpen: false})) {
-			return 'output';
-		}
-
-		return isNodeWritableStream(value, {checkOpen: false}) ? undefined : 'input';
-	},
-	webTransform: anyDirection,
-	duplex: anyDirection,
-	native(value) {
-		const standardStreamDirection = getStandardStreamDirection(value);
-		if (standardStreamDirection !== undefined) {
-			return standardStreamDirection;
-		}
-
-		if (isNodeStream(value, {checkOpen: false})) {
-			return guessStreamDirection.nodeStream(value);
-		}
-	},
-};
-
-const getStandardStreamDirection = value => {
-	if ([0, process.stdin].includes(value)) {
-		return 'input';
-	}
-
-	if ([1, 2, process.stdout, process.stderr].includes(value)) {
-		return 'output';
-	}
-};
-
-// When ambiguous, we initially keep the direction as `undefined`.
-// This allows arrays of `stdio` values to resolve the ambiguity.
-// For example, `stdio[3]: DuplexStream` is ambiguous, but `stdio[3]: [DuplexStream, WritableStream]` is not.
-// When the ambiguity remains, we default to `output` since it is the most common use case for additional file descriptors.
-const DEFAULT_DIRECTION = 'output';

package/.output/server/node_modules/execa/lib/stdio/duplicate.js

@@ -1,116 +0,0 @@
-import {
-	SPECIAL_DUPLICATE_TYPES_SYNC,
-	SPECIAL_DUPLICATE_TYPES,
-	FORBID_DUPLICATE_TYPES,
-	TYPE_TO_MESSAGE,
-} from './type.js';
-
-// Duplicates in the same file descriptor is most likely an error.
-// However, this can be useful with generators.
-export const filterDuplicates = stdioItems => stdioItems.filter((stdioItemOne, indexOne) =>
-	stdioItems.every((stdioItemTwo, indexTwo) => stdioItemOne.value !== stdioItemTwo.value
-		|| indexOne >= indexTwo
-		|| stdioItemOne.type === 'generator'
-		|| stdioItemOne.type === 'asyncGenerator'));
-
-// Check if two file descriptors are sharing the same target.
-// For example `{stdout: {file: './output.txt'}, stderr: {file: './output.txt'}}`.
-export const getDuplicateStream = ({stdioItem: {type, value, optionName}, direction, fileDescriptors, isSync}) => {
-	const otherStdioItems = getOtherStdioItems(fileDescriptors, type);
-	if (otherStdioItems.length === 0) {
-		return;
-	}
-
-	if (isSync) {
-		validateDuplicateStreamSync({
-			otherStdioItems,
-			type,
-			value,
-			optionName,
-			direction,
-		});
-		return;
-	}
-
-	if (SPECIAL_DUPLICATE_TYPES.has(type)) {
-		return getDuplicateStreamInstance({
-			otherStdioItems,
-			type,
-			value,
-			optionName,
-			direction,
-		});
-	}
-
-	if (FORBID_DUPLICATE_TYPES.has(type)) {
-		validateDuplicateTransform({
-			otherStdioItems,
-			type,
-			value,
-			optionName,
-		});
-	}
-};
-
-// Values shared by multiple file descriptors
-const getOtherStdioItems = (fileDescriptors, type) => fileDescriptors
-	.flatMap(({direction, stdioItems}) => stdioItems
-		.filter(stdioItem => stdioItem.type === type)
-		.map((stdioItem => ({...stdioItem, direction}))));
-
-// With `execaSync()`, do not allow setting a file path both in input and output
-const validateDuplicateStreamSync = ({otherStdioItems, type, value, optionName, direction}) => {
-	if (SPECIAL_DUPLICATE_TYPES_SYNC.has(type)) {
-		getDuplicateStreamInstance({
-			otherStdioItems,
-			type,
-			value,
-			optionName,
-			direction,
-		});
-	}
-};
-
-// When two file descriptors share the file or stream, we need to re-use the same underlying stream.
-// Otherwise, the stream would be closed twice when piping ends.
-// This is only an issue with output file descriptors.
-// This is not a problem with generator functions since those create a new instance for each file descriptor.
-// We also forbid input and output file descriptors sharing the same file or stream, since that does not make sense.
-const getDuplicateStreamInstance = ({otherStdioItems, type, value, optionName, direction}) => {
-	const duplicateStdioItems = otherStdioItems.filter(stdioItem => hasSameValue(stdioItem, value));
-	if (duplicateStdioItems.length === 0) {
-		return;
-	}
-
-	const differentStdioItem = duplicateStdioItems.find(stdioItem => stdioItem.direction !== direction);
-	throwOnDuplicateStream(differentStdioItem, optionName, type);
-
-	return direction === 'output' ? duplicateStdioItems[0].stream : undefined;
-};
-
-const hasSameValue = ({type, value}, secondValue) => {
-	if (type === 'filePath') {
-		return value.file === secondValue.file;
-	}
-
-	if (type === 'fileUrl') {
-		return value.href === secondValue.href;
-	}
-
-	return value === secondValue;
-};
-
-// We do not allow two file descriptors to share the same Duplex or TransformStream.
-// This is because those are set directly to `subprocess.std*`.
-// For example, this could result in `subprocess.stdout` and `subprocess.stderr` being the same value.
-// This means reading from either would get data from both stdout and stderr.
-const validateDuplicateTransform = ({otherStdioItems, type, value, optionName}) => {
-	const duplicateStdioItem = otherStdioItems.find(({value: {transform}}) => transform === value.transform);
-	throwOnDuplicateStream(duplicateStdioItem, optionName, type);
-};
-
-const throwOnDuplicateStream = (stdioItem, optionName, type) => {
-	if (stdioItem !== undefined) {
-		throw new TypeError(`The \`${stdioItem.optionName}\` and \`${optionName}\` options must not target ${TYPE_TO_MESSAGE[type]} that is the same.`);
-	}
-};

package/.output/server/node_modules/execa/lib/stdio/handle-async.js

@@ -1,52 +0,0 @@
-import {createReadStream, createWriteStream} from 'node:fs';
-import {Buffer} from 'node:buffer';
-import {Readable, Writable, Duplex} from 'node:stream';
-import {generatorToStream} from '../transform/generator.js';
-import {handleStdio} from './handle.js';
-import {TYPE_TO_MESSAGE} from './type.js';
-
-// Handle `input`, `inputFile`, `stdin`, `stdout` and `stderr` options, before spawning, in async mode
-export const handleStdioAsync = (options, verboseInfo) => handleStdio(addPropertiesAsync, options, verboseInfo, false);
-
-const forbiddenIfAsync = ({type, optionName}) => {
-	throw new TypeError(`The \`${optionName}\` option cannot be ${TYPE_TO_MESSAGE[type]}.`);
-};
-
-// Create streams used internally for piping when using specific values for the `std*` options, in async mode.
-// For example, `stdout: {file}` creates a file stream, which is piped from/to.
-const addProperties = {
-	fileNumber: forbiddenIfAsync,
-	generator: generatorToStream,
-	asyncGenerator: generatorToStream,
-	nodeStream: ({value}) => ({stream: value}),
-	webTransform({value: {transform, writableObjectMode, readableObjectMode}}) {
-		const objectMode = writableObjectMode || readableObjectMode;
-		const stream = Duplex.fromWeb(transform, {objectMode});
-		return {stream};
-	},
-	duplex: ({value: {transform}}) => ({stream: transform}),
-	native() {},
-};
-
-const addPropertiesAsync = {
-	input: {
-		...addProperties,
-		fileUrl: ({value}) => ({stream: createReadStream(value)}),
-		filePath: ({value: {file}}) => ({stream: createReadStream(file)}),
-		webStream: ({value}) => ({stream: Readable.fromWeb(value)}),
-		iterable: ({value}) => ({stream: Readable.from(value)}),
-		asyncIterable: ({value}) => ({stream: Readable.from(value)}),
-		string: ({value}) => ({stream: Readable.from(value)}),
-		uint8Array: ({value}) => ({stream: Readable.from(Buffer.from(value))}),
-	},
-	output: {
-		...addProperties,
-		fileUrl: ({value}) => ({stream: createWriteStream(value)}),
-		filePath: ({value: {file, append}}) => ({stream: createWriteStream(file, append ? {flags: 'a'} : {})}),
-		webStream: ({value}) => ({stream: Writable.fromWeb(value)}),
-		iterable: forbiddenIfAsync,
-		asyncIterable: forbiddenIfAsync,
-		string: forbiddenIfAsync,
-		uint8Array: forbiddenIfAsync,
-	},
-};

package/.output/server/node_modules/execa/lib/stdio/handle-sync.js

@@ -1,57 +0,0 @@
-import {readFileSync} from 'node:fs';
-import {bufferToUint8Array} from '../utils/uint-array.js';
-import {handleStdio} from './handle.js';
-import {TYPE_TO_MESSAGE} from './type.js';
-
-// Normalize `input`, `inputFile`, `stdin`, `stdout` and `stderr` options, before spawning, in sync mode
-export const handleStdioSync = (options, verboseInfo) => handleStdio(addPropertiesSync, options, verboseInfo, true);
-
-const forbiddenIfSync = ({type, optionName}) => {
-	throwInvalidSyncValue(optionName, TYPE_TO_MESSAGE[type]);
-};
-
-const forbiddenNativeIfSync = ({optionName, value}) => {
-	if (value === 'ipc' || value === 'overlapped') {
-		throwInvalidSyncValue(optionName, `"${value}"`);
-	}
-
-	return {};
-};
-
-const throwInvalidSyncValue = (optionName, value) => {
-	throw new TypeError(`The \`${optionName}\` option cannot be ${value} with synchronous methods.`);
-};
-
-// Create streams used internally for redirecting when using specific values for the `std*` options, in sync mode.
-// For example, `stdin: {file}` reads the file synchronously, then passes it as the `input` option.
-const addProperties = {
-	generator() {},
-	asyncGenerator: forbiddenIfSync,
-	webStream: forbiddenIfSync,
-	nodeStream: forbiddenIfSync,
-	webTransform: forbiddenIfSync,
-	duplex: forbiddenIfSync,
-	asyncIterable: forbiddenIfSync,
-	native: forbiddenNativeIfSync,
-};
-
-const addPropertiesSync = {
-	input: {
-		...addProperties,
-		fileUrl: ({value}) => ({contents: [bufferToUint8Array(readFileSync(value))]}),
-		filePath: ({value: {file}}) => ({contents: [bufferToUint8Array(readFileSync(file))]}),
-		fileNumber: forbiddenIfSync,
-		iterable: ({value}) => ({contents: [...value]}),
-		string: ({value}) => ({contents: [value]}),
-		uint8Array: ({value}) => ({contents: [value]}),
-	},
-	output: {
-		...addProperties,
-		fileUrl: ({value}) => ({path: value}),
-		filePath: ({value: {file, append}}) => ({path: file, append}),
-		fileNumber: ({value}) => ({path: value}),
-		iterable: forbiddenIfSync,
-		string: forbiddenIfSync,
-		uint8Array: forbiddenIfSync,
-	},
-};

package/.output/server/node_modules/execa/lib/stdio/handle.js

@@ -1,214 +0,0 @@
-import {getStreamName, isStandardStream} from '../utils/standard-stream.js';
-import {normalizeTransforms} from '../transform/normalize.js';
-import {getFdObjectMode} from '../transform/object-mode.js';
-import {
-	getStdioItemType,
-	isRegularUrl,
-	isUnknownStdioString,
-	FILE_TYPES,
-} from './type.js';
-import {getStreamDirection} from './direction.js';
-import {normalizeStdioOption} from './stdio-option.js';
-import {handleNativeStream} from './native.js';
-import {handleInputOptions} from './input-option.js';
-import {filterDuplicates, getDuplicateStream} from './duplicate.js';
-
-// Handle `input`, `inputFile`, `stdin`, `stdout` and `stderr` options, before spawning, in async/sync mode
-// They are converted into an array of `fileDescriptors`.
-// Each `fileDescriptor` is normalized, validated and contains all information necessary for further handling.
-export const handleStdio = (addProperties, options, verboseInfo, isSync) => {
-	const stdio = normalizeStdioOption(options, verboseInfo, isSync);
-	const initialFileDescriptors = stdio.map((stdioOption, fdNumber) => getFileDescriptor({
-		stdioOption,
-		fdNumber,
-		options,
-		isSync,
-	}));
-	const fileDescriptors = getFinalFileDescriptors({
-		initialFileDescriptors,
-		addProperties,
-		options,
-		isSync,
-	});
-	options.stdio = fileDescriptors.map(({stdioItems}) => forwardStdio(stdioItems));
-	return fileDescriptors;
-};
-
-const getFileDescriptor = ({stdioOption, fdNumber, options, isSync}) => {
-	const optionName = getStreamName(fdNumber);
-	const {stdioItems: initialStdioItems, isStdioArray} = initializeStdioItems({
-		stdioOption,
-		fdNumber,
-		options,
-		optionName,
-	});
-	const direction = getStreamDirection(initialStdioItems, fdNumber, optionName);
-	const stdioItems = initialStdioItems.map(stdioItem => handleNativeStream({
-		stdioItem,
-		isStdioArray,
-		fdNumber,
-		direction,
-		isSync,
-	}));
-	const normalizedStdioItems = normalizeTransforms(stdioItems, optionName, direction, options);
-	const objectMode = getFdObjectMode(normalizedStdioItems, direction);
-	validateFileObjectMode(normalizedStdioItems, objectMode);
-	return {direction, objectMode, stdioItems: normalizedStdioItems};
-};
-
-// We make sure passing an array with a single item behaves the same as passing that item without an array.
-// This is what users would expect.
-// For example, `stdout: ['ignore']` behaves the same as `stdout: 'ignore'`.
-const initializeStdioItems = ({stdioOption, fdNumber, options, optionName}) => {
-	const values = Array.isArray(stdioOption) ? stdioOption : [stdioOption];
-	const initialStdioItems = [
-		...values.map(value => initializeStdioItem(value, optionName)),
-		...handleInputOptions(options, fdNumber),
-	];
-
-	const stdioItems = filterDuplicates(initialStdioItems);
-	const isStdioArray = stdioItems.length > 1;
-	validateStdioArray(stdioItems, isStdioArray, optionName);
-	validateStreams(stdioItems);
-	return {stdioItems, isStdioArray};
-};
-
-const initializeStdioItem = (value, optionName) => ({
-	type: getStdioItemType(value, optionName),
-	value,
-	optionName,
-});
-
-const validateStdioArray = (stdioItems, isStdioArray, optionName) => {
-	if (stdioItems.length === 0) {
-		throw new TypeError(`The \`${optionName}\` option must not be an empty array.`);
-	}
-
-	if (!isStdioArray) {
-		return;
-	}
-
-	for (const {value, optionName} of stdioItems) {
-		if (INVALID_STDIO_ARRAY_OPTIONS.has(value)) {
-			throw new Error(`The \`${optionName}\` option must not include \`${value}\`.`);
-		}
-	}
-};
-
-// Using those `stdio` values together with others for the same stream does not make sense, so we make it fail.
-// However, we do allow it if the array has a single item.
-const INVALID_STDIO_ARRAY_OPTIONS = new Set(['ignore', 'ipc']);
-
-const validateStreams = stdioItems => {
-	for (const stdioItem of stdioItems) {
-		validateFileStdio(stdioItem);
-	}
-};
-
-const validateFileStdio = ({type, value, optionName}) => {
-	if (isRegularUrl(value)) {
-		throw new TypeError(`The \`${optionName}: URL\` option must use the \`file:\` scheme.
-For example, you can use the \`pathToFileURL()\` method of the \`url\` core module.`);
-	}
-
-	if (isUnknownStdioString(type, value)) {
-		throw new TypeError(`The \`${optionName}: { file: '...' }\` option must be used instead of \`${optionName}: '...'\`.`);
-	}
-};
-
-const validateFileObjectMode = (stdioItems, objectMode) => {
-	if (!objectMode) {
-		return;
-	}
-
-	const fileStdioItem = stdioItems.find(({type}) => FILE_TYPES.has(type));
-	if (fileStdioItem !== undefined) {
-		throw new TypeError(`The \`${fileStdioItem.optionName}\` option cannot use both files and transforms in objectMode.`);
-	}
-};
-
-// Some `stdio` values require Execa to create streams.
-// For example, file paths create file read/write streams.
-// Those transformations are specified in `addProperties`, which is both direction-specific and type-specific.
-const getFinalFileDescriptors = ({initialFileDescriptors, addProperties, options, isSync}) => {
-	const fileDescriptors = [];
-
-	try {
-		for (const fileDescriptor of initialFileDescriptors) {
-			fileDescriptors.push(getFinalFileDescriptor({
-				fileDescriptor,
-				fileDescriptors,
-				addProperties,
-				options,
-				isSync,
-			}));
-		}
-
-		return fileDescriptors;
-	} catch (error) {
-		cleanupCustomStreams(fileDescriptors);
-		throw error;
-	}
-};
-
-const getFinalFileDescriptor = ({
-	fileDescriptor: {direction, objectMode, stdioItems},
-	fileDescriptors,
-	addProperties,
-	options,
-	isSync,
-}) => {
-	const finalStdioItems = stdioItems.map(stdioItem => addStreamProperties({
-		stdioItem,
-		addProperties,
-		direction,
-		options,
-		fileDescriptors,
-		isSync,
-	}));
-	return {direction, objectMode, stdioItems: finalStdioItems};
-};
-
-const addStreamProperties = ({stdioItem, addProperties, direction, options, fileDescriptors, isSync}) => {
-	const duplicateStream = getDuplicateStream({
-		stdioItem,
-		direction,
-		fileDescriptors,
-		isSync,
-	});
-
-	if (duplicateStream !== undefined) {
-		return {...stdioItem, stream: duplicateStream};
-	}
-
-	return {
-		...stdioItem,
-		...addProperties[direction][stdioItem.type](stdioItem, options),
-	};
-};
-
-// The stream error handling is performed by the piping logic above, which cannot be performed before subprocess spawning.
-// If the subprocess spawning fails (e.g. due to an invalid command), the streams need to be manually destroyed.
-// We need to create those streams before subprocess spawning, in case their creation fails, e.g. when passing an invalid generator as argument.
-// Like this, an exception would be thrown, which would prevent spawning a subprocess.
-export const cleanupCustomStreams = fileDescriptors => {
-	for (const {stdioItems} of fileDescriptors) {
-		for (const {stream} of stdioItems) {
-			if (stream !== undefined && !isStandardStream(stream)) {
-				stream.destroy();
-			}
-		}
-	}
-};
-
-// When the `std*: Iterable | WebStream | URL | filePath`, `input` or `inputFile` option is used, we pipe to `subprocess.std*`.
-// When the `std*: Array` option is used, we emulate some of the native values ('inherit', Node.js stream and file descriptor integer). To do so, we also need to pipe to `subprocess.std*`.
-// Therefore the `std*` options must be either `pipe` or `overlapped`. Other values do not set `subprocess.std*`.
-const forwardStdio = stdioItems => {
-	if (stdioItems.length > 1) {
-		return stdioItems.some(({value}) => value === 'overlapped') ? 'overlapped' : 'pipe';
-	}
-
-	const [{type, value}] = stdioItems;
-	return type === 'native' ? value : 'pipe';
-};