@kubb/agent 4.28.0 → 4.29.0

package/.output/server/node_modules/execa/lib/stdio/input-option.js

@@ -1,50 +0,0 @@
-import {isReadableStream} from 'is-stream';
-import {isUint8Array} from '../utils/uint-array.js';
-import {isUrl, isFilePathString} from './type.js';
-
-// Append the `stdin` option with the `input` and `inputFile` options
-export const handleInputOptions = ({input, inputFile}, fdNumber) => fdNumber === 0
-	? [
-		...handleInputOption(input),
-		...handleInputFileOption(inputFile),
-	]
-	: [];
-
-const handleInputOption = input => input === undefined ? [] : [{
-	type: getInputType(input),
-	value: input,
-	optionName: 'input',
-}];
-
-const getInputType = input => {
-	if (isReadableStream(input, {checkOpen: false})) {
-		return 'nodeStream';
-	}
-
-	if (typeof input === 'string') {
-		return 'string';
-	}
-
-	if (isUint8Array(input)) {
-		return 'uint8Array';
-	}
-
-	throw new Error('The `input` option must be a string, a Uint8Array or a Node.js Readable stream.');
-};
-
-const handleInputFileOption = inputFile => inputFile === undefined ? [] : [{
-	...getInputFileType(inputFile),
-	optionName: 'inputFile',
-}];
-
-const getInputFileType = inputFile => {
-	if (isUrl(inputFile)) {
-		return {type: 'fileUrl', value: inputFile};
-	}
-
-	if (isFilePathString(inputFile)) {
-		return {type: 'filePath', value: {file: inputFile}};
-	}
-
-	throw new Error('The `inputFile` option must be a file path string or a file URL.');
-};

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

@@ -1,106 +0,0 @@
-import {readFileSync} from 'node:fs';
-import tty from 'node:tty';
-import {isStream as isNodeStream} from 'is-stream';
-import {STANDARD_STREAMS} from '../utils/standard-stream.js';
-import {bufferToUint8Array} from '../utils/uint-array.js';
-import {serializeOptionValue} from '../arguments/fd-options.js';
-
-// When we use multiple `stdio` values for the same streams, we pass 'pipe' to `child_process.spawn()`.
-// We then emulate the piping done by core Node.js.
-// To do so, we transform the following values:
-//  - Node.js streams are marked as `type: nodeStream`
-//  - 'inherit' becomes `process.stdin|stdout|stderr`
-//  - any file descriptor integer becomes `process.stdio[fdNumber]`
-// All of the above transformations tell Execa to perform manual piping.
-export const handleNativeStream = ({stdioItem, stdioItem: {type}, isStdioArray, fdNumber, direction, isSync}) => {
-	if (!isStdioArray || type !== 'native') {
-		return stdioItem;
-	}
-
-	return isSync
-		? handleNativeStreamSync({stdioItem, fdNumber, direction})
-		: handleNativeStreamAsync({stdioItem, fdNumber});
-};
-
-// Synchronous methods use a different logic.
-// 'inherit', file descriptors and process.std* are handled by readFileSync()/writeFileSync().
-const handleNativeStreamSync = ({stdioItem, stdioItem: {value, optionName}, fdNumber, direction}) => {
-	const targetFd = getTargetFd({
-		value,
-		optionName,
-		fdNumber,
-		direction,
-	});
-	if (targetFd !== undefined) {
-		return targetFd;
-	}
-
-	if (isNodeStream(value, {checkOpen: false})) {
-		throw new TypeError(`The \`${optionName}: Stream\` option cannot both be an array and include a stream with synchronous methods.`);
-	}
-
-	return stdioItem;
-};
-
-const getTargetFd = ({value, optionName, fdNumber, direction}) => {
-	const targetFdNumber = getTargetFdNumber(value, fdNumber);
-	if (targetFdNumber === undefined) {
-		return;
-	}
-
-	if (direction === 'output') {
-		return {type: 'fileNumber', value: targetFdNumber, optionName};
-	}
-
-	if (tty.isatty(targetFdNumber)) {
-		throw new TypeError(`The \`${optionName}: ${serializeOptionValue(value)}\` option is invalid: it cannot be a TTY with synchronous methods.`);
-	}
-
-	return {type: 'uint8Array', value: bufferToUint8Array(readFileSync(targetFdNumber)), optionName};
-};
-
-const getTargetFdNumber = (value, fdNumber) => {
-	if (value === 'inherit') {
-		return fdNumber;
-	}
-
-	if (typeof value === 'number') {
-		return value;
-	}
-
-	const standardStreamIndex = STANDARD_STREAMS.indexOf(value);
-	if (standardStreamIndex !== -1) {
-		return standardStreamIndex;
-	}
-};
-
-const handleNativeStreamAsync = ({stdioItem, stdioItem: {value, optionName}, fdNumber}) => {
-	if (value === 'inherit') {
-		return {type: 'nodeStream', value: getStandardStream(fdNumber, value, optionName), optionName};
-	}
-
-	if (typeof value === 'number') {
-		return {type: 'nodeStream', value: getStandardStream(value, value, optionName), optionName};
-	}
-
-	if (isNodeStream(value, {checkOpen: false})) {
-		return {type: 'nodeStream', value, optionName};
-	}
-
-	return stdioItem;
-};
-
-// Node.js does not allow to easily retrieve file descriptors beyond stdin/stdout/stderr as streams.
-//  - `fs.createReadStream()`/`fs.createWriteStream()` with the `fd` option do not work with character devices that use blocking reads/writes (such as interactive TTYs).
-//  - Using a TCP `Socket` would work but be rather complex to implement.
-// Since this is an edge case, we simply throw an error message.
-// See https://github.com/sindresorhus/execa/pull/643#discussion_r1435905707
-const getStandardStream = (fdNumber, value, optionName) => {
-	const standardStream = STANDARD_STREAMS[fdNumber];
-
-	if (standardStream === undefined) {
-		throw new TypeError(`The \`${optionName}: ${value}\` option is invalid: no such standard stream.`);
-	}
-
-	return standardStream;
-};

package/.output/server/node_modules/execa/lib/stdio/stdio-option.js

@@ -1,60 +0,0 @@
-import {STANDARD_STREAMS_ALIASES} from '../utils/standard-stream.js';
-import {normalizeIpcStdioArray} from '../ipc/array.js';
-import {isFullVerbose} from '../verbose/values.js';
-
-// Add support for `stdin`/`stdout`/`stderr` as an alias for `stdio`.
-// Also normalize the `stdio` option.
-export const normalizeStdioOption = ({stdio, ipc, buffer, ...options}, verboseInfo, isSync) => {
-	const stdioArray = getStdioArray(stdio, options).map((stdioOption, fdNumber) => addDefaultValue(stdioOption, fdNumber));
-	return isSync
-		? normalizeStdioSync(stdioArray, buffer, verboseInfo)
-		: normalizeIpcStdioArray(stdioArray, ipc);
-};
-
-const getStdioArray = (stdio, options) => {
-	if (stdio === undefined) {
-		return STANDARD_STREAMS_ALIASES.map(alias => options[alias]);
-	}
-
-	if (hasAlias(options)) {
-		throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${STANDARD_STREAMS_ALIASES.map(alias => `\`${alias}\``).join(', ')}`);
-	}
-
-	if (typeof stdio === 'string') {
-		return [stdio, stdio, stdio];
-	}
-
-	if (!Array.isArray(stdio)) {
-		throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
-	}
-
-	const length = Math.max(stdio.length, STANDARD_STREAMS_ALIASES.length);
-	return Array.from({length}, (_, fdNumber) => stdio[fdNumber]);
-};
-
-const hasAlias = options => STANDARD_STREAMS_ALIASES.some(alias => options[alias] !== undefined);
-
-const addDefaultValue = (stdioOption, fdNumber) => {
-	if (Array.isArray(stdioOption)) {
-		return stdioOption.map(item => addDefaultValue(item, fdNumber));
-	}
-
-	if (stdioOption === null || stdioOption === undefined) {
-		return fdNumber >= STANDARD_STREAMS_ALIASES.length ? 'ignore' : 'pipe';
-	}
-
-	return stdioOption;
-};
-
-// Using `buffer: false` with synchronous methods implies `stdout`/`stderr`: `ignore`.
-// Unless the output is needed, e.g. due to `verbose: 'full'` or to redirecting to a file.
-const normalizeStdioSync = (stdioArray, buffer, verboseInfo) => stdioArray.map((stdioOption, fdNumber) =>
-	!buffer[fdNumber]
-	&& fdNumber !== 0
-	&& !isFullVerbose(verboseInfo, fdNumber)
-	&& isOutputPipeOnly(stdioOption)
-		? 'ignore'
-		: stdioOption);
-
-const isOutputPipeOnly = stdioOption => stdioOption === 'pipe'
-	|| (Array.isArray(stdioOption) && stdioOption.every(item => item === 'pipe'));

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

@@ -1,173 +0,0 @@
-import {isStream as isNodeStream, isDuplexStream} from 'is-stream';
-import isPlainObj from 'is-plain-obj';
-import {isUint8Array} from '../utils/uint-array.js';
-
-// The `stdin`/`stdout`/`stderr` option can be of many types. This detects it.
-export const getStdioItemType = (value, optionName) => {
-	if (isAsyncGenerator(value)) {
-		return 'asyncGenerator';
-	}
-
-	if (isSyncGenerator(value)) {
-		return 'generator';
-	}
-
-	if (isUrl(value)) {
-		return 'fileUrl';
-	}
-
-	if (isFilePathObject(value)) {
-		return 'filePath';
-	}
-
-	if (isWebStream(value)) {
-		return 'webStream';
-	}
-
-	if (isNodeStream(value, {checkOpen: false})) {
-		return 'native';
-	}
-
-	if (isUint8Array(value)) {
-		return 'uint8Array';
-	}
-
-	if (isAsyncIterableObject(value)) {
-		return 'asyncIterable';
-	}
-
-	if (isIterableObject(value)) {
-		return 'iterable';
-	}
-
-	if (isTransformStream(value)) {
-		return getTransformStreamType({transform: value}, optionName);
-	}
-
-	if (isTransformOptions(value)) {
-		return getTransformObjectType(value, optionName);
-	}
-
-	return 'native';
-};
-
-const getTransformObjectType = (value, optionName) => {
-	if (isDuplexStream(value.transform, {checkOpen: false})) {
-		return getDuplexType(value, optionName);
-	}
-
-	if (isTransformStream(value.transform)) {
-		return getTransformStreamType(value, optionName);
-	}
-
-	return getGeneratorObjectType(value, optionName);
-};
-
-const getDuplexType = (value, optionName) => {
-	validateNonGeneratorType(value, optionName, 'Duplex stream');
-	return 'duplex';
-};
-
-const getTransformStreamType = (value, optionName) => {
-	validateNonGeneratorType(value, optionName, 'web TransformStream');
-	return 'webTransform';
-};
-
-const validateNonGeneratorType = ({final, binary, objectMode}, optionName, typeName) => {
-	checkUndefinedOption(final, `${optionName}.final`, typeName);
-	checkUndefinedOption(binary, `${optionName}.binary`, typeName);
-	checkBooleanOption(objectMode, `${optionName}.objectMode`);
-};
-
-const checkUndefinedOption = (value, optionName, typeName) => {
-	if (value !== undefined) {
-		throw new TypeError(`The \`${optionName}\` option can only be defined when using a generator, not a ${typeName}.`);
-	}
-};
-
-const getGeneratorObjectType = ({transform, final, binary, objectMode}, optionName) => {
-	if (transform !== undefined && !isGenerator(transform)) {
-		throw new TypeError(`The \`${optionName}.transform\` option must be a generator, a Duplex stream or a web TransformStream.`);
-	}
-
-	if (isDuplexStream(final, {checkOpen: false})) {
-		throw new TypeError(`The \`${optionName}.final\` option must not be a Duplex stream.`);
-	}
-
-	if (isTransformStream(final)) {
-		throw new TypeError(`The \`${optionName}.final\` option must not be a web TransformStream.`);
-	}
-
-	if (final !== undefined && !isGenerator(final)) {
-		throw new TypeError(`The \`${optionName}.final\` option must be a generator.`);
-	}
-
-	checkBooleanOption(binary, `${optionName}.binary`);
-	checkBooleanOption(objectMode, `${optionName}.objectMode`);
-
-	return isAsyncGenerator(transform) || isAsyncGenerator(final) ? 'asyncGenerator' : 'generator';
-};
-
-const checkBooleanOption = (value, optionName) => {
-	if (value !== undefined && typeof value !== 'boolean') {
-		throw new TypeError(`The \`${optionName}\` option must use a boolean.`);
-	}
-};
-
-const isGenerator = value => isAsyncGenerator(value) || isSyncGenerator(value);
-export const isAsyncGenerator = value => Object.prototype.toString.call(value) === '[object AsyncGeneratorFunction]';
-const isSyncGenerator = value => Object.prototype.toString.call(value) === '[object GeneratorFunction]';
-const isTransformOptions = value => isPlainObj(value)
-	&& (value.transform !== undefined || value.final !== undefined);
-
-export const isUrl = value => Object.prototype.toString.call(value) === '[object URL]';
-export const isRegularUrl = value => isUrl(value) && value.protocol !== 'file:';
-
-const isFilePathObject = value => isPlainObj(value)
-	&& Object.keys(value).length > 0
-	&& Object.keys(value).every(key => FILE_PATH_KEYS.has(key))
-	&& isFilePathString(value.file);
-const FILE_PATH_KEYS = new Set(['file', 'append']);
-export const isFilePathString = file => typeof file === 'string';
-
-export const isUnknownStdioString = (type, value) => type === 'native'
-	&& typeof value === 'string'
-	&& !KNOWN_STDIO_STRINGS.has(value);
-const KNOWN_STDIO_STRINGS = new Set(['ipc', 'ignore', 'inherit', 'overlapped', 'pipe']);
-
-const isReadableStream = value => Object.prototype.toString.call(value) === '[object ReadableStream]';
-export const isWritableStream = value => Object.prototype.toString.call(value) === '[object WritableStream]';
-const isWebStream = value => isReadableStream(value) || isWritableStream(value);
-const isTransformStream = value => isReadableStream(value?.readable) && isWritableStream(value?.writable);
-
-const isAsyncIterableObject = value => isObject(value) && typeof value[Symbol.asyncIterator] === 'function';
-const isIterableObject = value => isObject(value) && typeof value[Symbol.iterator] === 'function';
-const isObject = value => typeof value === 'object' && value !== null;
-
-// Types which modify `subprocess.std*`
-export const TRANSFORM_TYPES = new Set(['generator', 'asyncGenerator', 'duplex', 'webTransform']);
-// Types which write to a file or a file descriptor
-export const FILE_TYPES = new Set(['fileUrl', 'filePath', 'fileNumber']);
-// When two file descriptors of this type share the same target, we need to do some special logic
-export const SPECIAL_DUPLICATE_TYPES_SYNC = new Set(['fileUrl', 'filePath']);
-export const SPECIAL_DUPLICATE_TYPES = new Set([...SPECIAL_DUPLICATE_TYPES_SYNC, 'webStream', 'nodeStream']);
-// Do not allow two file descriptors of this type sharing the same target
-export const FORBID_DUPLICATE_TYPES = new Set(['webTransform', 'duplex']);
-
-// Convert types to human-friendly strings for error messages
-export const TYPE_TO_MESSAGE = {
-	generator: 'a generator',
-	asyncGenerator: 'an async generator',
-	fileUrl: 'a file URL',
-	filePath: 'a file path string',
-	fileNumber: 'a file descriptor number',
-	webStream: 'a web stream',
-	nodeStream: 'a Node.js stream',
-	webTransform: 'a web TransformStream',
-	duplex: 'a Duplex stream',
-	native: 'any value',
-	iterable: 'an iterable',
-	asyncIterable: 'an async iterable',
-	string: 'a string',
-	uint8Array: 'a Uint8Array',
-};

package/.output/server/node_modules/execa/lib/terminate/cancel.js

@@ -1,20 +0,0 @@
-import {onAbortedSignal} from '../utils/abort-signal.js';
-
-// Validate the `cancelSignal` option
-export const validateCancelSignal = ({cancelSignal}) => {
-	if (cancelSignal !== undefined && Object.prototype.toString.call(cancelSignal) !== '[object AbortSignal]') {
-		throw new Error(`The \`cancelSignal\` option must be an AbortSignal: ${String(cancelSignal)}`);
-	}
-};
-
-// Terminate the subprocess when aborting the `cancelSignal` option and `gracefulSignal` is `false`
-export const throwOnCancel = ({subprocess, cancelSignal, gracefulCancel, context, controller}) => cancelSignal === undefined || gracefulCancel
-	? []
-	: [terminateOnCancel(subprocess, cancelSignal, context, controller)];
-
-const terminateOnCancel = async (subprocess, cancelSignal, context, {signal}) => {
-	await onAbortedSignal(cancelSignal, signal);
-	context.terminationReason ??= 'cancel';
-	subprocess.kill();
-	throw cancelSignal.reason;
-};

package/.output/server/node_modules/execa/lib/terminate/cleanup.js

@@ -1,16 +0,0 @@
-import {addAbortListener} from 'node:events';
-import {onExit} from 'signal-exit';
-
-// If the `cleanup` option is used, call `subprocess.kill()` when the parent process exits
-export const cleanupOnExit = (subprocess, {cleanup, detached}, {signal}) => {
-	if (!cleanup || detached) {
-		return;
-	}
-
-	const removeExitHandler = onExit(() => {
-		subprocess.kill();
-	});
-	addAbortListener(signal, () => {
-		removeExitHandler();
-	});
-};

package/.output/server/node_modules/execa/lib/terminate/graceful.js

@@ -1,71 +0,0 @@
-import {onAbortedSignal} from '../utils/abort-signal.js';
-import {sendAbort} from '../ipc/graceful.js';
-import {killOnTimeout} from './kill.js';
-
-// Validate the `gracefulCancel` option
-export const validateGracefulCancel = ({gracefulCancel, cancelSignal, ipc, serialization}) => {
-	if (!gracefulCancel) {
-		return;
-	}
-
-	if (cancelSignal === undefined) {
-		throw new Error('The `cancelSignal` option must be defined when setting the `gracefulCancel` option.');
-	}
-
-	if (!ipc) {
-		throw new Error('The `ipc` option cannot be false when setting the `gracefulCancel` option.');
-	}
-
-	if (serialization === 'json') {
-		throw new Error('The `serialization` option cannot be \'json\' when setting the `gracefulCancel` option.');
-	}
-};
-
-// Send abort reason to the subprocess when aborting the `cancelSignal` option and `gracefulCancel` is `true`
-export const throwOnGracefulCancel = ({
-	subprocess,
-	cancelSignal,
-	gracefulCancel,
-	forceKillAfterDelay,
-	context,
-	controller,
-}) => gracefulCancel
-	? [sendOnAbort({
-		subprocess,
-		cancelSignal,
-		forceKillAfterDelay,
-		context,
-		controller,
-	})]
-	: [];
-
-const sendOnAbort = async ({subprocess, cancelSignal, forceKillAfterDelay, context, controller: {signal}}) => {
-	await onAbortedSignal(cancelSignal, signal);
-	const reason = getReason(cancelSignal);
-	await sendAbort(subprocess, reason);
-	killOnTimeout({
-		kill: subprocess.kill,
-		forceKillAfterDelay,
-		context,
-		controllerSignal: signal,
-	});
-	context.terminationReason ??= 'gracefulCancel';
-	throw cancelSignal.reason;
-};
-
-// The default `reason` is a DOMException, which is not serializable with V8
-// See https://github.com/nodejs/node/issues/53225
-const getReason = ({reason}) => {
-	if (!(reason instanceof DOMException)) {
-		return reason;
-	}
-
-	const error = new Error(reason.message);
-	Object.defineProperty(error, 'stack', {
-		value: reason.stack,
-		enumerable: false,
-		configurable: true,
-		writable: true,
-	});
-	return error;
-};

package/.output/server/node_modules/execa/lib/terminate/kill.js

@@ -1,93 +0,0 @@
-import {setTimeout} from 'node:timers/promises';
-import {isErrorInstance} from '../return/final-error.js';
-import {normalizeSignalArgument} from './signal.js';
-
-// Normalize the `forceKillAfterDelay` option
-export const normalizeForceKillAfterDelay = forceKillAfterDelay => {
-	if (forceKillAfterDelay === false) {
-		return forceKillAfterDelay;
-	}
-
-	if (forceKillAfterDelay === true) {
-		return DEFAULT_FORCE_KILL_TIMEOUT;
-	}
-
-	if (!Number.isFinite(forceKillAfterDelay) || forceKillAfterDelay < 0) {
-		throw new TypeError(`Expected the \`forceKillAfterDelay\` option to be a non-negative integer, got \`${forceKillAfterDelay}\` (${typeof forceKillAfterDelay})`);
-	}
-
-	return forceKillAfterDelay;
-};
-
-const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
-
-// Monkey-patches `subprocess.kill()` to add `forceKillAfterDelay` behavior and `.kill(error)`
-export const subprocessKill = (
-	{kill, options: {forceKillAfterDelay, killSignal}, onInternalError, context, controller},
-	signalOrError,
-	errorArgument,
-) => {
-	const {signal, error} = parseKillArguments(signalOrError, errorArgument, killSignal);
-	emitKillError(error, onInternalError);
-	const killResult = kill(signal);
-	setKillTimeout({
-		kill,
-		signal,
-		forceKillAfterDelay,
-		killSignal,
-		killResult,
-		context,
-		controller,
-	});
-	return killResult;
-};
-
-const parseKillArguments = (signalOrError, errorArgument, killSignal) => {
-	const [signal = killSignal, error] = isErrorInstance(signalOrError)
-		? [undefined, signalOrError]
-		: [signalOrError, errorArgument];
-
-	if (typeof signal !== 'string' && !Number.isInteger(signal)) {
-		throw new TypeError(`The first argument must be an error instance or a signal name string/integer: ${String(signal)}`);
-	}
-
-	if (error !== undefined && !isErrorInstance(error)) {
-		throw new TypeError(`The second argument is optional. If specified, it must be an error instance: ${error}`);
-	}
-
-	return {signal: normalizeSignalArgument(signal), error};
-};
-
-// Fails right away when calling `subprocess.kill(error)`.
-// Does not wait for actual signal termination.
-// Uses a deferred promise instead of the `error` event on the subprocess, as this is less intrusive.
-const emitKillError = (error, onInternalError) => {
-	if (error !== undefined) {
-		onInternalError.reject(error);
-	}
-};
-
-const setKillTimeout = async ({kill, signal, forceKillAfterDelay, killSignal, killResult, context, controller}) => {
-	if (signal === killSignal && killResult) {
-		killOnTimeout({
-			kill,
-			forceKillAfterDelay,
-			context,
-			controllerSignal: controller.signal,
-		});
-	}
-};
-
-// Forcefully terminate a subprocess after a timeout
-export const killOnTimeout = async ({kill, forceKillAfterDelay, context, controllerSignal}) => {
-	if (forceKillAfterDelay === false) {
-		return;
-	}
-
-	try {
-		await setTimeout(forceKillAfterDelay, undefined, {signal: controllerSignal});
-		if (kill('SIGKILL')) {
-			context.isForcefullyTerminated ??= true;
-		}
-	} catch {}
-};

package/.output/server/node_modules/execa/lib/terminate/signal.js

@@ -1,70 +0,0 @@
-import {constants} from 'node:os';
-import {signalsByName} from 'human-signals';
-
-// Normalize signals for comparison purpose.
-// Also validate the signal exists.
-export const normalizeKillSignal = killSignal => {
-	const optionName = 'option `killSignal`';
-	if (killSignal === 0) {
-		throw new TypeError(`Invalid ${optionName}: 0 cannot be used.`);
-	}
-
-	return normalizeSignal(killSignal, optionName);
-};
-
-export const normalizeSignalArgument = signal => signal === 0
-	? signal
-	: normalizeSignal(signal, '`subprocess.kill()`\'s argument');
-
-const normalizeSignal = (signalNameOrInteger, optionName) => {
-	if (Number.isInteger(signalNameOrInteger)) {
-		return normalizeSignalInteger(signalNameOrInteger, optionName);
-	}
-
-	if (typeof signalNameOrInteger === 'string') {
-		return normalizeSignalName(signalNameOrInteger, optionName);
-	}
-
-	throw new TypeError(`Invalid ${optionName} ${String(signalNameOrInteger)}: it must be a string or an integer.\n${getAvailableSignals()}`);
-};
-
-const normalizeSignalInteger = (signalInteger, optionName) => {
-	if (signalsIntegerToName.has(signalInteger)) {
-		return signalsIntegerToName.get(signalInteger);
-	}
-
-	throw new TypeError(`Invalid ${optionName} ${signalInteger}: this signal integer does not exist.\n${getAvailableSignals()}`);
-};
-
-const getSignalsIntegerToName = () => new Map(Object.entries(constants.signals)
-	.reverse()
-	.map(([signalName, signalInteger]) => [signalInteger, signalName]));
-
-const signalsIntegerToName = getSignalsIntegerToName();
-
-const normalizeSignalName = (signalName, optionName) => {
-	if (signalName in constants.signals) {
-		return signalName;
-	}
-
-	if (signalName.toUpperCase() in constants.signals) {
-		throw new TypeError(`Invalid ${optionName} '${signalName}': please rename it to '${signalName.toUpperCase()}'.`);
-	}
-
-	throw new TypeError(`Invalid ${optionName} '${signalName}': this signal name does not exist.\n${getAvailableSignals()}`);
-};
-
-const getAvailableSignals = () => `Available signal names: ${getAvailableSignalNames()}.
-Available signal numbers: ${getAvailableSignalIntegers()}.`;
-
-const getAvailableSignalNames = () => Object.keys(constants.signals)
-	.sort()
-	.map(signalName => `'${signalName}'`)
-	.join(', ');
-
-const getAvailableSignalIntegers = () => [...new Set(Object.values(constants.signals)
-	.sort((signalInteger, signalIntegerTwo) => signalInteger - signalIntegerTwo))]
-	.join(', ');
-
-// Human-friendly description of a signal
-export const getSignalDescription = signal => signalsByName[signal].description;

package/.output/server/node_modules/execa/lib/terminate/timeout.js

@@ -1,21 +0,0 @@
-import {setTimeout} from 'node:timers/promises';
-import {DiscardedError} from '../return/final-error.js';
-
-// Validate `timeout` option
-export const validateTimeout = ({timeout}) => {
-	if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
-		throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
-	}
-};
-
-// Fails when the `timeout` option is exceeded
-export const throwOnTimeout = (subprocess, timeout, context, controller) => timeout === 0 || timeout === undefined
-	? []
-	: [killAfterTimeout(subprocess, timeout, context, controller)];
-
-const killAfterTimeout = async (subprocess, timeout, context, {signal}) => {
-	await setTimeout(timeout, undefined, {signal});
-	context.terminationReason ??= 'timeout';
-	subprocess.kill();
-	throw new DiscardedError();
-};