karajan-code 3.4.1 → 3.4.2

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

@@ -1,163 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,15 +0,0 @@
-// 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

@@ -1,22 +0,0 @@
-// 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

@@ -1,153 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,24 +0,0 @@
-// 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

@@ -1,72 +0,0 @@
-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]);