@kubb/agent 4.28.1 → 4.29.0

package/.output/server/node_modules/execa/lib/io/iterate.js

@@ -1,110 +0,0 @@
-import {on} from 'node:events';
-import {getDefaultHighWaterMark} from 'node:stream';
-import {getEncodingTransformGenerator} from '../transform/encoding-transform.js';
-import {getSplitLinesGenerator} from '../transform/split.js';
-import {transformChunkSync, finalChunksSync} from '../transform/run-sync.js';
-
-// Iterate over lines of `subprocess.stdout`, used by `subprocess.readable|duplex|iterable()`
-export const iterateOnSubprocessStream = ({subprocessStdout, subprocess, binary, shouldEncode, encoding, preserveNewlines}) => {
-	const controller = new AbortController();
-	stopReadingOnExit(subprocess, controller);
-	return iterateOnStream({
-		stream: subprocessStdout,
-		controller,
-		binary,
-		shouldEncode: !subprocessStdout.readableObjectMode && shouldEncode,
-		encoding,
-		shouldSplit: !subprocessStdout.readableObjectMode,
-		preserveNewlines,
-	});
-};
-
-const stopReadingOnExit = async (subprocess, controller) => {
-	try {
-		await subprocess;
-	} catch {} finally {
-		controller.abort();
-	}
-};
-
-// Iterate over lines of `subprocess.stdout`, used by `result.stdout` and the `verbose: 'full'` option.
-// Applies the `lines` and `encoding` options.
-export const iterateForResult = ({stream, onStreamEnd, lines, encoding, stripFinalNewline, allMixed}) => {
-	const controller = new AbortController();
-	stopReadingOnStreamEnd(onStreamEnd, controller, stream);
-	const objectMode = stream.readableObjectMode && !allMixed;
-	return iterateOnStream({
-		stream,
-		controller,
-		binary: encoding === 'buffer',
-		shouldEncode: !objectMode,
-		encoding,
-		shouldSplit: !objectMode && lines,
-		preserveNewlines: !stripFinalNewline,
-	});
-};
-
-const stopReadingOnStreamEnd = async (onStreamEnd, controller, stream) => {
-	try {
-		await onStreamEnd;
-	} catch {
-		stream.destroy();
-	} finally {
-		controller.abort();
-	}
-};
-
-const iterateOnStream = ({stream, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines}) => {
-	const onStdoutChunk = on(stream, 'data', {
-		signal: controller.signal,
-		highWaterMark: HIGH_WATER_MARK,
-		// Backward compatibility with older name for this option
-		// See https://github.com/nodejs/node/pull/52080#discussion_r1525227861
-		// @todo Remove after removing support for Node 21
-		highWatermark: HIGH_WATER_MARK,
-	});
-	return iterateOnData({
-		onStdoutChunk,
-		controller,
-		binary,
-		shouldEncode,
-		encoding,
-		shouldSplit,
-		preserveNewlines,
-	});
-};
-
-export const DEFAULT_OBJECT_HIGH_WATER_MARK = getDefaultHighWaterMark(true);
-
-// The `highWaterMark` of `events.on()` is measured in number of events, not in bytes.
-// Not knowing the average amount of bytes per `data` event, we use the same heuristic as streams in objectMode, since they have the same issue.
-// Therefore, we use the value of `getDefaultHighWaterMark(true)`.
-// Note: this option does not exist on Node 18, but this is ok since the logic works without it. It just consumes more memory.
-const HIGH_WATER_MARK = DEFAULT_OBJECT_HIGH_WATER_MARK;
-
-const iterateOnData = async function * ({onStdoutChunk, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines}) {
-	const generators = getGenerators({
-		binary,
-		shouldEncode,
-		encoding,
-		shouldSplit,
-		preserveNewlines,
-	});
-
-	try {
-		for await (const [chunk] of onStdoutChunk) {
-			yield * transformChunkSync(chunk, generators, 0);
-		}
-	} catch (error) {
-		if (!controller.signal.aborted) {
-			throw error;
-		}
-	} finally {
-		yield * finalChunksSync(generators);
-	}
-};
-
-const getGenerators = ({binary, shouldEncode, encoding, shouldSplit, preserveNewlines}) => [
-	getEncodingTransformGenerator(binary, encoding, !shouldEncode),
-	getSplitLinesGenerator(binary, preserveNewlines, !shouldSplit, {}),
-].filter(Boolean);

package/.output/server/node_modules/execa/lib/io/max-buffer.js

@@ -1,89 +0,0 @@
-import {MaxBufferError} from 'get-stream';
-import {getStreamName} from '../utils/standard-stream.js';
-import {getFdSpecificValue} from '../arguments/specific.js';
-
-// When the `maxBuffer` option is hit, a MaxBufferError is thrown.
-// The stream is aborted, then specific information is kept for the error message.
-export const handleMaxBuffer = ({error, stream, readableObjectMode, lines, encoding, fdNumber}) => {
-	if (!(error instanceof MaxBufferError)) {
-		throw error;
-	}
-
-	if (fdNumber === 'all') {
-		return error;
-	}
-
-	const unit = getMaxBufferUnit(readableObjectMode, lines, encoding);
-	error.maxBufferInfo = {fdNumber, unit};
-	stream.destroy();
-	throw error;
-};
-
-const getMaxBufferUnit = (readableObjectMode, lines, encoding) => {
-	if (readableObjectMode) {
-		return 'objects';
-	}
-
-	if (lines) {
-		return 'lines';
-	}
-
-	if (encoding === 'buffer') {
-		return 'bytes';
-	}
-
-	return 'characters';
-};
-
-// Check the `maxBuffer` option with `result.ipcOutput`
-export const checkIpcMaxBuffer = (subprocess, ipcOutput, maxBuffer) => {
-	if (ipcOutput.length !== maxBuffer) {
-		return;
-	}
-
-	const error = new MaxBufferError();
-	error.maxBufferInfo = {fdNumber: 'ipc'};
-	throw error;
-};
-
-// Error message when `maxBuffer` is hit
-export const getMaxBufferMessage = (error, maxBuffer) => {
-	const {streamName, threshold, unit} = getMaxBufferInfo(error, maxBuffer);
-	return `Command's ${streamName} was larger than ${threshold} ${unit}`;
-};
-
-const getMaxBufferInfo = (error, maxBuffer) => {
-	if (error?.maxBufferInfo === undefined) {
-		return {streamName: 'output', threshold: maxBuffer[1], unit: 'bytes'};
-	}
-
-	const {maxBufferInfo: {fdNumber, unit}} = error;
-	delete error.maxBufferInfo;
-
-	const threshold = getFdSpecificValue(maxBuffer, fdNumber);
-	if (fdNumber === 'ipc') {
-		return {streamName: 'IPC output', threshold, unit: 'messages'};
-	}
-
-	return {streamName: getStreamName(fdNumber), threshold, unit};
-};
-
-// The only way to apply `maxBuffer` with `spawnSync()` is to use the native `maxBuffer` option Node.js provides.
-// However, this has multiple limitations, and cannot behave the exact same way as the async behavior.
-// When the `maxBuffer` is hit, a `ENOBUFS` error is thrown.
-export const isMaxBufferSync = (resultError, output, maxBuffer) => resultError?.code === 'ENOBUFS'
-	&& output !== null
-	&& output.some(result => result !== null && result.length > getMaxBufferSync(maxBuffer));
-
-// When `maxBuffer` is hit, ensure the result is truncated
-export const truncateMaxBufferSync = (result, isMaxBuffer, maxBuffer) => {
-	if (!isMaxBuffer) {
-		return result;
-	}
-
-	const maxBufferValue = getMaxBufferSync(maxBuffer);
-	return result.length > maxBufferValue ? result.slice(0, maxBufferValue) : result;
-};
-
-// `spawnSync()` does not allow differentiating `maxBuffer` per file descriptor, so we always use `stdout`
-export const getMaxBufferSync = ([, stdoutMaxBuffer]) => stdoutMaxBuffer;

package/.output/server/node_modules/execa/lib/io/output-async.js

@@ -1,80 +0,0 @@
-import mergeStreams from '@sindresorhus/merge-streams';
-import {isStandardStream} from '../utils/standard-stream.js';
-import {incrementMaxListeners} from '../utils/max-listeners.js';
-import {TRANSFORM_TYPES} from '../stdio/type.js';
-import {pipeStreams} from './pipeline.js';
-
-// Handle `input`, `inputFile`, `stdin`, `stdout` and `stderr` options, after spawning, in async mode
-// When multiple input streams are used, we merge them to ensure the output stream ends only once each input stream has ended
-export const pipeOutputAsync = (subprocess, fileDescriptors, controller) => {
-	const pipeGroups = new Map();
-
-	for (const [fdNumber, {stdioItems, direction}] of Object.entries(fileDescriptors)) {
-		for (const {stream} of stdioItems.filter(({type}) => TRANSFORM_TYPES.has(type))) {
-			pipeTransform(subprocess, stream, direction, fdNumber);
-		}
-
-		for (const {stream} of stdioItems.filter(({type}) => !TRANSFORM_TYPES.has(type))) {
-			pipeStdioItem({
-				subprocess,
-				stream,
-				direction,
-				fdNumber,
-				pipeGroups,
-				controller,
-			});
-		}
-	}
-
-	for (const [outputStream, inputStreams] of pipeGroups.entries()) {
-		const inputStream = inputStreams.length === 1 ? inputStreams[0] : mergeStreams(inputStreams);
-		pipeStreams(inputStream, outputStream);
-	}
-};
-
-// When using transforms, `subprocess.stdin|stdout|stderr|stdio` is directly mutated
-const pipeTransform = (subprocess, stream, direction, fdNumber) => {
-	if (direction === 'output') {
-		pipeStreams(subprocess.stdio[fdNumber], stream);
-	} else {
-		pipeStreams(stream, subprocess.stdio[fdNumber]);
-	}
-
-	const streamProperty = SUBPROCESS_STREAM_PROPERTIES[fdNumber];
-	if (streamProperty !== undefined) {
-		subprocess[streamProperty] = stream;
-	}
-
-	subprocess.stdio[fdNumber] = stream;
-};
-
-const SUBPROCESS_STREAM_PROPERTIES = ['stdin', 'stdout', 'stderr'];
-
-// Most `std*` option values involve piping `subprocess.std*` to a stream.
-// The stream is either passed by the user or created internally.
-const pipeStdioItem = ({subprocess, stream, direction, fdNumber, pipeGroups, controller}) => {
-	if (stream === undefined) {
-		return;
-	}
-
-	setStandardStreamMaxListeners(stream, controller);
-
-	const [inputStream, outputStream] = direction === 'output'
-		? [stream, subprocess.stdio[fdNumber]]
-		: [subprocess.stdio[fdNumber], stream];
-	const outputStreams = pipeGroups.get(inputStream) ?? [];
-	pipeGroups.set(inputStream, [...outputStreams, outputStream]);
-};
-
-// Multiple subprocesses might be piping from/to `process.std*` at the same time.
-// This is not necessarily an error and should not print a `maxListeners` warning.
-const setStandardStreamMaxListeners = (stream, {signal}) => {
-	if (isStandardStream(stream)) {
-		incrementMaxListeners(stream, MAX_LISTENERS_INCREMENT, signal);
-	}
-};
-
-// `source.pipe(destination)` adds at most 1 listener for each event.
-// If `stdin` option is an array, the values might be combined with `merge-streams`.
-// That library also listens for `source` end, which adds 1 more listener.
-const MAX_LISTENERS_INCREMENT = 2;

package/.output/server/node_modules/execa/lib/io/output-sync.js

@@ -1,135 +0,0 @@
-import {writeFileSync, appendFileSync} from 'node:fs';
-import {shouldLogOutput, logLinesSync} from '../verbose/output.js';
-import {runGeneratorsSync} from '../transform/generator.js';
-import {splitLinesSync} from '../transform/split.js';
-import {joinToString, joinToUint8Array, bufferToUint8Array} from '../utils/uint-array.js';
-import {FILE_TYPES} from '../stdio/type.js';
-import {truncateMaxBufferSync} from './max-buffer.js';
-
-// Apply `stdout`/`stderr` options, after spawning, in sync mode
-export const transformOutputSync = ({fileDescriptors, syncResult: {output}, options, isMaxBuffer, verboseInfo}) => {
-	if (output === null) {
-		return {output: Array.from({length: 3})};
-	}
-
-	const state = {};
-	const outputFiles = new Set([]);
-	const transformedOutput = output.map((result, fdNumber) =>
-		transformOutputResultSync({
-			result,
-			fileDescriptors,
-			fdNumber,
-			state,
-			outputFiles,
-			isMaxBuffer,
-			verboseInfo,
-		}, options));
-	return {output: transformedOutput, ...state};
-};
-
-const transformOutputResultSync = (
-	{result, fileDescriptors, fdNumber, state, outputFiles, isMaxBuffer, verboseInfo},
-	{buffer, encoding, lines, stripFinalNewline, maxBuffer},
-) => {
-	if (result === null) {
-		return;
-	}
-
-	const truncatedResult = truncateMaxBufferSync(result, isMaxBuffer, maxBuffer);
-	const uint8ArrayResult = bufferToUint8Array(truncatedResult);
-	const {stdioItems, objectMode} = fileDescriptors[fdNumber];
-	const chunks = runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state);
-	const {serializedResult, finalResult = serializedResult} = serializeChunks({
-		chunks,
-		objectMode,
-		encoding,
-		lines,
-		stripFinalNewline,
-		fdNumber,
-	});
-
-	logOutputSync({
-		serializedResult,
-		fdNumber,
-		state,
-		verboseInfo,
-		encoding,
-		stdioItems,
-		objectMode,
-	});
-
-	const returnedResult = buffer[fdNumber] ? finalResult : undefined;
-
-	try {
-		if (state.error === undefined) {
-			writeToFiles(serializedResult, stdioItems, outputFiles);
-		}
-
-		return returnedResult;
-	} catch (error) {
-		state.error = error;
-		return returnedResult;
-	}
-};
-
-// Applies transform generators to `stdout`/`stderr`
-const runOutputGeneratorsSync = (chunks, stdioItems, encoding, state) => {
-	try {
-		return runGeneratorsSync(chunks, stdioItems, encoding, false);
-	} catch (error) {
-		state.error = error;
-		return chunks;
-	}
-};
-
-// The contents is converted to three stages:
-//  - serializedResult: used when the target is a file path/URL or a file descriptor (including 'inherit')
-//  - finalResult/returnedResult: returned as `result.std*`
-const serializeChunks = ({chunks, objectMode, encoding, lines, stripFinalNewline, fdNumber}) => {
-	if (objectMode) {
-		return {serializedResult: chunks};
-	}
-
-	if (encoding === 'buffer') {
-		return {serializedResult: joinToUint8Array(chunks)};
-	}
-
-	const serializedResult = joinToString(chunks, encoding);
-	if (lines[fdNumber]) {
-		return {serializedResult, finalResult: splitLinesSync(serializedResult, !stripFinalNewline[fdNumber], objectMode)};
-	}
-
-	return {serializedResult};
-};
-
-const logOutputSync = ({serializedResult, fdNumber, state, verboseInfo, encoding, stdioItems, objectMode}) => {
-	if (!shouldLogOutput({
-		stdioItems,
-		encoding,
-		verboseInfo,
-		fdNumber,
-	})) {
-		return;
-	}
-
-	const linesArray = splitLinesSync(serializedResult, false, objectMode);
-
-	try {
-		logLinesSync(linesArray, fdNumber, verboseInfo);
-	} catch (error) {
-		state.error ??= error;
-	}
-};
-
-// When the `std*` target is a file path/URL or a file descriptor
-const writeToFiles = (serializedResult, stdioItems, outputFiles) => {
-	for (const {path, append} of stdioItems.filter(({type}) => FILE_TYPES.has(type))) {
-		const pathString = typeof path === 'string' ? path : path.toString();
-		if (append || outputFiles.has(pathString)) {
-			appendFileSync(path, serializedResult);
-		} else {
-			outputFiles.add(pathString);
-			writeFileSync(path, serializedResult);
-		}
-	}
-};

package/.output/server/node_modules/execa/lib/io/pipeline.js

@@ -1,48 +0,0 @@
-import {finished} from 'node:stream/promises';
-import {isStandardStream} from '../utils/standard-stream.js';
-
-// Similar to `Stream.pipeline(source, destination)`, but does not destroy standard streams
-export const pipeStreams = (source, destination) => {
-	source.pipe(destination);
-	onSourceFinish(source, destination);
-	onDestinationFinish(source, destination);
-};
-
-// `source.pipe(destination)` makes `destination` end when `source` ends.
-// But it does not propagate aborts or errors. This function does it.
-const onSourceFinish = async (source, destination) => {
-	if (isStandardStream(source) || isStandardStream(destination)) {
-		return;
-	}
-
-	try {
-		await finished(source, {cleanup: true, readable: true, writable: false});
-	} catch {}
-
-	endDestinationStream(destination);
-};
-
-export const endDestinationStream = destination => {
-	if (destination.writable) {
-		destination.end();
-	}
-};
-
-// We do the same thing in the other direction as well.
-const onDestinationFinish = async (source, destination) => {
-	if (isStandardStream(source) || isStandardStream(destination)) {
-		return;
-	}
-
-	try {
-		await finished(destination, {cleanup: true, readable: false, writable: true});
-	} catch {}
-
-	abortSourceStream(source);
-};
-
-export const abortSourceStream = source => {
-	if (source.readable) {
-		source.destroy();
-	}
-};

package/.output/server/node_modules/execa/lib/io/strip-newline.js

@@ -1,12 +0,0 @@
-import stripFinalNewlineFunction from 'strip-final-newline';
-
-// Apply `stripFinalNewline` option, which applies to `result.stdout|stderr|all|stdio[*]`.
-// If the `lines` option is used, it is applied on each line, but using a different function.
-export const stripNewline = (value, {stripFinalNewline}, fdNumber) => getStripFinalNewline(stripFinalNewline, fdNumber) && value !== undefined && !Array.isArray(value)
-	? stripFinalNewlineFunction(value)
-	: value;
-
-// Retrieve `stripFinalNewline` option value, including with `subprocess.all`
-export const getStripFinalNewline = (stripFinalNewline, fdNumber) => fdNumber === 'all'
-	? stripFinalNewline[1] || stripFinalNewline[2]
-	: stripFinalNewline[fdNumber];

package/.output/server/node_modules/execa/lib/ipc/array.js

@@ -1,4 +0,0 @@
-// The `ipc` option adds an `ipc` item to the `stdio` option
-export const normalizeIpcStdioArray = (stdioArray, ipc) => ipc && !stdioArray.includes('ipc')
-	? [...stdioArray, 'ipc']
-	: stdioArray;

package/.output/server/node_modules/execa/lib/ipc/buffer-messages.js

@@ -1,47 +0,0 @@
-import {checkIpcMaxBuffer} from '../io/max-buffer.js';
-import {shouldLogIpc, logIpcOutput} from '../verbose/ipc.js';
-import {getFdSpecificValue} from '../arguments/specific.js';
-import {loopOnMessages} from './get-each.js';
-
-// Iterate through IPC messages sent by the subprocess
-export const waitForIpcOutput = async ({
-	subprocess,
-	buffer: bufferArray,
-	maxBuffer: maxBufferArray,
-	ipc,
-	ipcOutput,
-	verboseInfo,
-}) => {
-	if (!ipc) {
-		return ipcOutput;
-	}
-
-	const isVerbose = shouldLogIpc(verboseInfo);
-	const buffer = getFdSpecificValue(bufferArray, 'ipc');
-	const maxBuffer = getFdSpecificValue(maxBufferArray, 'ipc');
-
-	for await (const message of loopOnMessages({
-		anyProcess: subprocess,
-		channel: subprocess.channel,
-		isSubprocess: false,
-		ipc,
-		shouldAwait: false,
-		reference: true,
-	})) {
-		if (buffer) {
-			checkIpcMaxBuffer(subprocess, ipcOutput, maxBuffer);
-			ipcOutput.push(message);
-		}
-
-		if (isVerbose) {
-			logIpcOutput(message, verboseInfo);
-		}
-	}
-
-	return ipcOutput;
-};
-
-export const getBufferedIpcOutput = async (ipcOutputPromise, ipcOutput) => {
-	await Promise.allSettled([ipcOutputPromise]);
-	return ipcOutput;
-};

package/.output/server/node_modules/execa/lib/ipc/forward.js

@@ -1,56 +0,0 @@
-import {EventEmitter} from 'node:events';
-import {onMessage, onDisconnect} from './incoming.js';
-import {undoAddedReferences} from './reference.js';
-
-// Forward the `message` and `disconnect` events from the process and subprocess to a proxy emitter.
-// This prevents the `error` event from stopping IPC.
-// This also allows debouncing the `message` event.
-export const getIpcEmitter = (anyProcess, channel, isSubprocess) => {
-	if (IPC_EMITTERS.has(anyProcess)) {
-		return IPC_EMITTERS.get(anyProcess);
-	}
-
-	// Use an `EventEmitter`, like the `process` that is being proxied
-	// eslint-disable-next-line unicorn/prefer-event-target
-	const ipcEmitter = new EventEmitter();
-	ipcEmitter.connected = true;
-	IPC_EMITTERS.set(anyProcess, ipcEmitter);
-	forwardEvents({
-		ipcEmitter,
-		anyProcess,
-		channel,
-		isSubprocess,
-	});
-	return ipcEmitter;
-};
-
-const IPC_EMITTERS = new WeakMap();
-
-// The `message` and `disconnect` events are buffered in the subprocess until the first listener is setup.
-// However, unbuffering happens after one tick, so this give enough time for the caller to setup the listener on the proxy emitter first.
-// See https://github.com/nodejs/node/blob/2aaeaa863c35befa2ebaa98fb7737ec84df4d8e9/lib/internal/child_process.js#L721
-const forwardEvents = ({ipcEmitter, anyProcess, channel, isSubprocess}) => {
-	const boundOnMessage = onMessage.bind(undefined, {
-		anyProcess,
-		channel,
-		isSubprocess,
-		ipcEmitter,
-	});
-	anyProcess.on('message', boundOnMessage);
-	anyProcess.once('disconnect', onDisconnect.bind(undefined, {
-		anyProcess,
-		channel,
-		isSubprocess,
-		ipcEmitter,
-		boundOnMessage,
-	}));
-	undoAddedReferences(channel, isSubprocess);
-};
-
-// Check whether there might still be some `message` events to receive
-export const isConnected = anyProcess => {
-	const ipcEmitter = IPC_EMITTERS.get(anyProcess);
-	return ipcEmitter === undefined
-		? anyProcess.channel !== null
-		: ipcEmitter.connected;
-};

package/.output/server/node_modules/execa/lib/ipc/get-each.js

@@ -1,89 +0,0 @@
-import {once, on} from 'node:events';
-import {validateIpcMethod, disconnect, getStrictResponseError} from './validation.js';
-import {getIpcEmitter, isConnected} from './forward.js';
-import {addReference, removeReference} from './reference.js';
-
-// Like `[sub]process.on('message')` but promise-based
-export const getEachMessage = ({anyProcess, channel, isSubprocess, ipc}, {reference = true} = {}) => loopOnMessages({
-	anyProcess,
-	channel,
-	isSubprocess,
-	ipc,
-	shouldAwait: !isSubprocess,
-	reference,
-});
-
-// Same but used internally
-export const loopOnMessages = ({anyProcess, channel, isSubprocess, ipc, shouldAwait, reference}) => {
-	validateIpcMethod({
-		methodName: 'getEachMessage',
-		isSubprocess,
-		ipc,
-		isConnected: isConnected(anyProcess),
-	});
-
-	addReference(channel, reference);
-	const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
-	const controller = new AbortController();
-	const state = {};
-	stopOnDisconnect(anyProcess, ipcEmitter, controller);
-	abortOnStrictError({
-		ipcEmitter,
-		isSubprocess,
-		controller,
-		state,
-	});
-	return iterateOnMessages({
-		anyProcess,
-		channel,
-		ipcEmitter,
-		isSubprocess,
-		shouldAwait,
-		controller,
-		state,
-		reference,
-	});
-};
-
-const stopOnDisconnect = async (anyProcess, ipcEmitter, controller) => {
-	try {
-		await once(ipcEmitter, 'disconnect', {signal: controller.signal});
-		controller.abort();
-	} catch {}
-};
-
-const abortOnStrictError = async ({ipcEmitter, isSubprocess, controller, state}) => {
-	try {
-		const [error] = await once(ipcEmitter, 'strict:error', {signal: controller.signal});
-		state.error = getStrictResponseError(error, isSubprocess);
-		controller.abort();
-	} catch {}
-};
-
-const iterateOnMessages = async function * ({anyProcess, channel, ipcEmitter, isSubprocess, shouldAwait, controller, state, reference}) {
-	try {
-		for await (const [message] of on(ipcEmitter, 'message', {signal: controller.signal})) {
-			throwIfStrictError(state);
-			yield message;
-		}
-	} catch {
-		throwIfStrictError(state);
-	} finally {
-		controller.abort();
-		removeReference(channel, reference);
-
-		if (!isSubprocess) {
-			disconnect(anyProcess);
-		}
-
-		if (shouldAwait) {
-			await anyProcess;
-		}
-	}
-};
-
-const throwIfStrictError = ({error}) => {
-	if (error) {
-		throw error;
-	}
-};