@kubb/agent 4.28.1 → 4.29.0

package/.output/server/node_modules/execa/lib/methods/promise.js

@@ -1,15 +0,0 @@
-// The return value is a mixin of `subprocess` and `Promise`
-export const mergePromise = (subprocess, promise) => {
-	for (const [property, descriptor] of descriptors) {
-		const value = descriptor.value.bind(promise);
-		Reflect.defineProperty(subprocess, property, {...descriptor, value});
-	}
-};
-
-// eslint-disable-next-line unicorn/prefer-top-level-await
-const nativePromisePrototype = (async () => {})().constructor.prototype;
-
-const descriptors = ['then', 'catch', 'finally'].map(property => [
-	property,
-	Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property),
-]);

package/.output/server/node_modules/execa/lib/methods/script.js

@@ -1,22 +0,0 @@
-// Sets `$.sync` and `$.s`
-export const setScriptSync = (boundExeca, createNested, boundOptions) => {
-	boundExeca.sync = createNested(mapScriptSync, boundOptions);
-	boundExeca.s = boundExeca.sync;
-};
-
-// Main logic for `$`
-export const mapScriptAsync = ({options}) => getScriptOptions(options);
-
-// Main logic for `$.sync`
-const mapScriptSync = ({options}) => ({...getScriptOptions(options), isSync: true});
-
-// `$` is like `execa` but with script-friendly options: `{stdin: 'inherit', preferLocal: true}`
-const getScriptOptions = options => ({options: {...getScriptStdinOption(options), ...options}});
-
-const getScriptStdinOption = ({input, inputFile, stdio}) => input === undefined && inputFile === undefined && stdio === undefined
-	? {stdin: 'inherit'}
-	: {};
-
-// When using $(...).pipe(...), most script-friendly options should apply to both commands.
-// However, some options (like `stdin: 'inherit'`) would create issues with piping, i.e. cannot be deep.
-export const deepScriptOptions = {preferLocal: true};

package/.output/server/node_modules/execa/lib/methods/template.js

@@ -1,153 +0,0 @@
-import {ChildProcess} from 'node:child_process';
-import isPlainObject from 'is-plain-obj';
-import {isUint8Array, uint8ArrayToString} from '../utils/uint-array.js';
-
-// Check whether the template string syntax is being used
-export const isTemplateString = templates => Array.isArray(templates) && Array.isArray(templates.raw);
-
-// Convert execa`file ...commandArguments` to execa(file, commandArguments)
-export const parseTemplates = (templates, expressions) => {
-	let tokens = [];
-
-	for (const [index, template] of templates.entries()) {
-		tokens = parseTemplate({
-			templates,
-			expressions,
-			tokens,
-			index,
-			template,
-		});
-	}
-
-	if (tokens.length === 0) {
-		throw new TypeError('Template script must not be empty');
-	}
-
-	const [file, ...commandArguments] = tokens;
-	return [file, commandArguments, {}];
-};
-
-const parseTemplate = ({templates, expressions, tokens, index, template}) => {
-	if (template === undefined) {
-		throw new TypeError(`Invalid backslash sequence: ${templates.raw[index]}`);
-	}
-
-	const {nextTokens, leadingWhitespaces, trailingWhitespaces} = splitByWhitespaces(template, templates.raw[index]);
-	const newTokens = concatTokens(tokens, nextTokens, leadingWhitespaces);
-
-	if (index === expressions.length) {
-		return newTokens;
-	}
-
-	const expression = expressions[index];
-	const expressionTokens = Array.isArray(expression)
-		? expression.map(expression => parseExpression(expression))
-		: [parseExpression(expression)];
-	return concatTokens(newTokens, expressionTokens, trailingWhitespaces);
-};
-
-// Like `string.split(/[ \t\r\n]+/)` except newlines and tabs are:
-//  - ignored when input as a backslash sequence like: `echo foo\n bar`
-//  - not ignored when input directly
-// The only way to distinguish those in JavaScript is to use a tagged template and compare:
-//  - the first array argument, which does not escape backslash sequences
-//  - its `raw` property, which escapes them
-const splitByWhitespaces = (template, rawTemplate) => {
-	if (rawTemplate.length === 0) {
-		return {nextTokens: [], leadingWhitespaces: false, trailingWhitespaces: false};
-	}
-
-	const nextTokens = [];
-	let templateStart = 0;
-	const leadingWhitespaces = DELIMITERS.has(rawTemplate[0]);
-
-	for (
-		let templateIndex = 0, rawIndex = 0;
-		templateIndex < template.length;
-		templateIndex += 1, rawIndex += 1
-	) {
-		const rawCharacter = rawTemplate[rawIndex];
-		if (DELIMITERS.has(rawCharacter)) {
-			if (templateStart !== templateIndex) {
-				nextTokens.push(template.slice(templateStart, templateIndex));
-			}
-
-			templateStart = templateIndex + 1;
-		} else if (rawCharacter === '\\') {
-			const nextRawCharacter = rawTemplate[rawIndex + 1];
-			if (nextRawCharacter === '\n') {
-				// Handles escaped newlines in templates
-				templateIndex -= 1;
-				rawIndex += 1;
-			} else if (nextRawCharacter === 'u' && rawTemplate[rawIndex + 2] === '{') {
-				rawIndex = rawTemplate.indexOf('}', rawIndex + 3);
-			} else {
-				rawIndex += ESCAPE_LENGTH[nextRawCharacter] ?? 1;
-			}
-		}
-	}
-
-	const trailingWhitespaces = templateStart === template.length;
-	if (!trailingWhitespaces) {
-		nextTokens.push(template.slice(templateStart));
-	}
-
-	return {nextTokens, leadingWhitespaces, trailingWhitespaces};
-};
-
-const DELIMITERS = new Set([' ', '\t', '\r', '\n']);
-
-// Number of characters in backslash escape sequences: \0 \xXX or \uXXXX
-// \cX is allowed in RegExps but not in strings
-// Octal sequences are not allowed in strict mode
-const ESCAPE_LENGTH = {x: 3, u: 5};
-
-const concatTokens = (tokens, nextTokens, isSeparated) => isSeparated
-	|| tokens.length === 0
-	|| nextTokens.length === 0
-	? [...tokens, ...nextTokens]
-	: [
-		...tokens.slice(0, -1),
-		`${tokens.at(-1)}${nextTokens[0]}`,
-		...nextTokens.slice(1),
-	];
-
-// Handle `${expression}` inside the template string syntax
-const parseExpression = expression => {
-	const typeOfExpression = typeof expression;
-
-	if (typeOfExpression === 'string') {
-		return expression;
-	}
-
-	if (typeOfExpression === 'number') {
-		return String(expression);
-	}
-
-	if (isPlainObject(expression) && ('stdout' in expression || 'isMaxBuffer' in expression)) {
-		return getSubprocessResult(expression);
-	}
-
-	if (expression instanceof ChildProcess || Object.prototype.toString.call(expression) === '[object Promise]') {
-		// eslint-disable-next-line no-template-curly-in-string
-		throw new TypeError('Unexpected subprocess in template expression. Please use ${await subprocess} instead of ${subprocess}.');
-	}
-
-	throw new TypeError(`Unexpected "${typeOfExpression}" in template expression`);
-};
-
-const getSubprocessResult = ({stdout}) => {
-	if (typeof stdout === 'string') {
-		return stdout;
-	}
-
-	if (isUint8Array(stdout)) {
-		return uint8ArrayToString(stdout);
-	}
-
-	if (stdout === undefined) {
-		throw new TypeError('Missing result.stdout in template expression. This is probably due to the previous subprocess\' "stdout" option.');
-	}
-
-	throw new TypeError(`Unexpected "${typeof stdout}" stdout in template expression`);
-};

package/.output/server/node_modules/execa/lib/pipe/abort.js

@@ -1,20 +0,0 @@
-import {aborted} from 'node:util';
-import {createNonCommandError} from './throw.js';
-
-// When passing an `unpipeSignal` option, abort piping when the signal is aborted.
-// However, do not terminate the subprocesses.
-export const unpipeOnAbort = (unpipeSignal, unpipeContext) => unpipeSignal === undefined
-	? []
-	: [unpipeOnSignalAbort(unpipeSignal, unpipeContext)];
-
-const unpipeOnSignalAbort = async (unpipeSignal, {sourceStream, mergedStream, fileDescriptors, sourceOptions, startTime}) => {
-	await aborted(unpipeSignal, sourceStream);
-	await mergedStream.remove(sourceStream);
-	const error = new Error('Pipe canceled by `unpipeSignal` option.');
-	throw createNonCommandError({
-		error,
-		fileDescriptors,
-		sourceOptions,
-		startTime,
-	});
-};

package/.output/server/node_modules/execa/lib/pipe/pipe-arguments.js

@@ -1,91 +0,0 @@
-import {normalizeParameters} from '../methods/parameters.js';
-import {getStartTime} from '../return/duration.js';
-import {SUBPROCESS_OPTIONS, getToStream, getFromStream} from '../arguments/fd-options.js';
-import {isDenoExecPath} from '../arguments/file-url.js';
-
-// Normalize and validate arguments passed to `source.pipe(destination)`
-export const normalizePipeArguments = ({source, sourcePromise, boundOptions, createNested}, ...pipeArguments) => {
-	const startTime = getStartTime();
-	const {
-		destination,
-		destinationStream,
-		destinationError,
-		from,
-		unpipeSignal,
-	} = getDestinationStream(boundOptions, createNested, pipeArguments);
-	const {sourceStream, sourceError} = getSourceStream(source, from);
-	const {options: sourceOptions, fileDescriptors} = SUBPROCESS_OPTIONS.get(source);
-	return {
-		sourcePromise,
-		sourceStream,
-		sourceOptions,
-		sourceError,
-		destination,
-		destinationStream,
-		destinationError,
-		unpipeSignal,
-		fileDescriptors,
-		startTime,
-	};
-};
-
-const getDestinationStream = (boundOptions, createNested, pipeArguments) => {
-	try {
-		const {
-			destination,
-			pipeOptions: {from, to, unpipeSignal} = {},
-		} = getDestination(boundOptions, createNested, ...pipeArguments);
-		const destinationStream = getToStream(destination, to);
-		return {
-			destination,
-			destinationStream,
-			from,
-			unpipeSignal,
-		};
-	} catch (error) {
-		return {destinationError: error};
-	}
-};
-
-// Piping subprocesses can use three syntaxes:
-//  - source.pipe('command', commandArguments, pipeOptionsOrDestinationOptions)
-//  - source.pipe`command commandArgument` or source.pipe(pipeOptionsOrDestinationOptions)`command commandArgument`
-//  - source.pipe(execa(...), pipeOptions)
-const getDestination = (boundOptions, createNested, firstArgument, ...pipeArguments) => {
-	if (Array.isArray(firstArgument)) {
-		const destination = createNested(mapDestinationArguments, boundOptions)(firstArgument, ...pipeArguments);
-		return {destination, pipeOptions: boundOptions};
-	}
-
-	if (typeof firstArgument === 'string' || firstArgument instanceof URL || isDenoExecPath(firstArgument)) {
-		if (Object.keys(boundOptions).length > 0) {
-			throw new TypeError('Please use .pipe("file", ..., options) or .pipe(execa("file", ..., options)) instead of .pipe(options)("file", ...).');
-		}
-
-		const [rawFile, rawArguments, rawOptions] = normalizeParameters(firstArgument, ...pipeArguments);
-		const destination = createNested(mapDestinationArguments)(rawFile, rawArguments, rawOptions);
-		return {destination, pipeOptions: rawOptions};
-	}
-
-	if (SUBPROCESS_OPTIONS.has(firstArgument)) {
-		if (Object.keys(boundOptions).length > 0) {
-			throw new TypeError('Please use .pipe(options)`command` or .pipe($(options)`command`) instead of .pipe(options)($`command`).');
-		}
-
-		return {destination: firstArgument, pipeOptions: pipeArguments[0]};
-	}
-
-	throw new TypeError(`The first argument must be a template string, an options object, or an Execa subprocess: ${firstArgument}`);
-};
-
-// Force `stdin: 'pipe'` with the destination subprocess
-const mapDestinationArguments = ({options}) => ({options: {...options, stdin: 'pipe', piped: true}});
-
-const getSourceStream = (source, from) => {
-	try {
-		const sourceStream = getFromStream(source, from);
-		return {sourceStream};
-	} catch (error) {
-		return {sourceError: error};
-	}
-};

package/.output/server/node_modules/execa/lib/pipe/sequence.js

@@ -1,24 +0,0 @@
-// Like Bash, we await both subprocesses. This is unlike some other shells which only await the destination subprocess.
-// Like Bash with the `pipefail` option, if either subprocess fails, the whole pipe fails.
-// Like Bash, if both subprocesses fail, we return the failure of the destination.
-// This ensures both subprocesses' errors are present, using `error.pipedFrom`.
-export const waitForBothSubprocesses = async subprocessPromises => {
-	const [
-		{status: sourceStatus, reason: sourceReason, value: sourceResult = sourceReason},
-		{status: destinationStatus, reason: destinationReason, value: destinationResult = destinationReason},
-	] = await subprocessPromises;
-
-	if (!destinationResult.pipedFrom.includes(sourceResult)) {
-		destinationResult.pipedFrom.push(sourceResult);
-	}
-
-	if (destinationStatus === 'rejected') {
-		throw destinationResult;
-	}
-
-	if (sourceStatus === 'rejected') {
-		throw sourceResult;
-	}
-
-	return destinationResult;
-};

package/.output/server/node_modules/execa/lib/pipe/setup.js

@@ -1,72 +0,0 @@
-import isPlainObject from 'is-plain-obj';
-import {normalizePipeArguments} from './pipe-arguments.js';
-import {handlePipeArgumentsError} from './throw.js';
-import {waitForBothSubprocesses} from './sequence.js';
-import {pipeSubprocessStream} from './streaming.js';
-import {unpipeOnAbort} from './abort.js';
-
-// Pipe a subprocess' `stdout`/`stderr`/`stdio` into another subprocess' `stdin`
-export const pipeToSubprocess = (sourceInfo, ...pipeArguments) => {
-	if (isPlainObject(pipeArguments[0])) {
-		return pipeToSubprocess.bind(undefined, {
-			...sourceInfo,
-			boundOptions: {...sourceInfo.boundOptions, ...pipeArguments[0]},
-		});
-	}
-
-	const {destination, ...normalizedInfo} = normalizePipeArguments(sourceInfo, ...pipeArguments);
-	const promise = handlePipePromise({...normalizedInfo, destination});
-	promise.pipe = pipeToSubprocess.bind(undefined, {
-		...sourceInfo,
-		source: destination,
-		sourcePromise: promise,
-		boundOptions: {},
-	});
-	return promise;
-};
-
-// Asynchronous logic when piping subprocesses
-const handlePipePromise = async ({
-	sourcePromise,
-	sourceStream,
-	sourceOptions,
-	sourceError,
-	destination,
-	destinationStream,
-	destinationError,
-	unpipeSignal,
-	fileDescriptors,
-	startTime,
-}) => {
-	const subprocessPromises = getSubprocessPromises(sourcePromise, destination);
-	handlePipeArgumentsError({
-		sourceStream,
-		sourceError,
-		destinationStream,
-		destinationError,
-		fileDescriptors,
-		sourceOptions,
-		startTime,
-	});
-	const maxListenersController = new AbortController();
-	try {
-		const mergedStream = pipeSubprocessStream(sourceStream, destinationStream, maxListenersController);
-		return await Promise.race([
-			waitForBothSubprocesses(subprocessPromises),
-			...unpipeOnAbort(unpipeSignal, {
-				sourceStream,
-				mergedStream,
-				sourceOptions,
-				fileDescriptors,
-				startTime,
-			}),
-		]);
-	} finally {
-		maxListenersController.abort();
-	}
-};
-
-// `.pipe()` awaits the subprocess promises.
-// When invalid arguments are passed to `.pipe()`, we throw an error, which prevents awaiting them.
-// We need to ensure this does not create unhandled rejections.
-const getSubprocessPromises = (sourcePromise, destination) => Promise.allSettled([sourcePromise, destination]);

package/.output/server/node_modules/execa/lib/pipe/streaming.js

@@ -1,51 +0,0 @@
-import {finished} from 'node:stream/promises';
-import mergeStreams from '@sindresorhus/merge-streams';
-import {incrementMaxListeners} from '../utils/max-listeners.js';
-import {pipeStreams} from '../io/pipeline.js';
-
-// The piping behavior is like Bash.
-// In particular, when one subprocess exits, the other is not terminated by a signal.
-// Instead, its stdout (for the source) or stdin (for the destination) closes.
-// If the subprocess uses it, it will make it error with SIGPIPE or EPIPE (for the source) or end (for the destination).
-// If it does not use it, it will continue running.
-// This allows for subprocesses to gracefully exit and lower the coupling between subprocesses.
-export const pipeSubprocessStream = (sourceStream, destinationStream, maxListenersController) => {
-	const mergedStream = MERGED_STREAMS.has(destinationStream)
-		? pipeMoreSubprocessStream(sourceStream, destinationStream)
-		: pipeFirstSubprocessStream(sourceStream, destinationStream);
-	incrementMaxListeners(sourceStream, SOURCE_LISTENERS_PER_PIPE, maxListenersController.signal);
-	incrementMaxListeners(destinationStream, DESTINATION_LISTENERS_PER_PIPE, maxListenersController.signal);
-	cleanupMergedStreamsMap(destinationStream);
-	return mergedStream;
-};
-
-// We use `merge-streams` to allow for multiple sources to pipe to the same destination.
-const pipeFirstSubprocessStream = (sourceStream, destinationStream) => {
-	const mergedStream = mergeStreams([sourceStream]);
-	pipeStreams(mergedStream, destinationStream);
-	MERGED_STREAMS.set(destinationStream, mergedStream);
-	return mergedStream;
-};
-
-const pipeMoreSubprocessStream = (sourceStream, destinationStream) => {
-	const mergedStream = MERGED_STREAMS.get(destinationStream);
-	mergedStream.add(sourceStream);
-	return mergedStream;
-};
-
-const cleanupMergedStreamsMap = async destinationStream => {
-	try {
-		await finished(destinationStream, {cleanup: true, readable: false, writable: true});
-	} catch {}
-
-	MERGED_STREAMS.delete(destinationStream);
-};
-
-const MERGED_STREAMS = new WeakMap();
-
-// Number of listeners set up on `sourceStream` by each `sourceStream.pipe(destinationStream)`
-// Those are added by `merge-streams`
-const SOURCE_LISTENERS_PER_PIPE = 2;
-// Number of listeners set up on `destinationStream` by each `sourceStream.pipe(destinationStream)`
-// Those are added by `finished()` in `cleanupMergedStreamsMap()`
-const DESTINATION_LISTENERS_PER_PIPE = 1;

package/.output/server/node_modules/execa/lib/pipe/throw.js

@@ -1,58 +0,0 @@
-import {makeEarlyError} from '../return/result.js';
-import {abortSourceStream, endDestinationStream} from '../io/pipeline.js';
-
-// When passing invalid arguments to `source.pipe()`, throw asynchronously.
-// We also abort both subprocesses.
-export const handlePipeArgumentsError = ({
-	sourceStream,
-	sourceError,
-	destinationStream,
-	destinationError,
-	fileDescriptors,
-	sourceOptions,
-	startTime,
-}) => {
-	const error = getPipeArgumentsError({
-		sourceStream,
-		sourceError,
-		destinationStream,
-		destinationError,
-	});
-	if (error !== undefined) {
-		throw createNonCommandError({
-			error,
-			fileDescriptors,
-			sourceOptions,
-			startTime,
-		});
-	}
-};
-
-const getPipeArgumentsError = ({sourceStream, sourceError, destinationStream, destinationError}) => {
-	if (sourceError !== undefined && destinationError !== undefined) {
-		return destinationError;
-	}
-
-	if (destinationError !== undefined) {
-		abortSourceStream(sourceStream);
-		return destinationError;
-	}
-
-	if (sourceError !== undefined) {
-		endDestinationStream(destinationStream);
-		return sourceError;
-	}
-};
-
-// Specific error return value when passing invalid arguments to `subprocess.pipe()` or when using `unpipeSignal`
-export const createNonCommandError = ({error, fileDescriptors, sourceOptions, startTime}) => makeEarlyError({
-	error,
-	command: PIPE_COMMAND_MESSAGE,
-	escapedCommand: PIPE_COMMAND_MESSAGE,
-	fileDescriptors,
-	options: sourceOptions,
-	startTime,
-	isSync: false,
-});
-
-const PIPE_COMMAND_MESSAGE = 'source.pipe(destination)';

package/.output/server/node_modules/execa/lib/resolve/all-async.js

@@ -1,46 +0,0 @@
-import mergeStreams from '@sindresorhus/merge-streams';
-import {waitForSubprocessStream} from './stdio.js';
-
-// `all` interleaves `stdout` and `stderr`
-export const makeAllStream = ({stdout, stderr}, {all}) => all && (stdout || stderr)
-	? mergeStreams([stdout, stderr].filter(Boolean))
-	: undefined;
-
-// Read the contents of `subprocess.all` and|or wait for its completion
-export const waitForAllStream = ({subprocess, encoding, buffer, maxBuffer, lines, stripFinalNewline, verboseInfo, streamInfo}) => waitForSubprocessStream({
-	...getAllStream(subprocess, buffer),
-	fdNumber: 'all',
-	encoding,
-	maxBuffer: maxBuffer[1] + maxBuffer[2],
-	lines: lines[1] || lines[2],
-	allMixed: getAllMixed(subprocess),
-	stripFinalNewline,
-	verboseInfo,
-	streamInfo,
-});
-
-const getAllStream = ({stdout, stderr, all}, [, bufferStdout, bufferStderr]) => {
-	const buffer = bufferStdout || bufferStderr;
-	if (!buffer) {
-		return {stream: all, buffer};
-	}
-
-	if (!bufferStdout) {
-		return {stream: stderr, buffer};
-	}
-
-	if (!bufferStderr) {
-		return {stream: stdout, buffer};
-	}
-
-	return {stream: all, buffer};
-};
-
-// When `subprocess.stdout` is in objectMode but not `subprocess.stderr` (or the opposite), we need to use both:
-//  - `getStreamAsArray()` for the chunks in objectMode, to return as an array without changing each chunk
-//  - `getStreamAsArrayBuffer()` or `getStream()` for the chunks not in objectMode, to convert them from Buffers to string or Uint8Array
-// We do this by emulating the Buffer -> string|Uint8Array conversion performed by `get-stream` with our own, which is identical.
-const getAllMixed = ({all, stdout, stderr}) => all
-	&& stdout
-	&& stderr
-	&& stdout.readableObjectMode !== stderr.readableObjectMode;

package/.output/server/node_modules/execa/lib/resolve/all-sync.js

@@ -1,33 +0,0 @@
-import {isUint8Array, concatUint8Arrays} from '../utils/uint-array.js';
-import {stripNewline} from '../io/strip-newline.js';
-
-// Retrieve `result.all` with synchronous methods
-export const getAllSync = ([, stdout, stderr], options) => {
-	if (!options.all) {
-		return;
-	}
-
-	if (stdout === undefined) {
-		return stderr;
-	}
-
-	if (stderr === undefined) {
-		return stdout;
-	}
-
-	if (Array.isArray(stdout)) {
-		return Array.isArray(stderr)
-			? [...stdout, ...stderr]
-			: [...stdout, stripNewline(stderr, options, 'all')];
-	}
-
-	if (Array.isArray(stderr)) {
-		return [stripNewline(stdout, options, 'all'), ...stderr];
-	}
-
-	if (isUint8Array(stdout) && isUint8Array(stderr)) {
-		return concatUint8Arrays([stdout, stderr]);
-	}
-
-	return `${stdout}${stderr}`;
-};

package/.output/server/node_modules/execa/lib/resolve/exit-async.js

@@ -1,54 +0,0 @@
-import {once} from 'node:events';
-import {DiscardedError} from '../return/final-error.js';
-
-// If `error` is emitted before `spawn`, `exit` will never be emitted.
-// However, `error` might be emitted after `spawn`.
-// In that case, `exit` will still be emitted.
-// Since the `exit` event contains the signal name, we want to make sure we are listening for it.
-// This function also takes into account the following unlikely cases:
-//  - `exit` being emitted in the same microtask as `spawn`
-//  - `error` being emitted multiple times
-export const waitForExit = async (subprocess, context) => {
-	const [exitCode, signal] = await waitForExitOrError(subprocess);
-	context.isForcefullyTerminated ??= false;
-	return [exitCode, signal];
-};
-
-const waitForExitOrError = async subprocess => {
-	const [spawnPayload, exitPayload] = await Promise.allSettled([
-		once(subprocess, 'spawn'),
-		once(subprocess, 'exit'),
-	]);
-
-	if (spawnPayload.status === 'rejected') {
-		return [];
-	}
-
-	return exitPayload.status === 'rejected'
-		? waitForSubprocessExit(subprocess)
-		: exitPayload.value;
-};
-
-const waitForSubprocessExit = async subprocess => {
-	try {
-		return await once(subprocess, 'exit');
-	} catch {
-		return waitForSubprocessExit(subprocess);
-	}
-};
-
-// Retrieve the final exit code and|or signal name
-export const waitForSuccessfulExit = async exitPromise => {
-	const [exitCode, signal] = await exitPromise;
-
-	if (!isSubprocessErrorExit(exitCode, signal) && isFailedExit(exitCode, signal)) {
-		throw new DiscardedError();
-	}
-
-	return [exitCode, signal];
-};
-
-// When the subprocess fails due to an `error` event
-const isSubprocessErrorExit = (exitCode, signal) => exitCode === undefined && signal === undefined;
-// When the subprocess fails due to a non-0 exit code or to a signal termination
-export const isFailedExit = (exitCode, signal) => exitCode !== 0 || signal !== null;

package/.output/server/node_modules/execa/lib/resolve/exit-sync.js

@@ -1,25 +0,0 @@
-import {DiscardedError} from '../return/final-error.js';
-import {isMaxBufferSync} from '../io/max-buffer.js';
-import {isFailedExit} from './exit-async.js';
-
-// Retrieve exit code, signal name and error information, with synchronous methods
-export const getExitResultSync = ({error, status: exitCode, signal, output}, {maxBuffer}) => {
-	const resultError = getResultError(error, exitCode, signal);
-	const timedOut = resultError?.code === 'ETIMEDOUT';
-	const isMaxBuffer = isMaxBufferSync(resultError, output, maxBuffer);
-	return {
-		resultError,
-		exitCode,
-		signal,
-		timedOut,
-		isMaxBuffer,
-	};
-};
-
-const getResultError = (error, exitCode, signal) => {
-	if (error !== undefined) {
-		return error;
-	}
-
-	return isFailedExit(exitCode, signal) ? new DiscardedError() : undefined;
-};