karajan-code 3.4.1 → 3.4.2

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

@@ -1,108 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,11 +0,0 @@
-// 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

@@ -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/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/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/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/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/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/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();
-	}
-};