karajan-code 3.4.1 → 3.4.2

package/node_modules/execa/lib/transform/split.js

@@ -1,110 +0,0 @@
-// Split chunks line-wise for generators passed to the `std*` options
-export const getSplitLinesGenerator = (binary, preserveNewlines, skipped, state) => binary || skipped
-	? undefined
-	: initializeSplitLines(preserveNewlines, state);
-
-// Same but for synchronous methods
-export const splitLinesSync = (chunk, preserveNewlines, objectMode) => objectMode
-	? chunk.flatMap(item => splitLinesItemSync(item, preserveNewlines))
-	: splitLinesItemSync(chunk, preserveNewlines);
-
-const splitLinesItemSync = (chunk, preserveNewlines) => {
-	const {transform, final} = initializeSplitLines(preserveNewlines, {});
-	return [...transform(chunk), ...final()];
-};
-
-const initializeSplitLines = (preserveNewlines, state) => {
-	state.previousChunks = '';
-	return {
-		transform: splitGenerator.bind(undefined, state, preserveNewlines),
-		final: linesFinal.bind(undefined, state),
-	};
-};
-
-// This imperative logic is much faster than using `String.split()` and uses very low memory.
-const splitGenerator = function * (state, preserveNewlines, chunk) {
-	if (typeof chunk !== 'string') {
-		yield chunk;
-		return;
-	}
-
-	let {previousChunks} = state;
-	let start = -1;
-
-	for (let end = 0; end < chunk.length; end += 1) {
-		if (chunk[end] === '\n') {
-			const newlineLength = getNewlineLength(chunk, end, preserveNewlines, state);
-			let line = chunk.slice(start + 1, end + 1 - newlineLength);
-
-			if (previousChunks.length > 0) {
-				line = concatString(previousChunks, line);
-				previousChunks = '';
-			}
-
-			yield line;
-			start = end;
-		}
-	}
-
-	if (start !== chunk.length - 1) {
-		previousChunks = concatString(previousChunks, chunk.slice(start + 1));
-	}
-
-	state.previousChunks = previousChunks;
-};
-
-const getNewlineLength = (chunk, end, preserveNewlines, state) => {
-	if (preserveNewlines) {
-		return 0;
-	}
-
-	state.isWindowsNewline = end !== 0 && chunk[end - 1] === '\r';
-	return state.isWindowsNewline ? 2 : 1;
-};
-
-const linesFinal = function * ({previousChunks}) {
-	if (previousChunks.length > 0) {
-		yield previousChunks;
-	}
-};
-
-// Unless `preserveNewlines: true` is used, we strip the newline of each line.
-// This re-adds them after the user `transform` code has run.
-export const getAppendNewlineGenerator = ({binary, preserveNewlines, readableObjectMode, state}) => binary || preserveNewlines || readableObjectMode
-	? undefined
-	: {transform: appendNewlineGenerator.bind(undefined, state)};
-
-const appendNewlineGenerator = function * ({isWindowsNewline = false}, chunk) {
-	const {unixNewline, windowsNewline, LF, concatBytes} = typeof chunk === 'string' ? linesStringInfo : linesUint8ArrayInfo;
-
-	if (chunk.at(-1) === LF) {
-		yield chunk;
-		return;
-	}
-
-	const newline = isWindowsNewline ? windowsNewline : unixNewline;
-	yield concatBytes(chunk, newline);
-};
-
-const concatString = (firstChunk, secondChunk) => `${firstChunk}${secondChunk}`;
-
-const linesStringInfo = {
-	windowsNewline: '\r\n',
-	unixNewline: '\n',
-	LF: '\n',
-	concatBytes: concatString,
-};
-
-const concatUint8Array = (firstChunk, secondChunk) => {
-	const chunk = new Uint8Array(firstChunk.length + secondChunk.length);
-	chunk.set(firstChunk, 0);
-	chunk.set(secondChunk, firstChunk.length);
-	return chunk;
-};
-
-const linesUint8ArrayInfo = {
-	windowsNewline: new Uint8Array([0x0D, 0x0A]),
-	unixNewline: new Uint8Array([0x0A]),
-	LF: 0x0A,
-	concatBytes: concatUint8Array,
-};

package/node_modules/execa/lib/transform/validate.js

@@ -1,43 +0,0 @@
-import {Buffer} from 'node:buffer';
-import {isUint8Array} from '../utils/uint-array.js';
-
-// Validate the type of chunk argument passed to transform generators
-export const getValidateTransformInput = (writableObjectMode, optionName) => writableObjectMode
-	? undefined
-	: validateStringTransformInput.bind(undefined, optionName);
-
-const validateStringTransformInput = function * (optionName, chunk) {
-	if (typeof chunk !== 'string' && !isUint8Array(chunk) && !Buffer.isBuffer(chunk)) {
-		throw new TypeError(`The \`${optionName}\` option's transform must use "objectMode: true" to receive as input: ${typeof chunk}.`);
-	}
-
-	yield chunk;
-};
-
-// Validate the type of the value returned by transform generators
-export const getValidateTransformReturn = (readableObjectMode, optionName) => readableObjectMode
-	? validateObjectTransformReturn.bind(undefined, optionName)
-	: validateStringTransformReturn.bind(undefined, optionName);
-
-const validateObjectTransformReturn = function * (optionName, chunk) {
-	validateEmptyReturn(optionName, chunk);
-	yield chunk;
-};
-
-const validateStringTransformReturn = function * (optionName, chunk) {
-	validateEmptyReturn(optionName, chunk);
-
-	if (typeof chunk !== 'string' && !isUint8Array(chunk)) {
-		throw new TypeError(`The \`${optionName}\` option's function must yield a string or an Uint8Array, not ${typeof chunk}.`);
-	}
-
-	yield chunk;
-};
-
-const validateEmptyReturn = (optionName, chunk) => {
-	if (chunk === null || chunk === undefined) {
-		throw new TypeError(`The \`${optionName}\` option's function must not call \`yield ${chunk}\`.
-Instead, \`yield\` should either be called with a value, or not be called at all. For example:
-  if (condition) { yield value; }`);
-	}
-};

package/node_modules/execa/lib/utils/abort-signal.js

@@ -1,8 +0,0 @@
-import {once} from 'node:events';
-
-// Combines `util.aborted()` and `events.addAbortListener()`: promise-based and cleaned up with a stop signal
-export const onAbortedSignal = async (mainSignal, stopSignal) => {
-	if (!mainSignal.aborted) {
-		await once(mainSignal, 'abort', {signal: stopSignal});
-	}
-};

package/node_modules/execa/lib/utils/deferred.js

@@ -1,7 +0,0 @@
-export const createDeferred = () => {
-	const methods = {};
-	const promise = new Promise((resolve, reject) => {
-		Object.assign(methods, {resolve, reject});
-	});
-	return Object.assign(promise, methods);
-};

package/node_modules/execa/lib/utils/max-listeners.js

@@ -1,14 +0,0 @@
-import {addAbortListener} from 'node:events';
-
-// Temporarily increase the maximum number of listeners on an eventEmitter
-export const incrementMaxListeners = (eventEmitter, maxListenersIncrement, signal) => {
-	const maxListeners = eventEmitter.getMaxListeners();
-	if (maxListeners === 0 || maxListeners === Number.POSITIVE_INFINITY) {
-		return;
-	}
-
-	eventEmitter.setMaxListeners(maxListeners + maxListenersIncrement);
-	addAbortListener(signal, () => {
-		eventEmitter.setMaxListeners(eventEmitter.getMaxListeners() - maxListenersIncrement);
-	});
-};

package/node_modules/execa/lib/utils/standard-stream.js

@@ -1,6 +0,0 @@
-import process from 'node:process';
-
-export const isStandardStream = stream => STANDARD_STREAMS.includes(stream);
-export const STANDARD_STREAMS = [process.stdin, process.stdout, process.stderr];
-export const STANDARD_STREAMS_ALIASES = ['stdin', 'stdout', 'stderr'];
-export const getStreamName = fdNumber => STANDARD_STREAMS_ALIASES[fdNumber] ?? `stdio[${fdNumber}]`;

package/node_modules/execa/lib/utils/uint-array.js

@@ -1,69 +0,0 @@
-import {StringDecoder} from 'node:string_decoder';
-
-const {toString: objectToString} = Object.prototype;
-
-export const isArrayBuffer = value => objectToString.call(value) === '[object ArrayBuffer]';
-
-// Is either Uint8Array or Buffer
-export const isUint8Array = value => objectToString.call(value) === '[object Uint8Array]';
-
-export const bufferToUint8Array = buffer => new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-
-const textEncoder = new TextEncoder();
-const stringToUint8Array = string => textEncoder.encode(string);
-
-const textDecoder = new TextDecoder();
-export const uint8ArrayToString = uint8Array => textDecoder.decode(uint8Array);
-
-export const joinToString = (uint8ArraysOrStrings, encoding) => {
-	const strings = uint8ArraysToStrings(uint8ArraysOrStrings, encoding);
-	return strings.join('');
-};
-
-const uint8ArraysToStrings = (uint8ArraysOrStrings, encoding) => {
-	if (encoding === 'utf8' && uint8ArraysOrStrings.every(uint8ArrayOrString => typeof uint8ArrayOrString === 'string')) {
-		return uint8ArraysOrStrings;
-	}
-
-	const decoder = new StringDecoder(encoding);
-	const strings = uint8ArraysOrStrings
-		.map(uint8ArrayOrString => typeof uint8ArrayOrString === 'string'
-			? stringToUint8Array(uint8ArrayOrString)
-			: uint8ArrayOrString)
-		.map(uint8Array => decoder.write(uint8Array));
-	const finalString = decoder.end();
-	return finalString === '' ? strings : [...strings, finalString];
-};
-
-export const joinToUint8Array = uint8ArraysOrStrings => {
-	if (uint8ArraysOrStrings.length === 1 && isUint8Array(uint8ArraysOrStrings[0])) {
-		return uint8ArraysOrStrings[0];
-	}
-
-	return concatUint8Arrays(stringsToUint8Arrays(uint8ArraysOrStrings));
-};
-
-const stringsToUint8Arrays = uint8ArraysOrStrings => uint8ArraysOrStrings.map(uint8ArrayOrString => typeof uint8ArrayOrString === 'string'
-	? stringToUint8Array(uint8ArrayOrString)
-	: uint8ArrayOrString);
-
-export const concatUint8Arrays = uint8Arrays => {
-	const result = new Uint8Array(getJoinLength(uint8Arrays));
-
-	let index = 0;
-	for (const uint8Array of uint8Arrays) {
-		result.set(uint8Array, index);
-		index += uint8Array.length;
-	}
-
-	return result;
-};
-
-const getJoinLength = uint8Arrays => {
-	let joinLength = 0;
-	for (const uint8Array of uint8Arrays) {
-		joinLength += uint8Array.length;
-	}
-
-	return joinLength;
-};

package/node_modules/execa/lib/verbose/complete.js

@@ -1,24 +0,0 @@
-import prettyMs from 'pretty-ms';
-import {isVerbose} from './values.js';
-import {verboseLog} from './log.js';
-import {logError} from './error.js';
-
-// When `verbose` is `short|full|custom`, print each command's completion, duration and error
-export const logResult = (result, verboseInfo) => {
-	if (!isVerbose(verboseInfo)) {
-		return;
-	}
-
-	logError(result, verboseInfo);
-	logDuration(result, verboseInfo);
-};
-
-const logDuration = (result, verboseInfo) => {
-	const verboseMessage = `(done in ${prettyMs(result.durationMs)})`;
-	verboseLog({
-		type: 'duration',
-		verboseMessage,
-		verboseInfo,
-		result,
-	});
-};

package/node_modules/execa/lib/verbose/custom.js

@@ -1,26 +0,0 @@
-import {getVerboseFunction} from './values.js';
-
-// Apply the `verbose` function on each line
-export 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('');
-};
-
-const applyVerboseFunction = (verboseLine, verboseObject, verboseFunction) => {
-	if (verboseFunction === undefined) {
-		return verboseLine;
-	}
-
-	const printedLine = verboseFunction(verboseLine, verboseObject);
-	if (typeof printedLine === 'string') {
-		return printedLine;
-	}
-};
-
-const appendNewline = printedLine => printedLine.endsWith('\n')
-	? printedLine
-	: `${printedLine}\n`;

package/node_modules/execa/lib/verbose/default.js

@@ -1,54 +0,0 @@
-import figures from 'figures';
-import {
-	gray,
-	bold,
-	redBright,
-	yellowBright,
-} from 'yoctocolors';
-
-// Default when `verbose` is not a function
-export 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)}`;
-};
-
-// 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 padField = (field, padding) => String(field).padStart(padding, '0');
-
-const getFinalIcon = ({failed, reject}) => {
-	if (!failed) {
-		return figures.tick;
-	}
-
-	return reject ? figures.cross : figures.warning;
-};
-
-const ICONS = {
-	command: ({piped}) => piped ? '|' : '$',
-	output: () => ' ',
-	ipc: () => '*',
-	error: getFinalIcon,
-	duration: getFinalIcon,
-};
-
-const identity = string => string;
-
-const COLORS = {
-	command: () => bold,
-	output: () => identity,
-	ipc: () => identity,
-	error: ({reject}) => reject ? redBright : yellowBright,
-	duration: () => gray,
-};

package/node_modules/execa/lib/verbose/error.js

@@ -1,13 +0,0 @@
-import {verboseLog} from './log.js';
-
-// When `verbose` is `short|full|custom`, print each command's error when it fails
-export const logError = (result, verboseInfo) => {
-	if (result.failed) {
-		verboseLog({
-			type: 'error',
-			verboseMessage: result.shortMessage,
-			verboseInfo,
-			result,
-		});
-	}
-};

package/node_modules/execa/lib/verbose/info.js

@@ -1,39 +0,0 @@
-import {isVerbose, VERBOSE_VALUES, isVerboseFunction} from './values.js';
-
-// Information computed before spawning, used by the `verbose` option
-export const getVerboseInfo = (verbose, escapedCommand, rawOptions) => {
-	validateVerbose(verbose);
-	const commandId = getCommandId(verbose);
-	return {
-		verbose,
-		escapedCommand,
-		commandId,
-		rawOptions,
-	};
-};
-
-const getCommandId = verbose => isVerbose({verbose}) ? COMMAND_ID++ : undefined;
-
-// 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 validateVerbose = verbose => {
-	for (const fdVerbose of verbose) {
-		if (fdVerbose === false) {
-			throw new TypeError('The "verbose: false" option was renamed to "verbose: \'none\'".');
-		}
-
-		if (fdVerbose === true) {
-			throw new TypeError('The "verbose: true" option was renamed to "verbose: \'short\'".');
-		}
-
-		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.`);
-		}
-	}
-};

package/node_modules/execa/lib/verbose/ipc.js

@@ -1,15 +0,0 @@
-import {verboseLog, serializeVerboseMessage} from './log.js';
-import {isFullVerbose} from './values.js';
-
-// When `verbose` is `'full'`, print IPC messages from the subprocess
-export const shouldLogIpc = verboseInfo => isFullVerbose(verboseInfo, 'ipc');
-
-export const logIpcOutput = (message, verboseInfo) => {
-	const verboseMessage = serializeVerboseMessage(message);
-	verboseLog({
-		type: 'ipc',
-		verboseMessage,
-		fdNumber: 'ipc',
-		verboseInfo,
-	});
-};

package/node_modules/execa/lib/verbose/log.js

@@ -1,54 +0,0 @@
-import {inspect} from 'node:util';
-import {escapeLines} from '../arguments/escape.js';
-import {defaultVerboseFunction} from './default.js';
-import {applyVerboseOnLines} from './custom.js';
-
-// This prints on stderr.
-// If the subprocess prints on stdout and is using `stdout: 'inherit'`,
-// there is a chance both writes will compete (introducing a race condition).
-// This means their respective order is not deterministic.
-// In particular, this means the verbose command lines might be after the start of the subprocess output.
-// Using synchronous I/O does not solve this problem.
-// However, this only seems to happen when the stdout/stderr target
-// (e.g. a terminal) is being written to by many subprocesses at once, which is unlikely in real scenarios.
-export const verboseLog = ({type, verboseMessage, fdNumber, verboseInfo, result}) => {
-	const verboseObject = getVerboseObject({type, result, verboseInfo});
-	const printedLines = getPrintedLines(verboseMessage, verboseObject);
-	const finalLines = applyVerboseOnLines(printedLines, verboseInfo, fdNumber);
-	if (finalLines !== '') {
-		console.warn(finalLines.slice(0, -1));
-	}
-};
-
-const getVerboseObject = ({
-	type,
-	result,
-	verboseInfo: {escapedCommand, commandId, rawOptions: {piped = false, ...options}},
-}) => ({
-	type,
-	escapedCommand,
-	commandId: `${commandId}`,
-	timestamp: new Date(),
-	piped,
-	result,
-	options,
-});
-
-const getPrintedLines = (verboseMessage, verboseObject) => verboseMessage
-	.split('\n')
-	.map(message => getPrintedLine({...verboseObject, message}));
-
-const getPrintedLine = verboseObject => {
-	const verboseLine = defaultVerboseFunction(verboseObject);
-	return {verboseLine, verboseObject};
-};
-
-// Serialize any type to a line string, for logging
-export const serializeVerboseMessage = message => {
-	const messageString = typeof message === 'string' ? message : inspect(message);
-	const escapedMessage = escapeLines(messageString);
-	return escapedMessage.replaceAll('\t', ' '.repeat(TAB_SIZE));
-};
-
-// Same as `util.inspect()`
-const TAB_SIZE = 2;

package/node_modules/execa/lib/verbose/output.js

@@ -1,60 +0,0 @@
-import {BINARY_ENCODINGS} from '../arguments/encoding-option.js';
-import {TRANSFORM_TYPES} from '../stdio/type.js';
-import {verboseLog, serializeVerboseMessage} from './log.js';
-import {isFullVerbose} from './values.js';
-
-// `ignore` opts-out of `verbose` for a specific stream.
-// `ipc` cannot use piping.
-// `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`.
-export 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))
-	|| stdioItems.every(({type}) => TRANSFORM_TYPES.has(type)));
-
-// Printing input streams would be confusing.
-// Files and streams can produce big outputs, which we don't want to print.
-// We could print `stdio[3+]` but it often is redirected to files and streams, with the same issue.
-// So we only print stdout and stderr.
-const fdUsesVerbose = fdNumber => fdNumber === 1 || fdNumber === 2;
-
-const PIPED_STDIO_VALUES = new Set(['pipe', 'overlapped']);
-
-// `verbose: 'full'` printing logic with async methods
-export const logLines = async (linesIterable, stream, fdNumber, verboseInfo) => {
-	for await (const line of linesIterable) {
-		if (!isPipingStream(stream)) {
-			logLine(line, fdNumber, verboseInfo);
-		}
-	}
-};
-
-// `verbose: 'full'` printing logic with sync methods
-export const logLinesSync = (linesArray, fdNumber, verboseInfo) => {
-	for (const line of linesArray) {
-		logLine(line, fdNumber, verboseInfo);
-	}
-};
-
-// When `subprocess.stdout|stderr.pipe()` is called, `verbose` becomes a noop.
-// This prevents the following problems:
-//  - `.pipe()` achieves the same result as using `stdout: 'inherit'`, `stdout: stream`, etc. which also make `verbose` a noop.
-//    For example, `subprocess.stdout.pipe(process.stdin)` would print each line twice.
-//  - When chaining subprocesses with `subprocess.pipe(otherSubprocess)`, only the last one should print its output.
-// Detecting whether `.pipe()` is impossible without monkey-patching it, so we use the following undocumented property.
-// This is not a critical behavior since changes of the following property would only make `verbose` more verbose.
-const isPipingStream = stream => stream._readableState.pipes.length > 0;
-
-// When `verbose` is `full`, print stdout|stderr
-const logLine = (line, fdNumber, verboseInfo) => {
-	const verboseMessage = serializeVerboseMessage(line);
-	verboseLog({
-		type: 'output',
-		verboseMessage,
-		fdNumber,
-		verboseInfo,
-	});
-};

package/node_modules/execa/lib/verbose/start.js

@@ -1,15 +0,0 @@
-import {isVerbose} from './values.js';
-import {verboseLog} from './log.js';
-
-// When `verbose` is `short|full|custom`, print each command
-export const logCommand = (escapedCommand, verboseInfo) => {
-	if (!isVerbose(verboseInfo)) {
-		return;
-	}
-
-	verboseLog({
-		type: 'command',
-		verboseMessage: escapedCommand,
-		verboseInfo,
-	});
-};

package/node_modules/execa/lib/verbose/values.js

@@ -1,33 +0,0 @@
-import {getFdSpecificValue} from '../arguments/specific.js';
-
-// The `verbose` option can have different values for `stdout`/`stderr`
-export const isVerbose = ({verbose}, fdNumber) => getFdVerbose(verbose, fdNumber) !== 'none';
-
-// Whether IPC and output and logged
-export const isFullVerbose = ({verbose}, fdNumber) => !['none', 'short'].includes(getFdVerbose(verbose, fdNumber));
-
-// The `verbose` option can be a function to customize logging
-export const getVerboseFunction = ({verbose}, fdNumber) => {
-	const fdVerbose = getFdVerbose(verbose, fdNumber);
-	return isVerboseFunction(fdVerbose) ? fdVerbose : undefined;
-};
-
-// 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
-export const isVerboseFunction = fdVerbose => typeof fdVerbose === 'function';
-
-export const VERBOSE_VALUES = ['none', 'short', 'full'];

package/node_modules/execa/license

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.