vitest 0.2.5 → 0.3.0

package/dist/index-ce49e384.js

@@ -0,0 +1,1644 @@
+import path$2 from 'path';
+import fs$2 from 'fs';
+import require$$0 from 'util';
+import childProcess$1 from 'child_process';
+import { p as pathKey, m as mergeStream$1, a as getStream$1, b as crossSpawn$1 } from './index-6e709f57.js';
+import { a as signalExit, b as onetime$1 } from './index-648e7ab2.js';
+import require$$0$1 from 'os';
+import './_commonjsHelpers-c9e3b764.js';
+import 'buffer';
+import 'stream';
+import 'assert';
+import 'events';
+
+var findUp$1 = {exports: {}};
+
+var locatePath = {exports: {}};
+
+class Node {
+	/// value;
+	/// next;
+
+	constructor(value) {
+		this.value = value;
+
+		// TODO: Remove this when targeting Node.js 12.
+		this.next = undefined;
+	}
+}
+
+class Queue$1 {
+	// TODO: Use private class fields when targeting Node.js 12.
+	// #_head;
+	// #_tail;
+	// #_size;
+
+	constructor() {
+		this.clear();
+	}
+
+	enqueue(value) {
+		const node = new Node(value);
+
+		if (this._head) {
+			this._tail.next = node;
+			this._tail = node;
+		} else {
+			this._head = node;
+			this._tail = node;
+		}
+
+		this._size++;
+	}
+
+	dequeue() {
+		const current = this._head;
+		if (!current) {
+			return;
+		}
+
+		this._head = this._head.next;
+		this._size--;
+		return current.value;
+	}
+
+	clear() {
+		this._head = undefined;
+		this._tail = undefined;
+		this._size = 0;
+	}
+
+	get size() {
+		return this._size;
+	}
+
+	* [Symbol.iterator]() {
+		let current = this._head;
+
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+}
+
+var yoctoQueue = Queue$1;
+
+const Queue = yoctoQueue;
+
+const pLimit$1 = concurrency => {
+	if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+	}
+
+	const queue = new Queue();
+	let activeCount = 0;
+
+	const next = () => {
+		activeCount--;
+
+		if (queue.size > 0) {
+			queue.dequeue()();
+		}
+	};
+
+	const run = async (fn, resolve, ...args) => {
+		activeCount++;
+
+		const result = (async () => fn(...args))();
+
+		resolve(result);
+
+		try {
+			await result;
+		} catch {}
+
+		next();
+	};
+
+	const enqueue = (fn, resolve, ...args) => {
+		queue.enqueue(run.bind(null, fn, resolve, ...args));
+
+		(async () => {
+			// This function needs to wait until the next microtask before comparing
+			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+			// when the run function is dequeued and called. The comparison in the if-statement
+			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+			await Promise.resolve();
+
+			if (activeCount < concurrency && queue.size > 0) {
+				queue.dequeue()();
+			}
+		})();
+	};
+
+	const generator = (fn, ...args) => new Promise(resolve => {
+		enqueue(fn, resolve, ...args);
+	});
+
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount
+		},
+		pendingCount: {
+			get: () => queue.size
+		},
+		clearQueue: {
+			value: () => {
+				queue.clear();
+			}
+		}
+	});
+
+	return generator;
+};
+
+var pLimit_1 = pLimit$1;
+
+const pLimit = pLimit_1;
+
+class EndError extends Error {
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+}
+
+// The input can also be a promise, so we await it
+const testElement = async (element, tester) => tester(await element);
+
+// The input can also be a promise, so we `Promise.all()` them both
+const finder = async element => {
+	const values = await Promise.all(element);
+	if (values[1] === true) {
+		throw new EndError(values[0]);
+	}
+
+	return false;
+};
+
+const pLocate$1 = async (iterable, tester, options) => {
+	options = {
+		concurrency: Infinity,
+		preserveOrder: true,
+		...options
+	};
+
+	const limit = pLimit(options.concurrency);
+
+	// Start all the promises concurrently with optional limit
+	const items = [...iterable].map(element => [element, limit(testElement, element, tester)]);
+
+	// Check the promises either serially or concurrently
+	const checkLimit = pLimit(options.preserveOrder ? 1 : Infinity);
+
+	try {
+		await Promise.all(items.map(element => checkLimit(finder, element)));
+	} catch (error) {
+		if (error instanceof EndError) {
+			return error.value;
+		}
+
+		throw error;
+	}
+};
+
+var pLocate_1 = pLocate$1;
+
+const path$1 = path$2;
+const fs$1 = fs$2;
+const {promisify: promisify$1} = require$$0;
+const pLocate = pLocate_1;
+
+const fsStat = promisify$1(fs$1.stat);
+const fsLStat = promisify$1(fs$1.lstat);
+
+const typeMappings = {
+	directory: 'isDirectory',
+	file: 'isFile'
+};
+
+function checkType({type}) {
+	if (type in typeMappings) {
+		return;
+	}
+
+	throw new Error(`Invalid type specified: ${type}`);
+}
+
+const matchType = (type, stat) => type === undefined || stat[typeMappings[type]]();
+
+locatePath.exports = async (paths, options) => {
+	options = {
+		cwd: process.cwd(),
+		type: 'file',
+		allowSymlinks: true,
+		...options
+	};
+
+	checkType(options);
+
+	const statFn = options.allowSymlinks ? fsStat : fsLStat;
+
+	return pLocate(paths, async path_ => {
+		try {
+			const stat = await statFn(path$1.resolve(options.cwd, path_));
+			return matchType(options.type, stat);
+		} catch {
+			return false;
+		}
+	}, options);
+};
+
+locatePath.exports.sync = (paths, options) => {
+	options = {
+		cwd: process.cwd(),
+		allowSymlinks: true,
+		type: 'file',
+		...options
+	};
+
+	checkType(options);
+
+	const statFn = options.allowSymlinks ? fs$1.statSync : fs$1.lstatSync;
+
+	for (const path_ of paths) {
+		try {
+			const stat = statFn(path$1.resolve(options.cwd, path_));
+
+			if (matchType(options.type, stat)) {
+				return path_;
+			}
+		} catch {}
+	}
+};
+
+var pathExists = {exports: {}};
+
+const fs = fs$2;
+const {promisify} = require$$0;
+
+const pAccess = promisify(fs.access);
+
+pathExists.exports = async path => {
+	try {
+		await pAccess(path);
+		return true;
+	} catch (_) {
+		return false;
+	}
+};
+
+pathExists.exports.sync = path => {
+	try {
+		fs.accessSync(path);
+		return true;
+	} catch (_) {
+		return false;
+	}
+};
+
+(function (module) {
+const path = path$2;
+const locatePath$1 = locatePath.exports;
+const pathExists$1 = pathExists.exports;
+
+const stop = Symbol('findUp.stop');
+
+module.exports = async (name, options = {}) => {
+	let directory = path.resolve(options.cwd || '');
+	const {root} = path.parse(directory);
+	const paths = [].concat(name);
+
+	const runMatcher = async locateOptions => {
+		if (typeof name !== 'function') {
+			return locatePath$1(paths, locateOptions);
+		}
+
+		const foundPath = await name(locateOptions.cwd);
+		if (typeof foundPath === 'string') {
+			return locatePath$1([foundPath], locateOptions);
+		}
+
+		return foundPath;
+	};
+
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		// eslint-disable-next-line no-await-in-loop
+		const foundPath = await runMatcher({...options, cwd: directory});
+
+		if (foundPath === stop) {
+			return;
+		}
+
+		if (foundPath) {
+			return path.resolve(directory, foundPath);
+		}
+
+		if (directory === root) {
+			return;
+		}
+
+		directory = path.dirname(directory);
+	}
+};
+
+module.exports.sync = (name, options = {}) => {
+	let directory = path.resolve(options.cwd || '');
+	const {root} = path.parse(directory);
+	const paths = [].concat(name);
+
+	const runMatcher = locateOptions => {
+		if (typeof name !== 'function') {
+			return locatePath$1.sync(paths, locateOptions);
+		}
+
+		const foundPath = name(locateOptions.cwd);
+		if (typeof foundPath === 'string') {
+			return locatePath$1.sync([foundPath], locateOptions);
+		}
+
+		return foundPath;
+	};
+
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		const foundPath = runMatcher({...options, cwd: directory});
+
+		if (foundPath === stop) {
+			return;
+		}
+
+		if (foundPath) {
+			return path.resolve(directory, foundPath);
+		}
+
+		if (directory === root) {
+			return;
+		}
+
+		directory = path.dirname(directory);
+	}
+};
+
+module.exports.exists = pathExists$1;
+
+module.exports.sync.exists = pathExists$1.sync;
+
+module.exports.stop = stop;
+}(findUp$1));
+
+var findUp = findUp$1.exports;
+
+var execa$2 = {exports: {}};
+
+var stripFinalNewline$1 = input => {
+	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
+	const CR = typeof input === 'string' ? '\r' : '\r'.charCodeAt();
+
+	if (input[input.length - 1] === LF) {
+		input = input.slice(0, input.length - 1);
+	}
+
+	if (input[input.length - 1] === CR) {
+		input = input.slice(0, input.length - 1);
+	}
+
+	return input;
+};
+
+var npmRunPath$1 = {exports: {}};
+
+(function (module) {
+const path = path$2;
+const pathKey$1 = pathKey.exports;
+
+const npmRunPath = options => {
+	options = {
+		cwd: process.cwd(),
+		path: process.env[pathKey$1()],
+		execPath: process.execPath,
+		...options
+	};
+
+	let previous;
+	let cwdPath = path.resolve(options.cwd);
+	const result = [];
+
+	while (previous !== cwdPath) {
+		result.push(path.join(cwdPath, 'node_modules/.bin'));
+		previous = cwdPath;
+		cwdPath = path.resolve(cwdPath, '..');
+	}
+
+	// Ensure the running `node` binary is used
+	const execPathDir = path.resolve(options.cwd, options.execPath, '..');
+	result.push(execPathDir);
+
+	return result.concat(options.path).join(path.delimiter);
+};
+
+module.exports = npmRunPath;
+// TODO: Remove this for the next major release
+module.exports.default = npmRunPath;
+
+module.exports.env = options => {
+	options = {
+		env: process.env,
+		...options
+	};
+
+	const env = {...options.env};
+	const path = pathKey$1({env});
+
+	options.path = env[path];
+	env[path] = module.exports(options);
+
+	return env;
+};
+}(npmRunPath$1));
+
+var main = {};
+
+var signals = {};
+
+var core = {};
+
+Object.defineProperty(core,"__esModule",{value:true});core.SIGNALS=void 0;
+
+const SIGNALS=[
+{
+name:"SIGHUP",
+number:1,
+action:"terminate",
+description:"Terminal closed",
+standard:"posix"},
+
+{
+name:"SIGINT",
+number:2,
+action:"terminate",
+description:"User interruption with CTRL-C",
+standard:"ansi"},
+
+{
+name:"SIGQUIT",
+number:3,
+action:"core",
+description:"User interruption with CTRL-\\",
+standard:"posix"},
+
+{
+name:"SIGILL",
+number:4,
+action:"core",
+description:"Invalid machine instruction",
+standard:"ansi"},
+
+{
+name:"SIGTRAP",
+number:5,
+action:"core",
+description:"Debugger breakpoint",
+standard:"posix"},
+
+{
+name:"SIGABRT",
+number:6,
+action:"core",
+description:"Aborted",
+standard:"ansi"},
+
+{
+name:"SIGIOT",
+number:6,
+action:"core",
+description:"Aborted",
+standard:"bsd"},
+
+{
+name:"SIGBUS",
+number:7,
+action:"core",
+description:
+"Bus error due to misaligned, non-existing address or paging error",
+standard:"bsd"},
+
+{
+name:"SIGEMT",
+number:7,
+action:"terminate",
+description:"Command should be emulated but is not implemented",
+standard:"other"},
+
+{
+name:"SIGFPE",
+number:8,
+action:"core",
+description:"Floating point arithmetic error",
+standard:"ansi"},
+
+{
+name:"SIGKILL",
+number:9,
+action:"terminate",
+description:"Forced termination",
+standard:"posix",
+forced:true},
+
+{
+name:"SIGUSR1",
+number:10,
+action:"terminate",
+description:"Application-specific signal",
+standard:"posix"},
+
+{
+name:"SIGSEGV",
+number:11,
+action:"core",
+description:"Segmentation fault",
+standard:"ansi"},
+
+{
+name:"SIGUSR2",
+number:12,
+action:"terminate",
+description:"Application-specific signal",
+standard:"posix"},
+
+{
+name:"SIGPIPE",
+number:13,
+action:"terminate",
+description:"Broken pipe or socket",
+standard:"posix"},
+
+{
+name:"SIGALRM",
+number:14,
+action:"terminate",
+description:"Timeout or timer",
+standard:"posix"},
+
+{
+name:"SIGTERM",
+number:15,
+action:"terminate",
+description:"Termination",
+standard:"ansi"},
+
+{
+name:"SIGSTKFLT",
+number:16,
+action:"terminate",
+description:"Stack is empty or overflowed",
+standard:"other"},
+
+{
+name:"SIGCHLD",
+number:17,
+action:"ignore",
+description:"Child process terminated, paused or unpaused",
+standard:"posix"},
+
+{
+name:"SIGCLD",
+number:17,
+action:"ignore",
+description:"Child process terminated, paused or unpaused",
+standard:"other"},
+
+{
+name:"SIGCONT",
+number:18,
+action:"unpause",
+description:"Unpaused",
+standard:"posix",
+forced:true},
+
+{
+name:"SIGSTOP",
+number:19,
+action:"pause",
+description:"Paused",
+standard:"posix",
+forced:true},
+
+{
+name:"SIGTSTP",
+number:20,
+action:"pause",
+description:"Paused using CTRL-Z or \"suspend\"",
+standard:"posix"},
+
+{
+name:"SIGTTIN",
+number:21,
+action:"pause",
+description:"Background process cannot read terminal input",
+standard:"posix"},
+
+{
+name:"SIGBREAK",
+number:21,
+action:"terminate",
+description:"User interruption with CTRL-BREAK",
+standard:"other"},
+
+{
+name:"SIGTTOU",
+number:22,
+action:"pause",
+description:"Background process cannot write to terminal output",
+standard:"posix"},
+
+{
+name:"SIGURG",
+number:23,
+action:"ignore",
+description:"Socket received out-of-band data",
+standard:"bsd"},
+
+{
+name:"SIGXCPU",
+number:24,
+action:"core",
+description:"Process timed out",
+standard:"bsd"},
+
+{
+name:"SIGXFSZ",
+number:25,
+action:"core",
+description:"File too big",
+standard:"bsd"},
+
+{
+name:"SIGVTALRM",
+number:26,
+action:"terminate",
+description:"Timeout or timer",
+standard:"bsd"},
+
+{
+name:"SIGPROF",
+number:27,
+action:"terminate",
+description:"Timeout or timer",
+standard:"bsd"},
+
+{
+name:"SIGWINCH",
+number:28,
+action:"ignore",
+description:"Terminal window size changed",
+standard:"bsd"},
+
+{
+name:"SIGIO",
+number:29,
+action:"terminate",
+description:"I/O is available",
+standard:"other"},
+
+{
+name:"SIGPOLL",
+number:29,
+action:"terminate",
+description:"Watched event",
+standard:"other"},
+
+{
+name:"SIGINFO",
+number:29,
+action:"ignore",
+description:"Request for process information",
+standard:"other"},
+
+{
+name:"SIGPWR",
+number:30,
+action:"terminate",
+description:"Device running out of power",
+standard:"systemv"},
+
+{
+name:"SIGSYS",
+number:31,
+action:"core",
+description:"Invalid system call",
+standard:"other"},
+
+{
+name:"SIGUNUSED",
+number:31,
+action:"terminate",
+description:"Invalid system call",
+standard:"other"}];core.SIGNALS=SIGNALS;
+
+var realtime = {};
+
+Object.defineProperty(realtime,"__esModule",{value:true});realtime.SIGRTMAX=realtime.getRealtimeSignals=void 0;
+const getRealtimeSignals=function(){
+const length=SIGRTMAX-SIGRTMIN+1;
+return Array.from({length},getRealtimeSignal);
+};realtime.getRealtimeSignals=getRealtimeSignals;
+
+const getRealtimeSignal=function(value,index){
+return {
+name:`SIGRT${index+1}`,
+number:SIGRTMIN+index,
+action:"terminate",
+description:"Application-specific signal (realtime)",
+standard:"posix"};
+
+};
+
+const SIGRTMIN=34;
+const SIGRTMAX=64;realtime.SIGRTMAX=SIGRTMAX;
+
+Object.defineProperty(signals,"__esModule",{value:true});signals.getSignals=void 0;var _os$1=require$$0$1;
+
+var _core=core;
+var _realtime$1=realtime;
+
+
+
+const getSignals=function(){
+const realtimeSignals=(0, _realtime$1.getRealtimeSignals)();
+const signals=[..._core.SIGNALS,...realtimeSignals].map(normalizeSignal);
+return signals;
+};signals.getSignals=getSignals;
+
+
+
+
+
+
+
+const normalizeSignal=function({
+name,
+number:defaultNumber,
+description,
+action,
+forced=false,
+standard})
+{
+const{
+signals:{[name]:constantSignal}}=
+_os$1.constants;
+const supported=constantSignal!==undefined;
+const number=supported?constantSignal:defaultNumber;
+return {name,number,description,supported,action,forced,standard};
+};
+
+Object.defineProperty(main,"__esModule",{value:true});main.signalsByNumber=main.signalsByName=void 0;var _os=require$$0$1;
+
+var _signals=signals;
+var _realtime=realtime;
+
+
+
+const getSignalsByName=function(){
+const signals=(0, _signals.getSignals)();
+return signals.reduce(getSignalByName,{});
+};
+
+const getSignalByName=function(
+signalByNameMemo,
+{name,number,description,supported,action,forced,standard})
+{
+return {
+...signalByNameMemo,
+[name]:{name,number,description,supported,action,forced,standard}};
+
+};
+
+const signalsByName$1=getSignalsByName();main.signalsByName=signalsByName$1;
+
+
+
+
+const getSignalsByNumber=function(){
+const signals=(0, _signals.getSignals)();
+const length=_realtime.SIGRTMAX+1;
+const signalsA=Array.from({length},(value,number)=>
+getSignalByNumber(number,signals));
+
+return Object.assign({},...signalsA);
+};
+
+const getSignalByNumber=function(number,signals){
+const signal=findSignalByNumber(number,signals);
+
+if(signal===undefined){
+return {};
+}
+
+const{name,description,supported,action,forced,standard}=signal;
+return {
+[number]:{
+name,
+number,
+description,
+supported,
+action,
+forced,
+standard}};
+
+
+};
+
+
+
+const findSignalByNumber=function(number,signals){
+const signal=signals.find(({name})=>_os.constants.signals[name]===number);
+
+if(signal!==undefined){
+return signal;
+}
+
+return signals.find(signalA=>signalA.number===number);
+};
+
+const signalsByNumber=getSignalsByNumber();main.signalsByNumber=signalsByNumber;
+
+const {signalsByName} = main;
+
+const getErrorPrefix = ({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled}) => {
+	if (timedOut) {
+		return `timed out after ${timeout} milliseconds`;
+	}
+
+	if (isCanceled) {
+		return 'was canceled';
+	}
+
+	if (errorCode !== undefined) {
+		return `failed with ${errorCode}`;
+	}
+
+	if (signal !== undefined) {
+		return `was killed with ${signal} (${signalDescription})`;
+	}
+
+	if (exitCode !== undefined) {
+		return `failed with exit code ${exitCode}`;
+	}
+
+	return 'failed';
+};
+
+const makeError$1 = ({
+	stdout,
+	stderr,
+	all,
+	error,
+	signal,
+	exitCode,
+	command,
+	escapedCommand,
+	timedOut,
+	isCanceled,
+	killed,
+	parsed: {options: {timeout}}
+}) => {
+	// `signal` and `exitCode` emitted on `spawned.on('exit')` event can be `null`.
+	// We normalize them to `undefined`
+	exitCode = exitCode === null ? undefined : exitCode;
+	signal = signal === null ? undefined : signal;
+	const signalDescription = signal === undefined ? undefined : signalsByName[signal].description;
+
+	const errorCode = error && error.code;
+
+	const prefix = getErrorPrefix({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled});
+	const execaMessage = `Command ${prefix}: ${command}`;
+	const isError = Object.prototype.toString.call(error) === '[object Error]';
+	const shortMessage = isError ? `${execaMessage}\n${error.message}` : execaMessage;
+	const message = [shortMessage, stderr, stdout].filter(Boolean).join('\n');
+
+	if (isError) {
+		error.originalMessage = error.message;
+		error.message = message;
+	} else {
+		error = new Error(message);
+	}
+
+	error.shortMessage = shortMessage;
+	error.command = command;
+	error.escapedCommand = escapedCommand;
+	error.exitCode = exitCode;
+	error.signal = signal;
+	error.signalDescription = signalDescription;
+	error.stdout = stdout;
+	error.stderr = stderr;
+
+	if (all !== undefined) {
+		error.all = all;
+	}
+
+	if ('bufferedData' in error) {
+		delete error.bufferedData;
+	}
+
+	error.failed = true;
+	error.timedOut = Boolean(timedOut);
+	error.isCanceled = isCanceled;
+	error.killed = killed && !timedOut;
+
+	return error;
+};
+
+var error = makeError$1;
+
+var stdio = {exports: {}};
+
+const aliases = ['stdin', 'stdout', 'stderr'];
+
+const hasAlias = options => aliases.some(alias => options[alias] !== undefined);
+
+const normalizeStdio$1 = options => {
+	if (!options) {
+		return;
+	}
+
+	const {stdio} = options;
+
+	if (stdio === undefined) {
+		return aliases.map(alias => options[alias]);
+	}
+
+	if (hasAlias(options)) {
+		throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map(alias => `\`${alias}\``).join(', ')}`);
+	}
+
+	if (typeof stdio === 'string') {
+		return stdio;
+	}
+
+	if (!Array.isArray(stdio)) {
+		throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+	}
+
+	const length = Math.max(stdio.length, aliases.length);
+	return Array.from({length}, (value, index) => stdio[index]);
+};
+
+stdio.exports = normalizeStdio$1;
+
+// `ipc` is pushed unless it is already present
+stdio.exports.node = options => {
+	const stdio = normalizeStdio$1(options);
+
+	if (stdio === 'ipc') {
+		return 'ipc';
+	}
+
+	if (stdio === undefined || typeof stdio === 'string') {
+		return [stdio, stdio, stdio, 'ipc'];
+	}
+
+	if (stdio.includes('ipc')) {
+		return stdio;
+	}
+
+	return [...stdio, 'ipc'];
+};
+
+const os = require$$0$1;
+const onExit = signalExit.exports;
+
+const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
+
+// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
+const spawnedKill$1 = (kill, signal = 'SIGTERM', options = {}) => {
+	const killResult = kill(signal);
+	setKillTimeout(kill, signal, options, killResult);
+	return killResult;
+};
+
+const setKillTimeout = (kill, signal, options, killResult) => {
+	if (!shouldForceKill(signal, options, killResult)) {
+		return;
+	}
+
+	const timeout = getForceKillAfterTimeout(options);
+	const t = setTimeout(() => {
+		kill('SIGKILL');
+	}, timeout);
+
+	// Guarded because there's no `.unref()` when `execa` is used in the renderer
+	// process in Electron. This cannot be tested since we don't run tests in
+	// Electron.
+	// istanbul ignore else
+	if (t.unref) {
+		t.unref();
+	}
+};
+
+const shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => {
+	return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
+};
+
+const isSigterm = signal => {
+	return signal === os.constants.signals.SIGTERM ||
+		(typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');
+};
+
+const getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {
+	if (forceKillAfterTimeout === true) {
+		return DEFAULT_FORCE_KILL_TIMEOUT;
+	}
+
+	if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
+		throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
+	}
+
+	return forceKillAfterTimeout;
+};
+
+// `childProcess.cancel()`
+const spawnedCancel$1 = (spawned, context) => {
+	const killResult = spawned.kill();
+
+	if (killResult) {
+		context.isCanceled = true;
+	}
+};
+
+const timeoutKill = (spawned, signal, reject) => {
+	spawned.kill(signal);
+	reject(Object.assign(new Error('Timed out'), {timedOut: true, signal}));
+};
+
+// `timeout` option handling
+const setupTimeout$1 = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {
+	if (timeout === 0 || timeout === undefined) {
+		return spawnedPromise;
+	}
+
+	let timeoutId;
+	const timeoutPromise = new Promise((resolve, reject) => {
+		timeoutId = setTimeout(() => {
+			timeoutKill(spawned, killSignal, reject);
+		}, timeout);
+	});
+
+	const safeSpawnedPromise = spawnedPromise.finally(() => {
+		clearTimeout(timeoutId);
+	});
+
+	return Promise.race([timeoutPromise, safeSpawnedPromise]);
+};
+
+const validateTimeout$1 = ({timeout}) => {
+	if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
+		throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+	}
+};
+
+// `cleanup` option handling
+const setExitHandler$1 = async (spawned, {cleanup, detached}, timedPromise) => {
+	if (!cleanup || detached) {
+		return timedPromise;
+	}
+
+	const removeExitHandler = onExit(() => {
+		spawned.kill();
+	});
+
+	return timedPromise.finally(() => {
+		removeExitHandler();
+	});
+};
+
+var kill = {
+	spawnedKill: spawnedKill$1,
+	spawnedCancel: spawnedCancel$1,
+	setupTimeout: setupTimeout$1,
+	validateTimeout: validateTimeout$1,
+	setExitHandler: setExitHandler$1
+};
+
+const isStream$1 = stream =>
+	stream !== null &&
+	typeof stream === 'object' &&
+	typeof stream.pipe === 'function';
+
+isStream$1.writable = stream =>
+	isStream$1(stream) &&
+	stream.writable !== false &&
+	typeof stream._write === 'function' &&
+	typeof stream._writableState === 'object';
+
+isStream$1.readable = stream =>
+	isStream$1(stream) &&
+	stream.readable !== false &&
+	typeof stream._read === 'function' &&
+	typeof stream._readableState === 'object';
+
+isStream$1.duplex = stream =>
+	isStream$1.writable(stream) &&
+	isStream$1.readable(stream);
+
+isStream$1.transform = stream =>
+	isStream$1.duplex(stream) &&
+	typeof stream._transform === 'function';
+
+var isStream_1 = isStream$1;
+
+const isStream = isStream_1;
+const getStream = getStream$1.exports;
+const mergeStream = mergeStream$1;
+
+// `input` option
+const handleInput$1 = (spawned, input) => {
+	// Checking for stdin is workaround for https://github.com/nodejs/node/issues/26852
+	// @todo remove `|| spawned.stdin === undefined` once we drop support for Node.js <=12.2.0
+	if (input === undefined || spawned.stdin === undefined) {
+		return;
+	}
+
+	if (isStream(input)) {
+		input.pipe(spawned.stdin);
+	} else {
+		spawned.stdin.end(input);
+	}
+};
+
+// `all` interleaves `stdout` and `stderr`
+const makeAllStream$1 = (spawned, {all}) => {
+	if (!all || (!spawned.stdout && !spawned.stderr)) {
+		return;
+	}
+
+	const mixed = mergeStream();
+
+	if (spawned.stdout) {
+		mixed.add(spawned.stdout);
+	}
+
+	if (spawned.stderr) {
+		mixed.add(spawned.stderr);
+	}
+
+	return mixed;
+};
+
+// On failure, `result.stdout|stderr|all` should contain the currently buffered stream
+const getBufferedData = async (stream, streamPromise) => {
+	if (!stream) {
+		return;
+	}
+
+	stream.destroy();
+
+	try {
+		return await streamPromise;
+	} catch (error) {
+		return error.bufferedData;
+	}
+};
+
+const getStreamPromise = (stream, {encoding, buffer, maxBuffer}) => {
+	if (!stream || !buffer) {
+		return;
+	}
+
+	if (encoding) {
+		return getStream(stream, {encoding, maxBuffer});
+	}
+
+	return getStream.buffer(stream, {maxBuffer});
+};
+
+// Retrieve result of child process: exit code, signal, error, streams (stdout/stderr/all)
+const getSpawnedResult$1 = async ({stdout, stderr, all}, {encoding, buffer, maxBuffer}, processDone) => {
+	const stdoutPromise = getStreamPromise(stdout, {encoding, buffer, maxBuffer});
+	const stderrPromise = getStreamPromise(stderr, {encoding, buffer, maxBuffer});
+	const allPromise = getStreamPromise(all, {encoding, buffer, maxBuffer: maxBuffer * 2});
+
+	try {
+		return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
+	} catch (error) {
+		return Promise.all([
+			{error, signal: error.signal, timedOut: error.timedOut},
+			getBufferedData(stdout, stdoutPromise),
+			getBufferedData(stderr, stderrPromise),
+			getBufferedData(all, allPromise)
+		]);
+	}
+};
+
+const validateInputSync$1 = ({input}) => {
+	if (isStream(input)) {
+		throw new TypeError('The `input` option cannot be a stream in sync mode');
+	}
+};
+
+var stream = {
+	handleInput: handleInput$1,
+	makeAllStream: makeAllStream$1,
+	getSpawnedResult: getSpawnedResult$1,
+	validateInputSync: validateInputSync$1
+};
+
+const nativePromisePrototype = (async () => {})().constructor.prototype;
+const descriptors = ['then', 'catch', 'finally'].map(property => [
+	property,
+	Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
+]);
+
+// The return value is a mixin of `childProcess` and `Promise`
+const mergePromise$1 = (spawned, promise) => {
+	for (const [property, descriptor] of descriptors) {
+		// Starting the main `promise` is deferred to avoid consuming streams
+		const value = typeof promise === 'function' ?
+			(...args) => Reflect.apply(descriptor.value, promise(), args) :
+			descriptor.value.bind(promise);
+
+		Reflect.defineProperty(spawned, property, {...descriptor, value});
+	}
+
+	return spawned;
+};
+
+// Use promises instead of `child_process` events
+const getSpawnedPromise$1 = spawned => {
+	return new Promise((resolve, reject) => {
+		spawned.on('exit', (exitCode, signal) => {
+			resolve({exitCode, signal});
+		});
+
+		spawned.on('error', error => {
+			reject(error);
+		});
+
+		if (spawned.stdin) {
+			spawned.stdin.on('error', error => {
+				reject(error);
+			});
+		}
+	});
+};
+
+var promise = {
+	mergePromise: mergePromise$1,
+	getSpawnedPromise: getSpawnedPromise$1
+};
+
+const normalizeArgs = (file, args = []) => {
+	if (!Array.isArray(args)) {
+		return [file];
+	}
+
+	return [file, ...args];
+};
+
+const NO_ESCAPE_REGEXP = /^[\w.-]+$/;
+const DOUBLE_QUOTES_REGEXP = /"/g;
+
+const escapeArg = arg => {
+	if (typeof arg !== 'string' || NO_ESCAPE_REGEXP.test(arg)) {
+		return arg;
+	}
+
+	return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
+};
+
+const joinCommand$1 = (file, args) => {
+	return normalizeArgs(file, args).join(' ');
+};
+
+const getEscapedCommand$1 = (file, args) => {
+	return normalizeArgs(file, args).map(arg => escapeArg(arg)).join(' ');
+};
+
+const SPACES_REGEXP = / +/g;
+
+// Handle `execa.command()`
+const parseCommand$1 = command => {
+	const tokens = [];
+	for (const token of command.trim().split(SPACES_REGEXP)) {
+		// Allow spaces to be escaped by a backslash if not meant as a delimiter
+		const previousToken = tokens[tokens.length - 1];
+		if (previousToken && previousToken.endsWith('\\')) {
+			// Merge previous token with current one
+			tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
+		} else {
+			tokens.push(token);
+		}
+	}
+
+	return tokens;
+};
+
+var command = {
+	joinCommand: joinCommand$1,
+	getEscapedCommand: getEscapedCommand$1,
+	parseCommand: parseCommand$1
+};
+
+const path = path$2;
+const childProcess = childProcess$1;
+const crossSpawn = crossSpawn$1.exports;
+const stripFinalNewline = stripFinalNewline$1;
+const npmRunPath = npmRunPath$1.exports;
+const onetime = onetime$1.exports;
+const makeError = error;
+const normalizeStdio = stdio.exports;
+const {spawnedKill, spawnedCancel, setupTimeout, validateTimeout, setExitHandler} = kill;
+const {handleInput, getSpawnedResult, makeAllStream, validateInputSync} = stream;
+const {mergePromise, getSpawnedPromise} = promise;
+const {joinCommand, parseCommand, getEscapedCommand} = command;
+
+const DEFAULT_MAX_BUFFER = 1000 * 1000 * 100;
+
+const getEnv = ({env: envOption, extendEnv, preferLocal, localDir, execPath}) => {
+	const env = extendEnv ? {...process.env, ...envOption} : envOption;
+
+	if (preferLocal) {
+		return npmRunPath.env({env, cwd: localDir, execPath});
+	}
+
+	return env;
+};
+
+const handleArguments = (file, args, options = {}) => {
+	const parsed = crossSpawn._parse(file, args, options);
+	file = parsed.command;
+	args = parsed.args;
+	options = parsed.options;
+
+	options = {
+		maxBuffer: DEFAULT_MAX_BUFFER,
+		buffer: true,
+		stripFinalNewline: true,
+		extendEnv: true,
+		preferLocal: false,
+		localDir: options.cwd || process.cwd(),
+		execPath: process.execPath,
+		encoding: 'utf8',
+		reject: true,
+		cleanup: true,
+		all: false,
+		windowsHide: true,
+		...options
+	};
+
+	options.env = getEnv(options);
+
+	options.stdio = normalizeStdio(options);
+
+	if (process.platform === 'win32' && path.basename(file, '.exe') === 'cmd') {
+		// #116
+		args.unshift('/q');
+	}
+
+	return {file, args, options, parsed};
+};
+
+const handleOutput = (options, value, error) => {
+	if (typeof value !== 'string' && !Buffer.isBuffer(value)) {
+		// When `execa.sync()` errors, we normalize it to '' to mimic `execa()`
+		return error === undefined ? undefined : '';
+	}
+
+	if (options.stripFinalNewline) {
+		return stripFinalNewline(value);
+	}
+
+	return value;
+};
+
+const execa = (file, args, options) => {
+	const parsed = handleArguments(file, args, options);
+	const command = joinCommand(file, args);
+	const escapedCommand = getEscapedCommand(file, args);
+
+	validateTimeout(parsed.options);
+
+	let spawned;
+	try {
+		spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
+	} catch (error) {
+		// Ensure the returned error is always both a promise and a child process
+		const dummySpawned = new childProcess.ChildProcess();
+		const errorPromise = Promise.reject(makeError({
+			error,
+			stdout: '',
+			stderr: '',
+			all: '',
+			command,
+			escapedCommand,
+			parsed,
+			timedOut: false,
+			isCanceled: false,
+			killed: false
+		}));
+		return mergePromise(dummySpawned, errorPromise);
+	}
+
+	const spawnedPromise = getSpawnedPromise(spawned);
+	const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
+	const processDone = setExitHandler(spawned, parsed.options, timedPromise);
+
+	const context = {isCanceled: false};
+
+	spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
+	spawned.cancel = spawnedCancel.bind(null, spawned, context);
+
+	const handlePromise = async () => {
+		const [{error, exitCode, signal, timedOut}, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
+		const stdout = handleOutput(parsed.options, stdoutResult);
+		const stderr = handleOutput(parsed.options, stderrResult);
+		const all = handleOutput(parsed.options, allResult);
+
+		if (error || exitCode !== 0 || signal !== null) {
+			const returnedError = makeError({
+				error,
+				exitCode,
+				signal,
+				stdout,
+				stderr,
+				all,
+				command,
+				escapedCommand,
+				parsed,
+				timedOut,
+				isCanceled: context.isCanceled,
+				killed: spawned.killed
+			});
+
+			if (!parsed.options.reject) {
+				return returnedError;
+			}
+
+			throw returnedError;
+		}
+
+		return {
+			command,
+			escapedCommand,
+			exitCode: 0,
+			stdout,
+			stderr,
+			all,
+			failed: false,
+			timedOut: false,
+			isCanceled: false,
+			killed: false
+		};
+	};
+
+	const handlePromiseOnce = onetime(handlePromise);
+
+	handleInput(spawned, parsed.options.input);
+
+	spawned.all = makeAllStream(spawned, parsed.options);
+
+	return mergePromise(spawned, handlePromiseOnce);
+};
+
+execa$2.exports = execa;
+
+execa$2.exports.sync = (file, args, options) => {
+	const parsed = handleArguments(file, args, options);
+	const command = joinCommand(file, args);
+	const escapedCommand = getEscapedCommand(file, args);
+
+	validateInputSync(parsed.options);
+
+	let result;
+	try {
+		result = childProcess.spawnSync(parsed.file, parsed.args, parsed.options);
+	} catch (error) {
+		throw makeError({
+			error,
+			stdout: '',
+			stderr: '',
+			all: '',
+			command,
+			escapedCommand,
+			parsed,
+			timedOut: false,
+			isCanceled: false,
+			killed: false
+		});
+	}
+
+	const stdout = handleOutput(parsed.options, result.stdout, result.error);
+	const stderr = handleOutput(parsed.options, result.stderr, result.error);
+
+	if (result.error || result.status !== 0 || result.signal !== null) {
+		const error = makeError({
+			stdout,
+			stderr,
+			error: result.error,
+			signal: result.signal,
+			exitCode: result.status,
+			command,
+			escapedCommand,
+			parsed,
+			timedOut: result.error && result.error.code === 'ETIMEDOUT',
+			isCanceled: false,
+			killed: result.signal !== null
+		});
+
+		if (!parsed.options.reject) {
+			return error;
+		}
+
+		throw error;
+	}
+
+	return {
+		command,
+		escapedCommand,
+		exitCode: 0,
+		stdout,
+		stderr,
+		failed: false,
+		timedOut: false,
+		isCanceled: false,
+		killed: false
+	};
+};
+
+execa$2.exports.command = (command, options) => {
+	const [file, ...args] = parseCommand(command);
+	return execa(file, args, options);
+};
+
+execa$2.exports.commandSync = (command, options) => {
+	const [file, ...args] = parseCommand(command);
+	return execa.sync(file, args, options);
+};
+
+execa$2.exports.node = (scriptPath, args, options = {}) => {
+	if (args && !Array.isArray(args) && typeof args === 'object') {
+		options = args;
+		args = [];
+	}
+
+	const stdio = normalizeStdio.node(options);
+	const defaultExecArgv = process.execArgv.filter(arg => !arg.startsWith('--inspect'));
+
+	const {
+		nodePath = process.execPath,
+		nodeOptions = defaultExecArgv
+	} = options;
+
+	return execa(
+		nodePath,
+		[
+			...nodeOptions,
+			scriptPath,
+			...(Array.isArray(args) ? args : [])
+		],
+		{
+			...options,
+			stdin: undefined,
+			stdout: undefined,
+			stderr: undefined,
+			stdio,
+			shell: false
+		}
+	);
+};
+
+var execa$1 = execa$2.exports;
+
+// src/detect.ts
+var LOCKS = {
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm"
+};
+async function detectPackageManager(cwd = process.cwd()) {
+  const result = await findUp(Object.keys(LOCKS), { cwd });
+  const agent = result ? LOCKS[path$2.basename(result)] : null;
+  return agent;
+}
+async function installPackage(names, options = {}) {
+  const agent = options.packageManager || await detectPackageManager(options.cwd) || "npm";
+  if (!Array.isArray(names))
+    names = [names];
+  const args = options.additionalArgs || [];
+  if (options.preferOffline)
+    args.unshift("--prefer-offline");
+  return execa$1(agent, [
+    agent === "yarn" ? "add" : "install",
+    options.dev ? "-D" : "",
+    ...args,
+    ...names
+  ].filter(Boolean), {
+    stdio: options.silent ? "ignore" : "inherit",
+    cwd: options.cwd
+  });
+}
+
+export { detectPackageManager, installPackage };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-ce49e384.js","sources":["../../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js","../../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js","../../../node_modules/.pnpm/p-locate@5.0.0/node_modules/p-locate/index.js","../../../node_modules/.pnpm/locate-path@6.0.0/node_modules/locate-path/index.js","../../../node_modules/.pnpm/path-exists@4.0.0/node_modules/path-exists/index.js","../../../node_modules/.pnpm/find-up@5.0.0/node_modules/find-up/index.js","../../../node_modules/.pnpm/strip-final-newline@2.0.0/node_modules/strip-final-newline/index.js","../../../node_modules/.pnpm/npm-run-path@4.0.1/node_modules/npm-run-path/index.js","../../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/core.js","../../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/realtime.js","../../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/signals.js","../../../node_modules/.pnpm/human-signals@2.1.0/node_modules/human-signals/build/src/main.js","../../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/error.js","../../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stdio.js","../../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/kill.js","../../../node_modules/.pnpm/is-stream@2.0.1/node_modules/is-stream/index.js","../../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/stream.js","../../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/promise.js","../../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/command.js","../../../node_modules/.pnpm/execa@5.1.1/node_modules/execa/index.js","../../../node_modules/.pnpm/@antfu+install-pkg@0.1.0/node_modules/@antfu/install-pkg/dist/index.mjs"],"sourcesContent":["class Node {\n\t/// value;\n\t/// next;\n\n\tconstructor(value) {\n\t\tthis.value = value;\n\n\t\t// TODO: Remove this when targeting Node.js 12.\n\t\tthis.next = undefined;\n\t}\n}\n\nclass Queue {\n\t// TODO: Use private class fields when targeting Node.js 12.\n\t// #_head;\n\t// #_tail;\n\t// #_size;\n\n\tconstructor() {\n\t\tthis.clear();\n\t}\n\n\tenqueue(value) {\n\t\tconst node = new Node(value);\n\n\t\tif (this._head) {\n\t\t\tthis._tail.next = node;\n\t\t\tthis._tail = node;\n\t\t} else {\n\t\t\tthis._head = node;\n\t\t\tthis._tail = node;\n\t\t}\n\n\t\tthis._size++;\n\t}\n\n\tdequeue() {\n\t\tconst current = this._head;\n\t\tif (!current) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis._head = this._head.next;\n\t\tthis._size--;\n\t\treturn current.value;\n\t}\n\n\tclear() {\n\t\tthis._head = undefined;\n\t\tthis._tail = undefined;\n\t\tthis._size = 0;\n\t}\n\n\tget size() {\n\t\treturn this._size;\n\t}\n\n\t* [Symbol.iterator]() {\n\t\tlet current = this._head;\n\n\t\twhile (current) {\n\t\t\tyield current.value;\n\t\t\tcurrent = current.next;\n\t\t}\n\t}\n}\n\nmodule.exports = Queue;\n","'use strict';\nconst Queue = require('yocto-queue');\n\nconst pLimit = concurrency => {\n\tif (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {\n\t\tthrow new TypeError('Expected `concurrency` to be a number from 1 and up');\n\t}\n\n\tconst queue = new Queue();\n\tlet activeCount = 0;\n\n\tconst next = () => {\n\t\tactiveCount--;\n\n\t\tif (queue.size > 0) {\n\t\t\tqueue.dequeue()();\n\t\t}\n\t};\n\n\tconst run = async (fn, resolve, ...args) => {\n\t\tactiveCount++;\n\n\t\tconst result = (async () => fn(...args))();\n\n\t\tresolve(result);\n\n\t\ttry {\n\t\t\tawait result;\n\t\t} catch {}\n\n\t\tnext();\n\t};\n\n\tconst enqueue = (fn, resolve, ...args) => {\n\t\tqueue.enqueue(run.bind(null, fn, resolve, ...args));\n\n\t\t(async () => {\n\t\t\t// This function needs to wait until the next microtask before comparing\n\t\t\t// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously\n\t\t\t// when the run function is dequeued and called. The comparison in the if-statement\n\t\t\t// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.\n\t\t\tawait Promise.resolve();\n\n\t\t\tif (activeCount < concurrency && queue.size > 0) {\n\t\t\t\tqueue.dequeue()();\n\t\t\t}\n\t\t})();\n\t};\n\n\tconst generator = (fn, ...args) => new Promise(resolve => {\n\t\tenqueue(fn, resolve, ...args);\n\t});\n\n\tObject.defineProperties(generator, {\n\t\tactiveCount: {\n\t\t\tget: () => activeCount\n\t\t},\n\t\tpendingCount: {\n\t\t\tget: () => queue.size\n\t\t},\n\t\tclearQueue: {\n\t\t\tvalue: () => {\n\t\t\t\tqueue.clear();\n\t\t\t}\n\t\t}\n\t});\n\n\treturn generator;\n};\n\nmodule.exports = pLimit;\n","'use strict';\nconst pLimit = require('p-limit');\n\nclass EndError extends Error {\n\tconstructor(value) {\n\t\tsuper();\n\t\tthis.value = value;\n\t}\n}\n\n// The input can also be a promise, so we await it\nconst testElement = async (element, tester) => tester(await element);\n\n// The input can also be a promise, so we `Promise.all()` them both\nconst finder = async element => {\n\tconst values = await Promise.all(element);\n\tif (values[1] === true) {\n\t\tthrow new EndError(values[0]);\n\t}\n\n\treturn false;\n};\n\nconst pLocate = async (iterable, tester, options) => {\n\toptions = {\n\t\tconcurrency: Infinity,\n\t\tpreserveOrder: true,\n\t\t...options\n\t};\n\n\tconst limit = pLimit(options.concurrency);\n\n\t// Start all the promises concurrently with optional limit\n\tconst items = [...iterable].map(element => [element, limit(testElement, element, tester)]);\n\n\t// Check the promises either serially or concurrently\n\tconst checkLimit = pLimit(options.preserveOrder ? 1 : Infinity);\n\n\ttry {\n\t\tawait Promise.all(items.map(element => checkLimit(finder, element)));\n\t} catch (error) {\n\t\tif (error instanceof EndError) {\n\t\t\treturn error.value;\n\t\t}\n\n\t\tthrow error;\n\t}\n};\n\nmodule.exports = pLocate;\n","'use strict';\nconst path = require('path');\nconst fs = require('fs');\nconst {promisify} = require('util');\nconst pLocate = require('p-locate');\n\nconst fsStat = promisify(fs.stat);\nconst fsLStat = promisify(fs.lstat);\n\nconst typeMappings = {\n\tdirectory: 'isDirectory',\n\tfile: 'isFile'\n};\n\nfunction checkType({type}) {\n\tif (type in typeMappings) {\n\t\treturn;\n\t}\n\n\tthrow new Error(`Invalid type specified: ${type}`);\n}\n\nconst matchType = (type, stat) => type === undefined || stat[typeMappings[type]]();\n\nmodule.exports = async (paths, options) => {\n\toptions = {\n\t\tcwd: process.cwd(),\n\t\ttype: 'file',\n\t\tallowSymlinks: true,\n\t\t...options\n\t};\n\n\tcheckType(options);\n\n\tconst statFn = options.allowSymlinks ? fsStat : fsLStat;\n\n\treturn pLocate(paths, async path_ => {\n\t\ttry {\n\t\t\tconst stat = await statFn(path.resolve(options.cwd, path_));\n\t\t\treturn matchType(options.type, stat);\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}, options);\n};\n\nmodule.exports.sync = (paths, options) => {\n\toptions = {\n\t\tcwd: process.cwd(),\n\t\tallowSymlinks: true,\n\t\ttype: 'file',\n\t\t...options\n\t};\n\n\tcheckType(options);\n\n\tconst statFn = options.allowSymlinks ? fs.statSync : fs.lstatSync;\n\n\tfor (const path_ of paths) {\n\t\ttry {\n\t\t\tconst stat = statFn(path.resolve(options.cwd, path_));\n\n\t\t\tif (matchType(options.type, stat)) {\n\t\t\t\treturn path_;\n\t\t\t}\n\t\t} catch {}\n\t}\n};\n","'use strict';\nconst fs = require('fs');\nconst {promisify} = require('util');\n\nconst pAccess = promisify(fs.access);\n\nmodule.exports = async path => {\n\ttry {\n\t\tawait pAccess(path);\n\t\treturn true;\n\t} catch (_) {\n\t\treturn false;\n\t}\n};\n\nmodule.exports.sync = path => {\n\ttry {\n\t\tfs.accessSync(path);\n\t\treturn true;\n\t} catch (_) {\n\t\treturn false;\n\t}\n};\n","'use strict';\nconst path = require('path');\nconst locatePath = require('locate-path');\nconst pathExists = require('path-exists');\n\nconst stop = Symbol('findUp.stop');\n\nmodule.exports = async (name, options = {}) => {\n\tlet directory = path.resolve(options.cwd || '');\n\tconst {root} = path.parse(directory);\n\tconst paths = [].concat(name);\n\n\tconst runMatcher = async locateOptions => {\n\t\tif (typeof name !== 'function') {\n\t\t\treturn locatePath(paths, locateOptions);\n\t\t}\n\n\t\tconst foundPath = await name(locateOptions.cwd);\n\t\tif (typeof foundPath === 'string') {\n\t\t\treturn locatePath([foundPath], locateOptions);\n\t\t}\n\n\t\treturn foundPath;\n\t};\n\n\t// eslint-disable-next-line no-constant-condition\n\twhile (true) {\n\t\t// eslint-disable-next-line no-await-in-loop\n\t\tconst foundPath = await runMatcher({...options, cwd: directory});\n\n\t\tif (foundPath === stop) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (foundPath) {\n\t\t\treturn path.resolve(directory, foundPath);\n\t\t}\n\n\t\tif (directory === root) {\n\t\t\treturn;\n\t\t}\n\n\t\tdirectory = path.dirname(directory);\n\t}\n};\n\nmodule.exports.sync = (name, options = {}) => {\n\tlet directory = path.resolve(options.cwd || '');\n\tconst {root} = path.parse(directory);\n\tconst paths = [].concat(name);\n\n\tconst runMatcher = locateOptions => {\n\t\tif (typeof name !== 'function') {\n\t\t\treturn locatePath.sync(paths, locateOptions);\n\t\t}\n\n\t\tconst foundPath = name(locateOptions.cwd);\n\t\tif (typeof foundPath === 'string') {\n\t\t\treturn locatePath.sync([foundPath], locateOptions);\n\t\t}\n\n\t\treturn foundPath;\n\t};\n\n\t// eslint-disable-next-line no-constant-condition\n\twhile (true) {\n\t\tconst foundPath = runMatcher({...options, cwd: directory});\n\n\t\tif (foundPath === stop) {\n\t\t\treturn;\n\t\t}\n\n\t\tif (foundPath) {\n\t\t\treturn path.resolve(directory, foundPath);\n\t\t}\n\n\t\tif (directory === root) {\n\t\t\treturn;\n\t\t}\n\n\t\tdirectory = path.dirname(directory);\n\t}\n};\n\nmodule.exports.exists = pathExists;\n\nmodule.exports.sync.exists = pathExists.sync;\n\nmodule.exports.stop = stop;\n","'use strict';\n\nmodule.exports = input => {\n\tconst LF = typeof input === 'string' ? '\\n' : '\\n'.charCodeAt();\n\tconst CR = typeof input === 'string' ? '\\r' : '\\r'.charCodeAt();\n\n\tif (input[input.length - 1] === LF) {\n\t\tinput = input.slice(0, input.length - 1);\n\t}\n\n\tif (input[input.length - 1] === CR) {\n\t\tinput = input.slice(0, input.length - 1);\n\t}\n\n\treturn input;\n};\n","'use strict';\nconst path = require('path');\nconst pathKey = require('path-key');\n\nconst npmRunPath = options => {\n\toptions = {\n\t\tcwd: process.cwd(),\n\t\tpath: process.env[pathKey()],\n\t\texecPath: process.execPath,\n\t\t...options\n\t};\n\n\tlet previous;\n\tlet cwdPath = path.resolve(options.cwd);\n\tconst result = [];\n\n\twhile (previous !== cwdPath) {\n\t\tresult.push(path.join(cwdPath, 'node_modules/.bin'));\n\t\tprevious = cwdPath;\n\t\tcwdPath = path.resolve(cwdPath, '..');\n\t}\n\n\t// Ensure the running `node` binary is used\n\tconst execPathDir = path.resolve(options.cwd, options.execPath, '..');\n\tresult.push(execPathDir);\n\n\treturn result.concat(options.path).join(path.delimiter);\n};\n\nmodule.exports = npmRunPath;\n// TODO: Remove this for the next major release\nmodule.exports.default = npmRunPath;\n\nmodule.exports.env = options => {\n\toptions = {\n\t\tenv: process.env,\n\t\t...options\n\t};\n\n\tconst env = {...options.env};\n\tconst path = pathKey({env});\n\n\toptions.path = env[path];\n\tenv[path] = module.exports(options);\n\n\treturn env;\n};\n","\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:true});exports.SIGNALS=void 0;\n\nconst SIGNALS=[\n{\nname:\"SIGHUP\",\nnumber:1,\naction:\"terminate\",\ndescription:\"Terminal closed\",\nstandard:\"posix\"},\n\n{\nname:\"SIGINT\",\nnumber:2,\naction:\"terminate\",\ndescription:\"User interruption with CTRL-C\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGQUIT\",\nnumber:3,\naction:\"core\",\ndescription:\"User interruption with CTRL-\\\\\",\nstandard:\"posix\"},\n\n{\nname:\"SIGILL\",\nnumber:4,\naction:\"core\",\ndescription:\"Invalid machine instruction\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGTRAP\",\nnumber:5,\naction:\"core\",\ndescription:\"Debugger breakpoint\",\nstandard:\"posix\"},\n\n{\nname:\"SIGABRT\",\nnumber:6,\naction:\"core\",\ndescription:\"Aborted\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGIOT\",\nnumber:6,\naction:\"core\",\ndescription:\"Aborted\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGBUS\",\nnumber:7,\naction:\"core\",\ndescription:\n\"Bus error due to misaligned, non-existing address or paging error\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGEMT\",\nnumber:7,\naction:\"terminate\",\ndescription:\"Command should be emulated but is not implemented\",\nstandard:\"other\"},\n\n{\nname:\"SIGFPE\",\nnumber:8,\naction:\"core\",\ndescription:\"Floating point arithmetic error\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGKILL\",\nnumber:9,\naction:\"terminate\",\ndescription:\"Forced termination\",\nstandard:\"posix\",\nforced:true},\n\n{\nname:\"SIGUSR1\",\nnumber:10,\naction:\"terminate\",\ndescription:\"Application-specific signal\",\nstandard:\"posix\"},\n\n{\nname:\"SIGSEGV\",\nnumber:11,\naction:\"core\",\ndescription:\"Segmentation fault\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGUSR2\",\nnumber:12,\naction:\"terminate\",\ndescription:\"Application-specific signal\",\nstandard:\"posix\"},\n\n{\nname:\"SIGPIPE\",\nnumber:13,\naction:\"terminate\",\ndescription:\"Broken pipe or socket\",\nstandard:\"posix\"},\n\n{\nname:\"SIGALRM\",\nnumber:14,\naction:\"terminate\",\ndescription:\"Timeout or timer\",\nstandard:\"posix\"},\n\n{\nname:\"SIGTERM\",\nnumber:15,\naction:\"terminate\",\ndescription:\"Termination\",\nstandard:\"ansi\"},\n\n{\nname:\"SIGSTKFLT\",\nnumber:16,\naction:\"terminate\",\ndescription:\"Stack is empty or overflowed\",\nstandard:\"other\"},\n\n{\nname:\"SIGCHLD\",\nnumber:17,\naction:\"ignore\",\ndescription:\"Child process terminated, paused or unpaused\",\nstandard:\"posix\"},\n\n{\nname:\"SIGCLD\",\nnumber:17,\naction:\"ignore\",\ndescription:\"Child process terminated, paused or unpaused\",\nstandard:\"other\"},\n\n{\nname:\"SIGCONT\",\nnumber:18,\naction:\"unpause\",\ndescription:\"Unpaused\",\nstandard:\"posix\",\nforced:true},\n\n{\nname:\"SIGSTOP\",\nnumber:19,\naction:\"pause\",\ndescription:\"Paused\",\nstandard:\"posix\",\nforced:true},\n\n{\nname:\"SIGTSTP\",\nnumber:20,\naction:\"pause\",\ndescription:\"Paused using CTRL-Z or \\\"suspend\\\"\",\nstandard:\"posix\"},\n\n{\nname:\"SIGTTIN\",\nnumber:21,\naction:\"pause\",\ndescription:\"Background process cannot read terminal input\",\nstandard:\"posix\"},\n\n{\nname:\"SIGBREAK\",\nnumber:21,\naction:\"terminate\",\ndescription:\"User interruption with CTRL-BREAK\",\nstandard:\"other\"},\n\n{\nname:\"SIGTTOU\",\nnumber:22,\naction:\"pause\",\ndescription:\"Background process cannot write to terminal output\",\nstandard:\"posix\"},\n\n{\nname:\"SIGURG\",\nnumber:23,\naction:\"ignore\",\ndescription:\"Socket received out-of-band data\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGXCPU\",\nnumber:24,\naction:\"core\",\ndescription:\"Process timed out\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGXFSZ\",\nnumber:25,\naction:\"core\",\ndescription:\"File too big\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGVTALRM\",\nnumber:26,\naction:\"terminate\",\ndescription:\"Timeout or timer\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGPROF\",\nnumber:27,\naction:\"terminate\",\ndescription:\"Timeout or timer\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGWINCH\",\nnumber:28,\naction:\"ignore\",\ndescription:\"Terminal window size changed\",\nstandard:\"bsd\"},\n\n{\nname:\"SIGIO\",\nnumber:29,\naction:\"terminate\",\ndescription:\"I/O is available\",\nstandard:\"other\"},\n\n{\nname:\"SIGPOLL\",\nnumber:29,\naction:\"terminate\",\ndescription:\"Watched event\",\nstandard:\"other\"},\n\n{\nname:\"SIGINFO\",\nnumber:29,\naction:\"ignore\",\ndescription:\"Request for process information\",\nstandard:\"other\"},\n\n{\nname:\"SIGPWR\",\nnumber:30,\naction:\"terminate\",\ndescription:\"Device running out of power\",\nstandard:\"systemv\"},\n\n{\nname:\"SIGSYS\",\nnumber:31,\naction:\"core\",\ndescription:\"Invalid system call\",\nstandard:\"other\"},\n\n{\nname:\"SIGUNUSED\",\nnumber:31,\naction:\"terminate\",\ndescription:\"Invalid system call\",\nstandard:\"other\"}];exports.SIGNALS=SIGNALS;\n//# sourceMappingURL=core.js.map","\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:true});exports.SIGRTMAX=exports.getRealtimeSignals=void 0;\nconst getRealtimeSignals=function(){\nconst length=SIGRTMAX-SIGRTMIN+1;\nreturn Array.from({length},getRealtimeSignal);\n};exports.getRealtimeSignals=getRealtimeSignals;\n\nconst getRealtimeSignal=function(value,index){\nreturn{\nname:`SIGRT${index+1}`,\nnumber:SIGRTMIN+index,\naction:\"terminate\",\ndescription:\"Application-specific signal (realtime)\",\nstandard:\"posix\"};\n\n};\n\nconst SIGRTMIN=34;\nconst SIGRTMAX=64;exports.SIGRTMAX=SIGRTMAX;\n//# sourceMappingURL=realtime.js.map","\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:true});exports.getSignals=void 0;var _os=require(\"os\");\n\nvar _core=require(\"./core.js\");\nvar _realtime=require(\"./realtime.js\");\n\n\n\nconst getSignals=function(){\nconst realtimeSignals=(0,_realtime.getRealtimeSignals)();\nconst signals=[..._core.SIGNALS,...realtimeSignals].map(normalizeSignal);\nreturn signals;\n};exports.getSignals=getSignals;\n\n\n\n\n\n\n\nconst normalizeSignal=function({\nname,\nnumber:defaultNumber,\ndescription,\naction,\nforced=false,\nstandard})\n{\nconst{\nsignals:{[name]:constantSignal}}=\n_os.constants;\nconst supported=constantSignal!==undefined;\nconst number=supported?constantSignal:defaultNumber;\nreturn{name,number,description,supported,action,forced,standard};\n};\n//# sourceMappingURL=signals.js.map","\"use strict\";Object.defineProperty(exports,\"__esModule\",{value:true});exports.signalsByNumber=exports.signalsByName=void 0;var _os=require(\"os\");\n\nvar _signals=require(\"./signals.js\");\nvar _realtime=require(\"./realtime.js\");\n\n\n\nconst getSignalsByName=function(){\nconst signals=(0,_signals.getSignals)();\nreturn signals.reduce(getSignalByName,{});\n};\n\nconst getSignalByName=function(\nsignalByNameMemo,\n{name,number,description,supported,action,forced,standard})\n{\nreturn{\n...signalByNameMemo,\n[name]:{name,number,description,supported,action,forced,standard}};\n\n};\n\nconst signalsByName=getSignalsByName();exports.signalsByName=signalsByName;\n\n\n\n\nconst getSignalsByNumber=function(){\nconst signals=(0,_signals.getSignals)();\nconst length=_realtime.SIGRTMAX+1;\nconst signalsA=Array.from({length},(value,number)=>\ngetSignalByNumber(number,signals));\n\nreturn Object.assign({},...signalsA);\n};\n\nconst getSignalByNumber=function(number,signals){\nconst signal=findSignalByNumber(number,signals);\n\nif(signal===undefined){\nreturn{};\n}\n\nconst{name,description,supported,action,forced,standard}=signal;\nreturn{\n[number]:{\nname,\nnumber,\ndescription,\nsupported,\naction,\nforced,\nstandard}};\n\n\n};\n\n\n\nconst findSignalByNumber=function(number,signals){\nconst signal=signals.find(({name})=>_os.constants.signals[name]===number);\n\nif(signal!==undefined){\nreturn signal;\n}\n\nreturn signals.find(signalA=>signalA.number===number);\n};\n\nconst signalsByNumber=getSignalsByNumber();exports.signalsByNumber=signalsByNumber;\n//# sourceMappingURL=main.js.map","'use strict';\nconst {signalsByName} = require('human-signals');\n\nconst getErrorPrefix = ({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled}) => {\n\tif (timedOut) {\n\t\treturn `timed out after ${timeout} milliseconds`;\n\t}\n\n\tif (isCanceled) {\n\t\treturn 'was canceled';\n\t}\n\n\tif (errorCode !== undefined) {\n\t\treturn `failed with ${errorCode}`;\n\t}\n\n\tif (signal !== undefined) {\n\t\treturn `was killed with ${signal} (${signalDescription})`;\n\t}\n\n\tif (exitCode !== undefined) {\n\t\treturn `failed with exit code ${exitCode}`;\n\t}\n\n\treturn 'failed';\n};\n\nconst makeError = ({\n\tstdout,\n\tstderr,\n\tall,\n\terror,\n\tsignal,\n\texitCode,\n\tcommand,\n\tescapedCommand,\n\ttimedOut,\n\tisCanceled,\n\tkilled,\n\tparsed: {options: {timeout}}\n}) => {\n\t// `signal` and `exitCode` emitted on `spawned.on('exit')` event can be `null`.\n\t// We normalize them to `undefined`\n\texitCode = exitCode === null ? undefined : exitCode;\n\tsignal = signal === null ? undefined : signal;\n\tconst signalDescription = signal === undefined ? undefined : signalsByName[signal].description;\n\n\tconst errorCode = error && error.code;\n\n\tconst prefix = getErrorPrefix({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled});\n\tconst execaMessage = `Command ${prefix}: ${command}`;\n\tconst isError = Object.prototype.toString.call(error) === '[object Error]';\n\tconst shortMessage = isError ? `${execaMessage}\\n${error.message}` : execaMessage;\n\tconst message = [shortMessage, stderr, stdout].filter(Boolean).join('\\n');\n\n\tif (isError) {\n\t\terror.originalMessage = error.message;\n\t\terror.message = message;\n\t} else {\n\t\terror = new Error(message);\n\t}\n\n\terror.shortMessage = shortMessage;\n\terror.command = command;\n\terror.escapedCommand = escapedCommand;\n\terror.exitCode = exitCode;\n\terror.signal = signal;\n\terror.signalDescription = signalDescription;\n\terror.stdout = stdout;\n\terror.stderr = stderr;\n\n\tif (all !== undefined) {\n\t\terror.all = all;\n\t}\n\n\tif ('bufferedData' in error) {\n\t\tdelete error.bufferedData;\n\t}\n\n\terror.failed = true;\n\terror.timedOut = Boolean(timedOut);\n\terror.isCanceled = isCanceled;\n\terror.killed = killed && !timedOut;\n\n\treturn error;\n};\n\nmodule.exports = makeError;\n","'use strict';\nconst aliases = ['stdin', 'stdout', 'stderr'];\n\nconst hasAlias = options => aliases.some(alias => options[alias] !== undefined);\n\nconst normalizeStdio = options => {\n\tif (!options) {\n\t\treturn;\n\t}\n\n\tconst {stdio} = options;\n\n\tif (stdio === undefined) {\n\t\treturn aliases.map(alias => options[alias]);\n\t}\n\n\tif (hasAlias(options)) {\n\t\tthrow new Error(`It's not possible to provide \\`stdio\\` in combination with one of ${aliases.map(alias => `\\`${alias}\\``).join(', ')}`);\n\t}\n\n\tif (typeof stdio === 'string') {\n\t\treturn stdio;\n\t}\n\n\tif (!Array.isArray(stdio)) {\n\t\tthrow new TypeError(`Expected \\`stdio\\` to be of type \\`string\\` or \\`Array\\`, got \\`${typeof stdio}\\``);\n\t}\n\n\tconst length = Math.max(stdio.length, aliases.length);\n\treturn Array.from({length}, (value, index) => stdio[index]);\n};\n\nmodule.exports = normalizeStdio;\n\n// `ipc` is pushed unless it is already present\nmodule.exports.node = options => {\n\tconst stdio = normalizeStdio(options);\n\n\tif (stdio === 'ipc') {\n\t\treturn 'ipc';\n\t}\n\n\tif (stdio === undefined || typeof stdio === 'string') {\n\t\treturn [stdio, stdio, stdio, 'ipc'];\n\t}\n\n\tif (stdio.includes('ipc')) {\n\t\treturn stdio;\n\t}\n\n\treturn [...stdio, 'ipc'];\n};\n","'use strict';\nconst os = require('os');\nconst onExit = require('signal-exit');\n\nconst DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;\n\n// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior\nconst spawnedKill = (kill, signal = 'SIGTERM', options = {}) => {\n\tconst killResult = kill(signal);\n\tsetKillTimeout(kill, signal, options, killResult);\n\treturn killResult;\n};\n\nconst setKillTimeout = (kill, signal, options, killResult) => {\n\tif (!shouldForceKill(signal, options, killResult)) {\n\t\treturn;\n\t}\n\n\tconst timeout = getForceKillAfterTimeout(options);\n\tconst t = setTimeout(() => {\n\t\tkill('SIGKILL');\n\t}, timeout);\n\n\t// Guarded because there's no `.unref()` when `execa` is used in the renderer\n\t// process in Electron. This cannot be tested since we don't run tests in\n\t// Electron.\n\t// istanbul ignore else\n\tif (t.unref) {\n\t\tt.unref();\n\t}\n};\n\nconst shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => {\n\treturn isSigterm(signal) && forceKillAfterTimeout !== false && killResult;\n};\n\nconst isSigterm = signal => {\n\treturn signal === os.constants.signals.SIGTERM ||\n\t\t(typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');\n};\n\nconst getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {\n\tif (forceKillAfterTimeout === true) {\n\t\treturn DEFAULT_FORCE_KILL_TIMEOUT;\n\t}\n\n\tif (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {\n\t\tthrow new TypeError(`Expected the \\`forceKillAfterTimeout\\` option to be a non-negative integer, got \\`${forceKillAfterTimeout}\\` (${typeof forceKillAfterTimeout})`);\n\t}\n\n\treturn forceKillAfterTimeout;\n};\n\n// `childProcess.cancel()`\nconst spawnedCancel = (spawned, context) => {\n\tconst killResult = spawned.kill();\n\n\tif (killResult) {\n\t\tcontext.isCanceled = true;\n\t}\n};\n\nconst timeoutKill = (spawned, signal, reject) => {\n\tspawned.kill(signal);\n\treject(Object.assign(new Error('Timed out'), {timedOut: true, signal}));\n};\n\n// `timeout` option handling\nconst setupTimeout = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {\n\tif (timeout === 0 || timeout === undefined) {\n\t\treturn spawnedPromise;\n\t}\n\n\tlet timeoutId;\n\tconst timeoutPromise = new Promise((resolve, reject) => {\n\t\ttimeoutId = setTimeout(() => {\n\t\t\ttimeoutKill(spawned, killSignal, reject);\n\t\t}, timeout);\n\t});\n\n\tconst safeSpawnedPromise = spawnedPromise.finally(() => {\n\t\tclearTimeout(timeoutId);\n\t});\n\n\treturn Promise.race([timeoutPromise, safeSpawnedPromise]);\n};\n\nconst validateTimeout = ({timeout}) => {\n\tif (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {\n\t\tthrow new TypeError(`Expected the \\`timeout\\` option to be a non-negative integer, got \\`${timeout}\\` (${typeof timeout})`);\n\t}\n};\n\n// `cleanup` option handling\nconst setExitHandler = async (spawned, {cleanup, detached}, timedPromise) => {\n\tif (!cleanup || detached) {\n\t\treturn timedPromise;\n\t}\n\n\tconst removeExitHandler = onExit(() => {\n\t\tspawned.kill();\n\t});\n\n\treturn timedPromise.finally(() => {\n\t\tremoveExitHandler();\n\t});\n};\n\nmodule.exports = {\n\tspawnedKill,\n\tspawnedCancel,\n\tsetupTimeout,\n\tvalidateTimeout,\n\tsetExitHandler\n};\n","'use strict';\n\nconst isStream = stream =>\n\tstream !== null &&\n\ttypeof stream === 'object' &&\n\ttypeof stream.pipe === 'function';\n\nisStream.writable = stream =>\n\tisStream(stream) &&\n\tstream.writable !== false &&\n\ttypeof stream._write === 'function' &&\n\ttypeof stream._writableState === 'object';\n\nisStream.readable = stream =>\n\tisStream(stream) &&\n\tstream.readable !== false &&\n\ttypeof stream._read === 'function' &&\n\ttypeof stream._readableState === 'object';\n\nisStream.duplex = stream =>\n\tisStream.writable(stream) &&\n\tisStream.readable(stream);\n\nisStream.transform = stream =>\n\tisStream.duplex(stream) &&\n\ttypeof stream._transform === 'function';\n\nmodule.exports = isStream;\n","'use strict';\nconst isStream = require('is-stream');\nconst getStream = require('get-stream');\nconst mergeStream = require('merge-stream');\n\n// `input` option\nconst handleInput = (spawned, input) => {\n\t// Checking for stdin is workaround for https://github.com/nodejs/node/issues/26852\n\t// @todo remove `|| spawned.stdin === undefined` once we drop support for Node.js <=12.2.0\n\tif (input === undefined || spawned.stdin === undefined) {\n\t\treturn;\n\t}\n\n\tif (isStream(input)) {\n\t\tinput.pipe(spawned.stdin);\n\t} else {\n\t\tspawned.stdin.end(input);\n\t}\n};\n\n// `all` interleaves `stdout` and `stderr`\nconst makeAllStream = (spawned, {all}) => {\n\tif (!all || (!spawned.stdout && !spawned.stderr)) {\n\t\treturn;\n\t}\n\n\tconst mixed = mergeStream();\n\n\tif (spawned.stdout) {\n\t\tmixed.add(spawned.stdout);\n\t}\n\n\tif (spawned.stderr) {\n\t\tmixed.add(spawned.stderr);\n\t}\n\n\treturn mixed;\n};\n\n// On failure, `result.stdout|stderr|all` should contain the currently buffered stream\nconst getBufferedData = async (stream, streamPromise) => {\n\tif (!stream) {\n\t\treturn;\n\t}\n\n\tstream.destroy();\n\n\ttry {\n\t\treturn await streamPromise;\n\t} catch (error) {\n\t\treturn error.bufferedData;\n\t}\n};\n\nconst getStreamPromise = (stream, {encoding, buffer, maxBuffer}) => {\n\tif (!stream || !buffer) {\n\t\treturn;\n\t}\n\n\tif (encoding) {\n\t\treturn getStream(stream, {encoding, maxBuffer});\n\t}\n\n\treturn getStream.buffer(stream, {maxBuffer});\n};\n\n// Retrieve result of child process: exit code, signal, error, streams (stdout/stderr/all)\nconst getSpawnedResult = async ({stdout, stderr, all}, {encoding, buffer, maxBuffer}, processDone) => {\n\tconst stdoutPromise = getStreamPromise(stdout, {encoding, buffer, maxBuffer});\n\tconst stderrPromise = getStreamPromise(stderr, {encoding, buffer, maxBuffer});\n\tconst allPromise = getStreamPromise(all, {encoding, buffer, maxBuffer: maxBuffer * 2});\n\n\ttry {\n\t\treturn await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);\n\t} catch (error) {\n\t\treturn Promise.all([\n\t\t\t{error, signal: error.signal, timedOut: error.timedOut},\n\t\t\tgetBufferedData(stdout, stdoutPromise),\n\t\t\tgetBufferedData(stderr, stderrPromise),\n\t\t\tgetBufferedData(all, allPromise)\n\t\t]);\n\t}\n};\n\nconst validateInputSync = ({input}) => {\n\tif (isStream(input)) {\n\t\tthrow new TypeError('The `input` option cannot be a stream in sync mode');\n\t}\n};\n\nmodule.exports = {\n\thandleInput,\n\tmakeAllStream,\n\tgetSpawnedResult,\n\tvalidateInputSync\n};\n\n","'use strict';\n\nconst nativePromisePrototype = (async () => {})().constructor.prototype;\nconst descriptors = ['then', 'catch', 'finally'].map(property => [\n\tproperty,\n\tReflect.getOwnPropertyDescriptor(nativePromisePrototype, property)\n]);\n\n// The return value is a mixin of `childProcess` and `Promise`\nconst mergePromise = (spawned, promise) => {\n\tfor (const [property, descriptor] of descriptors) {\n\t\t// Starting the main `promise` is deferred to avoid consuming streams\n\t\tconst value = typeof promise === 'function' ?\n\t\t\t(...args) => Reflect.apply(descriptor.value, promise(), args) :\n\t\t\tdescriptor.value.bind(promise);\n\n\t\tReflect.defineProperty(spawned, property, {...descriptor, value});\n\t}\n\n\treturn spawned;\n};\n\n// Use promises instead of `child_process` events\nconst getSpawnedPromise = spawned => {\n\treturn new Promise((resolve, reject) => {\n\t\tspawned.on('exit', (exitCode, signal) => {\n\t\t\tresolve({exitCode, signal});\n\t\t});\n\n\t\tspawned.on('error', error => {\n\t\t\treject(error);\n\t\t});\n\n\t\tif (spawned.stdin) {\n\t\t\tspawned.stdin.on('error', error => {\n\t\t\t\treject(error);\n\t\t\t});\n\t\t}\n\t});\n};\n\nmodule.exports = {\n\tmergePromise,\n\tgetSpawnedPromise\n};\n\n","'use strict';\nconst normalizeArgs = (file, args = []) => {\n\tif (!Array.isArray(args)) {\n\t\treturn [file];\n\t}\n\n\treturn [file, ...args];\n};\n\nconst NO_ESCAPE_REGEXP = /^[\\w.-]+$/;\nconst DOUBLE_QUOTES_REGEXP = /\"/g;\n\nconst escapeArg = arg => {\n\tif (typeof arg !== 'string' || NO_ESCAPE_REGEXP.test(arg)) {\n\t\treturn arg;\n\t}\n\n\treturn `\"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\\\\"')}\"`;\n};\n\nconst joinCommand = (file, args) => {\n\treturn normalizeArgs(file, args).join(' ');\n};\n\nconst getEscapedCommand = (file, args) => {\n\treturn normalizeArgs(file, args).map(arg => escapeArg(arg)).join(' ');\n};\n\nconst SPACES_REGEXP = / +/g;\n\n// Handle `execa.command()`\nconst parseCommand = command => {\n\tconst tokens = [];\n\tfor (const token of command.trim().split(SPACES_REGEXP)) {\n\t\t// Allow spaces to be escaped by a backslash if not meant as a delimiter\n\t\tconst previousToken = tokens[tokens.length - 1];\n\t\tif (previousToken && previousToken.endsWith('\\\\')) {\n\t\t\t// Merge previous token with current one\n\t\t\ttokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;\n\t\t} else {\n\t\t\ttokens.push(token);\n\t\t}\n\t}\n\n\treturn tokens;\n};\n\nmodule.exports = {\n\tjoinCommand,\n\tgetEscapedCommand,\n\tparseCommand\n};\n","'use strict';\nconst path = require('path');\nconst childProcess = require('child_process');\nconst crossSpawn = require('cross-spawn');\nconst stripFinalNewline = require('strip-final-newline');\nconst npmRunPath = require('npm-run-path');\nconst onetime = require('onetime');\nconst makeError = require('./lib/error');\nconst normalizeStdio = require('./lib/stdio');\nconst {spawnedKill, spawnedCancel, setupTimeout, validateTimeout, setExitHandler} = require('./lib/kill');\nconst {handleInput, getSpawnedResult, makeAllStream, validateInputSync} = require('./lib/stream');\nconst {mergePromise, getSpawnedPromise} = require('./lib/promise');\nconst {joinCommand, parseCommand, getEscapedCommand} = require('./lib/command');\n\nconst DEFAULT_MAX_BUFFER = 1000 * 1000 * 100;\n\nconst getEnv = ({env: envOption, extendEnv, preferLocal, localDir, execPath}) => {\n\tconst env = extendEnv ? {...process.env, ...envOption} : envOption;\n\n\tif (preferLocal) {\n\t\treturn npmRunPath.env({env, cwd: localDir, execPath});\n\t}\n\n\treturn env;\n};\n\nconst handleArguments = (file, args, options = {}) => {\n\tconst parsed = crossSpawn._parse(file, args, options);\n\tfile = parsed.command;\n\targs = parsed.args;\n\toptions = parsed.options;\n\n\toptions = {\n\t\tmaxBuffer: DEFAULT_MAX_BUFFER,\n\t\tbuffer: true,\n\t\tstripFinalNewline: true,\n\t\textendEnv: true,\n\t\tpreferLocal: false,\n\t\tlocalDir: options.cwd || process.cwd(),\n\t\texecPath: process.execPath,\n\t\tencoding: 'utf8',\n\t\treject: true,\n\t\tcleanup: true,\n\t\tall: false,\n\t\twindowsHide: true,\n\t\t...options\n\t};\n\n\toptions.env = getEnv(options);\n\n\toptions.stdio = normalizeStdio(options);\n\n\tif (process.platform === 'win32' && path.basename(file, '.exe') === 'cmd') {\n\t\t// #116\n\t\targs.unshift('/q');\n\t}\n\n\treturn {file, args, options, parsed};\n};\n\nconst handleOutput = (options, value, error) => {\n\tif (typeof value !== 'string' && !Buffer.isBuffer(value)) {\n\t\t// When `execa.sync()` errors, we normalize it to '' to mimic `execa()`\n\t\treturn error === undefined ? undefined : '';\n\t}\n\n\tif (options.stripFinalNewline) {\n\t\treturn stripFinalNewline(value);\n\t}\n\n\treturn value;\n};\n\nconst execa = (file, args, options) => {\n\tconst parsed = handleArguments(file, args, options);\n\tconst command = joinCommand(file, args);\n\tconst escapedCommand = getEscapedCommand(file, args);\n\n\tvalidateTimeout(parsed.options);\n\n\tlet spawned;\n\ttry {\n\t\tspawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);\n\t} catch (error) {\n\t\t// Ensure the returned error is always both a promise and a child process\n\t\tconst dummySpawned = new childProcess.ChildProcess();\n\t\tconst errorPromise = Promise.reject(makeError({\n\t\t\terror,\n\t\t\tstdout: '',\n\t\t\tstderr: '',\n\t\t\tall: '',\n\t\t\tcommand,\n\t\t\tescapedCommand,\n\t\t\tparsed,\n\t\t\ttimedOut: false,\n\t\t\tisCanceled: false,\n\t\t\tkilled: false\n\t\t}));\n\t\treturn mergePromise(dummySpawned, errorPromise);\n\t}\n\n\tconst spawnedPromise = getSpawnedPromise(spawned);\n\tconst timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);\n\tconst processDone = setExitHandler(spawned, parsed.options, timedPromise);\n\n\tconst context = {isCanceled: false};\n\n\tspawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));\n\tspawned.cancel = spawnedCancel.bind(null, spawned, context);\n\n\tconst handlePromise = async () => {\n\t\tconst [{error, exitCode, signal, timedOut}, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);\n\t\tconst stdout = handleOutput(parsed.options, stdoutResult);\n\t\tconst stderr = handleOutput(parsed.options, stderrResult);\n\t\tconst all = handleOutput(parsed.options, allResult);\n\n\t\tif (error || exitCode !== 0 || signal !== null) {\n\t\t\tconst returnedError = makeError({\n\t\t\t\terror,\n\t\t\t\texitCode,\n\t\t\t\tsignal,\n\t\t\t\tstdout,\n\t\t\t\tstderr,\n\t\t\t\tall,\n\t\t\t\tcommand,\n\t\t\t\tescapedCommand,\n\t\t\t\tparsed,\n\t\t\t\ttimedOut,\n\t\t\t\tisCanceled: context.isCanceled,\n\t\t\t\tkilled: spawned.killed\n\t\t\t});\n\n\t\t\tif (!parsed.options.reject) {\n\t\t\t\treturn returnedError;\n\t\t\t}\n\n\t\t\tthrow returnedError;\n\t\t}\n\n\t\treturn {\n\t\t\tcommand,\n\t\t\tescapedCommand,\n\t\t\texitCode: 0,\n\t\t\tstdout,\n\t\t\tstderr,\n\t\t\tall,\n\t\t\tfailed: false,\n\t\t\ttimedOut: false,\n\t\t\tisCanceled: false,\n\t\t\tkilled: false\n\t\t};\n\t};\n\n\tconst handlePromiseOnce = onetime(handlePromise);\n\n\thandleInput(spawned, parsed.options.input);\n\n\tspawned.all = makeAllStream(spawned, parsed.options);\n\n\treturn mergePromise(spawned, handlePromiseOnce);\n};\n\nmodule.exports = execa;\n\nmodule.exports.sync = (file, args, options) => {\n\tconst parsed = handleArguments(file, args, options);\n\tconst command = joinCommand(file, args);\n\tconst escapedCommand = getEscapedCommand(file, args);\n\n\tvalidateInputSync(parsed.options);\n\n\tlet result;\n\ttry {\n\t\tresult = childProcess.spawnSync(parsed.file, parsed.args, parsed.options);\n\t} catch (error) {\n\t\tthrow makeError({\n\t\t\terror,\n\t\t\tstdout: '',\n\t\t\tstderr: '',\n\t\t\tall: '',\n\t\t\tcommand,\n\t\t\tescapedCommand,\n\t\t\tparsed,\n\t\t\ttimedOut: false,\n\t\t\tisCanceled: false,\n\t\t\tkilled: false\n\t\t});\n\t}\n\n\tconst stdout = handleOutput(parsed.options, result.stdout, result.error);\n\tconst stderr = handleOutput(parsed.options, result.stderr, result.error);\n\n\tif (result.error || result.status !== 0 || result.signal !== null) {\n\t\tconst error = makeError({\n\t\t\tstdout,\n\t\t\tstderr,\n\t\t\terror: result.error,\n\t\t\tsignal: result.signal,\n\t\t\texitCode: result.status,\n\t\t\tcommand,\n\t\t\tescapedCommand,\n\t\t\tparsed,\n\t\t\ttimedOut: result.error && result.error.code === 'ETIMEDOUT',\n\t\t\tisCanceled: false,\n\t\t\tkilled: result.signal !== null\n\t\t});\n\n\t\tif (!parsed.options.reject) {\n\t\t\treturn error;\n\t\t}\n\n\t\tthrow error;\n\t}\n\n\treturn {\n\t\tcommand,\n\t\tescapedCommand,\n\t\texitCode: 0,\n\t\tstdout,\n\t\tstderr,\n\t\tfailed: false,\n\t\ttimedOut: false,\n\t\tisCanceled: false,\n\t\tkilled: false\n\t};\n};\n\nmodule.exports.command = (command, options) => {\n\tconst [file, ...args] = parseCommand(command);\n\treturn execa(file, args, options);\n};\n\nmodule.exports.commandSync = (command, options) => {\n\tconst [file, ...args] = parseCommand(command);\n\treturn execa.sync(file, args, options);\n};\n\nmodule.exports.node = (scriptPath, args, options = {}) => {\n\tif (args && !Array.isArray(args) && typeof args === 'object') {\n\t\toptions = args;\n\t\targs = [];\n\t}\n\n\tconst stdio = normalizeStdio.node(options);\n\tconst defaultExecArgv = process.execArgv.filter(arg => !arg.startsWith('--inspect'));\n\n\tconst {\n\t\tnodePath = process.execPath,\n\t\tnodeOptions = defaultExecArgv\n\t} = options;\n\n\treturn execa(\n\t\tnodePath,\n\t\t[\n\t\t\t...nodeOptions,\n\t\t\tscriptPath,\n\t\t\t...(Array.isArray(args) ? args : [])\n\t\t],\n\t\t{\n\t\t\t...options,\n\t\t\tstdin: undefined,\n\t\t\tstdout: undefined,\n\t\t\tstderr: undefined,\n\t\t\tstdio,\n\t\t\tshell: false\n\t\t}\n\t);\n};\n","// src/detect.ts\nimport path from \"path\";\nimport findUp from \"find-up\";\nvar LOCKS = {\n  \"pnpm-lock.yaml\": \"pnpm\",\n  \"yarn.lock\": \"yarn\",\n  \"package-lock.json\": \"npm\"\n};\nasync function detectPackageManager(cwd = process.cwd()) {\n  const result = await findUp(Object.keys(LOCKS), { cwd });\n  const agent = result ? LOCKS[path.basename(result)] : null;\n  return agent;\n}\n\n// src/install.ts\nimport execa from \"execa\";\nasync function installPackage(names, options = {}) {\n  const agent = options.packageManager || await detectPackageManager(options.cwd) || \"npm\";\n  if (!Array.isArray(names))\n    names = [names];\n  const args = options.additionalArgs || [];\n  if (options.preferOffline)\n    args.unshift(\"--prefer-offline\");\n  return execa(agent, [\n    agent === \"yarn\" ? \"add\" : \"install\",\n    options.dev ? \"-D\" : \"\",\n    ...args,\n    ...names\n  ].filter(Boolean), {\n    stdio: options.silent ? \"ignore\" : \"inherit\",\n    cwd: options.cwd\n  });\n}\nexport {\n  detectPackageManager,\n  installPackage\n};\n"],"names":["Queue","require$$0","pLimit","pLocate","path","fs","require$$1","promisify","require$$2","require$$3","locatePathModule","pathExistsModule","locatePath","pathExists","stripFinalNewline","pathKey","_os","_realtime","signalsByName","makeError","normalizeStdio","stdioModule","spawnedKill","spawnedCancel","setupTimeout","validateTimeout","setExitHandler","isStream","handleInput","makeAllStream","getSpawnedResult","validateInputSync","mergePromise","getSpawnedPromise","joinCommand","getEscapedCommand","parseCommand","require$$4","require$$5","require$$6","require$$7","require$$8","require$$9","require$$10","require$$11","execaModule","execa"],"mappings":"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"}