@hot-updater/rock 0.20.11 → 0.20.13

package/dist/index.cjs

@@ -24,8 +24,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-let path = require("path");
-path = __toESM(path);
 let __hot_updater_plugin_core = require("@hot-updater/plugin-core");
 __hot_updater_plugin_core = __toESM(__hot_updater_plugin_core);
 let node_url = require("node:url");
@@ -42,6 +40,8 @@ let node_tty = require("node:tty");
 node_tty = __toESM(node_tty);
 let node_path = require("node:path");
 node_path = __toESM(node_path);
+let path = require("path");
+path = __toESM(path);
 let node_timers_promises = require("node:timers/promises");
 node_timers_promises = __toESM(node_timers_promises);
 let node_os = require("node:os");
@@ -108,8 +108,7 @@ const stringToUint8Array = (string) => textEncoder$1.encode(string);
 const textDecoder = new TextDecoder();
 const uint8ArrayToString = (uint8Array) => textDecoder.decode(uint8Array);
 const joinToString = (uint8ArraysOrStrings, encoding) => {
-	const strings = uint8ArraysToStrings(uint8ArraysOrStrings, encoding);
-	return strings.join("");
+	return uint8ArraysToStrings(uint8ArraysOrStrings, encoding).join("");
 };
 const uint8ArraysToStrings = (uint8ArraysOrStrings, encoding) => {
 	if (encoding === "utf8" && uint8ArraysOrStrings.every((uint8ArrayOrString) => typeof uint8ArrayOrString === "string")) return uint8ArraysOrStrings;
@@ -164,8 +163,7 @@ const parseTemplate = ({ templates, expressions, tokens, index, template }) => {
 	const newTokens = concatTokens(tokens, nextTokens, leadingWhitespaces);
 	if (index === expressions.length) return newTokens;
 	const expression = expressions[index];
-	const expressionTokens = Array.isArray(expression) ? expression.map((expression$1) => parseExpression(expression$1)) : [parseExpression(expression)];
-	return concatTokens(newTokens, expressionTokens, trailingWhitespaces);
+	return concatTokens(newTokens, Array.isArray(expression) ? expression.map((expression$1) => parseExpression(expression$1)) : [parseExpression(expression)], trailingWhitespaces);
 };
 const splitByWhitespaces = (template, rawTemplate) => {
 	if (rawTemplate.length === 0) return {
@@ -252,8 +250,7 @@ const normalizeFdSpecificOptions = (options) => {
 };
 const normalizeFdSpecificOption = (options, optionName) => {
 	const optionBaseArray = Array.from({ length: getStdioLength(options) + 1 });
-	const optionArray = normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName);
-	return addDefaultValue$1(optionArray, optionName);
+	return addDefaultValue$1(normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName), optionName);
 };
 const getStdioLength = ({ stdio }) => Array.isArray(stdio) ? Math.max(stdio.length, STANDARD_STREAMS_ALIASES.length) : STANDARD_STREAMS_ALIASES.length;
 const normalizeFdSpecificValue = (optionValue, optionArray, optionName) => isPlainObject(optionValue) ? normalizeOptionObject(optionValue, optionArray, optionName) : optionArray.fill(optionValue);
@@ -283,12 +280,11 @@ const parseFd = (fdName) => {
 };
 const FD_REGEXP = /^fd(\d+)$/;
 const addDefaultValue$1 = (optionArray, optionName) => optionArray.map((optionValue) => optionValue === void 0 ? DEFAULT_OPTIONS[optionName] : optionValue);
-const verboseDefault = (0, node_util.debuglog)("execa").enabled ? "full" : "none";
 const DEFAULT_OPTIONS = {
 	lines: false,
 	buffer: true,
 	maxBuffer: 1e3 * 1e3 * 100,
-	verbose: verboseDefault,
+	verbose: (0, node_util.debuglog)("execa").enabled ? "full" : "none",
 	stripFinalNewline: true
 };
 const FD_SPECIFIC_OPTIONS = [
@@ -321,11 +317,9 @@ const VERBOSE_VALUES = [
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/arguments/escape.js
 const joinCommand = (filePath, rawArguments) => {
 	const fileAndArguments = [filePath, ...rawArguments];
-	const command = fileAndArguments.join(" ");
-	const escapedCommand = fileAndArguments.map((fileAndArgument) => quoteString(escapeControlCharacters(fileAndArgument))).join(" ");
 	return {
-		command,
-		escapedCommand
+		command: fileAndArguments.join(" "),
+		escapedCommand: fileAndArguments.map((fileAndArgument) => quoteString(escapeControlCharacters(fileAndArgument))).join(" ")
 	};
 };
 const escapeLines = (lines) => (0, node_util.stripVTControlCharacters)(lines).split("\n").map((line) => escapeControlCharacters(line)).join("\n");
@@ -766,13 +760,11 @@ const appendNewline = (printedLine) => printedLine.endsWith("\n") ? printedLine
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/verbose/log.js
 const verboseLog = ({ type, verboseMessage, fdNumber, verboseInfo, result }) => {
-	const verboseObject = getVerboseObject({
+	const finalLines = applyVerboseOnLines(getPrintedLines(verboseMessage, getVerboseObject({
 		type,
 		result,
 		verboseInfo
-	});
-	const printedLines = getPrintedLines(verboseMessage, verboseObject);
-	const finalLines = applyVerboseOnLines(printedLines, verboseInfo, fdNumber);
+	})), verboseInfo, fdNumber);
 	if (finalLines !== "") console.warn(finalLines.slice(0, -1));
 };
 const getVerboseObject = ({ type, result, verboseInfo: { escapedCommand, commandId, rawOptions: { piped = false,...options } } }) => ({
@@ -789,16 +781,13 @@ const getPrintedLines = (verboseMessage, verboseObject) => verboseMessage.split(
 	message
 }));
 const getPrintedLine = (verboseObject) => {
-	const verboseLine = defaultVerboseFunction(verboseObject);
 	return {
-		verboseLine,
+		verboseLine: defaultVerboseFunction(verboseObject),
 		verboseObject
 	};
 };
 const serializeVerboseMessage = (message) => {
-	const messageString = typeof message === "string" ? message : (0, node_util.inspect)(message);
-	const escapedMessage = escapeLines(messageString);
-	return escapedMessage.replaceAll("	", " ".repeat(TAB_SIZE));
+	return escapeLines(typeof message === "string" ? message : (0, node_util.inspect)(message)).replaceAll("	", " ".repeat(TAB_SIZE));
 };
 const TAB_SIZE = 2;
 
@@ -817,11 +806,10 @@ const logCommand = (escapedCommand, verboseInfo) => {
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/verbose/info.js
 const getVerboseInfo = (verbose, escapedCommand, rawOptions) => {
 	validateVerbose(verbose);
-	const commandId = getCommandId(verbose);
 	return {
 		verbose,
 		escapedCommand,
-		commandId,
+		commandId: getCommandId(verbose),
 		rawOptions
 	};
 };
@@ -848,8 +836,7 @@ const getDurationMs = (startTime) => Number(node_process.hrtime.bigint() - start
 const handleCommand = (filePath, rawArguments, rawOptions) => {
 	const startTime = getStartTime();
 	const { command, escapedCommand } = joinCommand(filePath, rawArguments);
-	const verbose = normalizeFdSpecificOption(rawOptions, "verbose");
-	const verboseInfo = getVerboseInfo(verbose, escapedCommand, { ...rawOptions });
+	const verboseInfo = getVerboseInfo(normalizeFdSpecificOption(rawOptions, "verbose"), escapedCommand, { ...rawOptions });
 	logCommand(escapedCommand, verboseInfo);
 	return {
 		command,
@@ -917,8 +904,7 @@ var require_mode = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/isexe@
 		var g = parseInt("010", 8);
 		var o$1 = parseInt("001", 8);
 		var ug = u$1 | g;
-		var ret = mod & o$1 || mod & g && gid === myGid || mod & u$1 && uid === myUid || mod & ug && myUid === 0;
-		return ret;
+		return mod & o$1 || mod & g && gid === myGid || mod & u$1 && uid === myUid || mod & ug && myUid === 0;
 	}
 }) });
 
@@ -1000,8 +986,7 @@ var require_which = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/which
 			const ppRaw = pathEnv[i$1];
 			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
 			const pCmd = path$9.join(pathPart, cmd);
-			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-			resolve(subStep(p, i$1, 0));
+			resolve(subStep(!pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd, i$1, 0));
 		});
 		const subStep = (p, i$1, ii) => new Promise((resolve, reject) => {
 			if (ii === pathExt.length) return resolve(step(i$1 + 1));
@@ -1026,8 +1011,7 @@ var require_which = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/which
 			for (let j = 0; j < pathExt.length; j++) {
 				const cur = p + pathExt[j];
 				try {
-					const is = isexe.sync(cur, { pathExt: pathExtExe });
-					if (is) if (opt.all) found.push(cur);
+					if (isexe.sync(cur, { pathExt: pathExtExe })) if (opt.all) found.push(cur);
 					else return cur;
 				} catch (ex) {}
 			}
@@ -1045,8 +1029,7 @@ var require_which = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/which
 var require_path_key = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js": ((exports, module) => {
 	const pathKey$1 = (options = {}) => {
 		const environment = options.env || process.env;
-		const platform$1 = options.platform || process.platform;
-		if (platform$1 !== "win32") return "PATH";
+		if ((options.platform || process.platform) !== "win32") return "PATH";
 		return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
 	};
 	module.exports = pathKey$1;
@@ -1174,12 +1157,11 @@ var require_parse = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/cross
 			parsed.command = path$7.normalize(parsed.command);
 			parsed.command = escape.command(parsed.command);
 			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
-			const shellCommand = [parsed.command].concat(parsed.args).join(" ");
 			parsed.args = [
 				"/d",
 				"/s",
 				"/c",
-				`"${shellCommand}"`
+				`"${[parsed.command].concat(parsed.args).join(" ")}"`
 			];
 			parsed.command = process.env.comspec || "cmd.exe";
 			parsed.options.windowsVerbatimArguments = true;
@@ -1332,9 +1314,7 @@ const npmRunPathEnv = ({ env = node_process.default.env,...options } = {}) => {
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/return/final-error.js
 const getFinalError = (originalError, message, isSync) => {
-	const ErrorClass = isSync ? ExecaSyncError : ExecaError;
-	const options = originalError instanceof DiscardedError ? {} : { cause: originalError };
-	return new ErrorClass(message, options);
+	return new (isSync ? ExecaSyncError : ExecaError)(message, originalError instanceof DiscardedError ? {} : { cause: originalError });
 };
 var DiscardedError = class extends Error {};
 const setErrorName = (ErrorClass, value) => {
@@ -1653,16 +1633,14 @@ const SIGNALS = [
 //#region ../../node_modules/.pnpm/human-signals@8.0.0/node_modules/human-signals/build/src/signals.js
 const getSignals = () => {
 	const realtimeSignals = getRealtimeSignals();
-	const signals$1 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal$1);
-	return signals$1;
+	return [...SIGNALS, ...realtimeSignals].map(normalizeSignal$1);
 };
 const normalizeSignal$1 = ({ name, number: defaultNumber, description, action, forced = false, standard }) => {
 	const { signals: { [name]: constantSignal } } = node_os.constants;
 	const supported = constantSignal !== void 0;
-	const number = supported ? constantSignal : defaultNumber;
 	return {
 		name,
-		number,
+		number: supported ? constantSignal : defaultNumber,
 		description,
 		supported,
 		action,
@@ -2074,8 +2052,7 @@ const isConnected = (anyProcess) => {
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/ipc/strict.js
 const handleSendStrict = ({ anyProcess, channel, isSubprocess, message, strict }) => {
 	if (!strict) return message;
-	const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
-	const hasListeners = hasMessageListeners(anyProcess, ipcEmitter);
+	const hasListeners = hasMessageListeners(anyProcess, getIpcEmitter(anyProcess, channel, isSubprocess));
 	return {
 		id: count++,
 		type: REQUEST_TYPE,
@@ -2148,11 +2125,9 @@ const RESPONSE_TYPE = "execa:ipc:response";
 const startSendMessage = (anyProcess, wrappedMessage, strict) => {
 	if (!OUTGOING_MESSAGES.has(anyProcess)) OUTGOING_MESSAGES.set(anyProcess, /* @__PURE__ */ new Set());
 	const outgoingMessages = OUTGOING_MESSAGES.get(anyProcess);
-	const onMessageSent = createDeferred();
-	const id = strict ? wrappedMessage.id : void 0;
 	const outgoingMessage = {
-		onMessageSent,
-		id
+		onMessageSent: createDeferred(),
+		id: strict ? wrappedMessage.id : void 0
 	};
 	outgoingMessages.add(outgoingMessage);
 	return {
@@ -2313,8 +2288,7 @@ const throwOnGracefulCancel = ({ subprocess, cancelSignal, gracefulCancel, force
 })] : [];
 const sendOnAbort = async ({ subprocess, cancelSignal, forceKillAfterDelay, context, controller: { signal } }) => {
 	await onAbortedSignal(cancelSignal, signal);
-	const reason = getReason(cancelSignal);
-	await sendAbort(subprocess, reason);
+	await sendAbort(subprocess, getReason(cancelSignal));
 	killOnTimeout({
 		kill: subprocess.kill,
 		forceKillAfterDelay,
@@ -2488,8 +2462,7 @@ const normalizeOptions = (filePath, rawArguments, rawOptions) => {
 	rawOptions.cwd = normalizeCwd(rawOptions.cwd);
 	const [processedFile, processedArguments, processedOptions] = handleNodeOption(filePath, rawArguments, rawOptions);
 	const { command: file, args: commandArguments, options: initialOptions } = import_cross_spawn.default._parse(processedFile, processedArguments, processedOptions);
-	const fdOptions = normalizeFdSpecificOptions(initialOptions);
-	const options = addDefaultOptions(fdOptions);
+	const options = addDefaultOptions(normalizeFdSpecificOptions(initialOptions));
 	validateTimeout(options);
 	validateEncoding(options);
 	validateIpcInputOption(options);
@@ -2646,7 +2619,7 @@ const u = Object.create(a, {
 	}
 });
 function h({ preventCancel: r = !1 } = {}) {
-	const e = this.getReader(), t = new c(e, r), s = Object.create(u);
+	const t = new c(this.getReader(), r), s = Object.create(u);
 	return s[n] = t, s;
 }
 
@@ -2695,18 +2668,14 @@ const getStreamContents$1 = async (stream, { init, convertChunk, getSize, trunca
 	const state = init();
 	state.length = 0;
 	try {
-		for await (const chunk of asyncIterable) {
-			const chunkType = getChunkType(chunk);
-			const convertedChunk = convertChunk[chunkType](chunk, state);
-			appendChunk({
-				convertedChunk,
-				state,
-				getSize,
-				truncateChunk,
-				addChunk,
-				maxBuffer
-			});
-		}
+		for await (const chunk of asyncIterable) appendChunk({
+			convertedChunk: convertChunk[getChunkType(chunk)](chunk, state),
+			state,
+			getSize,
+			truncateChunk,
+			addChunk,
+			maxBuffer
+		});
 		appendFinalChunk({
 			state,
 			convertChunk,
@@ -2896,10 +2865,9 @@ const stringMethods = {
 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
+		unit: getMaxBufferUnit(readableObjectMode, lines, encoding)
 	};
 	stream.destroy();
 	throw error;
@@ -2969,19 +2937,16 @@ const createMessages = ({ stdio, all, ipcOutput, originalError, signal, signalDe
 		killSignal
 	});
 	const originalMessage = getOriginalMessage(originalError, cwd);
-	const suffix = originalMessage === void 0 ? "" : `\n${originalMessage}`;
-	const shortMessage = `${prefix}: ${escapedCommand}${suffix}`;
-	const messageStdio = all === void 0 ? [stdio[2], stdio[1]] : [all];
-	const message = [
-		shortMessage,
-		...messageStdio,
-		...stdio.slice(3),
-		ipcOutput.map((ipcMessage) => serializeIpcMessage(ipcMessage)).join("\n")
-	].map((messagePart) => escapeLines(stripFinalNewline(serializeMessagePart(messagePart)))).filter(Boolean).join("\n\n");
+	const shortMessage = `${prefix}: ${escapedCommand}${originalMessage === void 0 ? "" : `\n${originalMessage}`}`;
 	return {
 		originalMessage,
 		shortMessage,
-		message
+		message: [
+			shortMessage,
+			...all === void 0 ? [stdio[2], stdio[1]] : [all],
+			...stdio.slice(3),
+			ipcOutput.map((ipcMessage) => serializeIpcMessage(ipcMessage)).join("\n")
+		].map((messagePart) => escapeLines(stripFinalNewline(serializeMessagePart(messagePart)))).filter(Boolean).join("\n\n")
 	};
 };
 const getErrorPrefix = ({ originalError, timedOut, timeout, isMaxBuffer, maxBuffer, errorCode, signal, signalDescription, exitCode, isCanceled, isGracefullyCanceled, isForcefullyTerminated, forceKillAfterDelay, killSignal }) => {
@@ -3002,8 +2967,7 @@ const getErrorPrefix = ({ originalError, timedOut, timeout, isMaxBuffer, maxBuff
 const getForcefulSuffix = (isForcefullyTerminated, forceKillAfterDelay) => isForcefullyTerminated ? ` and was forcefully terminated after ${forceKillAfterDelay} milliseconds` : "";
 const getOriginalMessage = (originalError, cwd) => {
 	if (originalError instanceof DiscardedError) return;
-	const originalMessage = isExecaError(originalError) ? originalError.originalMessage : String(originalError?.message ?? originalError);
-	const escapedOriginalMessage = escapeLines(fixCwdError(originalMessage, cwd));
+	const escapedOriginalMessage = escapeLines(fixCwdError(isExecaError(originalError) ? originalError.originalMessage : String(originalError?.message ?? originalError), cwd));
 	return escapedOriginalMessage === "" ? void 0 : escapedOriginalMessage;
 };
 const serializeIpcMessage = (ipcMessage) => typeof ipcMessage === "string" ? ipcMessage : (0, node_util.inspect)(ipcMessage);
@@ -3125,11 +3089,10 @@ const omitUndefinedProperties = (result) => Object.fromEntries(Object.entries(re
 const normalizeExitPayload = (rawExitCode, rawSignal) => {
 	const exitCode = rawExitCode === null ? void 0 : rawExitCode;
 	const signal = rawSignal === null ? void 0 : rawSignal;
-	const signalDescription = signal === void 0 ? void 0 : getSignalDescription(rawSignal);
 	return {
 		exitCode,
 		signal,
-		signalDescription
+		signalDescription: signal === void 0 ? void 0 : getSignalDescription(rawSignal)
 	};
 };
 
@@ -3194,8 +3157,7 @@ function prettyMilliseconds(milliseconds, options) {
 	let result = [];
 	const floorDecimals = (value, decimalDigits) => {
 		const flooredInterimValue = Math.floor(value * 10 ** decimalDigits + SECOND_ROUNDING_EPSILON);
-		const flooredValue = Math.round(flooredInterimValue) / 10 ** decimalDigits;
-		return flooredValue.toFixed(decimalDigits);
+		return (Math.round(flooredInterimValue) / 10 ** decimalDigits).toFixed(decimalDigits);
 	};
 	const add = (value, long, short, valueString) => {
 		if ((result.length === 0 || !options.colonNotation) && isZero(value) && !(options.colonNotation && short === "m")) return;
@@ -3232,14 +3194,11 @@ function prettyMilliseconds(milliseconds, options) {
 		} else {
 			const millisecondsAndBelow = milliseconds$1 + microseconds / 1e3 + nanoseconds / 1e6;
 			const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === "number" ? options.millisecondsDecimalDigits : 0;
-			const roundedMilliseconds = millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
-			const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : roundedMilliseconds;
+			const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
 			add(Number.parseFloat(millisecondsString), "millisecond", "ms", millisecondsString);
 		}
 	} else {
-		const seconds = (isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds) / 1e3 % 60;
-		const secondsDecimalDigits = typeof options.secondsDecimalDigits === "number" ? options.secondsDecimalDigits : 1;
-		const secondsFixed = floorDecimals(seconds, secondsDecimalDigits);
+		const secondsFixed = floorDecimals((isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds) / 1e3 % 60, typeof options.secondsDecimalDigits === "number" ? options.secondsDecimalDigits : 1);
 		const secondsString = options.keepDecimalsOnWholeSeconds ? secondsFixed : secondsFixed.replace(/\.0+$/, "");
 		add(Number.parseFloat(secondsString), "second", "s", secondsString);
 	}
@@ -3268,10 +3227,9 @@ const logResult = (result, verboseInfo) => {
 	logDuration(result, verboseInfo);
 };
 const logDuration = (result, verboseInfo) => {
-	const verboseMessage = `(done in ${prettyMilliseconds(result.durationMs)})`;
 	verboseLog({
 		type: "duration",
-		verboseMessage,
+		verboseMessage: `(done in ${prettyMilliseconds(result.durationMs)})`,
 		verboseInfo,
 		result
 	});
@@ -3398,18 +3356,16 @@ const TYPE_TO_MESSAGE = {
 const getTransformObjectModes = (objectMode, index, newTransforms, direction) => direction === "output" ? getOutputObjectModes(objectMode, index, newTransforms) : getInputObjectModes(objectMode, index, newTransforms);
 const getOutputObjectModes = (objectMode, index, newTransforms) => {
 	const writableObjectMode = index !== 0 && newTransforms[index - 1].value.readableObjectMode;
-	const readableObjectMode = objectMode ?? writableObjectMode;
 	return {
 		writableObjectMode,
-		readableObjectMode
+		readableObjectMode: objectMode ?? writableObjectMode
 	};
 };
 const getInputObjectModes = (objectMode, index, newTransforms) => {
 	const writableObjectMode = index === 0 ? objectMode === true : newTransforms[index - 1].value.readableObjectMode;
-	const readableObjectMode = index !== newTransforms.length - 1 && (objectMode ?? writableObjectMode);
 	return {
 		writableObjectMode,
-		readableObjectMode
+		readableObjectMode: index !== newTransforms.length - 1 && (objectMode ?? writableObjectMode)
 	};
 };
 const getFdObjectMode = (stdioItems, direction) => {
@@ -3718,8 +3674,7 @@ const validateDuplicateStreamSync = ({ otherStdioItems, type, value, optionName,
 const getDuplicateStreamInstance = ({ otherStdioItems, type, value, optionName, direction }) => {
 	const duplicateStdioItems = otherStdioItems.filter((stdioItem) => hasSameValue(stdioItem, value));
 	if (duplicateStdioItems.length === 0) return;
-	const differentStdioItem = duplicateStdioItems.find((stdioItem) => stdioItem.direction !== direction);
-	throwOnDuplicateStream(differentStdioItem, optionName, type);
+	throwOnDuplicateStream(duplicateStdioItems.find((stdioItem) => stdioItem.direction !== direction), optionName, type);
 	return direction === "output" ? duplicateStdioItems[0].stream : void 0;
 };
 const hasSameValue = ({ type, value }, secondValue) => {
@@ -3728,8 +3683,7 @@ const hasSameValue = ({ type, value }, secondValue) => {
 	return value === secondValue;
 };
 const validateDuplicateTransform = ({ otherStdioItems, type, value, optionName }) => {
-	const duplicateStdioItem = otherStdioItems.find(({ value: { transform } }) => transform === value.transform);
-	throwOnDuplicateStream(duplicateStdioItem, optionName, type);
+	throwOnDuplicateStream(otherStdioItems.find(({ value: { transform } }) => transform === value.transform), optionName, type);
 };
 const throwOnDuplicateStream = (stdioItem, optionName, type) => {
 	if (stdioItem !== void 0) throw new TypeError(`The \`${stdioItem.optionName}\` and \`${optionName}\` options must not target ${TYPE_TO_MESSAGE[type]} that is the same.`);
@@ -3738,15 +3692,13 @@ const throwOnDuplicateStream = (stdioItem, optionName, type) => {
 //#endregion
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/stdio/handle.js
 const handleStdio = (addProperties$2, options, verboseInfo, isSync) => {
-	const stdio = normalizeStdioOption(options, verboseInfo, isSync);
-	const initialFileDescriptors = stdio.map((stdioOption, fdNumber) => getFileDescriptor({
-		stdioOption,
-		fdNumber,
-		options,
-		isSync
-	}));
 	const fileDescriptors = getFinalFileDescriptors({
-		initialFileDescriptors,
+		initialFileDescriptors: normalizeStdioOption(options, verboseInfo, isSync).map((stdioOption, fdNumber) => getFileDescriptor({
+			stdioOption,
+			fdNumber,
+			options,
+			isSync
+		})),
 		addProperties: addProperties$2,
 		options,
 		isSync
@@ -3763,14 +3715,13 @@ const getFileDescriptor = ({ stdioOption, fdNumber, options, isSync }) => {
 		optionName
 	});
 	const direction = getStreamDirection(initialStdioItems, fdNumber, optionName);
-	const stdioItems = initialStdioItems.map((stdioItem) => handleNativeStream({
+	const normalizedStdioItems = normalizeTransforms(initialStdioItems.map((stdioItem) => handleNativeStream({
 		stdioItem,
 		isStdioArray,
 		fdNumber,
 		direction,
 		isSync
-	}));
-	const normalizedStdioItems = normalizeTransforms(stdioItems, optionName, direction, options);
+	})), optionName, direction, options);
 	const objectMode = getFdObjectMode(normalizedStdioItems, direction);
 	validateFileObjectMode(normalizedStdioItems, objectMode);
 	return {
@@ -3780,9 +3731,7 @@ const getFileDescriptor = ({ stdioOption, fdNumber, options, isSync }) => {
 	};
 };
 const initializeStdioItems = ({ stdioOption, fdNumber, options, optionName }) => {
-	const values = Array.isArray(stdioOption) ? stdioOption : [stdioOption];
-	const initialStdioItems = [...values.map((value) => initializeStdioItem(value, optionName)), ...handleInputOptions(options, fdNumber)];
-	const stdioItems = filterDuplicates(initialStdioItems);
+	const stdioItems = filterDuplicates([...(Array.isArray(stdioOption) ? stdioOption : [stdioOption]).map((value) => initializeStdioItem(value, optionName)), ...handleInputOptions(options, fdNumber)]);
 	const isStdioArray = stdioItems.length > 1;
 	validateStdioArray(stdioItems, isStdioArray, optionName);
 	validateStreams(stdioItems);
@@ -3832,18 +3781,17 @@ const getFinalFileDescriptors = ({ initialFileDescriptors, addProperties: addPro
 	}
 };
 const getFinalFileDescriptor = ({ fileDescriptor: { direction, objectMode, stdioItems }, fileDescriptors, addProperties: addProperties$2, options, isSync }) => {
-	const finalStdioItems = stdioItems.map((stdioItem) => addStreamProperties({
-		stdioItem,
-		addProperties: addProperties$2,
-		direction,
-		options,
-		fileDescriptors,
-		isSync
-	}));
 	return {
 		direction,
 		objectMode,
-		stdioItems: finalStdioItems
+		stdioItems: stdioItems.map((stdioItem) => addStreamProperties({
+			stdioItem,
+			addProperties: addProperties$2,
+			direction,
+			options,
+			fileDescriptors,
+			isSync
+		}))
 	};
 };
 const addStreamProperties = ({ stdioItem, addProperties: addProperties$2, direction, options, fileDescriptors, isSync }) => {
@@ -3973,8 +3921,7 @@ const appendNewlineGenerator = function* ({ isWindowsNewline = false }, chunk) {
 		yield chunk;
 		return;
 	}
-	const newline = isWindowsNewline ? windowsNewline : unixNewline;
-	yield concatBytes(chunk, newline);
+	yield concatBytes(chunk, isWindowsNewline ? windowsNewline : unixNewline);
 };
 const concatString = (firstChunk, secondChunk) => `${firstChunk}${secondChunk}`;
 const linesStringInfo = {
@@ -4119,7 +4066,7 @@ const generatorToStream = ({ value, value: { transform, final, writableObjectMod
 	const transformMethod = transformAsync ? pushChunks.bind(void 0, transformChunk, state) : pushChunksSync.bind(void 0, transformChunkSync);
 	const finalMethod = transformAsync || finalAsync ? pushChunks.bind(void 0, finalChunks, state) : pushChunksSync.bind(void 0, finalChunksSync);
 	const destroyMethod = transformAsync || finalAsync ? destroyTransform.bind(void 0, state) : void 0;
-	const stream = new node_stream.Transform({
+	return { stream: new node_stream.Transform({
 		writableObjectMode,
 		writableHighWaterMark: (0, node_stream.getDefaultHighWaterMark)(writableObjectMode),
 		readableObjectMode,
@@ -4135,16 +4082,12 @@ const generatorToStream = ({ value, value: { transform, final, writableObjectMod
 			finalMethod([generators], this, done);
 		},
 		destroy: destroyMethod
-	});
-	return { stream };
+	}) };
 };
 const runGeneratorsSync = (chunks, stdioItems, encoding, isInput) => {
 	const generators = stdioItems.filter(({ type }) => type === "generator");
 	const reversedGenerators = isInput ? generators.reverse() : generators;
-	for (const { value, optionName } of reversedGenerators) {
-		const generators$1 = addInternalGenerators(value, encoding, optionName);
-		chunks = runTransformSync(generators$1, chunks);
-	}
+	for (const { value, optionName } of reversedGenerators) chunks = runTransformSync(addInternalGenerators(value, encoding, optionName), chunks);
 	return chunks;
 };
 const addInternalGenerators = ({ transform, final, binary, writableObjectMode, readableObjectMode, preserveNewlines }, encoding, optionName) => {
@@ -4181,9 +4124,7 @@ const addInputOptionSync = (fileDescriptors, fdNumber, options) => {
 		const [{ type, optionName }] = allStdioItems;
 		throw new TypeError(`Only the \`stdin\` option, not \`${optionName}\`, can be ${TYPE_TO_MESSAGE[type]} with synchronous methods.`);
 	}
-	const allContents = allStdioItems.map(({ contents }) => contents);
-	const transformedContents = allContents.map((contents) => applySingleInputGeneratorsSync(contents, stdioItems));
-	options.input = joinToUint8Array(transformedContents);
+	options.input = joinToUint8Array(allStdioItems.map(({ contents }) => contents).map((contents) => applySingleInputGeneratorsSync(contents, stdioItems)));
 };
 const applySingleInputGeneratorsSync = (contents, stdioItems) => {
 	const newContents = runGeneratorsSync(contents, stdioItems, "utf8", true);
@@ -4208,10 +4149,9 @@ const logLinesSync = (linesArray, fdNumber, verboseInfo) => {
 };
 const isPipingStream = (stream) => stream._readableState.pipes.length > 0;
 const logLine = (line, fdNumber, verboseInfo) => {
-	const verboseMessage = serializeVerboseMessage(line);
 	verboseLog({
 		type: "output",
-		verboseMessage,
+		verboseMessage: serializeVerboseMessage(line),
 		fdNumber,
 		verboseInfo
 	});
@@ -4223,28 +4163,25 @@ const transformOutputSync = ({ fileDescriptors, syncResult: { output }, options,
 	if (output === null) return { output: Array.from({ length: 3 }) };
 	const state = {};
 	const outputFiles = /* @__PURE__ */ new Set([]);
-	const transformedOutput = output.map((result, fdNumber) => transformOutputResultSync({
-		result,
-		fileDescriptors,
-		fdNumber,
-		state,
-		outputFiles,
-		isMaxBuffer,
-		verboseInfo
-	}, options));
 	return {
-		output: transformedOutput,
+		output: output.map((result, fdNumber) => transformOutputResultSync({
+			result,
+			fileDescriptors,
+			fdNumber,
+			state,
+			outputFiles,
+			isMaxBuffer,
+			verboseInfo
+		}, options)),
 		...state
 	};
 };
 const transformOutputResultSync = ({ result, fileDescriptors, fdNumber, state, outputFiles, isMaxBuffer, verboseInfo }, { buffer, encoding, lines, stripFinalNewline: stripFinalNewline$1, maxBuffer }) => {
 	if (result === null) return;
-	const truncatedResult = truncateMaxBufferSync(result, isMaxBuffer, maxBuffer);
-	const uint8ArrayResult = bufferToUint8Array(truncatedResult);
+	const uint8ArrayResult = bufferToUint8Array(truncateMaxBufferSync(result, isMaxBuffer, maxBuffer));
 	const { stdioItems, objectMode } = fileDescriptors[fdNumber];
-	const chunks = runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state);
 	const { serializedResult, finalResult = serializedResult } = serializeChunks({
-		chunks,
+		chunks: runOutputGeneratorsSync([uint8ArrayResult], stdioItems, encoding, state),
 		objectMode,
 		encoding,
 		lines,
@@ -4355,14 +4292,12 @@ const isFailedExit = (exitCode, signal) => exitCode !== 0 || signal !== null;
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/resolve/exit-sync.js
 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
+		timedOut: resultError?.code === "ETIMEDOUT",
+		isMaxBuffer: isMaxBufferSync(resultError, output, maxBuffer)
 	};
 };
 const getResultError = (error, exitCode, signal) => {
@@ -4374,7 +4309,7 @@ const getResultError = (error, exitCode, signal) => {
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/methods/main-sync.js
 const execaCoreSync = (rawFile, rawArguments, rawOptions) => {
 	const { file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors } = handleSyncArguments(rawFile, rawArguments, rawOptions);
-	const result = spawnSubprocessSync({
+	return handleResult(spawnSubprocessSync({
 		file,
 		commandArguments,
 		options,
@@ -4383,15 +4318,12 @@ const execaCoreSync = (rawFile, rawArguments, rawOptions) => {
 		verboseInfo,
 		fileDescriptors,
 		startTime
-	});
-	return handleResult(result, verboseInfo, options);
+	}), verboseInfo, options);
 };
 const handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
 	const { command, escapedCommand, startTime, verboseInfo } = handleCommand(rawFile, rawArguments, rawOptions);
-	const syncOptions = normalizeSyncOptions(rawOptions);
-	const { file, commandArguments, options } = normalizeOptions(rawFile, rawArguments, syncOptions);
+	const { file, commandArguments, options } = normalizeOptions(rawFile, rawArguments, normalizeSyncOptions(rawOptions));
 	validateSyncOptions(options);
-	const fileDescriptors = handleStdioSync(options, verboseInfo);
 	return {
 		file,
 		commandArguments,
@@ -4400,7 +4332,7 @@ const handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
 		startTime,
 		verboseInfo,
 		options,
-		fileDescriptors
+		fileDescriptors: handleStdioSync(options, verboseInfo)
 	};
 };
 const normalizeSyncOptions = (options) => options.node && !options.ipc ? {
@@ -4435,16 +4367,14 @@ const spawnSubprocessSync = ({ file, commandArguments, options, command, escaped
 		isMaxBuffer,
 		verboseInfo
 	});
-	const stdio = output.map((stdioOutput, fdNumber) => stripNewline(stdioOutput, options, fdNumber));
-	const all = stripNewline(getAllSync(output, options), options, "all");
 	return getSyncResult({
 		error,
 		exitCode,
 		signal,
 		timedOut,
 		isMaxBuffer,
-		stdio,
-		all,
+		stdio: output.map((stdioOutput, fdNumber) => stripNewline(stdioOutput, options, fdNumber)),
+		all: stripNewline(getAllSync(output, options), options, "all"),
 		options,
 		command,
 		escapedCommand,
@@ -4454,8 +4384,7 @@ const spawnSubprocessSync = ({ file, commandArguments, options, command, escaped
 const runSubprocessSync = ({ file, commandArguments, options, command, escapedCommand, fileDescriptors, startTime }) => {
 	try {
 		addInputOptionsSync(fileDescriptors, options);
-		const normalizedOptions = normalizeSpawnSyncOptions(options);
-		return (0, node_child_process.spawnSync)(file, commandArguments, normalizedOptions);
+		return (0, node_child_process.spawnSync)(file, commandArguments, normalizeSpawnSyncOptions(options));
 	} catch (error) {
 		return makeEarlyError({
 			error,
@@ -4673,19 +4602,17 @@ const handleEarlyError = ({ error, command, escapedCommand, fileDescriptors, opt
 		writable,
 		duplex
 	});
-	const earlyError = makeEarlyError({
-		error,
-		command,
-		escapedCommand,
-		fileDescriptors,
-		options,
-		startTime,
-		isSync: false
-	});
-	const promise = handleDummyPromise(earlyError, verboseInfo, options);
 	return {
 		subprocess,
-		promise
+		promise: handleDummyPromise(makeEarlyError({
+			error,
+			command,
+			escapedCommand,
+			fileDescriptors,
+			options,
+			startTime,
+			isSync: false
+		}), verboseInfo, options)
 	};
 };
 const createDummyStreams = (subprocess, fileDescriptors) => {
@@ -4734,8 +4661,7 @@ const addProperties = {
 	nodeStream: ({ value }) => ({ stream: value }),
 	webTransform({ value: { transform, writableObjectMode, readableObjectMode } }) {
 		const objectMode = writableObjectMode || readableObjectMode;
-		const stream = node_stream.Duplex.fromWeb(transform, { objectMode });
-		return { stream };
+		return { stream: node_stream.Duplex.fromWeb(transform, { objectMode }) };
 	},
 	duplex: ({ value: { transform } }) => ({ stream: transform }),
 	native() {}
@@ -4981,10 +4907,7 @@ const pipeOutputAsync = (subprocess, fileDescriptors, controller) => {
 			controller
 		});
 	}
-	for (const [outputStream, inputStreams] of pipeGroups.entries()) {
-		const inputStream = inputStreams.length === 1 ? inputStreams[0] : mergeStreams(inputStreams);
-		pipeStreams(inputStream, outputStream);
-	}
+	for (const [outputStream, inputStreams] of pipeGroups.entries()) pipeStreams(inputStreams.length === 1 ? inputStreams[0] : mergeStreams(inputStreams), outputStream);
 };
 const pipeTransform = (subprocess, stream, direction, fdNumber) => {
 	if (direction === "output") pipeStreams(subprocess.stdio[fdNumber], stream);
@@ -5246,10 +5169,9 @@ const normalizePipeArguments = ({ source, sourcePromise, boundOptions, createNes
 const getDestinationStream = (boundOptions, createNested, pipeArguments) => {
 	try {
 		const { destination, pipeOptions: { from, to, unpipeSignal } = {} } = getDestination(boundOptions, createNested, ...pipeArguments);
-		const destinationStream = getToStream(destination, to);
 		return {
 			destination,
-			destinationStream,
+			destinationStream: getToStream(destination, to),
 			from,
 			unpipeSignal
 		};
@@ -5258,19 +5180,15 @@ const getDestinationStream = (boundOptions, createNested, pipeArguments) => {
 	}
 };
 const getDestination = (boundOptions, createNested, firstArgument, ...pipeArguments) => {
-	if (Array.isArray(firstArgument)) {
-		const destination = createNested(mapDestinationArguments, boundOptions)(firstArgument, ...pipeArguments);
-		return {
-			destination,
-			pipeOptions: boundOptions
-		};
-	}
+	if (Array.isArray(firstArgument)) return {
+		destination: createNested(mapDestinationArguments, boundOptions)(firstArgument, ...pipeArguments),
+		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,
+			destination: createNested(mapDestinationArguments)(rawFile, rawArguments, rawOptions),
 			pipeOptions: rawOptions
 		};
 	}
@@ -5290,8 +5208,7 @@ const mapDestinationArguments = ({ options }) => ({ options: {
 } });
 const getSourceStream = (source, from) => {
 	try {
-		const sourceStream = getFromStream(source, from);
-		return { sourceStream };
+		return { sourceStream: getFromStream(source, from) };
 	} catch (error) {
 		return { sourceError: error };
 	}
@@ -5385,9 +5302,8 @@ const unpipeOnAbort = (unpipeSignal, unpipeContext) => unpipeSignal === void 0 ?
 const unpipeOnSignalAbort = async (unpipeSignal, { sourceStream, mergedStream, fileDescriptors, sourceOptions, startTime }) => {
 	await (0, node_util.aborted)(unpipeSignal, sourceStream);
 	await mergedStream.remove(sourceStream);
-	const error = /* @__PURE__ */ new Error("Pipe canceled by `unpipeSignal` option.");
 	throw createNonCommandError({
-		error,
+		error: /* @__PURE__ */ new Error("Pipe canceled by `unpipeSignal` option."),
 		fileDescriptors,
 		sourceOptions,
 		startTime
@@ -5490,13 +5406,12 @@ const stopReadingOnStreamEnd = async (onStreamEnd, controller, stream) => {
 	}
 };
 const iterateOnStream = ({ stream, controller, binary, shouldEncode, encoding, shouldSplit, preserveNewlines }) => {
-	const onStdoutChunk = (0, node_events.on)(stream, "data", {
-		signal: controller.signal,
-		highWaterMark: HIGH_WATER_MARK,
-		highWatermark: HIGH_WATER_MARK
-	});
 	return iterateOnData({
-		onStdoutChunk,
+		onStdoutChunk: (0, node_events.on)(stream, "data", {
+			signal: controller.signal,
+			highWaterMark: HIGH_WATER_MARK,
+			highWatermark: HIGH_WATER_MARK
+		}),
 		controller,
 		binary,
 		shouldEncode,
@@ -5541,13 +5456,12 @@ const getStreamOutput = async ({ stream, onStreamEnd, fdNumber, encoding, buffer
 		await Promise.all([resumeStream(stream), logPromise]);
 		return;
 	}
-	const stripFinalNewlineValue = getStripFinalNewline(stripFinalNewline$1, fdNumber);
 	const iterable = iterateForResult({
 		stream,
 		onStreamEnd,
 		lines,
 		encoding,
-		stripFinalNewline: stripFinalNewlineValue,
+		stripFinalNewline: getStripFinalNewline(stripFinalNewline$1, fdNumber),
 		allMixed
 	});
 	const [output] = await Promise.all([getStreamContents({
@@ -5567,15 +5481,14 @@ const logOutputAsync = async ({ stream, onStreamEnd, fdNumber, encoding, allMixe
 		verboseInfo,
 		fdNumber
 	})) return;
-	const linesIterable = iterateForResult({
+	await logLines(iterateForResult({
 		stream,
 		onStreamEnd,
 		lines: true,
 		encoding,
 		stripFinalNewline: true,
 		allMixed
-	});
-	await logLines(linesIterable, stream, fdNumber, verboseInfo);
+	}), stream, fdNumber, verboseInfo);
 };
 const resumeStream = async (stream) => {
 	await (0, node_timers_promises.setImmediate)();
@@ -5725,10 +5638,9 @@ const getAllMixed = ({ all, stdout, stderr }) => all && stdout && stderr && stdo
 //#region ../../node_modules/.pnpm/execa@9.5.2/node_modules/execa/lib/verbose/ipc.js
 const shouldLogIpc = (verboseInfo) => isFullVerbose(verboseInfo, "ipc");
 const logIpcOutput = (message, verboseInfo) => {
-	const verboseMessage = serializeVerboseMessage(message);
 	verboseLog({
 		type: "ipc",
-		verboseMessage,
+		verboseMessage: serializeVerboseMessage(message),
 		fdNumber: "ipc",
 		verboseInfo
 	});
@@ -5871,9 +5783,8 @@ const addConcurrentStream = (concurrentStreams, stream, waitName) => {
 	const promises = weakMap.get(stream);
 	const promise = createDeferred();
 	promises.push(promise);
-	const resolve = promise.resolve.bind(promise);
 	return {
-		resolve,
+		resolve: promise.resolve.bind(promise),
 		promises
 	};
 };
@@ -5954,10 +5865,9 @@ const createReadable = ({ subprocess, concurrentStreams, encoding }, { from, bin
 };
 const getSubprocessStdout = (subprocess, from, concurrentStreams) => {
 	const subprocessStdout = getFromStream(subprocess, from);
-	const waitReadableDestroy = addConcurrentStream(concurrentStreams, subprocessStdout, "readableDestroy");
 	return {
 		subprocessStdout,
-		waitReadableDestroy
+		waitReadableDestroy: addConcurrentStream(concurrentStreams, subprocessStdout, "readableDestroy")
 	};
 };
 const getReadableOptions = ({ readableEncoding, readableObjectMode, readableHighWaterMark }, binary) => binary ? {
@@ -6035,12 +5945,10 @@ const createWritable = ({ subprocess, concurrentStreams }, { to } = {}) => {
 };
 const getSubprocessStdin = (subprocess, to, concurrentStreams) => {
 	const subprocessStdin = getToStream(subprocess, to);
-	const waitWritableFinal = addConcurrentStream(concurrentStreams, subprocessStdin, "writableFinal");
-	const waitWritableDestroy = addConcurrentStream(concurrentStreams, subprocessStdin, "writableDestroy");
 	return {
 		subprocessStdin,
-		waitWritableFinal,
-		waitWritableDestroy
+		waitWritableFinal: addConcurrentStream(concurrentStreams, subprocessStdin, "writableFinal"),
+		waitWritableDestroy: addConcurrentStream(concurrentStreams, subprocessStdin, "writableDestroy")
 	};
 };
 const getWritableMethods = (subprocessStdin, subprocess, waitWritableFinal) => ({
@@ -6136,15 +6044,14 @@ const onDuplexDestroy = async ({ subprocessStdout, subprocessStdin, subprocess,
 const createIterable = (subprocess, encoding, { from, binary: binaryOption = false, preserveNewlines = false } = {}) => {
 	const binary = binaryOption || BINARY_ENCODINGS.has(encoding);
 	const subprocessStdout = getFromStream(subprocess, from);
-	const onStdoutData = iterateOnSubprocessStream({
+	return iterateOnStdoutData(iterateOnSubprocessStream({
 		subprocessStdout,
 		subprocess,
 		binary,
 		shouldEncode: true,
 		encoding,
 		preserveNewlines
-	});
-	return iterateOnStdoutData(onStdoutData, subprocessStdout, subprocess);
+	}), subprocessStdout, subprocess);
 };
 const iterateOnStdoutData = async function* (onStdoutData, subprocessStdout, subprocess) {
 	try {
@@ -6226,7 +6133,6 @@ const handleAsyncArguments = (rawFile, rawArguments, rawOptions) => {
 	const { command, escapedCommand, startTime, verboseInfo } = handleCommand(rawFile, rawArguments, rawOptions);
 	const { file, commandArguments, options: normalizedOptions } = normalizeOptions(rawFile, rawArguments, rawOptions);
 	const options = handleAsyncOptions(normalizedOptions);
-	const fileDescriptors = handleStdioAsync(options, verboseInfo);
 	return {
 		file,
 		commandArguments,
@@ -6235,7 +6141,7 @@ const handleAsyncArguments = (rawFile, rawArguments, rawOptions) => {
 		startTime,
 		verboseInfo,
 		options,
-		fileDescriptors
+		fileDescriptors: handleStdioAsync(options, verboseInfo)
 	};
 };
 const handleAsyncOptions = ({ timeout, signal,...options }) => {
@@ -6308,22 +6214,19 @@ const handlePromise = async ({ subprocess, options, startTime, verboseInfo, file
 	});
 	controller.abort();
 	onInternalError.resolve();
-	const stdio = stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber));
-	const all = stripNewline(allResult, options, "all");
-	const result = getAsyncResult({
+	return handleResult(getAsyncResult({
 		errorInfo,
 		exitCode,
 		signal,
-		stdio,
-		all,
+		stdio: stdioResults.map((stdioResult, fdNumber) => stripNewline(stdioResult, options, fdNumber)),
+		all: stripNewline(allResult, options, "all"),
 		ipcOutput,
 		context,
 		options,
 		command,
 		escapedCommand,
 		startTime
-	});
-	return handleResult(result, verboseInfo, options);
+	}), verboseInfo, options);
 };
 const getAsyncResult = ({ errorInfo, exitCode, signal, stdio, all, ipcOutput, context, options, command, escapedCommand, startTime }) => "error" in errorInfo ? makeError({
 	error: errorInfo.error,
@@ -6396,8 +6299,7 @@ const callBoundExeca = ({ mapArguments, deepOptions = {}, boundOptions = {}, set
 	return isSync ? execaCoreSync(file, commandArguments, options) : execaCoreAsync(file, commandArguments, options, createNested);
 };
 const parseArguments = ({ mapArguments, firstArgument, nextArguments, deepOptions, boundOptions }) => {
-	const callArguments = isTemplateString(firstArgument) ? parseTemplates(firstArgument, nextArguments) : [firstArgument, ...nextArguments];
-	const [initialFile, initialArguments, initialOptions] = normalizeParameters(...callArguments);
+	const [initialFile, initialArguments, initialOptions] = normalizeParameters(...isTemplateString(firstArgument) ? parseTemplates(firstArgument, nextArguments) : [firstArgument, ...nextArguments]);
 	const mergedOptions = mergeOptions(mergeOptions(deepOptions, boundOptions), initialOptions);
 	const { file = initialFile, commandArguments = initialArguments, options = mergedOptions, isSync = false } = mapArguments({
 		file: initialFile,
@@ -6493,15 +6395,14 @@ const runBundle = async ({ entryFile, cwd, platform: platform$1, buildPath, sour
 	__hot_updater_plugin_core.log.normal("\n");
 	let stdout = null;
 	try {
-		const result = await execa("npx", args, {
+		stdout = (await execa("npx", args, {
 			cwd,
 			env: {
 				...process.env,
 				BUILD_OUT_DIR: buildPath
 			},
 			reject: true
-		});
-		stdout = result.stdout;
+		})).stdout;
 	} catch (error) {
 		if (error instanceof ExecaError) throw error.stderr;
 	}