karajan-code 3.4.1 → 3.4.2

package/node_modules/execa/lib/return/message.js

@@ -1,157 +0,0 @@
-import {inspect} from 'node:util';
-import stripFinalNewline from 'strip-final-newline';
-import {isUint8Array, uint8ArrayToString} from '../utils/uint-array.js';
-import {fixCwdError} from '../arguments/cwd.js';
-import {escapeLines} from '../arguments/escape.js';
-import {getMaxBufferMessage} from '../io/max-buffer.js';
-import {getSignalDescription} from '../terminate/signal.js';
-import {DiscardedError, isExecaError} from './final-error.js';
-
-// Computes `error.message`, `error.shortMessage` and `error.originalMessage`
-export const createMessages = ({
-	stdio,
-	all,
-	ipcOutput,
-	originalError,
-	signal,
-	signalDescription,
-	exitCode,
-	escapedCommand,
-	timedOut,
-	isCanceled,
-	isGracefullyCanceled,
-	isMaxBuffer,
-	isForcefullyTerminated,
-	forceKillAfterDelay,
-	killSignal,
-	maxBuffer,
-	timeout,
-	cwd,
-}) => {
-	const errorCode = originalError?.code;
-	const prefix = getErrorPrefix({
-		originalError,
-		timedOut,
-		timeout,
-		isMaxBuffer,
-		maxBuffer,
-		errorCode,
-		signal,
-		signalDescription,
-		exitCode,
-		isCanceled,
-		isGracefullyCanceled,
-		isForcefullyTerminated,
-		forceKillAfterDelay,
-		killSignal,
-	});
-	const originalMessage = getOriginalMessage(originalError, cwd);
-	const suffix = originalMessage === undefined ? '' : `\n${originalMessage}`;
-	const shortMessage = `${prefix}: ${escapedCommand}${suffix}`;
-	const messageStdio = all === undefined ? [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');
-	return {originalMessage, shortMessage, message};
-};
-
-const getErrorPrefix = ({
-	originalError,
-	timedOut,
-	timeout,
-	isMaxBuffer,
-	maxBuffer,
-	errorCode,
-	signal,
-	signalDescription,
-	exitCode,
-	isCanceled,
-	isGracefullyCanceled,
-	isForcefullyTerminated,
-	forceKillAfterDelay,
-	killSignal,
-}) => {
-	const forcefulSuffix = getForcefulSuffix(isForcefullyTerminated, forceKillAfterDelay);
-
-	if (timedOut) {
-		return `Command timed out after ${timeout} milliseconds${forcefulSuffix}`;
-	}
-
-	if (isGracefullyCanceled) {
-		if (signal === undefined) {
-			return `Command was gracefully canceled with exit code ${exitCode}`;
-		}
-
-		return isForcefullyTerminated
-			? `Command was gracefully canceled${forcefulSuffix}`
-			: `Command was gracefully canceled with ${signal} (${signalDescription})`;
-	}
-
-	if (isCanceled) {
-		return `Command was canceled${forcefulSuffix}`;
-	}
-
-	if (isMaxBuffer) {
-		return `${getMaxBufferMessage(originalError, maxBuffer)}${forcefulSuffix}`;
-	}
-
-	if (errorCode !== undefined) {
-		return `Command failed with ${errorCode}${forcefulSuffix}`;
-	}
-
-	if (isForcefullyTerminated) {
-		return `Command was killed with ${killSignal} (${getSignalDescription(killSignal)})${forcefulSuffix}`;
-	}
-
-	if (signal !== undefined) {
-		return `Command was killed with ${signal} (${signalDescription})`;
-	}
-
-	if (exitCode !== undefined) {
-		return `Command failed with exit code ${exitCode}`;
-	}
-
-	return 'Command failed';
-};
-
-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));
-	return escapedOriginalMessage === '' ? undefined : escapedOriginalMessage;
-};
-
-const serializeIpcMessage = ipcMessage => typeof ipcMessage === 'string'
-	? ipcMessage
-	: inspect(ipcMessage);
-
-const serializeMessagePart = messagePart => Array.isArray(messagePart)
-	? messagePart.map(messageItem => stripFinalNewline(serializeMessageItem(messageItem))).filter(Boolean).join('\n')
-	: serializeMessageItem(messagePart);
-
-const serializeMessageItem = messageItem => {
-	if (typeof messageItem === 'string') {
-		return messageItem;
-	}
-
-	if (isUint8Array(messageItem)) {
-		return uint8ArrayToString(messageItem);
-	}
-
-	return '';
-};

package/node_modules/execa/lib/return/reject.js

@@ -1,13 +0,0 @@
-import {logResult} from '../verbose/complete.js';
-
-// Applies the `reject` option.
-// Also print the final log line with `verbose`.
-export const handleResult = (result, verboseInfo, {reject}) => {
-	logResult(result, verboseInfo);
-
-	if (result.failed && reject) {
-		throw result;
-	}
-
-	return result;
-};

package/node_modules/execa/lib/return/result.js

@@ -1,186 +0,0 @@
-import {getSignalDescription} from '../terminate/signal.js';
-import {getDurationMs} from './duration.js';
-import {getFinalError} from './final-error.js';
-import {createMessages} from './message.js';
-
-// Object returned on subprocess success
-export const makeSuccessResult = ({
-	command,
-	escapedCommand,
-	stdio,
-	all,
-	ipcOutput,
-	options: {cwd},
-	startTime,
-}) => omitUndefinedProperties({
-	command,
-	escapedCommand,
-	cwd,
-	durationMs: getDurationMs(startTime),
-	failed: false,
-	timedOut: false,
-	isCanceled: false,
-	isGracefullyCanceled: false,
-	isTerminated: false,
-	isMaxBuffer: false,
-	isForcefullyTerminated: false,
-	exitCode: 0,
-	stdout: stdio[1],
-	stderr: stdio[2],
-	all,
-	stdio,
-	ipcOutput,
-	pipedFrom: [],
-});
-
-// Object returned on subprocess failure before spawning
-export const makeEarlyError = ({
-	error,
-	command,
-	escapedCommand,
-	fileDescriptors,
-	options,
-	startTime,
-	isSync,
-}) => makeError({
-	error,
-	command,
-	escapedCommand,
-	startTime,
-	timedOut: false,
-	isCanceled: false,
-	isGracefullyCanceled: false,
-	isMaxBuffer: false,
-	isForcefullyTerminated: false,
-	stdio: Array.from({length: fileDescriptors.length}),
-	ipcOutput: [],
-	options,
-	isSync,
-});
-
-// Object returned on subprocess failure
-export const makeError = ({
-	error: originalError,
-	command,
-	escapedCommand,
-	startTime,
-	timedOut,
-	isCanceled,
-	isGracefullyCanceled,
-	isMaxBuffer,
-	isForcefullyTerminated,
-	exitCode: rawExitCode,
-	signal: rawSignal,
-	stdio,
-	all,
-	ipcOutput,
-	options: {
-		timeoutDuration,
-		timeout = timeoutDuration,
-		forceKillAfterDelay,
-		killSignal,
-		cwd,
-		maxBuffer,
-	},
-	isSync,
-}) => {
-	const {exitCode, signal, signalDescription} = normalizeExitPayload(rawExitCode, rawSignal);
-	const {originalMessage, shortMessage, message} = createMessages({
-		stdio,
-		all,
-		ipcOutput,
-		originalError,
-		signal,
-		signalDescription,
-		exitCode,
-		escapedCommand,
-		timedOut,
-		isCanceled,
-		isGracefullyCanceled,
-		isMaxBuffer,
-		isForcefullyTerminated,
-		forceKillAfterDelay,
-		killSignal,
-		maxBuffer,
-		timeout,
-		cwd,
-	});
-	const error = getFinalError(originalError, message, isSync);
-	Object.assign(error, getErrorProperties({
-		error,
-		command,
-		escapedCommand,
-		startTime,
-		timedOut,
-		isCanceled,
-		isGracefullyCanceled,
-		isMaxBuffer,
-		isForcefullyTerminated,
-		exitCode,
-		signal,
-		signalDescription,
-		stdio,
-		all,
-		ipcOutput,
-		cwd,
-		originalMessage,
-		shortMessage,
-	}));
-	return error;
-};
-
-const getErrorProperties = ({
-	error,
-	command,
-	escapedCommand,
-	startTime,
-	timedOut,
-	isCanceled,
-	isGracefullyCanceled,
-	isMaxBuffer,
-	isForcefullyTerminated,
-	exitCode,
-	signal,
-	signalDescription,
-	stdio,
-	all,
-	ipcOutput,
-	cwd,
-	originalMessage,
-	shortMessage,
-}) => omitUndefinedProperties({
-	shortMessage,
-	originalMessage,
-	command,
-	escapedCommand,
-	cwd,
-	durationMs: getDurationMs(startTime),
-	failed: true,
-	timedOut,
-	isCanceled,
-	isGracefullyCanceled,
-	isTerminated: signal !== undefined,
-	isMaxBuffer,
-	isForcefullyTerminated,
-	exitCode,
-	signal,
-	signalDescription,
-	code: error.cause?.code,
-	stdout: stdio[1],
-	stderr: stdio[2],
-	all,
-	stdio,
-	ipcOutput,
-	pipedFrom: [],
-});
-
-const omitUndefinedProperties = result => Object.fromEntries(Object.entries(result).filter(([, value]) => value !== undefined));
-
-// `signal` and `exitCode` emitted on `subprocess.on('exit')` event can be `null`.
-// We normalize them to `undefined`
-const normalizeExitPayload = (rawExitCode, rawSignal) => {
-	const exitCode = rawExitCode === null ? undefined : rawExitCode;
-	const signal = rawSignal === null ? undefined : rawSignal;
-	const signalDescription = signal === undefined ? undefined : getSignalDescription(rawSignal);
-	return {exitCode, signal, signalDescription};
-};

package/node_modules/execa/lib/stdio/direction.js

@@ -1,76 +0,0 @@
-import process from 'node:process';
-import {
-	isStream as isNodeStream,
-	isReadableStream as isNodeReadableStream,
-	isWritableStream as isNodeWritableStream,
-} from 'is-stream';
-import {isWritableStream} from './type.js';
-
-// For `stdio[fdNumber]` beyond stdin/stdout/stderr, we need to guess whether the value passed is intended for inputs or outputs.
-// This allows us to know whether to pipe _into_ or _from_ the stream.
-// When `stdio[fdNumber]` is a single value, this guess is fairly straightforward.
-// However, when it is an array instead, we also need to make sure the different values are not incompatible with each other.
-export const getStreamDirection = (stdioItems, fdNumber, optionName) => {
-	const directions = stdioItems.map(stdioItem => getStdioItemDirection(stdioItem, fdNumber));
-
-	if (directions.includes('input') && directions.includes('output')) {
-		throw new TypeError(`The \`${optionName}\` option must not be an array of both readable and writable values.`);
-	}
-
-	return directions.find(Boolean) ?? DEFAULT_DIRECTION;
-};
-
-const getStdioItemDirection = ({type, value}, fdNumber) => KNOWN_DIRECTIONS[fdNumber] ?? guessStreamDirection[type](value);
-
-// `stdin`/`stdout`/`stderr` have a known direction
-const KNOWN_DIRECTIONS = ['input', 'output', 'output'];
-
-const anyDirection = () => undefined;
-const alwaysInput = () => 'input';
-
-// `string` can only be added through the `input` option, i.e. does not need to be handled here
-const guessStreamDirection = {
-	generator: anyDirection,
-	asyncGenerator: anyDirection,
-	fileUrl: anyDirection,
-	filePath: anyDirection,
-	iterable: alwaysInput,
-	asyncIterable: alwaysInput,
-	uint8Array: alwaysInput,
-	webStream: value => isWritableStream(value) ? 'output' : 'input',
-	nodeStream(value) {
-		if (!isNodeReadableStream(value, {checkOpen: false})) {
-			return 'output';
-		}
-
-		return isNodeWritableStream(value, {checkOpen: false}) ? undefined : 'input';
-	},
-	webTransform: anyDirection,
-	duplex: anyDirection,
-	native(value) {
-		const standardStreamDirection = getStandardStreamDirection(value);
-		if (standardStreamDirection !== undefined) {
-			return standardStreamDirection;
-		}
-
-		if (isNodeStream(value, {checkOpen: false})) {
-			return guessStreamDirection.nodeStream(value);
-		}
-	},
-};
-
-const getStandardStreamDirection = value => {
-	if ([0, process.stdin].includes(value)) {
-		return 'input';
-	}
-
-	if ([1, 2, process.stdout, process.stderr].includes(value)) {
-		return 'output';
-	}
-};
-
-// When ambiguous, we initially keep the direction as `undefined`.
-// This allows arrays of `stdio` values to resolve the ambiguity.
-// For example, `stdio[3]: DuplexStream` is ambiguous, but `stdio[3]: [DuplexStream, WritableStream]` is not.
-// When the ambiguity remains, we default to `output` since it is the most common use case for additional file descriptors.
-const DEFAULT_DIRECTION = 'output';

package/node_modules/execa/lib/stdio/duplicate.js

@@ -1,116 +0,0 @@
-import {
-	SPECIAL_DUPLICATE_TYPES_SYNC,
-	SPECIAL_DUPLICATE_TYPES,
-	FORBID_DUPLICATE_TYPES,
-	TYPE_TO_MESSAGE,
-} from './type.js';
-
-// Duplicates in the same file descriptor is most likely an error.
-// However, this can be useful with generators.
-export const filterDuplicates = stdioItems => stdioItems.filter((stdioItemOne, indexOne) =>
-	stdioItems.every((stdioItemTwo, indexTwo) => stdioItemOne.value !== stdioItemTwo.value
-		|| indexOne >= indexTwo
-		|| stdioItemOne.type === 'generator'
-		|| stdioItemOne.type === 'asyncGenerator'));
-
-// Check if two file descriptors are sharing the same target.
-// For example `{stdout: {file: './output.txt'}, stderr: {file: './output.txt'}}`.
-export const getDuplicateStream = ({stdioItem: {type, value, optionName}, direction, fileDescriptors, isSync}) => {
-	const otherStdioItems = getOtherStdioItems(fileDescriptors, type);
-	if (otherStdioItems.length === 0) {
-		return;
-	}
-
-	if (isSync) {
-		validateDuplicateStreamSync({
-			otherStdioItems,
-			type,
-			value,
-			optionName,
-			direction,
-		});
-		return;
-	}
-
-	if (SPECIAL_DUPLICATE_TYPES.has(type)) {
-		return getDuplicateStreamInstance({
-			otherStdioItems,
-			type,
-			value,
-			optionName,
-			direction,
-		});
-	}
-
-	if (FORBID_DUPLICATE_TYPES.has(type)) {
-		validateDuplicateTransform({
-			otherStdioItems,
-			type,
-			value,
-			optionName,
-		});
-	}
-};
-
-// Values shared by multiple file descriptors
-const getOtherStdioItems = (fileDescriptors, type) => fileDescriptors
-	.flatMap(({direction, stdioItems}) => stdioItems
-		.filter(stdioItem => stdioItem.type === type)
-		.map((stdioItem => ({...stdioItem, direction}))));
-
-// With `execaSync()`, do not allow setting a file path both in input and output
-const validateDuplicateStreamSync = ({otherStdioItems, type, value, optionName, direction}) => {
-	if (SPECIAL_DUPLICATE_TYPES_SYNC.has(type)) {
-		getDuplicateStreamInstance({
-			otherStdioItems,
-			type,
-			value,
-			optionName,
-			direction,
-		});
-	}
-};
-
-// When two file descriptors share the file or stream, we need to re-use the same underlying stream.
-// Otherwise, the stream would be closed twice when piping ends.
-// This is only an issue with output file descriptors.
-// This is not a problem with generator functions since those create a new instance for each file descriptor.
-// We also forbid input and output file descriptors sharing the same file or stream, since that does not make sense.
-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);
-
-	return direction === 'output' ? duplicateStdioItems[0].stream : undefined;
-};
-
-const hasSameValue = ({type, value}, secondValue) => {
-	if (type === 'filePath') {
-		return value.file === secondValue.file;
-	}
-
-	if (type === 'fileUrl') {
-		return value.href === secondValue.href;
-	}
-
-	return value === secondValue;
-};
-
-// We do not allow two file descriptors to share the same Duplex or TransformStream.
-// This is because those are set directly to `subprocess.std*`.
-// For example, this could result in `subprocess.stdout` and `subprocess.stderr` being the same value.
-// This means reading from either would get data from both stdout and stderr.
-const validateDuplicateTransform = ({otherStdioItems, type, value, optionName}) => {
-	const duplicateStdioItem = otherStdioItems.find(({value: {transform}}) => transform === value.transform);
-	throwOnDuplicateStream(duplicateStdioItem, optionName, type);
-};
-
-const throwOnDuplicateStream = (stdioItem, optionName, type) => {
-	if (stdioItem !== undefined) {
-		throw new TypeError(`The \`${stdioItem.optionName}\` and \`${optionName}\` options must not target ${TYPE_TO_MESSAGE[type]} that is the same.`);
-	}
-};

package/node_modules/execa/lib/stdio/handle-async.js

@@ -1,52 +0,0 @@
-import {createReadStream, createWriteStream} from 'node:fs';
-import {Buffer} from 'node:buffer';
-import {Readable, Writable, Duplex} from 'node:stream';
-import {generatorToStream} from '../transform/generator.js';
-import {handleStdio} from './handle.js';
-import {TYPE_TO_MESSAGE} from './type.js';
-
-// Handle `input`, `inputFile`, `stdin`, `stdout` and `stderr` options, before spawning, in async mode
-export const handleStdioAsync = (options, verboseInfo) => handleStdio(addPropertiesAsync, options, verboseInfo, false);
-
-const forbiddenIfAsync = ({type, optionName}) => {
-	throw new TypeError(`The \`${optionName}\` option cannot be ${TYPE_TO_MESSAGE[type]}.`);
-};
-
-// Create streams used internally for piping when using specific values for the `std*` options, in async mode.
-// For example, `stdout: {file}` creates a file stream, which is piped from/to.
-const addProperties = {
-	fileNumber: forbiddenIfAsync,
-	generator: generatorToStream,
-	asyncGenerator: generatorToStream,
-	nodeStream: ({value}) => ({stream: value}),
-	webTransform({value: {transform, writableObjectMode, readableObjectMode}}) {
-		const objectMode = writableObjectMode || readableObjectMode;
-		const stream = Duplex.fromWeb(transform, {objectMode});
-		return {stream};
-	},
-	duplex: ({value: {transform}}) => ({stream: transform}),
-	native() {},
-};
-
-const addPropertiesAsync = {
-	input: {
-		...addProperties,
-		fileUrl: ({value}) => ({stream: createReadStream(value)}),
-		filePath: ({value: {file}}) => ({stream: createReadStream(file)}),
-		webStream: ({value}) => ({stream: Readable.fromWeb(value)}),
-		iterable: ({value}) => ({stream: Readable.from(value)}),
-		asyncIterable: ({value}) => ({stream: Readable.from(value)}),
-		string: ({value}) => ({stream: Readable.from(value)}),
-		uint8Array: ({value}) => ({stream: Readable.from(Buffer.from(value))}),
-	},
-	output: {
-		...addProperties,
-		fileUrl: ({value}) => ({stream: createWriteStream(value)}),
-		filePath: ({value: {file, append}}) => ({stream: createWriteStream(file, append ? {flags: 'a'} : {})}),
-		webStream: ({value}) => ({stream: Writable.fromWeb(value)}),
-		iterable: forbiddenIfAsync,
-		asyncIterable: forbiddenIfAsync,
-		string: forbiddenIfAsync,
-		uint8Array: forbiddenIfAsync,
-	},
-};

package/node_modules/execa/lib/stdio/handle-sync.js

@@ -1,57 +0,0 @@
-import {readFileSync} from 'node:fs';
-import {bufferToUint8Array} from '../utils/uint-array.js';
-import {handleStdio} from './handle.js';
-import {TYPE_TO_MESSAGE} from './type.js';
-
-// Normalize `input`, `inputFile`, `stdin`, `stdout` and `stderr` options, before spawning, in sync mode
-export const handleStdioSync = (options, verboseInfo) => handleStdio(addPropertiesSync, options, verboseInfo, true);
-
-const forbiddenIfSync = ({type, optionName}) => {
-	throwInvalidSyncValue(optionName, TYPE_TO_MESSAGE[type]);
-};
-
-const forbiddenNativeIfSync = ({optionName, value}) => {
-	if (value === 'ipc' || value === 'overlapped') {
-		throwInvalidSyncValue(optionName, `"${value}"`);
-	}
-
-	return {};
-};
-
-const throwInvalidSyncValue = (optionName, value) => {
-	throw new TypeError(`The \`${optionName}\` option cannot be ${value} with synchronous methods.`);
-};
-
-// Create streams used internally for redirecting when using specific values for the `std*` options, in sync mode.
-// For example, `stdin: {file}` reads the file synchronously, then passes it as the `input` option.
-const addProperties = {
-	generator() {},
-	asyncGenerator: forbiddenIfSync,
-	webStream: forbiddenIfSync,
-	nodeStream: forbiddenIfSync,
-	webTransform: forbiddenIfSync,
-	duplex: forbiddenIfSync,
-	asyncIterable: forbiddenIfSync,
-	native: forbiddenNativeIfSync,
-};
-
-const addPropertiesSync = {
-	input: {
-		...addProperties,
-		fileUrl: ({value}) => ({contents: [bufferToUint8Array(readFileSync(value))]}),
-		filePath: ({value: {file}}) => ({contents: [bufferToUint8Array(readFileSync(file))]}),
-		fileNumber: forbiddenIfSync,
-		iterable: ({value}) => ({contents: [...value]}),
-		string: ({value}) => ({contents: [value]}),
-		uint8Array: ({value}) => ({contents: [value]}),
-	},
-	output: {
-		...addProperties,
-		fileUrl: ({value}) => ({path: value}),
-		filePath: ({value: {file, append}}) => ({path: file, append}),
-		fileNumber: ({value}) => ({path: value}),
-		iterable: forbiddenIfSync,
-		string: forbiddenIfSync,
-		uint8Array: forbiddenIfSync,
-	},
-};