karajan-code 3.3.0 → 3.4.0

package/node_modules/execa/lib/arguments/fd-options.js

@@ -0,0 +1,108 @@
+import {parseFd} from './specific.js';
+
+// Retrieve stream targeted by the `to` option
+export const getToStream = (destination, to = 'stdin') => {
+	const isWritable = true;
+	const {options, fileDescriptors} = SUBPROCESS_OPTIONS.get(destination);
+	const fdNumber = getFdNumber(fileDescriptors, to, isWritable);
+	const destinationStream = destination.stdio[fdNumber];
+
+	if (destinationStream === null) {
+		throw new TypeError(getInvalidStdioOptionMessage(fdNumber, to, options, isWritable));
+	}
+
+	return destinationStream;
+};
+
+// Retrieve stream targeted by the `from` option
+export const getFromStream = (source, from = 'stdout') => {
+	const isWritable = false;
+	const {options, fileDescriptors} = SUBPROCESS_OPTIONS.get(source);
+	const fdNumber = getFdNumber(fileDescriptors, from, isWritable);
+	const sourceStream = fdNumber === 'all' ? source.all : source.stdio[fdNumber];
+
+	if (sourceStream === null || sourceStream === undefined) {
+		throw new TypeError(getInvalidStdioOptionMessage(fdNumber, from, options, isWritable));
+	}
+
+	return sourceStream;
+};
+
+// Keeps track of the options passed to each Execa call
+export const SUBPROCESS_OPTIONS = new WeakMap();
+
+const getFdNumber = (fileDescriptors, fdName, isWritable) => {
+	const fdNumber = parseFdNumber(fdName, isWritable);
+	validateFdNumber(fdNumber, fdName, isWritable, fileDescriptors);
+	return fdNumber;
+};
+
+const parseFdNumber = (fdName, isWritable) => {
+	const fdNumber = parseFd(fdName);
+	if (fdNumber !== undefined) {
+		return fdNumber;
+	}
+
+	const {validOptions, defaultValue} = isWritable
+		? {validOptions: '"stdin"', defaultValue: 'stdin'}
+		: {validOptions: '"stdout", "stderr", "all"', defaultValue: 'stdout'};
+	throw new TypeError(`"${getOptionName(isWritable)}" must not be "${fdName}".
+It must be ${validOptions} or "fd3", "fd4" (and so on).
+It is optional and defaults to "${defaultValue}".`);
+};
+
+const validateFdNumber = (fdNumber, fdName, isWritable, fileDescriptors) => {
+	const fileDescriptor = fileDescriptors[getUsedDescriptor(fdNumber)];
+	if (fileDescriptor === undefined) {
+		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. That file descriptor does not exist.
+Please set the "stdio" option to ensure that file descriptor exists.`);
+	}
+
+	if (fileDescriptor.direction === 'input' && !isWritable) {
+		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. It must be a readable stream, not writable.`);
+	}
+
+	if (fileDescriptor.direction !== 'input' && isWritable) {
+		throw new TypeError(`"${getOptionName(isWritable)}" must not be ${fdName}. It must be a writable stream, not readable.`);
+	}
+};
+
+const getInvalidStdioOptionMessage = (fdNumber, fdName, options, isWritable) => {
+	if (fdNumber === 'all' && !options.all) {
+		return 'The "all" option must be true to use "from: \'all\'".';
+	}
+
+	const {optionName, optionValue} = getInvalidStdioOption(fdNumber, options);
+	return `The "${optionName}: ${serializeOptionValue(optionValue)}" option is incompatible with using "${getOptionName(isWritable)}: ${serializeOptionValue(fdName)}".
+Please set this option with "pipe" instead.`;
+};
+
+const getInvalidStdioOption = (fdNumber, {stdin, stdout, stderr, stdio}) => {
+	const usedDescriptor = getUsedDescriptor(fdNumber);
+
+	if (usedDescriptor === 0 && stdin !== undefined) {
+		return {optionName: 'stdin', optionValue: stdin};
+	}
+
+	if (usedDescriptor === 1 && stdout !== undefined) {
+		return {optionName: 'stdout', optionValue: stdout};
+	}
+
+	if (usedDescriptor === 2 && stderr !== undefined) {
+		return {optionName: 'stderr', optionValue: stderr};
+	}
+
+	return {optionName: `stdio[${usedDescriptor}]`, optionValue: stdio[usedDescriptor]};
+};
+
+const getUsedDescriptor = fdNumber => fdNumber === 'all' ? 1 : fdNumber;
+
+const getOptionName = isWritable => isWritable ? 'to' : 'from';
+
+export const serializeOptionValue = value => {
+	if (typeof value === 'string') {
+		return `'${value}'`;
+	}
+
+	return typeof value === 'number' ? `${value}` : 'Stream';
+};

package/node_modules/execa/lib/arguments/file-url.js

@@ -0,0 +1,25 @@
+import {fileURLToPath} from 'node:url';
+
+// Allow some arguments/options to be either a file path string or a file URL
+export const safeNormalizeFileUrl = (file, name) => {
+	const fileString = normalizeFileUrl(normalizeDenoExecPath(file));
+
+	if (typeof fileString !== 'string') {
+		throw new TypeError(`${name} must be a string or a file URL: ${fileString}.`);
+	}
+
+	return fileString;
+};
+
+// In Deno node:process execPath is a special object, not just a string:
+// https://github.com/denoland/deno/blob/f460188e583f00144000aa0d8ade08218d47c3c1/ext/node/polyfills/process.ts#L344
+const normalizeDenoExecPath = file => isDenoExecPath(file)
+	? file.toString()
+	: file;
+
+export const isDenoExecPath = file => typeof file !== 'string'
+	&& file
+	&& Object.getPrototypeOf(file) === String.prototype;
+
+// Same but also allows other values, e.g. `boolean` for the `shell` option
+export const normalizeFileUrl = file => file instanceof URL ? fileURLToPath(file) : file;

package/node_modules/execa/lib/arguments/options.js

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import process from 'node:process';
+import crossSpawn from 'cross-spawn';
+import {npmRunPathEnv} from 'npm-run-path';
+import {normalizeForceKillAfterDelay} from '../terminate/kill.js';
+import {normalizeKillSignal} from '../terminate/signal.js';
+import {validateCancelSignal} from '../terminate/cancel.js';
+import {validateGracefulCancel} from '../terminate/graceful.js';
+import {validateTimeout} from '../terminate/timeout.js';
+import {handleNodeOption} from '../methods/node.js';
+import {validateIpcInputOption} from '../ipc/ipc-input.js';
+import {validateEncoding, BINARY_ENCODINGS} from './encoding-option.js';
+import {normalizeCwd} from './cwd.js';
+import {normalizeFileUrl} from './file-url.js';
+import {normalizeFdSpecificOptions} from './specific.js';
+
+// Normalize the options object, and sometimes also the file paths and arguments.
+// Applies default values, validate allowed options, normalize them.
+export const normalizeOptions = (filePath, rawArguments, rawOptions) => {
+	rawOptions.cwd = normalizeCwd(rawOptions.cwd);
+	const [processedFile, processedArguments, processedOptions] = handleNodeOption(filePath, rawArguments, rawOptions);
+
+	const {command: file, args: commandArguments, options: initialOptions} = crossSpawn._parse(processedFile, processedArguments, processedOptions);
+
+	const fdOptions = normalizeFdSpecificOptions(initialOptions);
+	const options = addDefaultOptions(fdOptions);
+	validateTimeout(options);
+	validateEncoding(options);
+	validateIpcInputOption(options);
+	validateCancelSignal(options);
+	validateGracefulCancel(options);
+	options.shell = normalizeFileUrl(options.shell);
+	options.env = getEnv(options);
+	options.killSignal = normalizeKillSignal(options.killSignal);
+	options.forceKillAfterDelay = normalizeForceKillAfterDelay(options.forceKillAfterDelay);
+	options.lines = options.lines.map((lines, fdNumber) => lines && !BINARY_ENCODINGS.has(options.encoding) && options.buffer[fdNumber]);
+
+	if (process.platform === 'win32' && path.basename(file, '.exe') === 'cmd') {
+		// #116
+		commandArguments.unshift('/q');
+	}
+
+	return {file, commandArguments, options};
+};
+
+const addDefaultOptions = ({
+	extendEnv = true,
+	preferLocal = false,
+	cwd,
+	localDir: localDirectory = cwd,
+	encoding = 'utf8',
+	reject = true,
+	cleanup = true,
+	all = false,
+	windowsHide = true,
+	killSignal = 'SIGTERM',
+	forceKillAfterDelay = true,
+	gracefulCancel = false,
+	ipcInput,
+	ipc = ipcInput !== undefined || gracefulCancel,
+	serialization = 'advanced',
+	...options
+}) => ({
+	...options,
+	extendEnv,
+	preferLocal,
+	cwd,
+	localDirectory,
+	encoding,
+	reject,
+	cleanup,
+	all,
+	windowsHide,
+	killSignal,
+	forceKillAfterDelay,
+	gracefulCancel,
+	ipcInput,
+	ipc,
+	serialization,
+});
+
+const getEnv = ({env: envOption, extendEnv, preferLocal, node, localDirectory, nodePath}) => {
+	const env = extendEnv ? {...process.env, ...envOption} : envOption;
+
+	if (preferLocal || node) {
+		return npmRunPathEnv({
+			env,
+			cwd: localDirectory,
+			execPath: nodePath,
+			preferLocal,
+			addExecPath: node,
+		});
+	}
+
+	return env;
+};

package/node_modules/execa/lib/arguments/shell.js

@@ -0,0 +1,11 @@
+// When the `shell` option is set, any command argument is concatenated as a single string by Node.js:
+// https://github.com/nodejs/node/blob/e38ce27f3ca0a65f68a31cedd984cddb927d4002/lib/child_process.js#L614-L624
+// However, since Node 24, it also prints a deprecation warning.
+// To avoid this warning, we perform that same operation before calling `node:child_process`.
+// Shells only understand strings, which is why Node.js performs that concatenation.
+// However, we rely on users splitting command arguments as an array.
+// For example, this allows us to easily detect which arguments are passed.
+// So we do want users to pass array of arguments even with `shell: true`, but we also want to avoid any warning.
+export const concatenateShell = (file, commandArguments, options) => options.shell && commandArguments.length > 0
+	? [[file, ...commandArguments].join(' '), [], options]
+	: [file, commandArguments, options];

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

@@ -0,0 +1,111 @@
+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/node_modules/execa/lib/convert/add.js

@@ -0,0 +1,15 @@
+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/node_modules/execa/lib/convert/concurrent.js

@@ -0,0 +1,33 @@
+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/node_modules/execa/lib/convert/duplex.js

@@ -0,0 +1,69 @@
+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/node_modules/execa/lib/convert/iterable.js

@@ -0,0 +1,34 @@
+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/node_modules/execa/lib/convert/readable.js

@@ -0,0 +1,113 @@
+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/node_modules/execa/lib/convert/shared.js

@@ -0,0 +1,46 @@
+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();
+	}
+};