@karmaniverous/get-dotenv 4.5.0 → 4.5.1

package/dist/getdotenv.cli.mjs

@@ -6,8 +6,8 @@ import fs$v, { writeFileSync as writeFileSync$1, statSync as statSync$1, readFil
 import process$3, { platform as platform$1, hrtime, execPath, execArgv } from 'node:process';
 import { fileURLToPath } from 'node:url';
 import { StringDecoder } from 'node:string_decoder';
-import tty from 'node:tty';
 import { debuglog, stripVTControlCharacters, inspect, promisify as promisify$1, callbackify, aborted } from 'node:util';
+import tty from 'node:tty';
 import require$$0$3 from 'child_process';
 import require$$0$2, { join } from 'path';
 import require$$0$1 from 'fs';
@@ -4120,56 +4120,220 @@ const getSubprocessResult = ({stdout}) => {
 	throw new TypeError(`Unexpected "${typeof stdout}" stdout in template expression`);
 };
 
-// eslint-disable-next-line no-warning-comments
-// TODO: Use a better method when it's added to Node.js (https://github.com/nodejs/node/pull/40240)
-const hasColors = tty.WriteStream.prototype.hasColors();
+const isStandardStream = stream => STANDARD_STREAMS.includes(stream);
+const STANDARD_STREAMS = [process$3.stdin, process$3.stdout, process$3.stderr];
+const STANDARD_STREAMS_ALIASES = ['stdin', 'stdout', 'stderr'];
+const getStreamName = fdNumber => STANDARD_STREAMS_ALIASES[fdNumber] ?? `stdio[${fdNumber}]`;
 
-// Intentionally not using template literal for performance.
-const format = (startCode, endCode) => hasColors ? string => '\u001B[' + startCode + 'm' + string + '\u001B[' + endCode + 'm' : string => string;
-const bold = format(1, 22);
-const gray = format(90, 39);
+// Some options can have different values for `stdout`/`stderr`/`fd3`.
+// This normalizes those to array of values.
+// For example, `{verbose: {stdout: 'none', stderr: 'full'}}` becomes `{verbose: ['none', 'none', 'full']}`
+const normalizeFdSpecificOptions = options => {
+	const optionsCopy = {...options};
 
-const redBright = format(91, 39);
-const yellowBright = format(93, 39);
+	for (const optionName of FD_SPECIFIC_OPTIONS) {
+		optionsCopy[optionName] = normalizeFdSpecificOption(options, optionName);
+	}
+
+	return optionsCopy;
+};
+
+const normalizeFdSpecificOption = (options, optionName) => {
+	const optionBaseArray = Array.from({length: getStdioLength(options) + 1});
+	const optionArray = normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName);
+	return addDefaultValue$1(optionArray, 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);
+
+const normalizeOptionObject = (optionValue, optionArray, optionName) => {
+	for (const fdName of Object.keys(optionValue).sort(compareFdName)) {
+		for (const fdNumber of parseFdName(fdName, optionName, optionArray)) {
+			optionArray[fdNumber] = optionValue[fdName];
+		}
+	}
+
+	return optionArray;
+};
+
+// Ensure priority order when setting both `stdout`/`stderr`, `fd1`/`fd2`, and `all`
+const compareFdName = (fdNameA, fdNameB) => getFdNameOrder(fdNameA) < getFdNameOrder(fdNameB) ? 1 : -1;
+
+const getFdNameOrder = fdName => {
+	if (fdName === 'stdout' || fdName === 'stderr') {
+		return 0;
+	}
+
+	return fdName === 'all' ? 2 : 1;
+};
+
+const parseFdName = (fdName, optionName, optionArray) => {
+	if (fdName === 'ipc') {
+		return [optionArray.length - 1];
+	}
+
+	const fdNumber = parseFd(fdName);
+	if (fdNumber === undefined || fdNumber === 0) {
+		throw new TypeError(`"${optionName}.${fdName}" is invalid.
+It must be "${optionName}.stdout", "${optionName}.stderr", "${optionName}.all", "${optionName}.ipc", or "${optionName}.fd3", "${optionName}.fd4" (and so on).`);
+	}
+
+	if (fdNumber >= optionArray.length) {
+		throw new TypeError(`"${optionName}.${fdName}" is invalid: that file descriptor does not exist.
+Please set the "stdio" option to ensure that file descriptor exists.`);
+	}
+
+	return fdNumber === 'all' ? [1, 2] : [fdNumber];
+};
+
+// Use the same syntax for fd-specific options and the `from`/`to` options
+const parseFd = fdName => {
+	if (fdName === 'all') {
+		return fdName;
+	}
+
+	if (STANDARD_STREAMS_ALIASES.includes(fdName)) {
+		return STANDARD_STREAMS_ALIASES.indexOf(fdName);
+	}
+
+	const regexpResult = FD_REGEXP.exec(fdName);
+	if (regexpResult !== null) {
+		return Number(regexpResult[1]);
+	}
+};
+
+const FD_REGEXP = /^fd(\d+)$/;
+
+const addDefaultValue$1 = (optionArray, optionName) => optionArray.map(optionValue => optionValue === undefined
+	? DEFAULT_OPTIONS[optionName]
+	: optionValue);
 
 // Default value for the `verbose` option
 const verboseDefault = debuglog('execa').enabled ? 'full' : 'none';
 
-// Information computed before spawning, used by the `verbose` option
-const getVerboseInfo = verbose => {
-	const verboseId = isVerbose(verbose) ? VERBOSE_ID++ : undefined;
-	validateVerbose(verbose);
-	return {verbose, verboseId};
+const DEFAULT_OPTIONS = {
+	lines: false,
+	buffer: true,
+	maxBuffer: 1000 * 1000 * 100,
+	verbose: verboseDefault,
+	stripFinalNewline: true,
 };
 
-// Prepending the `pid` is useful when multiple commands print their output at the same time.
-// However, we cannot use the real PID since this is not available with `child_process.spawnSync()`.
-// Also, we cannot use the real PID if we want to print it before `child_process.spawn()` is run.
-// As a pro, it is shorter than a normal PID and never re-uses the same id.
-// As a con, it cannot be used to send signals.
-let VERBOSE_ID = 0n;
+// List of options which can have different values for `stdout`/`stderr`
+const FD_SPECIFIC_OPTIONS = ['lines', 'buffer', 'maxBuffer', 'verbose', 'stripFinalNewline'];
+
+// Retrieve fd-specific option
+const getFdSpecificValue = (optionArray, fdNumber) => fdNumber === 'ipc'
+	? optionArray.at(-1)
+	: optionArray[fdNumber];
 
 // The `verbose` option can have different values for `stdout`/`stderr`
-const isVerbose = verbose => verbose.some(fdVerbose => fdVerbose !== 'none');
+const isVerbose = ({verbose}, fdNumber) => getFdVerbose(verbose, fdNumber) !== 'none';
 
-const validateVerbose = verbose => {
-	for (const verboseItem of verbose) {
-		if (verboseItem === false) {
-			throw new TypeError('The "verbose: false" option was renamed to "verbose: \'none\'".');
-		}
+// Whether IPC and output and logged
+const isFullVerbose = ({verbose}, fdNumber) => !['none', 'short'].includes(getFdVerbose(verbose, fdNumber));
 
-		if (verboseItem === true) {
-			throw new TypeError('The "verbose: true" option was renamed to "verbose: \'short\'".');
-		}
+// The `verbose` option can be a function to customize logging
+const getVerboseFunction = ({verbose}, fdNumber) => {
+	const fdVerbose = getFdVerbose(verbose, fdNumber);
+	return isVerboseFunction(fdVerbose) ? fdVerbose : undefined;
+};
 
-		if (!VERBOSE_VALUES.has(verboseItem)) {
-			const allowedValues = [...VERBOSE_VALUES].map(allowedValue => `'${allowedValue}'`).join(', ');
-			throw new TypeError(`The "verbose" option must not be ${verboseItem}. Allowed values are: ${allowedValues}.`);
-		}
+// When using `verbose: {stdout, stderr, fd3, ipc}`:
+//  - `verbose.stdout|stderr|fd3` is used for 'output'
+//  - `verbose.ipc` is only used for 'ipc'
+//  - highest `verbose.*` value is used for 'command', 'error' and 'duration'
+const getFdVerbose = (verbose, fdNumber) => fdNumber === undefined
+	? getFdGenericVerbose(verbose)
+	: getFdSpecificValue(verbose, fdNumber);
+
+// When using `verbose: {stdout, stderr, fd3, ipc}` and logging is not specific to a file descriptor.
+// We then use the highest `verbose.*` value, using the following order:
+//  - function > 'full' > 'short' > 'none'
+//  - if several functions are defined: stdout > stderr > fd3 > ipc
+const getFdGenericVerbose = verbose => verbose.find(fdVerbose => isVerboseFunction(fdVerbose))
+	?? VERBOSE_VALUES.findLast(fdVerbose => verbose.includes(fdVerbose));
+
+// Whether the `verbose` option is customized using a function
+const isVerboseFunction = fdVerbose => typeof fdVerbose === 'function';
+
+const VERBOSE_VALUES = ['none', 'short', 'full'];
+
+// Compute `result.command` and `result.escapedCommand`
+const joinCommand = (filePath, rawArguments) => {
+	const fileAndArguments = [filePath, ...rawArguments];
+	const command = fileAndArguments.join(' ');
+	const escapedCommand = fileAndArguments
+		.map(fileAndArgument => quoteString(escapeControlCharacters(fileAndArgument)))
+		.join(' ');
+	return {command, escapedCommand};
+};
+
+// Remove ANSI sequences and escape control characters and newlines
+const escapeLines = lines => stripVTControlCharacters(lines)
+	.split('\n')
+	.map(line => escapeControlCharacters(line))
+	.join('\n');
+
+const escapeControlCharacters = line => line.replaceAll(SPECIAL_CHAR_REGEXP, character => escapeControlCharacter(character));
+
+const escapeControlCharacter = character => {
+	const commonEscape = COMMON_ESCAPES[character];
+	if (commonEscape !== undefined) {
+		return commonEscape;
+	}
+
+	const codepoint = character.codePointAt(0);
+	const codepointHex = codepoint.toString(16);
+	return codepoint <= ASTRAL_START
+		? `\\u${codepointHex.padStart(4, '0')}`
+		: `\\U${codepointHex}`;
+};
+
+// Characters that would create issues when printed are escaped using the \u or \U notation.
+// Those include control characters and newlines.
+// The \u and \U notation is Bash specific, but there is no way to do this in a shell-agnostic way.
+// Some shells do not even have a way to print those characters in an escaped fashion.
+// Therefore, we prioritize printing those safely, instead of allowing those to be copy-pasted.
+// List of Unicode character categories: https://www.fileformat.info/info/unicode/category/index.htm
+const SPECIAL_CHAR_REGEXP = /\p{Separator}|\p{Other}/gu;
+
+// Accepted by $'...' in Bash.
+// Exclude \a \e \v which are accepted in Bash but not in JavaScript (except \v) and JSON.
+const COMMON_ESCAPES = {
+	' ': ' ',
+	'\b': '\\b',
+	'\f': '\\f',
+	'\n': '\\n',
+	'\r': '\\r',
+	'\t': '\\t',
+};
+
+// Up until that codepoint, \u notation can be used instead of \U
+const ASTRAL_START = 65_535;
+
+// Some characters are shell-specific, i.e. need to be escaped when the command is copy-pasted then run.
+// Escaping is shell-specific. We cannot know which shell is used: `process.platform` detection is not enough.
+// For example, Windows users could be using `cmd.exe`, Powershell or Bash for Windows which all use different escaping.
+// We use '...' on Unix, which is POSIX shell compliant and escape all characters but ' so this is fairly safe.
+// On Windows, we assume cmd.exe is used and escape with "...", which also works with Powershell.
+const quoteString = escapedArgument => {
+	if (NO_ESCAPE_REGEXP.test(escapedArgument)) {
+		return escapedArgument;
 	}
+
+	return platform$1 === 'win32'
+		? `"${escapedArgument.replaceAll('"', '""')}"`
+		: `'${escapedArgument.replaceAll('\'', '\'\\\'\'')}'`;
 };
 
-const VERBOSE_VALUES = new Set(['none', 'short', 'full']);
+const NO_ESCAPE_REGEXP = /^[\w./-]+$/;
 
 function isUnicodeSupported() {
 	if (process$3.platform !== 'win32') {
@@ -4463,120 +4627,126 @@ const fallbackSymbols = {...common$7, ...specialFallbackSymbols};
 const shouldUseMain = isUnicodeSupported();
 const figures = shouldUseMain ? mainSymbols : fallbackSymbols;
 
-// Compute `result.command` and `result.escapedCommand`
-const joinCommand = (filePath, rawArguments) => {
-	const fileAndArguments = [filePath, ...rawArguments];
-	const command = fileAndArguments.join(' ');
-	const escapedCommand = fileAndArguments
-		.map(fileAndArgument => quoteString(escapeControlCharacters(fileAndArgument)))
-		.join(' ');
-	return {command, escapedCommand};
+// eslint-disable-next-line no-warning-comments
+// TODO: Use a better method when it's added to Node.js (https://github.com/nodejs/node/pull/40240)
+const hasColors = tty.WriteStream.prototype.hasColors();
+
+// Intentionally not using template literal for performance.
+const format = (startCode, endCode) => hasColors ? string => '\u001B[' + startCode + 'm' + string + '\u001B[' + endCode + 'm' : string => string;
+const bold = format(1, 22);
+const gray = format(90, 39);
+
+const redBright = format(91, 39);
+const yellowBright = format(93, 39);
+
+// Default when `verbose` is not a function
+const defaultVerboseFunction = ({
+	type,
+	message,
+	timestamp,
+	piped,
+	commandId,
+	result: {failed = false} = {},
+	options: {reject = true},
+}) => {
+	const timestampString = serializeTimestamp(timestamp);
+	const icon = ICONS[type]({failed, reject, piped});
+	const color = COLORS[type]({reject});
+	return `${gray(`[${timestampString}]`)} ${gray(`[${commandId}]`)} ${color(icon)} ${color(message)}`;
 };
 
-// Remove ANSI sequences and escape control characters and newlines
-const escapeLines = lines => stripVTControlCharacters(lines)
-	.split('\n')
-	.map(line => escapeControlCharacters(line))
-	.join('\n');
+// Prepending the timestamp allows debugging the slow paths of a subprocess
+const serializeTimestamp = timestamp => `${padField(timestamp.getHours(), 2)}:${padField(timestamp.getMinutes(), 2)}:${padField(timestamp.getSeconds(), 2)}.${padField(timestamp.getMilliseconds(), 3)}`;
 
-const escapeControlCharacters = line => line.replaceAll(SPECIAL_CHAR_REGEXP, character => escapeControlCharacter(character));
+const padField = (field, padding) => String(field).padStart(padding, '0');
 
-const escapeControlCharacter = character => {
-	const commonEscape = COMMON_ESCAPES[character];
-	if (commonEscape !== undefined) {
-		return commonEscape;
+const getFinalIcon = ({failed, reject}) => {
+	if (!failed) {
+		return figures.tick;
 	}
 
-	const codepoint = character.codePointAt(0);
-	const codepointHex = codepoint.toString(16);
-	return codepoint <= ASTRAL_START
-		? `\\u${codepointHex.padStart(4, '0')}`
-		: `\\U${codepointHex}`;
+	return reject ? figures.cross : figures.warning;
 };
 
-// Characters that would create issues when printed are escaped using the \u or \U notation.
-// Those include control characters and newlines.
-// The \u and \U notation is Bash specific, but there is no way to do this in a shell-agnostic way.
-// Some shells do not even have a way to print those characters in an escaped fashion.
-// Therefore, we prioritize printing those safely, instead of allowing those to be copy-pasted.
-// List of Unicode character categories: https://www.fileformat.info/info/unicode/category/index.htm
-const SPECIAL_CHAR_REGEXP = /\p{Separator}|\p{Other}/gu;
+const ICONS = {
+	command: ({piped}) => piped ? '|' : '$',
+	output: () => ' ',
+	ipc: () => '*',
+	error: getFinalIcon,
+	duration: getFinalIcon,
+};
 
-// Accepted by $'...' in Bash.
-// Exclude \a \e \v which are accepted in Bash but not in JavaScript (except \v) and JSON.
-const COMMON_ESCAPES = {
-	' ': ' ',
-	'\b': '\\b',
-	'\f': '\\f',
-	'\n': '\\n',
-	'\r': '\\r',
-	'\t': '\\t',
+const identity$1 = string => string;
+
+const COLORS = {
+	command: () => bold,
+	output: () => identity$1,
+	ipc: () => identity$1,
+	error: ({reject}) => reject ? redBright : yellowBright,
+	duration: () => gray,
 };
 
-// Up until that codepoint, \u notation can be used instead of \U
-const ASTRAL_START = 65_535;
+// Apply the `verbose` function on each line
+const applyVerboseOnLines = (printedLines, verboseInfo, fdNumber) => {
+	const verboseFunction = getVerboseFunction(verboseInfo, fdNumber);
+	return printedLines
+		.map(({verboseLine, verboseObject}) => applyVerboseFunction(verboseLine, verboseObject, verboseFunction))
+		.filter(printedLine => printedLine !== undefined)
+		.map(printedLine => appendNewline(printedLine))
+		.join('');
+};
 
-// Some characters are shell-specific, i.e. need to be escaped when the command is copy-pasted then run.
-// Escaping is shell-specific. We cannot know which shell is used: `process.platform` detection is not enough.
-// For example, Windows users could be using `cmd.exe`, Powershell or Bash for Windows which all use different escaping.
-// We use '...' on Unix, which is POSIX shell compliant and escape all characters but ' so this is fairly safe.
-// On Windows, we assume cmd.exe is used and escape with "...", which also works with Powershell.
-const quoteString = escapedArgument => {
-	if (NO_ESCAPE_REGEXP.test(escapedArgument)) {
-		return escapedArgument;
+const applyVerboseFunction = (verboseLine, verboseObject, verboseFunction) => {
+	if (verboseFunction === undefined) {
+		return verboseLine;
 	}
 
-	return platform$1 === 'win32'
-		? `"${escapedArgument.replaceAll('"', '""')}"`
-		: `'${escapedArgument.replaceAll('\'', '\'\\\'\'')}'`;
+	const printedLine = verboseFunction(verboseLine, verboseObject);
+	if (typeof printedLine === 'string') {
+		return printedLine;
+	}
 };
 
-const NO_ESCAPE_REGEXP = /^[\w./-]+$/;
+const appendNewline = printedLine => printedLine.endsWith('\n')
+	? printedLine
+	: `${printedLine}\n`;
 
 // Write synchronously to ensure lines are properly ordered and not interleaved with `stdout`
-const verboseLog = (string, verboseId, icon, color) => {
-	const prefixedLines = addPrefix(string, verboseId, icon, color);
-	writeFileSync$1(STDERR_FD, `${prefixedLines}\n`);
+const verboseLog = ({type, verboseMessage, fdNumber, verboseInfo, result}) => {
+	const verboseObject = getVerboseObject({type, result, verboseInfo});
+	const printedLines = getPrintedLines(verboseMessage, verboseObject);
+	const finalLines = applyVerboseOnLines(printedLines, verboseInfo, fdNumber);
+	writeFileSync$1(STDERR_FD, finalLines);
 };
 
-const STDERR_FD = 2;
-
-const addPrefix = (string, verboseId, icon, color) => string.includes('\n')
-	? string
-		.split('\n')
-		.map(line => addPrefixToLine(line, verboseId, icon, color))
-		.join('\n')
-	: addPrefixToLine(string, verboseId, icon, color);
-
-const addPrefixToLine = (line, verboseId, icon, color = identity$1) => [
-	gray(`[${getTimestamp()}]`),
-	gray(`[${verboseId}]`),
-	color(ICONS[icon]),
-	color(line),
-].join(' ');
+const getVerboseObject = ({
+	type,
+	result,
+	verboseInfo: {escapedCommand, commandId, rawOptions: {piped = false, ...options}},
+}) => ({
+	type,
+	escapedCommand,
+	commandId: `${commandId}`,
+	timestamp: new Date(),
+	piped,
+	result,
+	options,
+});
 
-const identity$1 = string => string;
+const getPrintedLines = (verboseMessage, verboseObject) => verboseMessage
+	.split('\n')
+	.map(message => getPrintedLine({...verboseObject, message}));
 
-// Prepending the timestamp allows debugging the slow paths of a subprocess
-const getTimestamp = () => {
-	const date = new Date();
-	return `${padField(date.getHours(), 2)}:${padField(date.getMinutes(), 2)}:${padField(date.getSeconds(), 2)}.${padField(date.getMilliseconds(), 3)}`;
+const getPrintedLine = verboseObject => {
+	const verboseLine = defaultVerboseFunction(verboseObject);
+	return {verboseLine, verboseObject};
 };
 
-const padField = (field, padding) => String(field).padStart(padding, '0');
-
-const ICONS = {
-	command: '$',
-	pipedCommand: '|',
-	output: ' ',
-	ipc: '*',
-	error: figures.cross,
-	warning: figures.warning,
-	success: figures.tick,
-};
+// Unless a `verbose` function is used, print all logs on `stderr`
+const STDERR_FD = 2;
 
 // Serialize any type to a line string, for logging
-const serializeLogMessage = message => {
+const serializeVerboseMessage = message => {
 	const messageString = typeof message === 'string' ? message : inspect(message);
 	const escapedMessage = escapeLines(messageString);
 	return escapedMessage.replaceAll('\t', ' '.repeat(TAB_SIZE));
@@ -4585,134 +4755,71 @@ const serializeLogMessage = message => {
 // Same as `util.inspect()`
 const TAB_SIZE = 2;
 
-// When `verbose` is `short|full`, print each command
-const logCommand = (escapedCommand, {verbose, verboseId}, {piped = false}) => {
-	if (!isVerbose(verbose)) {
+// When `verbose` is `short|full|custom`, print each command
+const logCommand = (escapedCommand, verboseInfo) => {
+	if (!isVerbose(verboseInfo)) {
 		return;
 	}
 
-	const icon = piped ? 'pipedCommand' : 'command';
-	verboseLog(escapedCommand, verboseId, icon, bold);
-};
-
-// Start counting time before spawning the subprocess
-const getStartTime = () => hrtime.bigint();
-
-// Compute duration after the subprocess ended.
-// Printed by the `verbose` option.
-const getDurationMs = startTime => Number(hrtime.bigint() - startTime) / 1e6;
-
-const isStandardStream = stream => STANDARD_STREAMS.includes(stream);
-const STANDARD_STREAMS = [process$3.stdin, process$3.stdout, process$3.stderr];
-const STANDARD_STREAMS_ALIASES = ['stdin', 'stdout', 'stderr'];
-const getStreamName = fdNumber => STANDARD_STREAMS_ALIASES[fdNumber] ?? `stdio[${fdNumber}]`;
-
-// Some options can have different values for `stdout`/`stderr`/`fd3`.
-// This normalizes those to array of values.
-// For example, `{verbose: {stdout: 'none', stderr: 'full'}}` becomes `{verbose: ['none', 'none', 'full']}`
-const normalizeFdSpecificOptions = options => {
-	const optionsCopy = {...options};
-
-	for (const optionName of FD_SPECIFIC_OPTIONS) {
-		optionsCopy[optionName] = normalizeFdSpecificOption(options, optionName);
-	}
-
-	return optionsCopy;
+	verboseLog({
+		type: 'command',
+		verboseMessage: escapedCommand,
+		verboseInfo,
+	});
 };
 
-const normalizeFdSpecificOption = (options, optionName) => {
-	const optionBaseArray = Array.from({length: getStdioLength(options) + 1});
-	const optionArray = normalizeFdSpecificValue(options[optionName], optionBaseArray, optionName);
-	return addDefaultValue$1(optionArray, optionName);
+// Information computed before spawning, used by the `verbose` option
+const getVerboseInfo = (verbose, escapedCommand, rawOptions) => {
+	validateVerbose(verbose);
+	const commandId = getCommandId(verbose);
+	return {
+		verbose,
+		escapedCommand,
+		commandId,
+		rawOptions,
+	};
 };
 
-const getStdioLength = ({stdio}) => Array.isArray(stdio)
-	? Math.max(stdio.length, STANDARD_STREAMS_ALIASES.length)
-	: STANDARD_STREAMS_ALIASES.length;
+const getCommandId = verbose => isVerbose({verbose}) ? COMMAND_ID++ : undefined;
 
-const normalizeFdSpecificValue = (optionValue, optionArray, optionName) => isPlainObject(optionValue)
-	? normalizeOptionObject(optionValue, optionArray, optionName)
-	: optionArray.fill(optionValue);
+// Prepending the `pid` is useful when multiple commands print their output at the same time.
+// However, we cannot use the real PID since this is not available with `child_process.spawnSync()`.
+// Also, we cannot use the real PID if we want to print it before `child_process.spawn()` is run.
+// As a pro, it is shorter than a normal PID and never re-uses the same id.
+// As a con, it cannot be used to send signals.
+let COMMAND_ID = 0n;
 
-const normalizeOptionObject = (optionValue, optionArray, optionName) => {
-	for (const fdName of Object.keys(optionValue).sort(compareFdName)) {
-		for (const fdNumber of parseFdName(fdName, optionName, optionArray)) {
-			optionArray[fdNumber] = optionValue[fdName];
+const validateVerbose = verbose => {
+	for (const fdVerbose of verbose) {
+		if (fdVerbose === false) {
+			throw new TypeError('The "verbose: false" option was renamed to "verbose: \'none\'".');
 		}
-	}
-
-	return optionArray;
-};
 
-// Ensure priority order when setting both `stdout`/`stderr`, `fd1`/`fd2`, and `all`
-const compareFdName = (fdNameA, fdNameB) => getFdNameOrder(fdNameA) < getFdNameOrder(fdNameB) ? 1 : -1;
-
-const getFdNameOrder = fdName => {
-	if (fdName === 'stdout' || fdName === 'stderr') {
-		return 0;
-	}
-
-	return fdName === 'all' ? 2 : 1;
-};
-
-const parseFdName = (fdName, optionName, optionArray) => {
-	if (fdName === 'ipc') {
-		return [optionArray.length - 1];
-	}
-
-	const fdNumber = parseFd(fdName);
-	if (fdNumber === undefined || fdNumber === 0) {
-		throw new TypeError(`"${optionName}.${fdName}" is invalid.
-It must be "${optionName}.stdout", "${optionName}.stderr", "${optionName}.all", "${optionName}.ipc", or "${optionName}.fd3", "${optionName}.fd4" (and so on).`);
-	}
-
-	if (fdNumber >= optionArray.length) {
-		throw new TypeError(`"${optionName}.${fdName}" is invalid: that file descriptor does not exist.
-Please set the "stdio" option to ensure that file descriptor exists.`);
-	}
-
-	return fdNumber === 'all' ? [1, 2] : [fdNumber];
-};
-
-// Use the same syntax for fd-specific options and the `from`/`to` options
-const parseFd = fdName => {
-	if (fdName === 'all') {
-		return fdName;
-	}
-
-	if (STANDARD_STREAMS_ALIASES.includes(fdName)) {
-		return STANDARD_STREAMS_ALIASES.indexOf(fdName);
-	}
+		if (fdVerbose === true) {
+			throw new TypeError('The "verbose: true" option was renamed to "verbose: \'short\'".');
+		}
 
-	const regexpResult = FD_REGEXP.exec(fdName);
-	if (regexpResult !== null) {
-		return Number(regexpResult[1]);
+		if (!VERBOSE_VALUES.includes(fdVerbose) && !isVerboseFunction(fdVerbose)) {
+			const allowedValues = VERBOSE_VALUES.map(allowedValue => `'${allowedValue}'`).join(', ');
+			throw new TypeError(`The "verbose" option must not be ${fdVerbose}. Allowed values are: ${allowedValues} or a function.`);
+		}
 	}
 };
 
-const FD_REGEXP = /^fd(\d+)$/;
-
-const addDefaultValue$1 = (optionArray, optionName) => optionArray.map(optionValue => optionValue === undefined
-	? DEFAULT_OPTIONS[optionName]
-	: optionValue);
-
-const DEFAULT_OPTIONS = {
-	lines: false,
-	buffer: true,
-	maxBuffer: 1000 * 1000 * 100,
-	verbose: verboseDefault,
-	stripFinalNewline: true,
-};
+// Start counting time before spawning the subprocess
+const getStartTime = () => hrtime.bigint();
 
-// List of options which can have different values for `stdout`/`stderr`
-const FD_SPECIFIC_OPTIONS = ['lines', 'buffer', 'maxBuffer', 'verbose', 'stripFinalNewline'];
+// Compute duration after the subprocess ended.
+// Printed by the `verbose` option.
+const getDurationMs = startTime => Number(hrtime.bigint() - startTime) / 1e6;
 
 // Compute `result.command`, `result.escapedCommand` and `verbose`-related information
 const handleCommand = (filePath, rawArguments, rawOptions) => {
 	const startTime = getStartTime();
 	const {command, escapedCommand} = joinCommand(filePath, rawArguments);
-	const verboseInfo = getVerboseInfo(normalizeFdSpecificOption(rawOptions, 'verbose'));
-	logCommand(escapedCommand, verboseInfo, rawOptions);
+	const verbose = normalizeFdSpecificOption(rawOptions, 'verbose');
+	const verboseInfo = getVerboseInfo(verbose, escapedCommand, {...rawOptions});
+	logCommand(escapedCommand, verboseInfo);
 	return {
 		command,
 		escapedCommand,
@@ -6577,7 +6684,7 @@ const hasMessageListeners = (anyProcess, ipcEmitter) => ipcEmitter.listenerCount
 // 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)
-	&& !SUBPROCESS_OPTIONS.get(anyProcess).options.buffer.at(-1)
+	&& !getFdSpecificValue(SUBPROCESS_OPTIONS.get(anyProcess).options.buffer, 'ipc')
 	? 1
 	: 0;
 
@@ -7622,11 +7729,12 @@ const getMaxBufferInfo = (error, maxBuffer) => {
 	const {maxBufferInfo: {fdNumber, unit}} = error;
 	delete error.maxBufferInfo;
 
+	const threshold = getFdSpecificValue(maxBuffer, fdNumber);
 	if (fdNumber === 'ipc') {
-		return {streamName: 'IPC output', threshold: maxBuffer.at(-1), unit: 'messages'};
+		return {streamName: 'IPC output', threshold, unit: 'messages'};
 	}
 
-	return {streamName: getStreamName(fdNumber), threshold: maxBuffer[fdNumber], unit};
+	return {streamName: getStreamName(fdNumber), threshold, unit};
 };
 
 // The only way to apply `maxBuffer` with `spawnSync()` is to use the native `maxBuffer` option Node.js provides.
@@ -8159,71 +8267,42 @@ function prettyMilliseconds(milliseconds, options) {
 	return result.join(separator);
 }
 
-// When `verbose` is `short|full`, print each command's error when it fails
-const logError = ({message, failed, reject, verboseId, icon}) => {
-	if (!failed) {
-		return;
+// When `verbose` is `short|full|custom`, print each command's error when it fails
+const logError = (result, verboseInfo) => {
+	if (result.failed) {
+		verboseLog({
+			type: 'error',
+			verboseMessage: result.shortMessage,
+			verboseInfo,
+			result,
+		});
 	}
-
-	const color = reject ? redBright : yellowBright;
-	verboseLog(message, verboseId, icon, color);
 };
 
-// When `verbose` is `short|full`, print each command's completion, duration and error
-const logFinalResult = ({shortMessage, failed, durationMs}, reject, verboseInfo) => {
-	logResult({
-		message: shortMessage,
-		failed,
-		reject,
-		durationMs,
-		verboseInfo,
-	});
-};
-
-// Same but for early validation errors
-const logEarlyResult = (error, startTime, verboseInfo) => {
-	logResult({
-		message: escapeLines(String(error)),
-		failed: true,
-		reject: true,
-		durationMs: getDurationMs(startTime),
-		verboseInfo,
-	});
-};
-
-const logResult = ({message, failed, reject, durationMs, verboseInfo: {verbose, verboseId}}) => {
-	if (!isVerbose(verbose)) {
+// When `verbose` is `short|full|custom`, print each command's completion, duration and error
+const logResult = (result, verboseInfo) => {
+	if (!isVerbose(verboseInfo)) {
 		return;
 	}
 
-	const icon = getIcon(failed, reject);
-	logError({
-		message,
-		failed,
-		reject,
-		verboseId,
-		icon,
-	});
-	logDuration(durationMs, verboseId, icon);
-};
-
-const logDuration = (durationMs, verboseId, icon) => {
-	const durationMessage = `(done in ${prettyMilliseconds(durationMs)})`;
-	verboseLog(durationMessage, verboseId, icon, gray);
+	logError(result, verboseInfo);
+	logDuration(result, verboseInfo);
 };
 
-const getIcon = (failed, reject) => {
-	if (!failed) {
-		return 'success';
-	}
-
-	return reject ? 'error' : 'warning';
+const logDuration = (result, verboseInfo) => {
+	const verboseMessage = `(done in ${prettyMilliseconds(result.durationMs)})`;
+	verboseLog({
+		type: 'duration',
+		verboseMessage,
+		verboseInfo,
+		result,
+	});
 };
 
 // Applies the `reject` option.
 // Also print the final log line with `verbose`.
 const handleResult = (result, verboseInfo, {reject}) => {
-	logFinalResult(result, reject, verboseInfo);
+	logResult(result, verboseInfo);
 
 	if (result.failed && reject) {
 		throw result;
@@ -8623,10 +8702,10 @@ const normalizeIpcStdioArray = (stdioArray, ipc) => ipc && !stdioArray.includes(
 
 // Add support for `stdin`/`stdout`/`stderr` as an alias for `stdio`.
 // Also normalize the `stdio` option.
-const normalizeStdioOption = ({stdio, ipc, buffer, verbose, ...options}, isSync) => {
+const normalizeStdioOption = ({stdio, ipc, buffer, ...options}, verboseInfo, isSync) => {
 	const stdioArray = getStdioArray(stdio, options).map((stdioOption, fdNumber) => addDefaultValue(stdioOption, fdNumber));
 	return isSync
-		? normalizeStdioSync(stdioArray, buffer, verbose)
+		? normalizeStdioSync(stdioArray, buffer, verboseInfo)
 		: normalizeIpcStdioArray(stdioArray, ipc);
 };
 
@@ -8667,10 +8746,10 @@ const addDefaultValue = (stdioOption, fdNumber) => {
 
 // Using `buffer: false` with synchronous methods implies `stdout`/`stderr`: `ignore`.
 // Unless the output is needed, e.g. due to `verbose: 'full'` or to redirecting to a file.
-const normalizeStdioSync = (stdioArray, buffer, verbose) => stdioArray.map((stdioOption, fdNumber) =>
+const normalizeStdioSync = (stdioArray, buffer, verboseInfo) => stdioArray.map((stdioOption, fdNumber) =>
 	!buffer[fdNumber]
 	&& fdNumber !== 0
-	&& verbose[fdNumber] !== 'full'
+	&& !isFullVerbose(verboseInfo, fdNumber)
 	&& isOutputPipeOnly(stdioOption)
 		? 'ignore'
 		: stdioOption);
@@ -8939,7 +9018,7 @@ const throwOnDuplicateStream = (stdioItem, optionName, type) => {
 // They are converted into an array of `fileDescriptors`.
 // Each `fileDescriptor` is normalized, validated and contains all information necessary for further handling.
 const handleStdio = (addProperties, options, verboseInfo, isSync) => {
-	const stdio = normalizeStdioOption(options, isSync);
+	const stdio = normalizeStdioOption(options, verboseInfo, isSync);
 	const initialFileDescriptors = stdio.map((stdioOption, fdNumber) => getFileDescriptor({
 		stdioOption,
 		fdNumber,
@@ -9645,8 +9724,8 @@ const validateSerializable = newContents => {
 // `inherit` would result in double printing.
 // They can also lead to double printing when passing file descriptor integers or `process.std*`.
 // This only leaves with `pipe` and `overlapped`.
-const shouldLogOutput = ({stdioItems, encoding, verboseInfo: {verbose}, fdNumber}) => fdNumber !== 'all'
-	&& verbose[fdNumber] === 'full'
+const shouldLogOutput = ({stdioItems, encoding, verboseInfo, fdNumber}) => fdNumber !== 'all'
+	&& isFullVerbose(verboseInfo, fdNumber)
 	&& !BINARY_ENCODINGS.has(encoding)
 	&& fdUsesVerbose(fdNumber)
 	&& (stdioItems.some(({type, value}) => type === 'native' && PIPED_STDIO_VALUES.has(value))
@@ -9661,18 +9740,18 @@ const fdUsesVerbose = fdNumber => fdNumber === 1 || fdNumber === 2;
 const PIPED_STDIO_VALUES = new Set(['pipe', 'overlapped']);
 
 // `verbose: 'full'` printing logic with async methods
-const logLines = async (linesIterable, stream, verboseInfo) => {
+const logLines = async (linesIterable, stream, fdNumber, verboseInfo) => {
 	for await (const line of linesIterable) {
 		if (!isPipingStream(stream)) {
-			logLine(line, verboseInfo);
+			logLine(line, fdNumber, verboseInfo);
 		}
 	}
 };
 
 // `verbose: 'full'` printing logic with sync methods
-const logLinesSync = (linesArray, verboseInfo) => {
+const logLinesSync = (linesArray, fdNumber, verboseInfo) => {
 	for (const line of linesArray) {
-		logLine(line, verboseInfo);
+		logLine(line, fdNumber, verboseInfo);
 	}
 };
 
@@ -9686,8 +9765,14 @@ const logLinesSync = (linesArray, verboseInfo) => {
 const isPipingStream = stream => stream._readableState.pipes.length > 0;
 
 // When `verbose` is `full`, print stdout|stderr
-const logLine = (line, {verboseId}) => {
-	verboseLog(serializeLogMessage(line), verboseId, 'output');
+const logLine = (line, fdNumber, verboseInfo) => {
+	const verboseMessage = serializeVerboseMessage(line);
+	verboseLog({
+		type: 'output',
+		verboseMessage,
+		fdNumber,
+		verboseInfo,
+	});
 };
 
 // Apply `stdout`/`stderr` options, after spawning, in sync mode
@@ -9732,15 +9817,15 @@ const transformOutputResultSync = (
 		fdNumber,
 	});
 
-	if (shouldLogOutput({
-		stdioItems,
-		encoding,
-		verboseInfo,
+	logOutputSync({
+		serializedResult,
 		fdNumber,
-	})) {
-		const linesArray = splitLinesSync(serializedResult, false, objectMode);
-		logLinesSync(linesArray, verboseInfo);
-	}
+		state,
+		verboseInfo,
+		encoding,
+		stdioItems,
+		objectMode,
+	});
 
 	const returnedResult = buffer[fdNumber] ? finalResult : undefined;
 
@@ -9786,6 +9871,25 @@ const serializeChunks = ({chunks, objectMode, encoding, lines, stripFinalNewline
 	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} of stdioItems.filter(({type}) => FILE_TYPES.has(type))) {
@@ -9923,26 +10027,20 @@ const execaCoreSync = (rawFile, rawArguments, rawOptions) => {
 // Compute arguments to pass to `child_process.spawnSync()`
 const handleSyncArguments = (rawFile, rawArguments, rawOptions) => {
 	const {command, escapedCommand, startTime, verboseInfo} = handleCommand(rawFile, rawArguments, rawOptions);
-
-	try {
-		const syncOptions = normalizeSyncOptions(rawOptions);
-		const {file, commandArguments, options} = normalizeOptions$2(rawFile, rawArguments, syncOptions);
-		validateSyncOptions(options);
-		const fileDescriptors = handleStdioSync(options, verboseInfo);
-		return {
-			file,
-			commandArguments,
-			command,
-			escapedCommand,
-			startTime,
-			verboseInfo,
-			options,
-			fileDescriptors,
-		};
-	} catch (error) {
-		logEarlyResult(error, startTime, verboseInfo);
-		throw error;
-	}
+	const syncOptions = normalizeSyncOptions(rawOptions);
+	const {file, commandArguments, options} = normalizeOptions$2(rawFile, rawArguments, syncOptions);
+	validateSyncOptions(options);
+	const fileDescriptors = handleStdioSync(options, verboseInfo);
+	return {
+		file,
+		commandArguments,
+		command,
+		escapedCommand,
+		startTime,
+		verboseInfo,
+		options,
+		fileDescriptors,
+	};
 };
 
 // Options normalization logic specific to sync methods
@@ -11459,26 +11557,19 @@ const getGenerators = ({binary, shouldEncode, encoding, shouldSplit, preserveNew
 ].filter(Boolean);
 
 // Retrieve `result.stdout|stderr|all|stdio[*]`
-const getStreamOutput = async ({stream, onStreamEnd, fdNumber, encoding, buffer, maxBuffer, lines, allMixed, stripFinalNewline, verboseInfo, streamInfo: {fileDescriptors}}) => {
-	if (shouldLogOutput({
-		stdioItems: fileDescriptors[fdNumber]?.stdioItems,
+const getStreamOutput = async ({stream, onStreamEnd, fdNumber, encoding, buffer, maxBuffer, lines, allMixed, stripFinalNewline, verboseInfo, streamInfo}) => {
+	const logPromise = logOutputAsync({
+		stream,
+		onStreamEnd,
+		fdNumber,
 		encoding,
+		allMixed,
 		verboseInfo,
-		fdNumber,
-	})) {
-		const linesIterable = iterateForResult({
-			stream,
-			onStreamEnd,
-			lines: true,
-			encoding,
-			stripFinalNewline: true,
-			allMixed,
-		});
-		logLines(linesIterable, stream, verboseInfo);
-	}
+		streamInfo,
+	});
 
 	if (!buffer) {
-		await resumeStream(stream);
+		await Promise.all([resumeStream(stream), logPromise]);
 		return;
 	}
 
@@ -11491,14 +11582,39 @@ const getStreamOutput = async ({stream, onStreamEnd, fdNumber, encoding, buffer,
 		stripFinalNewline: stripFinalNewlineValue,
 		allMixed,
 	});
-	return getStreamContents({
-		stream,
-		iterable,
+	const [output] = await Promise.all([
+		getStreamContents({
+			stream,
+			iterable,
+			fdNumber,
+			encoding,
+			maxBuffer,
+			lines,
+		}),
+		logPromise,
+	]);
+	return output;
+};
+
+const logOutputAsync = async ({stream, onStreamEnd, fdNumber, encoding, allMixed, verboseInfo, streamInfo: {fileDescriptors}}) => {
+	if (!shouldLogOutput({
+		stdioItems: fileDescriptors[fdNumber]?.stdioItems,
+		encoding,
+		verboseInfo,
 		fdNumber,
+	})) {
+		return;
+	}
+
+	const linesIterable = iterateForResult({
+		stream,
+		onStreamEnd,
+		lines: true,
 		encoding,
-		maxBuffer,
-		lines,
+		stripFinalNewline: true,
+		allMixed,
 	});
+	await logLines(linesIterable, stream, fdNumber, verboseInfo);
 };
 
 // When using `buffer: false`, users need to read `subprocess.stdout|stderr|all` right away
@@ -11734,10 +11850,16 @@ const getAllMixed = ({all, stdout, stderr}) => all
 	&& stdout.readableObjectMode !== stderr.readableObjectMode;
 
 // When `verbose` is `'full'`, print IPC messages from the subprocess
-const shouldLogIpc = ({verbose}) => verbose.at(-1) === 'full';
-
-const logIpcOutput = (message, {verboseId}) => {
-	verboseLog(serializeLogMessage(message), verboseId, 'ipc');
+const shouldLogIpc = verboseInfo => isFullVerbose(verboseInfo, 'ipc');
+
+const logIpcOutput = (message, verboseInfo) => {
+	const verboseMessage = serializeVerboseMessage(message);
+	verboseLog({
+		type: 'ipc',
+		verboseMessage,
+		fdNumber: 'ipc',
+		verboseInfo,
+	});
 };
 
 // Iterate through IPC messages sent by the subprocess
@@ -11754,8 +11876,8 @@ const waitForIpcOutput = async ({
 	}
 
 	const isVerbose = shouldLogIpc(verboseInfo);
-	const buffer = bufferArray.at(-1);
-	const maxBuffer = maxBufferArray.at(-1);
+	const buffer = getFdSpecificValue(bufferArray, 'ipc');
+	const maxBuffer = getFdSpecificValue(maxBufferArray, 'ipc');
 
 	for await (const message of loopOnMessages({
 		anyProcess: subprocess,
@@ -12308,25 +12430,19 @@ const execaCoreAsync = (rawFile, rawArguments, rawOptions, createNested) => {
 // Compute arguments to pass to `child_process.spawn()`
 const handleAsyncArguments = (rawFile, rawArguments, rawOptions) => {
 	const {command, escapedCommand, startTime, verboseInfo} = handleCommand(rawFile, rawArguments, rawOptions);
-
-	try {
-		const {file, commandArguments, options: normalizedOptions} = normalizeOptions$2(rawFile, rawArguments, rawOptions);
-		const options = handleAsyncOptions(normalizedOptions);
-		const fileDescriptors = handleStdioAsync(options, verboseInfo);
-		return {
-			file,
-			commandArguments,
-			command,
-			escapedCommand,
-			startTime,
-			verboseInfo,
-			options,
-			fileDescriptors,
-		};
-	} catch (error) {
-		logEarlyResult(error, startTime, verboseInfo);
-		throw error;
-	}
+	const {file, commandArguments, options: normalizedOptions} = normalizeOptions$2(rawFile, rawArguments, rawOptions);
+	const options = handleAsyncOptions(normalizedOptions);
+	const fileDescriptors = handleStdioAsync(options, verboseInfo);
+	return {
+		file,
+		commandArguments,
+		command,
+		escapedCommand,
+		startTime,
+		verboseInfo,
+		options,
+		fileDescriptors,
+	};
 };
 
 // Options normalization logic specific to async methods.
@@ -32886,7 +33002,8 @@ const getDotenv = async (options = {}) => {
                 for (const key in dynamic)
                     Object.assign(dotenv, {
                         [key]: _.isFunction(dynamic[key])
-                            ? dynamic[key](dotenv, env ?? defaultEnv)
+                            ? // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+                                dynamic[key](dotenv, env ?? defaultEnv)
                             : dynamic[key],
                     });
             }
@@ -32920,7 +33037,8 @@ const resolveCommand = (scripts, command) => (scripts && _.isObject(scripts[comm
     ? scripts[command].cmd
     : scripts?.[command] ?? command);
 const resolveShell = (scripts, command, shell) => scripts && _.isObject(scripts[command])
-    ? scripts[command].shell
+    ? // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        scripts[command].shell
     : shell;
 
 /*