karajan-code 3.4.1 → 3.4.2

package/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/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/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/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/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/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;
-	}
-};

package/node_modules/execa/lib/ipc/get-one.js

@@ -1,69 +0,0 @@
-import {once, on} from 'node:events';
-import {
-	validateIpcMethod,
-	throwOnEarlyDisconnect,
-	disconnect,
-	getStrictResponseError,
-} from './validation.js';
-import {getIpcEmitter, isConnected} from './forward.js';
-import {addReference, removeReference} from './reference.js';
-
-// Like `[sub]process.once('message')` but promise-based
-export const getOneMessage = ({anyProcess, channel, isSubprocess, ipc}, {reference = true, filter} = {}) => {
-	validateIpcMethod({
-		methodName: 'getOneMessage',
-		isSubprocess,
-		ipc,
-		isConnected: isConnected(anyProcess),
-	});
-
-	return getOneMessageAsync({
-		anyProcess,
-		channel,
-		isSubprocess,
-		filter,
-		reference,
-	});
-};
-
-const getOneMessageAsync = async ({anyProcess, channel, isSubprocess, filter, reference}) => {
-	addReference(channel, reference);
-	const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
-	const controller = new AbortController();
-	try {
-		return await Promise.race([
-			getMessage(ipcEmitter, filter, controller),
-			throwOnDisconnect(ipcEmitter, isSubprocess, controller),
-			throwOnStrictError(ipcEmitter, isSubprocess, controller),
-		]);
-	} catch (error) {
-		disconnect(anyProcess);
-		throw error;
-	} finally {
-		controller.abort();
-		removeReference(channel, reference);
-	}
-};
-
-const getMessage = async (ipcEmitter, filter, {signal}) => {
-	if (filter === undefined) {
-		const [message] = await once(ipcEmitter, 'message', {signal});
-		return message;
-	}
-
-	for await (const [message] of on(ipcEmitter, 'message', {signal})) {
-		if (filter(message)) {
-			return message;
-		}
-	}
-};
-
-const throwOnDisconnect = async (ipcEmitter, isSubprocess, {signal}) => {
-	await once(ipcEmitter, 'disconnect', {signal});
-	throwOnEarlyDisconnect(isSubprocess);
-};
-
-const throwOnStrictError = async (ipcEmitter, isSubprocess, {signal}) => {
-	const [error] = await once(ipcEmitter, 'strict:error', {signal});
-	throw getStrictResponseError(error, isSubprocess);
-};

package/node_modules/execa/lib/ipc/graceful.js

@@ -1,72 +0,0 @@
-import {scheduler} from 'node:timers/promises';
-import {sendOneMessage} from './send.js';
-import {getIpcEmitter} from './forward.js';
-import {validateConnection, getAbortDisconnectError, throwOnMissingParent} from './validation.js';
-
-// Send an IPC message so the subprocess performs a graceful termination
-export const sendAbort = (subprocess, message) => {
-	const methodName = 'cancelSignal';
-	validateConnection(methodName, false, subprocess.connected);
-	return sendOneMessage({
-		anyProcess: subprocess,
-		methodName,
-		isSubprocess: false,
-		wrappedMessage: {type: GRACEFUL_CANCEL_TYPE, message},
-		message,
-	});
-};
-
-// When the signal is being used, start listening for incoming messages.
-// Unbuffering messages takes one microtask to complete, so this must be async.
-export const getCancelSignal = async ({anyProcess, channel, isSubprocess, ipc}) => {
-	await startIpc({
-		anyProcess,
-		channel,
-		isSubprocess,
-		ipc,
-	});
-	return cancelController.signal;
-};
-
-const startIpc = async ({anyProcess, channel, isSubprocess, ipc}) => {
-	if (cancelListening) {
-		return;
-	}
-
-	cancelListening = true;
-
-	if (!ipc) {
-		throwOnMissingParent();
-		return;
-	}
-
-	if (channel === null) {
-		abortOnDisconnect();
-		return;
-	}
-
-	getIpcEmitter(anyProcess, channel, isSubprocess);
-	await scheduler.yield();
-};
-
-let cancelListening = false;
-
-// Reception of IPC message to perform a graceful termination
-export const handleAbort = wrappedMessage => {
-	if (wrappedMessage?.type !== GRACEFUL_CANCEL_TYPE) {
-		return false;
-	}
-
-	cancelController.abort(wrappedMessage.message);
-	return true;
-};
-
-const GRACEFUL_CANCEL_TYPE = 'execa:ipc:cancel';
-
-// When the current process disconnects early, the subprocess `cancelSignal` is aborted.
-// Otherwise, the signal would never be able to be aborted later on.
-export const abortOnDisconnect = () => {
-	cancelController.abort(getAbortDisconnectError());
-};
-
-const cancelController = new AbortController();

package/node_modules/execa/lib/ipc/incoming.js

@@ -1,79 +0,0 @@
-import {once} from 'node:events';
-import {scheduler} from 'node:timers/promises';
-import {waitForOutgoingMessages} from './outgoing.js';
-import {redoAddedReferences} from './reference.js';
-import {handleStrictRequest, handleStrictResponse} from './strict.js';
-import {handleAbort, abortOnDisconnect} from './graceful.js';
-
-// By default, Node.js buffers `message` events.
-//  - Buffering happens when there is a `message` event is emitted but there is no handler.
-//  - As soon as a `message` event handler is set, all buffered `message` events are emitted, emptying the buffer.
-//  - This happens both in the current process and the subprocess.
-//  - See https://github.com/nodejs/node/blob/501546e8f37059cd577041e23941b640d0d4d406/lib/internal/child_process.js#L719
-// This is helpful. Notably, this allows sending messages to a subprocess that's still initializing.
-// However, it has several problems.
-//  - This works with `events.on()` but not `events.once()` since all buffered messages are emitted at once.
-//    For example, users cannot call `await getOneMessage()`/`getEachMessage()` multiple times in a row.
-//  - When a user intentionally starts listening to `message` at a specific point in time, past `message` events are replayed, which might be unexpected.
-//  - Buffering is unlimited, which might lead to an out-of-memory crash.
-//  - This does not work well with multiple consumers.
-//    For example, Execa consumes events with both `result.ipcOutput` and manual IPC calls like `getOneMessage()`.
-//    Since `result.ipcOutput` reads all incoming messages, no buffering happens for manual IPC calls.
-//  - Forgetting to setup a `message` listener, or setting it up too late, is a programming mistake.
-//    The default behavior does not allow users to realize they made that mistake.
-// To solve those problems, instead of buffering messages, we debounce them.
-// The `message` event so it is emitted at most once per macrotask.
-export const onMessage = async ({anyProcess, channel, isSubprocess, ipcEmitter}, wrappedMessage) => {
-	if (handleStrictResponse(wrappedMessage) || handleAbort(wrappedMessage)) {
-		return;
-	}
-
-	if (!INCOMING_MESSAGES.has(anyProcess)) {
-		INCOMING_MESSAGES.set(anyProcess, []);
-	}
-
-	const incomingMessages = INCOMING_MESSAGES.get(anyProcess);
-	incomingMessages.push(wrappedMessage);
-
-	if (incomingMessages.length > 1) {
-		return;
-	}
-
-	while (incomingMessages.length > 0) {
-		// eslint-disable-next-line no-await-in-loop
-		await waitForOutgoingMessages(anyProcess, ipcEmitter, wrappedMessage);
-		// eslint-disable-next-line no-await-in-loop
-		await scheduler.yield();
-
-		// eslint-disable-next-line no-await-in-loop
-		const message = await handleStrictRequest({
-			wrappedMessage: incomingMessages[0],
-			anyProcess,
-			channel,
-			isSubprocess,
-			ipcEmitter,
-		});
-
-		incomingMessages.shift();
-		ipcEmitter.emit('message', message);
-		ipcEmitter.emit('message:done');
-	}
-};
-
-// If the `message` event is currently debounced, the `disconnect` event must wait for it
-export const onDisconnect = async ({anyProcess, channel, isSubprocess, ipcEmitter, boundOnMessage}) => {
-	abortOnDisconnect();
-
-	const incomingMessages = INCOMING_MESSAGES.get(anyProcess);
-	while (incomingMessages?.length > 0) {
-		// eslint-disable-next-line no-await-in-loop
-		await once(ipcEmitter, 'message:done');
-	}
-
-	anyProcess.removeListener('message', boundOnMessage);
-	redoAddedReferences(channel, isSubprocess);
-	ipcEmitter.connected = false;
-	ipcEmitter.emit('disconnect');
-};
-
-const INCOMING_MESSAGES = new WeakMap();

package/node_modules/execa/lib/ipc/ipc-input.js

@@ -1,44 +0,0 @@
-import {serialize} from 'node:v8';
-
-// Validate the `ipcInput` option
-export const validateIpcInputOption = ({ipcInput, ipc, serialization}) => {
-	if (ipcInput === undefined) {
-		return;
-	}
-
-	if (!ipc) {
-		throw new Error('The `ipcInput` option cannot be set unless the `ipc` option is `true`.');
-	}
-
-	validateIpcInput[serialization](ipcInput);
-};
-
-const validateAdvancedInput = ipcInput => {
-	try {
-		serialize(ipcInput);
-	} catch (error) {
-		throw new Error('The `ipcInput` option is not serializable with a structured clone.', {cause: error});
-	}
-};
-
-const validateJsonInput = ipcInput => {
-	try {
-		JSON.stringify(ipcInput);
-	} catch (error) {
-		throw new Error('The `ipcInput` option is not serializable with JSON.', {cause: error});
-	}
-};
-
-const validateIpcInput = {
-	advanced: validateAdvancedInput,
-	json: validateJsonInput,
-};
-
-// When the `ipcInput` option is set, it is sent as an initial IPC message to the subprocess
-export const sendIpcInput = async (subprocess, ipcInput) => {
-	if (ipcInput === undefined) {
-		return;
-	}
-
-	await subprocess.sendMessage(ipcInput);
-};

package/node_modules/execa/lib/ipc/methods.js

@@ -1,49 +0,0 @@
-import process from 'node:process';
-import {sendMessage} from './send.js';
-import {getOneMessage} from './get-one.js';
-import {getEachMessage} from './get-each.js';
-import {getCancelSignal} from './graceful.js';
-
-// Add promise-based IPC methods in current process
-export const addIpcMethods = (subprocess, {ipc}) => {
-	Object.assign(subprocess, getIpcMethods(subprocess, false, ipc));
-};
-
-// Get promise-based IPC in the subprocess
-export const getIpcExport = () => {
-	const anyProcess = process;
-	const isSubprocess = true;
-	const ipc = process.channel !== undefined;
-
-	return {
-		...getIpcMethods(anyProcess, isSubprocess, ipc),
-		getCancelSignal: getCancelSignal.bind(undefined, {
-			anyProcess,
-			channel: anyProcess.channel,
-			isSubprocess,
-			ipc,
-		}),
-	};
-};
-
-// Retrieve the `ipc` shared by both the current process and the subprocess
-const getIpcMethods = (anyProcess, isSubprocess, ipc) => ({
-	sendMessage: sendMessage.bind(undefined, {
-		anyProcess,
-		channel: anyProcess.channel,
-		isSubprocess,
-		ipc,
-	}),
-	getOneMessage: getOneMessage.bind(undefined, {
-		anyProcess,
-		channel: anyProcess.channel,
-		isSubprocess,
-		ipc,
-	}),
-	getEachMessage: getEachMessage.bind(undefined, {
-		anyProcess,
-		channel: anyProcess.channel,
-		isSubprocess,
-		ipc,
-	}),
-});

package/node_modules/execa/lib/ipc/outgoing.js

@@ -1,47 +0,0 @@
-import {createDeferred} from '../utils/deferred.js';
-import {getFdSpecificValue} from '../arguments/specific.js';
-import {SUBPROCESS_OPTIONS} from '../arguments/fd-options.js';
-import {validateStrictDeadlock} from './strict.js';
-
-// When `sendMessage()` is ongoing, any `message` being received waits before being emitted.
-// This allows calling one or multiple `await sendMessage()` followed by `await getOneMessage()`/`await getEachMessage()`.
-// Without running into a race condition when the other process sends a response too fast, before the current process set up a listener.
-export const startSendMessage = (anyProcess, wrappedMessage, strict) => {
-	if (!OUTGOING_MESSAGES.has(anyProcess)) {
-		OUTGOING_MESSAGES.set(anyProcess, new Set());
-	}
-
-	const outgoingMessages = OUTGOING_MESSAGES.get(anyProcess);
-	const onMessageSent = createDeferred();
-	const id = strict ? wrappedMessage.id : undefined;
-	const outgoingMessage = {onMessageSent, id};
-	outgoingMessages.add(outgoingMessage);
-	return {outgoingMessages, outgoingMessage};
-};
-
-export const endSendMessage = ({outgoingMessages, outgoingMessage}) => {
-	outgoingMessages.delete(outgoingMessage);
-	outgoingMessage.onMessageSent.resolve();
-};
-
-// Await while `sendMessage()` is ongoing, unless there is already a `message` listener
-export const waitForOutgoingMessages = async (anyProcess, ipcEmitter, wrappedMessage) => {
-	while (!hasMessageListeners(anyProcess, ipcEmitter) && OUTGOING_MESSAGES.get(anyProcess)?.size > 0) {
-		const outgoingMessages = [...OUTGOING_MESSAGES.get(anyProcess)];
-		validateStrictDeadlock(outgoingMessages, wrappedMessage);
-		// eslint-disable-next-line no-await-in-loop
-		await Promise.all(outgoingMessages.map(({onMessageSent}) => onMessageSent));
-	}
-};
-
-const OUTGOING_MESSAGES = new WeakMap();
-
-// Whether any `message` listener is setup
-export const hasMessageListeners = (anyProcess, ipcEmitter) => ipcEmitter.listenerCount('message') > getMinListenerCount(anyProcess);
-
-// When `buffer` is `false`, we set up a `message` listener that should be ignored.
-// That listener is only meant to intercept `strict` acknowledgement responses.
-const getMinListenerCount = anyProcess => SUBPROCESS_OPTIONS.has(anyProcess)
-	&& !getFdSpecificValue(SUBPROCESS_OPTIONS.get(anyProcess).options.buffer, 'ipc')
-	? 1
-	: 0;

package/node_modules/execa/lib/ipc/reference.js

@@ -1,44 +0,0 @@
-// By default, Node.js keeps the subprocess alive while it has a `message` or `disconnect` listener.
-// We replicate the same logic for the events that we proxy.
-// This ensures the subprocess is kept alive while `getOneMessage()` and `getEachMessage()` are ongoing.
-// This is not a problem with `sendMessage()` since Node.js handles that method automatically.
-// We do not use `anyProcess.channel.ref()` since this would prevent the automatic `.channel.refCounted()` Node.js is doing.
-// We keep a reference to `anyProcess.channel` since it might be `null` while `getOneMessage()` or `getEachMessage()` is still processing debounced messages.
-// See https://github.com/nodejs/node/blob/2aaeaa863c35befa2ebaa98fb7737ec84df4d8e9/lib/internal/child_process.js#L547
-export const addReference = (channel, reference) => {
-	if (reference) {
-		addReferenceCount(channel);
-	}
-};
-
-const addReferenceCount = channel => {
-	channel.refCounted();
-};
-
-export const removeReference = (channel, reference) => {
-	if (reference) {
-		removeReferenceCount(channel);
-	}
-};
-
-const removeReferenceCount = channel => {
-	channel.unrefCounted();
-};
-
-// To proxy events, we setup some global listeners on the `message` and `disconnect` events.
-// Those should not keep the subprocess alive, so we remove the automatic counting that Node.js is doing.
-// See https://github.com/nodejs/node/blob/1b965270a9c273d4cf70e8808e9d28b9ada7844f/lib/child_process.js#L180
-export const undoAddedReferences = (channel, isSubprocess) => {
-	if (isSubprocess) {
-		removeReferenceCount(channel);
-		removeReferenceCount(channel);
-	}
-};
-
-// Reverse it during `disconnect`
-export const redoAddedReferences = (channel, isSubprocess) => {
-	if (isSubprocess) {
-		addReferenceCount(channel);
-		addReferenceCount(channel);
-	}
-};