karajan-code 3.2.0 → 3.4.0

package/node_modules/execa/lib/methods/main-sync.js

@@ -0,0 +1,163 @@
+import {spawnSync} from 'node:child_process';
+import {handleCommand} from '../arguments/command.js';
+import {normalizeOptions} from '../arguments/options.js';
+import {concatenateShell} from '../arguments/shell.js';
+import {makeError, makeEarlyError, makeSuccessResult} from '../return/result.js';
+import {handleResult} from '../return/reject.js';
+import {handleStdioSync} from '../stdio/handle-sync.js';
+import {stripNewline} from '../io/strip-newline.js';
+import {addInputOptionsSync} from '../io/input-sync.js';
+import {transformOutputSync} from '../io/output-sync.js';
+import {getMaxBufferSync} from '../io/max-buffer.js';
+import {getAllSync} from '../resolve/all-sync.js';
+import {getExitResultSync} from '../resolve/exit-sync.js';
+
+// Main shared logic for all sync methods: `execaSync()`, `$.sync()`
+export const execaCoreSync = (rawFile, rawArguments, rawOptions) => {
+	const {file, commandArguments, command, escapedCommand, startTime, verboseInfo, options, fileDescriptors} = handleSyncArguments(rawFile, rawArguments, rawOptions);
+	const result = spawnSubprocessSync({
+		file,
+		commandArguments,
+		options,
+		command,
+		escapedCommand,
+		verboseInfo,
+		fileDescriptors,
+		startTime,
+	});
+	return handleResult(result, verboseInfo, options);
+};
+
+// Compute arguments to pass to `child_process.spawnSync()`
+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);
+	validateSyncOptions(options);
+	const fileDescriptors = handleStdioSync(options, verboseInfo);
+	return {
+		file,
+		commandArguments,
+		command,
+		escapedCommand,
+		startTime,
+		verboseInfo,
+		options,
+		fileDescriptors,
+	};
+};
+
+// Options normalization logic specific to sync methods
+const normalizeSyncOptions = options => options.node && !options.ipc ? {...options, ipc: false} : options;
+
+// Options validation logic specific to sync methods
+const validateSyncOptions = ({ipc, ipcInput, detached, cancelSignal}) => {
+	if (ipcInput) {
+		throwInvalidSyncOption('ipcInput');
+	}
+
+	if (ipc) {
+		throwInvalidSyncOption('ipc: true');
+	}
+
+	if (detached) {
+		throwInvalidSyncOption('detached: true');
+	}
+
+	if (cancelSignal) {
+		throwInvalidSyncOption('cancelSignal');
+	}
+};
+
+const throwInvalidSyncOption = value => {
+	throw new TypeError(`The "${value}" option cannot be used with synchronous methods.`);
+};
+
+const spawnSubprocessSync = ({file, commandArguments, options, command, escapedCommand, verboseInfo, fileDescriptors, startTime}) => {
+	const syncResult = runSubprocessSync({
+		file,
+		commandArguments,
+		options,
+		command,
+		escapedCommand,
+		fileDescriptors,
+		startTime,
+	});
+	if (syncResult.failed) {
+		return syncResult;
+	}
+
+	const {resultError, exitCode, signal, timedOut, isMaxBuffer} = getExitResultSync(syncResult, options);
+	const {output, error = resultError} = transformOutputSync({
+		fileDescriptors,
+		syncResult,
+		options,
+		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,
+		options,
+		command,
+		escapedCommand,
+		startTime,
+	});
+};
+
+const runSubprocessSync = ({file, commandArguments, options, command, escapedCommand, fileDescriptors, startTime}) => {
+	try {
+		addInputOptionsSync(fileDescriptors, options);
+		const normalizedOptions = normalizeSpawnSyncOptions(options);
+		return spawnSync(...concatenateShell(file, commandArguments, normalizedOptions));
+	} catch (error) {
+		return makeEarlyError({
+			error,
+			command,
+			escapedCommand,
+			fileDescriptors,
+			options,
+			startTime,
+			isSync: true,
+		});
+	}
+};
+
+// The `encoding` option is handled by Execa, not by `child_process.spawnSync()`
+const normalizeSpawnSyncOptions = ({encoding, maxBuffer, ...options}) => ({...options, encoding: 'buffer', maxBuffer: getMaxBufferSync(maxBuffer)});
+
+const getSyncResult = ({error, exitCode, signal, timedOut, isMaxBuffer, stdio, all, options, command, escapedCommand, startTime}) => error === undefined
+	? makeSuccessResult({
+		command,
+		escapedCommand,
+		stdio,
+		all,
+		ipcOutput: [],
+		options,
+		startTime,
+	})
+	: makeError({
+		error,
+		command,
+		escapedCommand,
+		timedOut,
+		isCanceled: false,
+		isGracefullyCanceled: false,
+		isMaxBuffer,
+		isForcefullyTerminated: false,
+		exitCode,
+		signal,
+		stdio,
+		all,
+		ipcOutput: [],
+		options,
+		startTime,
+		isSync: true,
+	});

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

@@ -0,0 +1,51 @@
+import {execPath, execArgv} from 'node:process';
+import path from 'node:path';
+import {safeNormalizeFileUrl} from '../arguments/file-url.js';
+
+// `execaNode()` is a shortcut for `execa(..., {node: true})`
+export const mapNode = ({options}) => {
+	if (options.node === false) {
+		throw new TypeError('The "node" option cannot be false with `execaNode()`.');
+	}
+
+	return {options: {...options, node: true}};
+};
+
+// Applies the `node: true` option, and the related `nodePath`/`nodeOptions` options.
+// Modifies the file commands/arguments to ensure the same Node binary and flags are re-used.
+// Also adds `ipc: true` and `shell: false`.
+export const handleNodeOption = (file, commandArguments, {
+	node: shouldHandleNode = false,
+	nodePath = execPath,
+	nodeOptions = execArgv.filter(nodeOption => !nodeOption.startsWith('--inspect')),
+	cwd,
+	execPath: formerNodePath,
+	...options
+}) => {
+	if (formerNodePath !== undefined) {
+		throw new TypeError('The "execPath" option has been removed. Please use the "nodePath" option instead.');
+	}
+
+	const normalizedNodePath = safeNormalizeFileUrl(nodePath, 'The "nodePath" option');
+	const resolvedNodePath = path.resolve(cwd, normalizedNodePath);
+	const newOptions = {
+		...options,
+		nodePath: resolvedNodePath,
+		node: shouldHandleNode,
+		cwd,
+	};
+
+	if (!shouldHandleNode) {
+		return [file, commandArguments, newOptions];
+	}
+
+	if (path.basename(file, '.exe') === 'node') {
+		throw new TypeError('When the "node" option is true, the first argument does not need to be "node".');
+	}
+
+	return [
+		resolvedNodePath,
+		[...nodeOptions, file, ...commandArguments],
+		{ipc: true, ...newOptions, shell: false},
+	];
+};

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

@@ -0,0 +1,31 @@
+import isPlainObject from 'is-plain-obj';
+import {safeNormalizeFileUrl} from '../arguments/file-url.js';
+
+// The command `arguments` and `options` are both optional.
+// This also does basic validation on them and on the command file.
+export const normalizeParameters = (rawFile, rawArguments = [], rawOptions = {}) => {
+	const filePath = safeNormalizeFileUrl(rawFile, 'First argument');
+	const [commandArguments, options] = isPlainObject(rawArguments)
+		? [[], rawArguments]
+		: [rawArguments, rawOptions];
+
+	if (!Array.isArray(commandArguments)) {
+		throw new TypeError(`Second argument must be either an array of arguments or an options object: ${commandArguments}`);
+	}
+
+	if (commandArguments.some(commandArgument => typeof commandArgument === 'object' && commandArgument !== null)) {
+		throw new TypeError(`Second argument must be an array of strings: ${commandArguments}`);
+	}
+
+	const normalizedArguments = commandArguments.map(String);
+	const nullByteArgument = normalizedArguments.find(normalizedArgument => normalizedArgument.includes('\0'));
+	if (nullByteArgument !== undefined) {
+		throw new TypeError(`Arguments cannot contain null bytes ("\\0"): ${nullByteArgument}`);
+	}
+
+	if (!isPlainObject(options)) {
+		throw new TypeError(`Last argument must be an options object: ${options}`);
+	}
+
+	return [filePath, normalizedArguments, options];
+};

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

@@ -0,0 +1,15 @@
+// The return value is a mixin of `subprocess` and `Promise`
+export const mergePromise = (subprocess, promise) => {
+	for (const [property, descriptor] of descriptors) {
+		const value = descriptor.value.bind(promise);
+		Reflect.defineProperty(subprocess, property, {...descriptor, value});
+	}
+};
+
+// eslint-disable-next-line unicorn/prefer-top-level-await
+const nativePromisePrototype = (async () => {})().constructor.prototype;
+
+const descriptors = ['then', 'catch', 'finally'].map(property => [
+	property,
+	Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property),
+]);

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

@@ -0,0 +1,22 @@
+// Sets `$.sync` and `$.s`
+export const setScriptSync = (boundExeca, createNested, boundOptions) => {
+	boundExeca.sync = createNested(mapScriptSync, boundOptions);
+	boundExeca.s = boundExeca.sync;
+};
+
+// Main logic for `$`
+export const mapScriptAsync = ({options}) => getScriptOptions(options);
+
+// Main logic for `$.sync`
+const mapScriptSync = ({options}) => ({...getScriptOptions(options), isSync: true});
+
+// `$` is like `execa` but with script-friendly options: `{stdin: 'inherit', preferLocal: true}`
+const getScriptOptions = options => ({options: {...getScriptStdinOption(options), ...options}});
+
+const getScriptStdinOption = ({input, inputFile, stdio}) => input === undefined && inputFile === undefined && stdio === undefined
+	? {stdin: 'inherit'}
+	: {};
+
+// When using $(...).pipe(...), most script-friendly options should apply to both commands.
+// However, some options (like `stdin: 'inherit'`) would create issues with piping, i.e. cannot be deep.
+export const deepScriptOptions = {preferLocal: true};

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

@@ -0,0 +1,153 @@
+import {ChildProcess} from 'node:child_process';
+import isPlainObject from 'is-plain-obj';
+import {isUint8Array, uint8ArrayToString} from '../utils/uint-array.js';
+
+// Check whether the template string syntax is being used
+export const isTemplateString = templates => Array.isArray(templates) && Array.isArray(templates.raw);
+
+// Convert execa`file ...commandArguments` to execa(file, commandArguments)
+export const parseTemplates = (templates, expressions) => {
+	let tokens = [];
+
+	for (const [index, template] of templates.entries()) {
+		tokens = parseTemplate({
+			templates,
+			expressions,
+			tokens,
+			index,
+			template,
+		});
+	}
+
+	if (tokens.length === 0) {
+		throw new TypeError('Template script must not be empty');
+	}
+
+	const [file, ...commandArguments] = tokens;
+	return [file, commandArguments, {}];
+};
+
+const parseTemplate = ({templates, expressions, tokens, index, template}) => {
+	if (template === undefined) {
+		throw new TypeError(`Invalid backslash sequence: ${templates.raw[index]}`);
+	}
+
+	const {nextTokens, leadingWhitespaces, trailingWhitespaces} = splitByWhitespaces(template, templates.raw[index]);
+	const newTokens = concatTokens(tokens, nextTokens, leadingWhitespaces);
+
+	if (index === expressions.length) {
+		return newTokens;
+	}
+
+	const expression = expressions[index];
+	const expressionTokens = Array.isArray(expression)
+		? expression.map(expression => parseExpression(expression))
+		: [parseExpression(expression)];
+	return concatTokens(newTokens, expressionTokens, trailingWhitespaces);
+};
+
+// Like `string.split(/[ \t\r\n]+/)` except newlines and tabs are:
+//  - ignored when input as a backslash sequence like: `echo foo\n bar`
+//  - not ignored when input directly
+// The only way to distinguish those in JavaScript is to use a tagged template and compare:
+//  - the first array argument, which does not escape backslash sequences
+//  - its `raw` property, which escapes them
+const splitByWhitespaces = (template, rawTemplate) => {
+	if (rawTemplate.length === 0) {
+		return {nextTokens: [], leadingWhitespaces: false, trailingWhitespaces: false};
+	}
+
+	const nextTokens = [];
+	let templateStart = 0;
+	const leadingWhitespaces = DELIMITERS.has(rawTemplate[0]);
+
+	for (
+		let templateIndex = 0, rawIndex = 0;
+		templateIndex < template.length;
+		templateIndex += 1, rawIndex += 1
+	) {
+		const rawCharacter = rawTemplate[rawIndex];
+		if (DELIMITERS.has(rawCharacter)) {
+			if (templateStart !== templateIndex) {
+				nextTokens.push(template.slice(templateStart, templateIndex));
+			}
+
+			templateStart = templateIndex + 1;
+		} else if (rawCharacter === '\\') {
+			const nextRawCharacter = rawTemplate[rawIndex + 1];
+			if (nextRawCharacter === '\n') {
+				// Handles escaped newlines in templates
+				templateIndex -= 1;
+				rawIndex += 1;
+			} else if (nextRawCharacter === 'u' && rawTemplate[rawIndex + 2] === '{') {
+				rawIndex = rawTemplate.indexOf('}', rawIndex + 3);
+			} else {
+				rawIndex += ESCAPE_LENGTH[nextRawCharacter] ?? 1;
+			}
+		}
+	}
+
+	const trailingWhitespaces = templateStart === template.length;
+	if (!trailingWhitespaces) {
+		nextTokens.push(template.slice(templateStart));
+	}
+
+	return {nextTokens, leadingWhitespaces, trailingWhitespaces};
+};
+
+const DELIMITERS = new Set([' ', '\t', '\r', '\n']);
+
+// Number of characters in backslash escape sequences: \0 \xXX or \uXXXX
+// \cX is allowed in RegExps but not in strings
+// Octal sequences are not allowed in strict mode
+const ESCAPE_LENGTH = {x: 3, u: 5};
+
+const concatTokens = (tokens, nextTokens, isSeparated) => isSeparated
+	|| tokens.length === 0
+	|| nextTokens.length === 0
+	? [...tokens, ...nextTokens]
+	: [
+		...tokens.slice(0, -1),
+		`${tokens.at(-1)}${nextTokens[0]}`,
+		...nextTokens.slice(1),
+	];
+
+// Handle `${expression}` inside the template string syntax
+const parseExpression = expression => {
+	const typeOfExpression = typeof expression;
+
+	if (typeOfExpression === 'string') {
+		return expression;
+	}
+
+	if (typeOfExpression === 'number') {
+		return String(expression);
+	}
+
+	if (isPlainObject(expression) && ('stdout' in expression || 'isMaxBuffer' in expression)) {
+		return getSubprocessResult(expression);
+	}
+
+	if (expression instanceof ChildProcess || Object.prototype.toString.call(expression) === '[object Promise]') {
+		// eslint-disable-next-line no-template-curly-in-string
+		throw new TypeError('Unexpected subprocess in template expression. Please use ${await subprocess} instead of ${subprocess}.');
+	}
+
+	throw new TypeError(`Unexpected "${typeOfExpression}" in template expression`);
+};
+
+const getSubprocessResult = ({stdout}) => {
+	if (typeof stdout === 'string') {
+		return stdout;
+	}
+
+	if (isUint8Array(stdout)) {
+		return uint8ArrayToString(stdout);
+	}
+
+	if (stdout === undefined) {
+		throw new TypeError('Missing result.stdout in template expression. This is probably due to the previous subprocess\' "stdout" option.');
+	}
+
+	throw new TypeError(`Unexpected "${typeof stdout}" stdout in template expression`);
+};

package/node_modules/execa/lib/pipe/abort.js

@@ -0,0 +1,20 @@
+import {aborted} from 'node:util';
+import {createNonCommandError} from './throw.js';
+
+// When passing an `unpipeSignal` option, abort piping when the signal is aborted.
+// However, do not terminate the subprocesses.
+export const unpipeOnAbort = (unpipeSignal, unpipeContext) => unpipeSignal === undefined
+	? []
+	: [unpipeOnSignalAbort(unpipeSignal, unpipeContext)];
+
+const unpipeOnSignalAbort = async (unpipeSignal, {sourceStream, mergedStream, fileDescriptors, sourceOptions, startTime}) => {
+	await aborted(unpipeSignal, sourceStream);
+	await mergedStream.remove(sourceStream);
+	const error = new Error('Pipe canceled by `unpipeSignal` option.');
+	throw createNonCommandError({
+		error,
+		fileDescriptors,
+		sourceOptions,
+		startTime,
+	});
+};

package/node_modules/execa/lib/pipe/pipe-arguments.js

@@ -0,0 +1,91 @@
+import {normalizeParameters} from '../methods/parameters.js';
+import {getStartTime} from '../return/duration.js';
+import {SUBPROCESS_OPTIONS, getToStream, getFromStream} from '../arguments/fd-options.js';
+import {isDenoExecPath} from '../arguments/file-url.js';
+
+// Normalize and validate arguments passed to `source.pipe(destination)`
+export const normalizePipeArguments = ({source, sourcePromise, boundOptions, createNested}, ...pipeArguments) => {
+	const startTime = getStartTime();
+	const {
+		destination,
+		destinationStream,
+		destinationError,
+		from,
+		unpipeSignal,
+	} = getDestinationStream(boundOptions, createNested, pipeArguments);
+	const {sourceStream, sourceError} = getSourceStream(source, from);
+	const {options: sourceOptions, fileDescriptors} = SUBPROCESS_OPTIONS.get(source);
+	return {
+		sourcePromise,
+		sourceStream,
+		sourceOptions,
+		sourceError,
+		destination,
+		destinationStream,
+		destinationError,
+		unpipeSignal,
+		fileDescriptors,
+		startTime,
+	};
+};
+
+const getDestinationStream = (boundOptions, createNested, pipeArguments) => {
+	try {
+		const {
+			destination,
+			pipeOptions: {from, to, unpipeSignal} = {},
+		} = getDestination(boundOptions, createNested, ...pipeArguments);
+		const destinationStream = getToStream(destination, to);
+		return {
+			destination,
+			destinationStream,
+			from,
+			unpipeSignal,
+		};
+	} catch (error) {
+		return {destinationError: error};
+	}
+};
+
+// Piping subprocesses can use three syntaxes:
+//  - source.pipe('command', commandArguments, pipeOptionsOrDestinationOptions)
+//  - source.pipe`command commandArgument` or source.pipe(pipeOptionsOrDestinationOptions)`command commandArgument`
+//  - source.pipe(execa(...), pipeOptions)
+const getDestination = (boundOptions, createNested, firstArgument, ...pipeArguments) => {
+	if (Array.isArray(firstArgument)) {
+		const destination = createNested(mapDestinationArguments, boundOptions)(firstArgument, ...pipeArguments);
+		return {destination, 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, pipeOptions: rawOptions};
+	}
+
+	if (SUBPROCESS_OPTIONS.has(firstArgument)) {
+		if (Object.keys(boundOptions).length > 0) {
+			throw new TypeError('Please use .pipe(options)`command` or .pipe($(options)`command`) instead of .pipe(options)($`command`).');
+		}
+
+		return {destination: firstArgument, pipeOptions: pipeArguments[0]};
+	}
+
+	throw new TypeError(`The first argument must be a template string, an options object, or an Execa subprocess: ${firstArgument}`);
+};
+
+// Force `stdin: 'pipe'` with the destination subprocess
+const mapDestinationArguments = ({options}) => ({options: {...options, stdin: 'pipe', piped: true}});
+
+const getSourceStream = (source, from) => {
+	try {
+		const sourceStream = getFromStream(source, from);
+		return {sourceStream};
+	} catch (error) {
+		return {sourceError: error};
+	}
+};

package/node_modules/execa/lib/pipe/sequence.js

@@ -0,0 +1,24 @@
+// Like Bash, we await both subprocesses. This is unlike some other shells which only await the destination subprocess.
+// Like Bash with the `pipefail` option, if either subprocess fails, the whole pipe fails.
+// Like Bash, if both subprocesses fail, we return the failure of the destination.
+// This ensures both subprocesses' errors are present, using `error.pipedFrom`.
+export const waitForBothSubprocesses = async subprocessPromises => {
+	const [
+		{status: sourceStatus, reason: sourceReason, value: sourceResult = sourceReason},
+		{status: destinationStatus, reason: destinationReason, value: destinationResult = destinationReason},
+	] = await subprocessPromises;
+
+	if (!destinationResult.pipedFrom.includes(sourceResult)) {
+		destinationResult.pipedFrom.push(sourceResult);
+	}
+
+	if (destinationStatus === 'rejected') {
+		throw destinationResult;
+	}
+
+	if (sourceStatus === 'rejected') {
+		throw sourceResult;
+	}
+
+	return destinationResult;
+};

package/node_modules/execa/lib/pipe/setup.js

@@ -0,0 +1,72 @@
+import isPlainObject from 'is-plain-obj';
+import {normalizePipeArguments} from './pipe-arguments.js';
+import {handlePipeArgumentsError} from './throw.js';
+import {waitForBothSubprocesses} from './sequence.js';
+import {pipeSubprocessStream} from './streaming.js';
+import {unpipeOnAbort} from './abort.js';
+
+// Pipe a subprocess' `stdout`/`stderr`/`stdio` into another subprocess' `stdin`
+export const pipeToSubprocess = (sourceInfo, ...pipeArguments) => {
+	if (isPlainObject(pipeArguments[0])) {
+		return pipeToSubprocess.bind(undefined, {
+			...sourceInfo,
+			boundOptions: {...sourceInfo.boundOptions, ...pipeArguments[0]},
+		});
+	}
+
+	const {destination, ...normalizedInfo} = normalizePipeArguments(sourceInfo, ...pipeArguments);
+	const promise = handlePipePromise({...normalizedInfo, destination});
+	promise.pipe = pipeToSubprocess.bind(undefined, {
+		...sourceInfo,
+		source: destination,
+		sourcePromise: promise,
+		boundOptions: {},
+	});
+	return promise;
+};
+
+// Asynchronous logic when piping subprocesses
+const handlePipePromise = async ({
+	sourcePromise,
+	sourceStream,
+	sourceOptions,
+	sourceError,
+	destination,
+	destinationStream,
+	destinationError,
+	unpipeSignal,
+	fileDescriptors,
+	startTime,
+}) => {
+	const subprocessPromises = getSubprocessPromises(sourcePromise, destination);
+	handlePipeArgumentsError({
+		sourceStream,
+		sourceError,
+		destinationStream,
+		destinationError,
+		fileDescriptors,
+		sourceOptions,
+		startTime,
+	});
+	const maxListenersController = new AbortController();
+	try {
+		const mergedStream = pipeSubprocessStream(sourceStream, destinationStream, maxListenersController);
+		return await Promise.race([
+			waitForBothSubprocesses(subprocessPromises),
+			...unpipeOnAbort(unpipeSignal, {
+				sourceStream,
+				mergedStream,
+				sourceOptions,
+				fileDescriptors,
+				startTime,
+			}),
+		]);
+	} finally {
+		maxListenersController.abort();
+	}
+};
+
+// `.pipe()` awaits the subprocess promises.
+// When invalid arguments are passed to `.pipe()`, we throw an error, which prevents awaiting them.
+// We need to ensure this does not create unhandled rejections.
+const getSubprocessPromises = (sourcePromise, destination) => Promise.allSettled([sourcePromise, destination]);