ccjk 14.2.2 → 15.0.0

package/dist/chunks/linux.mjs

@@ -1,3863 +0,0 @@
-import os__default from 'node:os';
-import path__default from 'node:path';
-import fs__default from 'node:fs';
-import { randomUUID } from 'node:crypto';
-import { c as commonjsGlobal, g as getDefaultExportFromCjs } from '../shared/ccjk.BAGoDD49.mjs';
-import require$$0 from 'fs';
-import sysPath from 'path';
-import require$$0$1 from 'child_process';
-import require$$0$2 from 'os';
-import require$$4 from 'util';
-import require$$5 from 'assert';
-import require$$2 from 'events';
-import require$$0$4 from 'buffer';
-import require$$0$3 from 'stream';
-import { m as moveFile } from '../shared/ccjk.Bx_rmYfN.mjs';
-import { c as commonjsRequire } from '../shared/ccjk.COweQ1RR.mjs';
-import 'node:process';
-
-var xdgTrashdir$1 = {exports: {}};
-
-var df$1 = {exports: {}};
-
-var execa = {exports: {}};
-
-var crossSpawn = {exports: {}};
-
-var windows;
-var hasRequiredWindows;
-
-function requireWindows () {
-	if (hasRequiredWindows) return windows;
-	hasRequiredWindows = 1;
-	windows = isexe;
-	isexe.sync = sync;
-
-	var fs = require$$0;
-
-	function checkPathExt (path, options) {
-	  var pathext = options.pathExt !== undefined ?
-	    options.pathExt : process.env.PATHEXT;
-
-	  if (!pathext) {
-	    return true
-	  }
-
-	  pathext = pathext.split(';');
-	  if (pathext.indexOf('') !== -1) {
-	    return true
-	  }
-	  for (var i = 0; i < pathext.length; i++) {
-	    var p = pathext[i].toLowerCase();
-	    if (p && path.substr(-p.length).toLowerCase() === p) {
-	      return true
-	    }
-	  }
-	  return false
-	}
-
-	function checkStat (stat, path, options) {
-	  if (!stat.isSymbolicLink() && !stat.isFile()) {
-	    return false
-	  }
-	  return checkPathExt(path, options)
-	}
-
-	function isexe (path, options, cb) {
-	  fs.stat(path, function (er, stat) {
-	    cb(er, er ? false : checkStat(stat, path, options));
-	  });
-	}
-
-	function sync (path, options) {
-	  return checkStat(fs.statSync(path), path, options)
-	}
-	return windows;
-}
-
-var mode;
-var hasRequiredMode;
-
-function requireMode () {
-	if (hasRequiredMode) return mode;
-	hasRequiredMode = 1;
-	mode = isexe;
-	isexe.sync = sync;
-
-	var fs = require$$0;
-
-	function isexe (path, options, cb) {
-	  fs.stat(path, function (er, stat) {
-	    cb(er, er ? false : checkStat(stat, options));
-	  });
-	}
-
-	function sync (path, options) {
-	  return checkStat(fs.statSync(path), options)
-	}
-
-	function checkStat (stat, options) {
-	  return stat.isFile() && checkMode(stat, options)
-	}
-
-	function checkMode (stat, options) {
-	  var mod = stat.mode;
-	  var uid = stat.uid;
-	  var gid = stat.gid;
-
-	  var myUid = options.uid !== undefined ?
-	    options.uid : process.getuid && process.getuid();
-	  var myGid = options.gid !== undefined ?
-	    options.gid : process.getgid && process.getgid();
-
-	  var u = parseInt('100', 8);
-	  var g = parseInt('010', 8);
-	  var o = parseInt('001', 8);
-	  var ug = u | g;
-
-	  var ret = (mod & o) ||
-	    (mod & g) && gid === myGid ||
-	    (mod & u) && uid === myUid ||
-	    (mod & ug) && myUid === 0;
-
-	  return ret
-	}
-	return mode;
-}
-
-var isexe_1;
-var hasRequiredIsexe;
-
-function requireIsexe () {
-	if (hasRequiredIsexe) return isexe_1;
-	hasRequiredIsexe = 1;
-	var core;
-	if (process.platform === 'win32' || commonjsGlobal.TESTING_WINDOWS) {
-	  core = requireWindows();
-	} else {
-	  core = requireMode();
-	}
-
-	isexe_1 = isexe;
-	isexe.sync = sync;
-
-	function isexe (path, options, cb) {
-	  if (typeof options === 'function') {
-	    cb = options;
-	    options = {};
-	  }
-
-	  if (!cb) {
-	    if (typeof Promise !== 'function') {
-	      throw new TypeError('callback not provided')
-	    }
-
-	    return new Promise(function (resolve, reject) {
-	      isexe(path, options || {}, function (er, is) {
-	        if (er) {
-	          reject(er);
-	        } else {
-	          resolve(is);
-	        }
-	      });
-	    })
-	  }
-
-	  core(path, options || {}, function (er, is) {
-	    // ignore EACCES because that just means we aren't allowed to run it
-	    if (er) {
-	      if (er.code === 'EACCES' || options && options.ignoreErrors) {
-	        er = null;
-	        is = false;
-	      }
-	    }
-	    cb(er, is);
-	  });
-	}
-
-	function sync (path, options) {
-	  // my kingdom for a filtered catch
-	  try {
-	    return core.sync(path, options || {})
-	  } catch (er) {
-	    if (options && options.ignoreErrors || er.code === 'EACCES') {
-	      return false
-	    } else {
-	      throw er
-	    }
-	  }
-	}
-	return isexe_1;
-}
-
-var which_1;
-var hasRequiredWhich;
-
-function requireWhich () {
-	if (hasRequiredWhich) return which_1;
-	hasRequiredWhich = 1;
-	const isWindows = process.platform === 'win32' ||
-	    process.env.OSTYPE === 'cygwin' ||
-	    process.env.OSTYPE === 'msys';
-
-	const path = sysPath;
-	const COLON = isWindows ? ';' : ':';
-	const isexe = requireIsexe();
-
-	const getNotFoundError = (cmd) =>
-	  Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' });
-
-	const getPathInfo = (cmd, opt) => {
-	  const colon = opt.colon || COLON;
-
-	  // If it has a slash, then we don't bother searching the pathenv.
-	  // just check the file itself, and that's it.
-	  const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
-	    : (
-	      [
-	        // windows always checks the cwd first
-	        ...(isWindows ? [process.cwd()] : []),
-	        ...(opt.path || process.env.PATH ||
-	          /* istanbul ignore next: very unusual */ '').split(colon),
-	      ]
-	    );
-	  const pathExtExe = isWindows
-	    ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
-	    : '';
-	  const pathExt = isWindows ? pathExtExe.split(colon) : [''];
-
-	  if (isWindows) {
-	    if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
-	      pathExt.unshift('');
-	  }
-
-	  return {
-	    pathEnv,
-	    pathExt,
-	    pathExtExe,
-	  }
-	};
-
-	const which = (cmd, opt, cb) => {
-	  if (typeof opt === 'function') {
-	    cb = opt;
-	    opt = {};
-	  }
-	  if (!opt)
-	    opt = {};
-
-	  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-	  const found = [];
-
-	  const step = i => new Promise((resolve, reject) => {
-	    if (i === pathEnv.length)
-	      return opt.all && found.length ? resolve(found)
-	        : reject(getNotFoundError(cmd))
-
-	    const ppRaw = pathEnv[i];
-	    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-
-	    const pCmd = path.join(pathPart, cmd);
-	    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
-	      : pCmd;
-
-	    resolve(subStep(p, i, 0));
-	  });
-
-	  const subStep = (p, i, ii) => new Promise((resolve, reject) => {
-	    if (ii === pathExt.length)
-	      return resolve(step(i + 1))
-	    const ext = pathExt[ii];
-	    isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
-	      if (!er && is) {
-	        if (opt.all)
-	          found.push(p + ext);
-	        else
-	          return resolve(p + ext)
-	      }
-	      return resolve(subStep(p, i, ii + 1))
-	    });
-	  });
-
-	  return cb ? step(0).then(res => cb(null, res), cb) : step(0)
-	};
-
-	const whichSync = (cmd, opt) => {
-	  opt = opt || {};
-
-	  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-	  const found = [];
-
-	  for (let i = 0; i < pathEnv.length; i ++) {
-	    const ppRaw = pathEnv[i];
-	    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-
-	    const pCmd = path.join(pathPart, cmd);
-	    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
-	      : pCmd;
-
-	    for (let j = 0; j < pathExt.length; j ++) {
-	      const cur = p + pathExt[j];
-	      try {
-	        const is = isexe.sync(cur, { pathExt: pathExtExe });
-	        if (is) {
-	          if (opt.all)
-	            found.push(cur);
-	          else
-	            return cur
-	        }
-	      } catch (ex) {}
-	    }
-	  }
-
-	  if (opt.all && found.length)
-	    return found
-
-	  if (opt.nothrow)
-	    return null
-
-	  throw getNotFoundError(cmd)
-	};
-
-	which_1 = which;
-	which.sync = whichSync;
-	return which_1;
-}
-
-var pathKey = {exports: {}};
-
-var hasRequiredPathKey;
-
-function requirePathKey () {
-	if (hasRequiredPathKey) return pathKey.exports;
-	hasRequiredPathKey = 1;
-
-	const pathKey$1 = (options = {}) => {
-		const environment = options.env || process.env;
-		const platform = options.platform || process.platform;
-
-		if (platform !== 'win32') {
-			return 'PATH';
-		}
-
-		return Object.keys(environment).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
-	};
-
-	pathKey.exports = pathKey$1;
-	// TODO: Remove this for the next major release
-	pathKey.exports.default = pathKey$1;
-	return pathKey.exports;
-}
-
-var resolveCommand_1;
-var hasRequiredResolveCommand;
-
-function requireResolveCommand () {
-	if (hasRequiredResolveCommand) return resolveCommand_1;
-	hasRequiredResolveCommand = 1;
-
-	const path = sysPath;
-	const which = requireWhich();
-	const getPathKey = requirePathKey();
-
-	function resolveCommandAttempt(parsed, withoutPathExt) {
-	    const env = parsed.options.env || process.env;
-	    const cwd = process.cwd();
-	    const hasCustomCwd = parsed.options.cwd != null;
-	    // Worker threads do not have process.chdir()
-	    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
-
-	    // If a custom `cwd` was specified, we need to change the process cwd
-	    // because `which` will do stat calls but does not support a custom cwd
-	    if (shouldSwitchCwd) {
-	        try {
-	            process.chdir(parsed.options.cwd);
-	        } catch (err) {
-	            /* Empty */
-	        }
-	    }
-
-	    let resolved;
-
-	    try {
-	        resolved = which.sync(parsed.command, {
-	            path: env[getPathKey({ env })],
-	            pathExt: withoutPathExt ? path.delimiter : undefined,
-	        });
-	    } catch (e) {
-	        /* Empty */
-	    } finally {
-	        if (shouldSwitchCwd) {
-	            process.chdir(cwd);
-	        }
-	    }
-
-	    // If we successfully resolved, ensure that an absolute path is returned
-	    // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
-	    if (resolved) {
-	        resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
-	    }
-
-	    return resolved;
-	}
-
-	function resolveCommand(parsed) {
-	    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
-	}
-
-	resolveCommand_1 = resolveCommand;
-	return resolveCommand_1;
-}
-
-var _escape = {};
-
-var hasRequired_escape;
-
-function require_escape () {
-	if (hasRequired_escape) return _escape;
-	hasRequired_escape = 1;
-
-	// See http://www.robvanderwoude.com/escapechars.php
-	const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
-
-	function escapeCommand(arg) {
-	    // Escape meta chars
-	    arg = arg.replace(metaCharsRegExp, '^$1');
-
-	    return arg;
-	}
-
-	function escapeArgument(arg, doubleEscapeMetaChars) {
-	    // Convert to string
-	    arg = `${arg}`;
-
-	    // Algorithm below is based on https://qntm.org/cmd
-	    // It's slightly altered to disable JS backtracking to avoid hanging on specially crafted input
-	    // Please see https://github.com/moxystudio/node-cross-spawn/pull/160 for more information
-
-	    // Sequence of backslashes followed by a double quote:
-	    // double up all the backslashes and escape the double quote
-	    arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
-
-	    // Sequence of backslashes followed by the end of the string
-	    // (which will become a double quote later):
-	    // double up all the backslashes
-	    arg = arg.replace(/(?=(\\+?)?)\1$/, '$1$1');
-
-	    // All other backslashes occur literally
-
-	    // Quote the whole thing:
-	    arg = `"${arg}"`;
-
-	    // Escape meta chars
-	    arg = arg.replace(metaCharsRegExp, '^$1');
-
-	    // Double escape meta chars if necessary
-	    if (doubleEscapeMetaChars) {
-	        arg = arg.replace(metaCharsRegExp, '^$1');
-	    }
-
-	    return arg;
-	}
-
-	_escape.command = escapeCommand;
-	_escape.argument = escapeArgument;
-	return _escape;
-}
-
-var shebangRegex;
-var hasRequiredShebangRegex;
-
-function requireShebangRegex () {
-	if (hasRequiredShebangRegex) return shebangRegex;
-	hasRequiredShebangRegex = 1;
-	shebangRegex = /^#!(.*)/;
-	return shebangRegex;
-}
-
-var shebangCommand;
-var hasRequiredShebangCommand;
-
-function requireShebangCommand () {
-	if (hasRequiredShebangCommand) return shebangCommand;
-	hasRequiredShebangCommand = 1;
-	const shebangRegex = requireShebangRegex();
-
-	shebangCommand = (string = '') => {
-		const match = string.match(shebangRegex);
-
-		if (!match) {
-			return null;
-		}
-
-		const [path, argument] = match[0].replace(/#! ?/, '').split(' ');
-		const binary = path.split('/').pop();
-
-		if (binary === 'env') {
-			return argument;
-		}
-
-		return argument ? `${binary} ${argument}` : binary;
-	};
-	return shebangCommand;
-}
-
-var readShebang_1;
-var hasRequiredReadShebang;
-
-function requireReadShebang () {
-	if (hasRequiredReadShebang) return readShebang_1;
-	hasRequiredReadShebang = 1;
-
-	const fs = require$$0;
-	const shebangCommand = requireShebangCommand();
-
-	function readShebang(command) {
-	    // Read the first 150 bytes from the file
-	    const size = 150;
-	    const buffer = Buffer.alloc(size);
-
-	    let fd;
-
-	    try {
-	        fd = fs.openSync(command, 'r');
-	        fs.readSync(fd, buffer, 0, size, 0);
-	        fs.closeSync(fd);
-	    } catch (e) { /* Empty */ }
-
-	    // Attempt to extract shebang (null is returned if not a shebang)
-	    return shebangCommand(buffer.toString());
-	}
-
-	readShebang_1 = readShebang;
-	return readShebang_1;
-}
-
-var parse_1;
-var hasRequiredParse;
-
-function requireParse () {
-	if (hasRequiredParse) return parse_1;
-	hasRequiredParse = 1;
-
-	const path = sysPath;
-	const resolveCommand = requireResolveCommand();
-	const escape = require_escape();
-	const readShebang = requireReadShebang();
-
-	const isWin = process.platform === 'win32';
-	const isExecutableRegExp = /\.(?:com|exe)$/i;
-	const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
-
-	function detectShebang(parsed) {
-	    parsed.file = resolveCommand(parsed);
-
-	    const shebang = parsed.file && readShebang(parsed.file);
-
-	    if (shebang) {
-	        parsed.args.unshift(parsed.file);
-	        parsed.command = shebang;
-
-	        return resolveCommand(parsed);
-	    }
-
-	    return parsed.file;
-	}
-
-	function parseNonShell(parsed) {
-	    if (!isWin) {
-	        return parsed;
-	    }
-
-	    // Detect & add support for shebangs
-	    const commandFile = detectShebang(parsed);
-
-	    // We don't need a shell if the command filename is an executable
-	    const needsShell = !isExecutableRegExp.test(commandFile);
-
-	    // If a shell is required, use cmd.exe and take care of escaping everything correctly
-	    // Note that `forceShell` is an hidden option used only in tests
-	    if (parsed.options.forceShell || needsShell) {
-	        // Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`
-	        // The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument
-	        // Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,
-	        // we need to double escape them
-	        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-
-	        // Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
-	        // This is necessary otherwise it will always fail with ENOENT in those cases
-	        parsed.command = path.normalize(parsed.command);
-
-	        // Escape command & arguments
-	        parsed.command = escape.command(parsed.command);
-	        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
-
-	        const shellCommand = [parsed.command].concat(parsed.args).join(' ');
-
-	        parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
-	        parsed.command = process.env.comspec || 'cmd.exe';
-	        parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
-	    }
-
-	    return parsed;
-	}
-
-	function parse(command, args, options) {
-	    // Normalize arguments, similar to nodejs
-	    if (args && !Array.isArray(args)) {
-	        options = args;
-	        args = null;
-	    }
-
-	    args = args ? args.slice(0) : []; // Clone array to avoid changing the original
-	    options = Object.assign({}, options); // Clone object to avoid changing the original
-
-	    // Build our parsed object
-	    const parsed = {
-	        command,
-	        args,
-	        options,
-	        file: undefined,
-	        original: {
-	            command,
-	            args,
-	        },
-	    };
-
-	    // Delegate further parsing to shell or non-shell
-	    return options.shell ? parsed : parseNonShell(parsed);
-	}
-
-	parse_1 = parse;
-	return parse_1;
-}
-
-var enoent;
-var hasRequiredEnoent;
-
-function requireEnoent () {
-	if (hasRequiredEnoent) return enoent;
-	hasRequiredEnoent = 1;
-
-	const isWin = process.platform === 'win32';
-
-	function notFoundError(original, syscall) {
-	    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
-	        code: 'ENOENT',
-	        errno: 'ENOENT',
-	        syscall: `${syscall} ${original.command}`,
-	        path: original.command,
-	        spawnargs: original.args,
-	    });
-	}
-
-	function hookChildProcess(cp, parsed) {
-	    if (!isWin) {
-	        return;
-	    }
-
-	    const originalEmit = cp.emit;
-
-	    cp.emit = function (name, arg1) {
-	        // If emitting "exit" event and exit code is 1, we need to check if
-	        // the command exists and emit an "error" instead
-	        // See https://github.com/IndigoUnited/node-cross-spawn/issues/16
-	        if (name === 'exit') {
-	            const err = verifyENOENT(arg1, parsed);
-
-	            if (err) {
-	                return originalEmit.call(cp, 'error', err);
-	            }
-	        }
-
-	        return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params
-	    };
-	}
-
-	function verifyENOENT(status, parsed) {
-	    if (isWin && status === 1 && !parsed.file) {
-	        return notFoundError(parsed.original, 'spawn');
-	    }
-
-	    return null;
-	}
-
-	function verifyENOENTSync(status, parsed) {
-	    if (isWin && status === 1 && !parsed.file) {
-	        return notFoundError(parsed.original, 'spawnSync');
-	    }
-
-	    return null;
-	}
-
-	enoent = {
-	    hookChildProcess,
-	    verifyENOENT,
-	    verifyENOENTSync,
-	    notFoundError,
-	};
-	return enoent;
-}
-
-var hasRequiredCrossSpawn;
-
-function requireCrossSpawn () {
-	if (hasRequiredCrossSpawn) return crossSpawn.exports;
-	hasRequiredCrossSpawn = 1;
-
-	const cp = require$$0$1;
-	const parse = requireParse();
-	const enoent = requireEnoent();
-
-	function spawn(command, args, options) {
-	    // Parse the arguments
-	    const parsed = parse(command, args, options);
-
-	    // Spawn the child process
-	    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
-
-	    // Hook into child process "exit" event to emit an error if the command
-	    // does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
-	    enoent.hookChildProcess(spawned, parsed);
-
-	    return spawned;
-	}
-
-	function spawnSync(command, args, options) {
-	    // Parse the arguments
-	    const parsed = parse(command, args, options);
-
-	    // Spawn the child process
-	    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
-
-	    // Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
-	    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
-
-	    return result;
-	}
-
-	crossSpawn.exports = spawn;
-	crossSpawn.exports.spawn = spawn;
-	crossSpawn.exports.sync = spawnSync;
-
-	crossSpawn.exports._parse = parse;
-	crossSpawn.exports._enoent = enoent;
-	return crossSpawn.exports;
-}
-
-var stripFinalNewline;
-var hasRequiredStripFinalNewline;
-
-function requireStripFinalNewline () {
-	if (hasRequiredStripFinalNewline) return stripFinalNewline;
-	hasRequiredStripFinalNewline = 1;
-
-	stripFinalNewline = 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;
-	};
-	return stripFinalNewline;
-}
-
-var npmRunPath = {exports: {}};
-
-npmRunPath.exports;
-
-var hasRequiredNpmRunPath;
-
-function requireNpmRunPath () {
-	if (hasRequiredNpmRunPath) return npmRunPath.exports;
-	hasRequiredNpmRunPath = 1;
-	(function (module) {
-		const path = sysPath;
-		const pathKey = requirePathKey();
-
-		const npmRunPath = options => {
-			options = {
-				cwd: process.cwd(),
-				path: process.env[pathKey()],
-				...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
-			result.push(path.dirname(process.execPath));
-
-			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({env});
-
-			options.path = env[path];
-			env[path] = module.exports(options);
-
-			return env;
-		}; 
-	} (npmRunPath));
-	return npmRunPath.exports;
-}
-
-var onetime = {exports: {}};
-
-var mimicFn = {exports: {}};
-
-var hasRequiredMimicFn;
-
-function requireMimicFn () {
-	if (hasRequiredMimicFn) return mimicFn.exports;
-	hasRequiredMimicFn = 1;
-
-	const mimicFn$1 = (to, from) => {
-		for (const prop of Reflect.ownKeys(from)) {
-			Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
-		}
-
-		return to;
-	};
-
-	mimicFn.exports = mimicFn$1;
-	// TODO: Remove this for the next major release
-	mimicFn.exports.default = mimicFn$1;
-	return mimicFn.exports;
-}
-
-var hasRequiredOnetime;
-
-function requireOnetime () {
-	if (hasRequiredOnetime) return onetime.exports;
-	hasRequiredOnetime = 1;
-	const mimicFn = requireMimicFn();
-
-	const calledFunctions = new WeakMap();
-
-	const onetime$1 = (function_, options = {}) => {
-		if (typeof function_ !== 'function') {
-			throw new TypeError('Expected a function');
-		}
-
-		let returnValue;
-		let callCount = 0;
-		const functionName = function_.displayName || function_.name || '<anonymous>';
-
-		const onetime = function (...arguments_) {
-			calledFunctions.set(onetime, ++callCount);
-
-			if (callCount === 1) {
-				returnValue = function_.apply(this, arguments_);
-				function_ = null;
-			} else if (options.throw === true) {
-				throw new Error(`Function \`${functionName}\` can only be called once`);
-			}
-
-			return returnValue;
-		};
-
-		mimicFn(onetime, function_);
-		calledFunctions.set(onetime, callCount);
-
-		return onetime;
-	};
-
-	onetime.exports = onetime$1;
-	// TODO: Remove this for the next major release
-	onetime.exports.default = onetime$1;
-
-	onetime.exports.callCount = function_ => {
-		if (!calledFunctions.has(function_)) {
-			throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
-		}
-
-		return calledFunctions.get(function_);
-	};
-	return onetime.exports;
-}
-
-var error;
-var hasRequiredError;
-
-function requireError () {
-	if (hasRequiredError) return error;
-	hasRequiredError = 1;
-	const os = require$$0$2;
-	const util = require$$4;
-
-	const getCode = (error, code) => {
-		if (error && error.code) {
-			return [error.code, os.constants.errno[error.code]];
-		}
-
-		if (Number.isInteger(code)) {
-			return [util.getSystemErrorName(-code), code];
-		}
-
-		return [];
-	};
-
-	const getErrorPrefix = ({timedOut, timeout, signal, exitCodeName, exitCode, isCanceled}) => {
-		if (timedOut) {
-			return `timed out after ${timeout} milliseconds`;
-		}
-
-		if (isCanceled) {
-			return 'was canceled';
-		}
-
-		if (signal) {
-			return `was killed with ${signal}`;
-		}
-
-		if (exitCode !== undefined) {
-			return `failed with exit code ${exitCode} (${exitCodeName})`;
-		}
-
-		return 'failed';
-	};
-
-	const makeError = ({
-		stdout,
-		stderr,
-		all,
-		error,
-		signal,
-		code,
-		command,
-		timedOut,
-		isCanceled,
-		killed,
-		parsed: {options: {timeout}}
-	}) => {
-		const [exitCodeName, exitCode] = getCode(error, code);
-
-		const prefix = getErrorPrefix({timedOut, timeout, signal, exitCodeName, exitCode, isCanceled});
-		const message = `Command ${prefix}: ${command}`;
-
-		if (error instanceof Error) {
-			error.originalMessage = error.message;
-			error.message = `${message}\n${error.message}`;
-		} else {
-			error = new Error(message);
-		}
-
-		error.command = command;
-		delete error.code;
-		error.exitCode = exitCode;
-		error.exitCodeName = exitCodeName;
-		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;
-		// `signal` emitted on `spawned.on('exit')` event can be `null`. We normalize
-		// it to `undefined`
-		error.signal = signal || undefined;
-
-		return error;
-	};
-
-	error = makeError;
-	return error;
-}
-
-var stdio = {exports: {}};
-
-var hasRequiredStdio;
-
-function requireStdio () {
-	if (hasRequiredStdio) return stdio.exports;
-	hasRequiredStdio = 1;
-	const aliases = ['stdin', 'stdout', 'stderr'];
-
-	const hasAlias = opts => aliases.some(alias => opts[alias] !== undefined);
-
-	const normalizeStdio = opts => {
-		if (!opts) {
-			return;
-		}
-
-		const {stdio} = opts;
-
-		if (stdio === undefined) {
-			return aliases.map(alias => opts[alias]);
-		}
-
-		if (hasAlias(opts)) {
-			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;
-
-	// `ipc` is pushed unless it is already present
-	stdio.exports.node = opts => {
-		const stdio = normalizeStdio(opts);
-
-		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'];
-	};
-	return stdio.exports;
-}
-
-var signalExit = {exports: {}};
-
-var signals = {exports: {}};
-
-var hasRequiredSignals;
-
-function requireSignals () {
-	if (hasRequiredSignals) return signals.exports;
-	hasRequiredSignals = 1;
-	(function (module) {
-		// This is not the set of all possible signals.
-		//
-		// It IS, however, the set of all signals that trigger
-		// an exit on either Linux or BSD systems.  Linux is a
-		// superset of the signal names supported on BSD, and
-		// the unknown signals just fail to register, so we can
-		// catch that easily enough.
-		//
-		// Don't bother with SIGKILL.  It's uncatchable, which
-		// means that we can't fire any callbacks anyway.
-		//
-		// If a user does happen to register a handler on a non-
-		// fatal signal like SIGWINCH or something, and then
-		// exit, it'll end up firing `process.emit('exit')`, so
-		// the handler will be fired anyway.
-		//
-		// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
-		// artificially, inherently leave the process in a
-		// state from which it is not safe to try and enter JS
-		// listeners.
-		module.exports = [
-		  'SIGABRT',
-		  'SIGALRM',
-		  'SIGHUP',
-		  'SIGINT',
-		  'SIGTERM'
-		];
-
-		if (process.platform !== 'win32') {
-		  module.exports.push(
-		    'SIGVTALRM',
-		    'SIGXCPU',
-		    'SIGXFSZ',
-		    'SIGUSR2',
-		    'SIGTRAP',
-		    'SIGSYS',
-		    'SIGQUIT',
-		    'SIGIOT'
-		    // should detect profiler and enable/disable accordingly.
-		    // see #21
-		    // 'SIGPROF'
-		  );
-		}
-
-		if (process.platform === 'linux') {
-		  module.exports.push(
-		    'SIGIO',
-		    'SIGPOLL',
-		    'SIGPWR',
-		    'SIGSTKFLT',
-		    'SIGUNUSED'
-		  );
-		} 
-	} (signals));
-	return signals.exports;
-}
-
-var hasRequiredSignalExit;
-
-function requireSignalExit () {
-	if (hasRequiredSignalExit) return signalExit.exports;
-	hasRequiredSignalExit = 1;
-	// Note: since nyc uses this module to output coverage, any lines
-	// that are in the direct sync flow of nyc's outputCoverage are
-	// ignored, since we can never get coverage for them.
-	// grab a reference to node's real process object right away
-	var process = commonjsGlobal.process;
-
-	const processOk = function (process) {
-	  return process &&
-	    typeof process === 'object' &&
-	    typeof process.removeListener === 'function' &&
-	    typeof process.emit === 'function' &&
-	    typeof process.reallyExit === 'function' &&
-	    typeof process.listeners === 'function' &&
-	    typeof process.kill === 'function' &&
-	    typeof process.pid === 'number' &&
-	    typeof process.on === 'function'
-	};
-
-	// some kind of non-node environment, just no-op
-	/* istanbul ignore if */
-	if (!processOk(process)) {
-	  signalExit.exports = function () {
-	    return function () {}
-	  };
-	} else {
-	  var assert = require$$5;
-	  var signals = requireSignals();
-	  var isWin = /^win/i.test(process.platform);
-
-	  var EE = require$$2;
-	  /* istanbul ignore if */
-	  if (typeof EE !== 'function') {
-	    EE = EE.EventEmitter;
-	  }
-
-	  var emitter;
-	  if (process.__signal_exit_emitter__) {
-	    emitter = process.__signal_exit_emitter__;
-	  } else {
-	    emitter = process.__signal_exit_emitter__ = new EE();
-	    emitter.count = 0;
-	    emitter.emitted = {};
-	  }
-
-	  // Because this emitter is a global, we have to check to see if a
-	  // previous version of this library failed to enable infinite listeners.
-	  // I know what you're about to say.  But literally everything about
-	  // signal-exit is a compromise with evil.  Get used to it.
-	  if (!emitter.infinite) {
-	    emitter.setMaxListeners(Infinity);
-	    emitter.infinite = true;
-	  }
-
-	  signalExit.exports = function (cb, opts) {
-	    /* istanbul ignore if */
-	    if (!processOk(commonjsGlobal.process)) {
-	      return function () {}
-	    }
-	    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
-
-	    if (loaded === false) {
-	      load();
-	    }
-
-	    var ev = 'exit';
-	    if (opts && opts.alwaysLast) {
-	      ev = 'afterexit';
-	    }
-
-	    var remove = function () {
-	      emitter.removeListener(ev, cb);
-	      if (emitter.listeners('exit').length === 0 &&
-	          emitter.listeners('afterexit').length === 0) {
-	        unload();
-	      }
-	    };
-	    emitter.on(ev, cb);
-
-	    return remove
-	  };
-
-	  var unload = function unload () {
-	    if (!loaded || !processOk(commonjsGlobal.process)) {
-	      return
-	    }
-	    loaded = false;
-
-	    signals.forEach(function (sig) {
-	      try {
-	        process.removeListener(sig, sigListeners[sig]);
-	      } catch (er) {}
-	    });
-	    process.emit = originalProcessEmit;
-	    process.reallyExit = originalProcessReallyExit;
-	    emitter.count -= 1;
-	  };
-	  signalExit.exports.unload = unload;
-
-	  var emit = function emit (event, code, signal) {
-	    /* istanbul ignore if */
-	    if (emitter.emitted[event]) {
-	      return
-	    }
-	    emitter.emitted[event] = true;
-	    emitter.emit(event, code, signal);
-	  };
-
-	  // { <signal>: <listener fn>, ... }
-	  var sigListeners = {};
-	  signals.forEach(function (sig) {
-	    sigListeners[sig] = function listener () {
-	      /* istanbul ignore if */
-	      if (!processOk(commonjsGlobal.process)) {
-	        return
-	      }
-	      // If there are no other listeners, an exit is coming!
-	      // Simplest way: remove us and then re-send the signal.
-	      // We know that this will kill the process, so we can
-	      // safely emit now.
-	      var listeners = process.listeners(sig);
-	      if (listeners.length === emitter.count) {
-	        unload();
-	        emit('exit', null, sig);
-	        /* istanbul ignore next */
-	        emit('afterexit', null, sig);
-	        /* istanbul ignore next */
-	        if (isWin && sig === 'SIGHUP') {
-	          // "SIGHUP" throws an `ENOSYS` error on Windows,
-	          // so use a supported signal instead
-	          sig = 'SIGINT';
-	        }
-	        /* istanbul ignore next */
-	        process.kill(process.pid, sig);
-	      }
-	    };
-	  });
-
-	  signalExit.exports.signals = function () {
-	    return signals
-	  };
-
-	  var loaded = false;
-
-	  var load = function load () {
-	    if (loaded || !processOk(commonjsGlobal.process)) {
-	      return
-	    }
-	    loaded = true;
-
-	    // This is the number of onSignalExit's that are in play.
-	    // It's important so that we can count the correct number of
-	    // listeners on signals, and don't wait for the other one to
-	    // handle it instead of us.
-	    emitter.count += 1;
-
-	    signals = signals.filter(function (sig) {
-	      try {
-	        process.on(sig, sigListeners[sig]);
-	        return true
-	      } catch (er) {
-	        return false
-	      }
-	    });
-
-	    process.emit = processEmit;
-	    process.reallyExit = processReallyExit;
-	  };
-	  signalExit.exports.load = load;
-
-	  var originalProcessReallyExit = process.reallyExit;
-	  var processReallyExit = function processReallyExit (code) {
-	    /* istanbul ignore if */
-	    if (!processOk(commonjsGlobal.process)) {
-	      return
-	    }
-	    process.exitCode = code || /* istanbul ignore next */ 0;
-	    emit('exit', process.exitCode, null);
-	    /* istanbul ignore next */
-	    emit('afterexit', process.exitCode, null);
-	    /* istanbul ignore next */
-	    originalProcessReallyExit.call(process, process.exitCode);
-	  };
-
-	  var originalProcessEmit = process.emit;
-	  var processEmit = function processEmit (ev, arg) {
-	    if (ev === 'exit' && processOk(commonjsGlobal.process)) {
-	      /* istanbul ignore else */
-	      if (arg !== undefined) {
-	        process.exitCode = arg;
-	      }
-	      var ret = originalProcessEmit.apply(this, arguments);
-	      /* istanbul ignore next */
-	      emit('exit', process.exitCode, null);
-	      /* istanbul ignore next */
-	      emit('afterexit', process.exitCode, null);
-	      /* istanbul ignore next */
-	      return ret
-	    } else {
-	      return originalProcessEmit.apply(this, arguments)
-	    }
-	  };
-	}
-	return signalExit.exports;
-}
-
-var pFinally;
-var hasRequiredPFinally;
-
-function requirePFinally () {
-	if (hasRequiredPFinally) return pFinally;
-	hasRequiredPFinally = 1;
-
-	pFinally = async (
-		promise,
-		onFinally = (() => {})
-	) => {
-		let value;
-		try {
-			value = await promise;
-		} catch (error) {
-			await onFinally();
-			throw error;
-		}
-
-		await onFinally();
-		return value;
-	};
-	return pFinally;
-}
-
-var kill;
-var hasRequiredKill;
-
-function requireKill () {
-	if (hasRequiredKill) return kill;
-	hasRequiredKill = 1;
-	const os = require$$0$2;
-	const onExit = requireSignalExit();
-	const pFinally = requirePFinally();
-
-	const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
-
-	// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
-	const spawnedKill = (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);
-		setTimeout(() => {
-			kill('SIGKILL');
-		}, timeout).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.isInteger(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 = (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 = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {
-		if (timeout === 0 || timeout === undefined) {
-			return spawnedPromise;
-		}
-
-		if (!Number.isInteger(timeout) || timeout < 0) {
-			throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
-		}
-
-		let timeoutId;
-		const timeoutPromise = new Promise((resolve, reject) => {
-			timeoutId = setTimeout(() => {
-				timeoutKill(spawned, killSignal, reject);
-			}, timeout);
-		});
-
-		const safeSpawnedPromise = pFinally(spawnedPromise, () => {
-			clearTimeout(timeoutId);
-		});
-
-		return Promise.race([timeoutPromise, safeSpawnedPromise]);
-	};
-
-	// `cleanup` option handling
-	const setExitHandler = (spawned, {cleanup, detached}, timedPromise) => {
-		if (!cleanup || detached) {
-			return timedPromise;
-		}
-
-		const removeExitHandler = onExit(() => {
-			spawned.kill();
-		});
-
-		// TODO: Use native "finally" syntax when targeting Node.js 10
-		return pFinally(timedPromise, removeExitHandler);
-	};
-
-	kill = {
-		spawnedKill,
-		spawnedCancel,
-		setupTimeout,
-		setExitHandler
-	};
-	return kill;
-}
-
-var isStream_1;
-var hasRequiredIsStream;
-
-function requireIsStream () {
-	if (hasRequiredIsStream) return isStream_1;
-	hasRequiredIsStream = 1;
-
-	const isStream = stream =>
-		stream !== null &&
-		typeof stream === 'object' &&
-		typeof stream.pipe === 'function';
-
-	isStream.writable = stream =>
-		isStream(stream) &&
-		stream.writable !== false &&
-		typeof stream._write === 'function' &&
-		typeof stream._writableState === 'object';
-
-	isStream.readable = stream =>
-		isStream(stream) &&
-		stream.readable !== false &&
-		typeof stream._read === 'function' &&
-		typeof stream._readableState === 'object';
-
-	isStream.duplex = stream =>
-		isStream.writable(stream) &&
-		isStream.readable(stream);
-
-	isStream.transform = stream =>
-		isStream.duplex(stream) &&
-		typeof stream._transform === 'function';
-
-	isStream_1 = isStream;
-	return isStream_1;
-}
-
-var getStream = {exports: {}};
-
-var once = {exports: {}};
-
-var wrappy_1;
-var hasRequiredWrappy;
-
-function requireWrappy () {
-	if (hasRequiredWrappy) return wrappy_1;
-	hasRequiredWrappy = 1;
-	// Returns a wrapper function that returns a wrapped callback
-	// The wrapper function should do some stuff, and return a
-	// presumably different callback function.
-	// This makes sure that own properties are retained, so that
-	// decorations and such are not lost along the way.
-	wrappy_1 = wrappy;
-	function wrappy (fn, cb) {
-	  if (fn && cb) return wrappy(fn)(cb)
-
-	  if (typeof fn !== 'function')
-	    throw new TypeError('need wrapper function')
-
-	  Object.keys(fn).forEach(function (k) {
-	    wrapper[k] = fn[k];
-	  });
-
-	  return wrapper
-
-	  function wrapper() {
-	    var args = new Array(arguments.length);
-	    for (var i = 0; i < args.length; i++) {
-	      args[i] = arguments[i];
-	    }
-	    var ret = fn.apply(this, args);
-	    var cb = args[args.length-1];
-	    if (typeof ret === 'function' && ret !== cb) {
-	      Object.keys(cb).forEach(function (k) {
-	        ret[k] = cb[k];
-	      });
-	    }
-	    return ret
-	  }
-	}
-	return wrappy_1;
-}
-
-var hasRequiredOnce;
-
-function requireOnce () {
-	if (hasRequiredOnce) return once.exports;
-	hasRequiredOnce = 1;
-	var wrappy = requireWrappy();
-	once.exports = wrappy(once$1);
-	once.exports.strict = wrappy(onceStrict);
-
-	once$1.proto = once$1(function () {
-	  Object.defineProperty(Function.prototype, 'once', {
-	    value: function () {
-	      return once$1(this)
-	    },
-	    configurable: true
-	  });
-
-	  Object.defineProperty(Function.prototype, 'onceStrict', {
-	    value: function () {
-	      return onceStrict(this)
-	    },
-	    configurable: true
-	  });
-	});
-
-	function once$1 (fn) {
-	  var f = function () {
-	    if (f.called) return f.value
-	    f.called = true;
-	    return f.value = fn.apply(this, arguments)
-	  };
-	  f.called = false;
-	  return f
-	}
-
-	function onceStrict (fn) {
-	  var f = function () {
-	    if (f.called)
-	      throw new Error(f.onceError)
-	    f.called = true;
-	    return f.value = fn.apply(this, arguments)
-	  };
-	  var name = fn.name || 'Function wrapped with `once`';
-	  f.onceError = name + " shouldn't be called more than once";
-	  f.called = false;
-	  return f
-	}
-	return once.exports;
-}
-
-var endOfStream;
-var hasRequiredEndOfStream;
-
-function requireEndOfStream () {
-	if (hasRequiredEndOfStream) return endOfStream;
-	hasRequiredEndOfStream = 1;
-	var once = requireOnce();
-
-	var noop = function() {};
-
-	var qnt = commonjsGlobal.Bare ? queueMicrotask : process.nextTick.bind(process);
-
-	var isRequest = function(stream) {
-		return stream.setHeader && typeof stream.abort === 'function';
-	};
-
-	var isChildProcess = function(stream) {
-		return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
-	};
-
-	var eos = function(stream, opts, callback) {
-		if (typeof opts === 'function') return eos(stream, null, opts);
-		if (!opts) opts = {};
-
-		callback = once(callback || noop);
-
-		var ws = stream._writableState;
-		var rs = stream._readableState;
-		var readable = opts.readable || (opts.readable !== false && stream.readable);
-		var writable = opts.writable || (opts.writable !== false && stream.writable);
-		var cancelled = false;
-
-		var onlegacyfinish = function() {
-			if (!stream.writable) onfinish();
-		};
-
-		var onfinish = function() {
-			writable = false;
-			if (!readable) callback.call(stream);
-		};
-
-		var onend = function() {
-			readable = false;
-			if (!writable) callback.call(stream);
-		};
-
-		var onexit = function(exitCode) {
-			callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
-		};
-
-		var onerror = function(err) {
-			callback.call(stream, err);
-		};
-
-		var onclose = function() {
-			qnt(onclosenexttick);
-		};
-
-		var onclosenexttick = function() {
-			if (cancelled) return;
-			if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error('premature close'));
-			if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error('premature close'));
-		};
-
-		var onrequest = function() {
-			stream.req.on('finish', onfinish);
-		};
-
-		if (isRequest(stream)) {
-			stream.on('complete', onfinish);
-			stream.on('abort', onclose);
-			if (stream.req) onrequest();
-			else stream.on('request', onrequest);
-		} else if (writable && !ws) { // legacy streams
-			stream.on('end', onlegacyfinish);
-			stream.on('close', onlegacyfinish);
-		}
-
-		if (isChildProcess(stream)) stream.on('exit', onexit);
-
-		stream.on('end', onend);
-		stream.on('finish', onfinish);
-		if (opts.error !== false) stream.on('error', onerror);
-		stream.on('close', onclose);
-
-		return function() {
-			cancelled = true;
-			stream.removeListener('complete', onfinish);
-			stream.removeListener('abort', onclose);
-			stream.removeListener('request', onrequest);
-			if (stream.req) stream.req.removeListener('finish', onfinish);
-			stream.removeListener('end', onlegacyfinish);
-			stream.removeListener('close', onlegacyfinish);
-			stream.removeListener('finish', onfinish);
-			stream.removeListener('exit', onexit);
-			stream.removeListener('end', onend);
-			stream.removeListener('error', onerror);
-			stream.removeListener('close', onclose);
-		};
-	};
-
-	endOfStream = eos;
-	return endOfStream;
-}
-
-var pump_1;
-var hasRequiredPump;
-
-function requirePump () {
-	if (hasRequiredPump) return pump_1;
-	hasRequiredPump = 1;
-	var once = requireOnce();
-	var eos = requireEndOfStream();
-	var fs;
-
-	try {
-	  fs = require('fs'); // we only need fs to get the ReadStream and WriteStream prototypes
-	} catch (e) {}
-
-	var noop = function () {};
-	var ancient = typeof process === 'undefined' ? false : /^v?\.0/.test(process.version);
-
-	var isFn = function (fn) {
-	  return typeof fn === 'function'
-	};
-
-	var isFS = function (stream) {
-	  if (!ancient) return false // newer node version do not need to care about fs is a special way
-	  if (!fs) return false // browser
-	  return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)
-	};
-
-	var isRequest = function (stream) {
-	  return stream.setHeader && isFn(stream.abort)
-	};
-
-	var destroyer = function (stream, reading, writing, callback) {
-	  callback = once(callback);
-
-	  var closed = false;
-	  stream.on('close', function () {
-	    closed = true;
-	  });
-
-	  eos(stream, {readable: reading, writable: writing}, function (err) {
-	    if (err) return callback(err)
-	    closed = true;
-	    callback();
-	  });
-
-	  var destroyed = false;
-	  return function (err) {
-	    if (closed) return
-	    if (destroyed) return
-	    destroyed = true;
-
-	    if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks
-	    if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want
-
-	    if (isFn(stream.destroy)) return stream.destroy()
-
-	    callback(err || new Error('stream was destroyed'));
-	  }
-	};
-
-	var call = function (fn) {
-	  fn();
-	};
-
-	var pipe = function (from, to) {
-	  return from.pipe(to)
-	};
-
-	var pump = function () {
-	  var streams = Array.prototype.slice.call(arguments);
-	  var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop;
-
-	  if (Array.isArray(streams[0])) streams = streams[0];
-	  if (streams.length < 2) throw new Error('pump requires two streams per minimum')
-
-	  var error;
-	  var destroys = streams.map(function (stream, i) {
-	    var reading = i < streams.length - 1;
-	    var writing = i > 0;
-	    return destroyer(stream, reading, writing, function (err) {
-	      if (!error) error = err;
-	      if (err) destroys.forEach(call);
-	      if (reading) return
-	      destroys.forEach(call);
-	      callback(error);
-	    })
-	  });
-
-	  return streams.reduce(pipe)
-	};
-
-	pump_1 = pump;
-	return pump_1;
-}
-
-var bufferStream;
-var hasRequiredBufferStream;
-
-function requireBufferStream () {
-	if (hasRequiredBufferStream) return bufferStream;
-	hasRequiredBufferStream = 1;
-	const {PassThrough: PassThroughStream} = require$$0$3;
-
-	bufferStream = options => {
-		options = {...options};
-
-		const {array} = options;
-		let {encoding} = options;
-		const isBuffer = encoding === 'buffer';
-		let objectMode = false;
-
-		if (array) {
-			objectMode = !(encoding || isBuffer);
-		} else {
-			encoding = encoding || 'utf8';
-		}
-
-		if (isBuffer) {
-			encoding = null;
-		}
-
-		const stream = new PassThroughStream({objectMode});
-
-		if (encoding) {
-			stream.setEncoding(encoding);
-		}
-
-		let length = 0;
-		const chunks = [];
-
-		stream.on('data', chunk => {
-			chunks.push(chunk);
-
-			if (objectMode) {
-				length = chunks.length;
-			} else {
-				length += chunk.length;
-			}
-		});
-
-		stream.getBufferedValue = () => {
-			if (array) {
-				return chunks;
-			}
-
-			return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
-		};
-
-		stream.getBufferedLength = () => length;
-
-		return stream;
-	};
-	return bufferStream;
-}
-
-var hasRequiredGetStream;
-
-function requireGetStream () {
-	if (hasRequiredGetStream) return getStream.exports;
-	hasRequiredGetStream = 1;
-	const {constants: BufferConstants} = require$$0$4;
-	const pump = requirePump();
-	const bufferStream = requireBufferStream();
-
-	class MaxBufferError extends Error {
-		constructor() {
-			super('maxBuffer exceeded');
-			this.name = 'MaxBufferError';
-		}
-	}
-
-	async function getStream$1(inputStream, options) {
-		if (!inputStream) {
-			return Promise.reject(new Error('Expected a stream'));
-		}
-
-		options = {
-			maxBuffer: Infinity,
-			...options
-		};
-
-		const {maxBuffer} = options;
-
-		let stream;
-		await new Promise((resolve, reject) => {
-			const rejectPromise = error => {
-				// Don't retrieve an oversized buffer.
-				if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-					error.bufferedData = stream.getBufferedValue();
-				}
-
-				reject(error);
-			};
-
-			stream = pump(inputStream, bufferStream(options), error => {
-				if (error) {
-					rejectPromise(error);
-					return;
-				}
-
-				resolve();
-			});
-
-			stream.on('data', () => {
-				if (stream.getBufferedLength() > maxBuffer) {
-					rejectPromise(new MaxBufferError());
-				}
-			});
-		});
-
-		return stream.getBufferedValue();
-	}
-
-	getStream.exports = getStream$1;
-	// TODO: Remove this for the next major release
-	getStream.exports.default = getStream$1;
-	getStream.exports.buffer = (stream, options) => getStream$1(stream, {...options, encoding: 'buffer'});
-	getStream.exports.array = (stream, options) => getStream$1(stream, {...options, array: true});
-	getStream.exports.MaxBufferError = MaxBufferError;
-	return getStream.exports;
-}
-
-var mergeStream;
-var hasRequiredMergeStream;
-
-function requireMergeStream () {
-	if (hasRequiredMergeStream) return mergeStream;
-	hasRequiredMergeStream = 1;
-
-	const { PassThrough } = require$$0$3;
-
-	mergeStream = function (/*streams...*/) {
-	  var sources = [];
-	  var output  = new PassThrough({objectMode: true});
-
-	  output.setMaxListeners(0);
-
-	  output.add = add;
-	  output.isEmpty = isEmpty;
-
-	  output.on('unpipe', remove);
-
-	  Array.prototype.slice.call(arguments).forEach(add);
-
-	  return output
-
-	  function add (source) {
-	    if (Array.isArray(source)) {
-	      source.forEach(add);
-	      return this
-	    }
-
-	    sources.push(source);
-	    source.once('end', remove.bind(null, source));
-	    source.once('error', output.emit.bind(output, 'error'));
-	    source.pipe(output, {end: false});
-	    return this
-	  }
-
-	  function isEmpty () {
-	    return sources.length == 0;
-	  }
-
-	  function remove (source) {
-	    sources = sources.filter(function (it) { return it !== source });
-	    if (!sources.length && output.readable) { output.end(); }
-	  }
-	};
-	return mergeStream;
-}
-
-var stream;
-var hasRequiredStream;
-
-function requireStream () {
-	if (hasRequiredStream) return stream;
-	hasRequiredStream = 1;
-	const isStream = requireIsStream();
-	const getStream = requireGetStream();
-	const mergeStream = requireMergeStream();
-
-	// `input` option
-	const handleInput = (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 = spawned => {
-		if (!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) {
-			return;
-		}
-
-		if (!buffer) {
-			// TODO: Use `ret = util.promisify(stream.finished)(stream);` when targeting Node.js 10
-			return new Promise((resolve, reject) => {
-				stream
-					.once('end', resolve)
-					.once('error', reject);
-			});
-		}
-
-		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 = 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, code: error.code, signal: error.signal, timedOut: error.timedOut},
-				getBufferedData(stdout, stdoutPromise),
-				getBufferedData(stderr, stderrPromise),
-				getBufferedData(all, allPromise)
-			]);
-		}
-	};
-
-	const validateInputSync = ({input}) => {
-		if (isStream(input)) {
-			throw new TypeError('The `input` option cannot be a stream in sync mode');
-		}
-	};
-
-	stream = {
-		handleInput,
-		makeAllStream,
-		getSpawnedResult,
-		validateInputSync
-	};
-	return stream;
-}
-
-var promise;
-var hasRequiredPromise;
-
-function requirePromise () {
-	if (hasRequiredPromise) return promise;
-	hasRequiredPromise = 1;
-	const mergePromiseProperty = (spawned, promise, property) => {
-		// Starting the main `promise` is deferred to avoid consuming streams
-		const value = typeof promise === 'function' ?
-			(...args) => promise()[property](...args) :
-			promise[property].bind(promise);
-
-		Object.defineProperty(spawned, property, {
-			value,
-			writable: true,
-			enumerable: false,
-			configurable: true
-		});
-	};
-
-	// The return value is a mixin of `childProcess` and `Promise`
-	const mergePromise = (spawned, promise) => {
-		mergePromiseProperty(spawned, promise, 'then');
-		mergePromiseProperty(spawned, promise, 'catch');
-
-		// TODO: Remove the `if`-guard when targeting Node.js 10
-		if (Promise.prototype.finally) {
-			mergePromiseProperty(spawned, promise, 'finally');
-		}
-
-		return spawned;
-	};
-
-	// Use promises instead of `child_process` events
-	const getSpawnedPromise = spawned => {
-		return new Promise((resolve, reject) => {
-			spawned.on('exit', (code, signal) => {
-				resolve({code, signal});
-			});
-
-			spawned.on('error', error => {
-				reject(error);
-			});
-
-			if (spawned.stdin) {
-				spawned.stdin.on('error', error => {
-					reject(error);
-				});
-			}
-		});
-	};
-
-	promise = {
-		mergePromise,
-		getSpawnedPromise
-	};
-	return promise;
-}
-
-var command;
-var hasRequiredCommand;
-
-function requireCommand () {
-	if (hasRequiredCommand) return command;
-	hasRequiredCommand = 1;
-	const SPACES_REGEXP = / +/g;
-
-	const joinCommand = (file, args = []) => {
-		if (!Array.isArray(args)) {
-			return file;
-		}
-
-		return [file, ...args].join(' ');
-	};
-
-	// Allow spaces to be escaped by a backslash if not meant as a delimiter
-	const handleEscaping = (tokens, token, index) => {
-		if (index === 0) {
-			return [token];
-		}
-
-		const previousToken = tokens[tokens.length - 1];
-
-		if (previousToken.endsWith('\\')) {
-			return [...tokens.slice(0, -1), `${previousToken.slice(0, -1)} ${token}`];
-		}
-
-		return [...tokens, token];
-	};
-
-	// Handle `execa.command()`
-	const parseCommand = command => {
-		return command
-			.trim()
-			.split(SPACES_REGEXP)
-			.reduce(handleEscaping, []);
-	};
-
-	command = {
-		joinCommand,
-		parseCommand
-	};
-	return command;
-}
-
-var hasRequiredExeca;
-
-function requireExeca () {
-	if (hasRequiredExeca) return execa.exports;
-	hasRequiredExeca = 1;
-	const path = sysPath;
-	const childProcess = require$$0$1;
-	const crossSpawn = requireCrossSpawn();
-	const stripFinalNewline = requireStripFinalNewline();
-	const npmRunPath = requireNpmRunPath();
-	const onetime = requireOnetime();
-	const makeError = requireError();
-	const normalizeStdio = requireStdio();
-	const {spawnedKill, spawnedCancel, setupTimeout, setExitHandler} = requireKill();
-	const {handleInput, getSpawnedResult, makeAllStream, validateInputSync} = requireStream();
-	const {mergePromise, getSpawnedPromise} = requirePromise();
-	const {joinCommand, parseCommand} = requireCommand();
-
-	const DEFAULT_MAX_BUFFER = 1000 * 1000 * 100;
-
-	const getEnv = ({env: envOption, extendEnv, preferLocal, localDir}) => {
-		const env = extendEnv ? {...process.env, ...envOption} : envOption;
-
-		if (preferLocal) {
-			return npmRunPath.env({env, cwd: localDir});
-		}
-
-		return env;
-	};
-
-	const handleArgs = (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(),
-			encoding: 'utf8',
-			reject: true,
-			cleanup: true,
-			...options,
-			windowsHide: true
-		};
-
-		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$1 = (file, args, options) => {
-		const parsed = handleArgs(file, args, options);
-		const command = joinCommand(file, args);
-
-		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,
-				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, code, 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 || code !== 0 || signal !== null) {
-				const returnedError = makeError({
-					error,
-					code,
-					signal,
-					stdout,
-					stderr,
-					all,
-					command,
-					parsed,
-					timedOut,
-					isCanceled: context.isCanceled,
-					killed: spawned.killed
-				});
-
-				if (!parsed.options.reject) {
-					return returnedError;
-				}
-
-				throw returnedError;
-			}
-
-			return {
-				command,
-				exitCode: 0,
-				exitCodeName: 'SUCCESS',
-				stdout,
-				stderr,
-				all,
-				failed: false,
-				timedOut: false,
-				isCanceled: false,
-				killed: false
-			};
-		};
-
-		const handlePromiseOnce = onetime(handlePromise);
-
-		crossSpawn._enoent.hookChildProcess(spawned, parsed.parsed);
-
-		handleInput(spawned, parsed.options.input);
-
-		spawned.all = makeAllStream(spawned);
-
-		return mergePromise(spawned, handlePromiseOnce);
-	};
-
-	execa.exports = execa$1;
-
-	execa.exports.sync = (file, args, options) => {
-		const parsed = handleArgs(file, args, options);
-		const command = joinCommand(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,
-				parsed,
-				timedOut: false,
-				isCanceled: false,
-				killed: false
-			});
-		}
-
-		result.stdout = handleOutput(parsed.options, result.stdout, result.error);
-		result.stderr = handleOutput(parsed.options, result.stderr, result.error);
-
-		if (result.error || result.status !== 0 || result.signal !== null) {
-			const error = makeError({
-				...result,
-				code: result.status,
-				command,
-				parsed,
-				timedOut: result.error && result.error.code === 'ETIMEDOUT',
-				isCanceled: false,
-				killed: result.signal !== null
-			});
-
-			if (!parsed.options.reject) {
-				return error;
-			}
-
-			throw error;
-		}
-
-		return {
-			command,
-			exitCode: 0,
-			exitCodeName: 'SUCCESS',
-			stdout: result.stdout,
-			stderr: result.stderr,
-			failed: false,
-			timedOut: false,
-			isCanceled: false,
-			killed: false
-		};
-	};
-
-	execa.exports.command = (command, options) => {
-		const [file, ...args] = parseCommand(command);
-		return execa$1(file, args, options);
-	};
-
-	execa.exports.commandSync = (command, options) => {
-		const [file, ...args] = parseCommand(command);
-		return execa$1.sync(file, args, options);
-	};
-
-	execa.exports.node = (scriptPath, args, options = {}) => {
-		if (args && !Array.isArray(args) && typeof args === 'object') {
-			options = args;
-			args = [];
-		}
-
-		const stdio = normalizeStdio.node(options);
-
-		const {nodePath = process.execPath, nodeOptions = process.execArgv} = options;
-
-		return execa$1(
-			nodePath,
-			[
-				...nodeOptions,
-				scriptPath,
-				...(Array.isArray(args) ? args : [])
-			],
-			{
-				...options,
-				stdin: undefined,
-				stdout: undefined,
-				stderr: undefined,
-				stdio,
-				shell: false
-			}
-		);
-	};
-	return execa.exports;
-}
-
-var hasRequiredDf$1;
-
-function requireDf$1 () {
-	if (hasRequiredDf$1) return df$1.exports;
-	hasRequiredDf$1 = 1;
-	const execa = requireExeca();
-
-	const getColumnBoundaries = async header => {
-		// Regex captures each individual column
-		// ^\S+\s+       -> First column
-		// \s*\S+\s*\S+$ -> Last column (combined)
-		// \s*\S+        -> Regular columns
-		const regex = /^\S+\s+|\s*\S+\s*\S+$|\s*\S+/g;
-		const boundaries = [];
-		let match;
-
-		while ((match = regex.exec(header))) {
-			boundaries.push(match[0].length);
-		}
-
-		// Extend last column boundary
-		boundaries[boundaries.length - 1] = -1;
-
-		return boundaries;
-	};
-
-	const parseOutput = async output => {
-		const lines = output.trim().split('\n');
-		const boundaries = await getColumnBoundaries(lines[0]);
-
-		return lines.slice(1).map(line => {
-			const cl = boundaries.map(boundary => {
-				// Handle extra-long last column
-				const column = boundary > 0 ? line.slice(0, boundary) : line;
-				line = line.slice(boundary);
-				return column.trim();
-			});
-
-			return {
-				filesystem: cl[0],
-				size: parseInt(cl[1], 10) * 1024,
-				used: parseInt(cl[2], 10) * 1024,
-				available: parseInt(cl[3], 10) * 1024,
-				capacity: parseInt(cl[4], 10) / 100,
-				mountpoint: cl[5]
-			};
-		});
-	};
-
-	const run = async args => {
-		const {stdout} = await execa('df', args);
-		return parseOutput(stdout);
-	};
-
-	const df = async () => run(['-kP']);
-
-	df.fs = async name => {
-		if (typeof name !== 'string') {
-			throw new TypeError('The `name` parameter required');
-		}
-
-		const data = await run(['-kP']);
-
-		for (const item of data) {
-			if (item.filesystem === name) {
-				return item;
-			}
-		}
-
-		throw new Error(`The specified filesystem \`${name}\` doesn't exist`);
-	};
-
-	df.file = async file => {
-		if (typeof file !== 'string') {
-			throw new TypeError('The `file` parameter is required');
-		}
-
-		let data;
-		try {
-			data = await run(['-kP', file]);
-		} catch (error) {
-			if (/No such file or directory/.test(error.stderr)) {
-				throw new Error(`The specified file \`${file}\` doesn't exist`);
-			}
-
-			throw error;
-		}
-
-		return data[0];
-	};
-
-	df$1.exports = df;
-	// TODO: remove this in the next major version
-	df$1.exports.default = df;
-
-	if (process.env.NODE_ENV === 'test') {
-		df$1.exports._parseOutput = parseOutput;
-	}
-	return df$1.exports;
-}
-
-var df = {exports: {}};
-
-var hasRequiredDf;
-
-function requireDf () {
-	if (hasRequiredDf) return df.exports;
-	hasRequiredDf = 1;
-	var childProcess = require$$0$1;
-
-	function run(args, cb) {
-		childProcess.execFile('df', args, function (err, stdout) {
-			if (err) {
-				cb(err);
-				return;
-			}
-
-			cb(null, stdout.trim().split('\n').slice(1).map(function (el) {
-				var cl = el.split(/\s+(?=[\d\/])/);
-
-				return {
-					filesystem: cl[0],
-					size: parseInt(cl[1], 10) * 1024,
-					used: parseInt(cl[2], 10) * 1024,
-					available: parseInt(cl[3], 10) * 1024,
-					capacity: parseInt(cl[4], 10) / 100,
-					mountpoint: cl[5]
-				};
-			}));
-		});
-	}
-	var df$1 = df.exports = function (cb) {
-		run(['-kP'], cb);
-	};
-
-	df$1.fs = function (name, cb) {
-		if (typeof name !== 'string') {
-			throw new Error('name required');
-		}
-
-		run(['-kP'], function (err, data) {
-			if (err) {
-				cb(err);
-				return;
-			}
-
-			var ret;
-
-			data.forEach(function (el) {
-				if (el.filesystem === name) {
-					ret = el;
-				}
-			});
-
-			cb(null, ret);
-		});
-	};
-
-	df$1.file = function (file, cb) {
-		if (typeof file !== 'string') {
-			throw new Error('file required');
-		}
-
-		run(['-kP', file], function (err, data) {
-			if (err) {
-				cb(err);
-				return;
-			}
-
-			cb(null, data[0]);
-		});
-	};
-	return df.exports;
-}
-
-var pify = {exports: {}};
-
-var hasRequiredPify;
-
-function requirePify () {
-	if (hasRequiredPify) return pify.exports;
-	hasRequiredPify = 1;
-
-	var processFn = function (fn, P, opts) {
-		return function () {
-			var that = this;
-			var args = new Array(arguments.length);
-
-			for (var i = 0; i < arguments.length; i++) {
-				args[i] = arguments[i];
-			}
-
-			return new P(function (resolve, reject) {
-				args.push(function (err, result) {
-					if (err) {
-						reject(err);
-					} else if (opts.multiArgs) {
-						var results = new Array(arguments.length - 1);
-
-						for (var i = 1; i < arguments.length; i++) {
-							results[i - 1] = arguments[i];
-						}
-
-						resolve(results);
-					} else {
-						resolve(result);
-					}
-				});
-
-				fn.apply(that, args);
-			});
-		};
-	};
-
-	var pify$1 = pify.exports = function (obj, P, opts) {
-		if (typeof P !== 'function') {
-			opts = P;
-			P = Promise;
-		}
-
-		opts = opts || {};
-		opts.exclude = opts.exclude || [/.+Sync$/];
-
-		var filter = function (key) {
-			var match = function (pattern) {
-				return typeof pattern === 'string' ? key === pattern : pattern.test(key);
-			};
-
-			return opts.include ? opts.include.some(match) : !opts.exclude.some(match);
-		};
-
-		var ret = typeof obj === 'function' ? function () {
-			if (opts.excludeMain) {
-				return obj.apply(this, arguments);
-			}
-
-			return processFn(obj, P, opts).apply(this, arguments);
-		} : {};
-
-		return Object.keys(obj).reduce(function (ret, key) {
-			var x = obj[key];
-
-			ret[key] = typeof x === 'function' && filter(key) ? processFn(x, P, opts) : x;
-
-			return ret;
-		}, ret);
-	};
-
-	pify$1.all = pify$1;
-	return pify.exports;
-}
-
-var pinkie;
-var hasRequiredPinkie;
-
-function requirePinkie () {
-	if (hasRequiredPinkie) return pinkie;
-	hasRequiredPinkie = 1;
-
-	var PENDING = 'pending';
-	var SETTLED = 'settled';
-	var FULFILLED = 'fulfilled';
-	var REJECTED = 'rejected';
-	var NOOP = function () {};
-	var isNode = typeof commonjsGlobal !== 'undefined' && typeof commonjsGlobal.process !== 'undefined' && typeof commonjsGlobal.process.emit === 'function';
-
-	var asyncSetTimer = typeof setImmediate === 'undefined' ? setTimeout : setImmediate;
-	var asyncQueue = [];
-	var asyncTimer;
-
-	function asyncFlush() {
-		// run promise callbacks
-		for (var i = 0; i < asyncQueue.length; i++) {
-			asyncQueue[i][0](asyncQueue[i][1]);
-		}
-
-		// reset async asyncQueue
-		asyncQueue = [];
-		asyncTimer = false;
-	}
-
-	function asyncCall(callback, arg) {
-		asyncQueue.push([callback, arg]);
-
-		if (!asyncTimer) {
-			asyncTimer = true;
-			asyncSetTimer(asyncFlush, 0);
-		}
-	}
-
-	function invokeResolver(resolver, promise) {
-		function resolvePromise(value) {
-			resolve(promise, value);
-		}
-
-		function rejectPromise(reason) {
-			reject(promise, reason);
-		}
-
-		try {
-			resolver(resolvePromise, rejectPromise);
-		} catch (e) {
-			rejectPromise(e);
-		}
-	}
-
-	function invokeCallback(subscriber) {
-		var owner = subscriber.owner;
-		var settled = owner._state;
-		var value = owner._data;
-		var callback = subscriber[settled];
-		var promise = subscriber.then;
-
-		if (typeof callback === 'function') {
-			settled = FULFILLED;
-			try {
-				value = callback(value);
-			} catch (e) {
-				reject(promise, e);
-			}
-		}
-
-		if (!handleThenable(promise, value)) {
-			if (settled === FULFILLED) {
-				resolve(promise, value);
-			}
-
-			if (settled === REJECTED) {
-				reject(promise, value);
-			}
-		}
-	}
-
-	function handleThenable(promise, value) {
-		var resolved;
-
-		try {
-			if (promise === value) {
-				throw new TypeError('A promises callback cannot return that same promise.');
-			}
-
-			if (value && (typeof value === 'function' || typeof value === 'object')) {
-				// then should be retrieved only once
-				var then = value.then;
-
-				if (typeof then === 'function') {
-					then.call(value, function (val) {
-						if (!resolved) {
-							resolved = true;
-
-							if (value === val) {
-								fulfill(promise, val);
-							} else {
-								resolve(promise, val);
-							}
-						}
-					}, function (reason) {
-						if (!resolved) {
-							resolved = true;
-
-							reject(promise, reason);
-						}
-					});
-
-					return true;
-				}
-			}
-		} catch (e) {
-			if (!resolved) {
-				reject(promise, e);
-			}
-
-			return true;
-		}
-
-		return false;
-	}
-
-	function resolve(promise, value) {
-		if (promise === value || !handleThenable(promise, value)) {
-			fulfill(promise, value);
-		}
-	}
-
-	function fulfill(promise, value) {
-		if (promise._state === PENDING) {
-			promise._state = SETTLED;
-			promise._data = value;
-
-			asyncCall(publishFulfillment, promise);
-		}
-	}
-
-	function reject(promise, reason) {
-		if (promise._state === PENDING) {
-			promise._state = SETTLED;
-			promise._data = reason;
-
-			asyncCall(publishRejection, promise);
-		}
-	}
-
-	function publish(promise) {
-		promise._then = promise._then.forEach(invokeCallback);
-	}
-
-	function publishFulfillment(promise) {
-		promise._state = FULFILLED;
-		publish(promise);
-	}
-
-	function publishRejection(promise) {
-		promise._state = REJECTED;
-		publish(promise);
-		if (!promise._handled && isNode) {
-			commonjsGlobal.process.emit('unhandledRejection', promise._data, promise);
-		}
-	}
-
-	function notifyRejectionHandled(promise) {
-		commonjsGlobal.process.emit('rejectionHandled', promise);
-	}
-
-	/**
-	 * @class
-	 */
-	function Promise(resolver) {
-		if (typeof resolver !== 'function') {
-			throw new TypeError('Promise resolver ' + resolver + ' is not a function');
-		}
-
-		if (this instanceof Promise === false) {
-			throw new TypeError('Failed to construct \'Promise\': Please use the \'new\' operator, this object constructor cannot be called as a function.');
-		}
-
-		this._then = [];
-
-		invokeResolver(resolver, this);
-	}
-
-	Promise.prototype = {
-		constructor: Promise,
-
-		_state: PENDING,
-		_then: null,
-		_data: undefined,
-		_handled: false,
-
-		then: function (onFulfillment, onRejection) {
-			var subscriber = {
-				owner: this,
-				then: new this.constructor(NOOP),
-				fulfilled: onFulfillment,
-				rejected: onRejection
-			};
-
-			if ((onRejection || onFulfillment) && !this._handled) {
-				this._handled = true;
-				if (this._state === REJECTED && isNode) {
-					asyncCall(notifyRejectionHandled, this);
-				}
-			}
-
-			if (this._state === FULFILLED || this._state === REJECTED) {
-				// already resolved, call callback async
-				asyncCall(invokeCallback, subscriber);
-			} else {
-				// subscribe
-				this._then.push(subscriber);
-			}
-
-			return subscriber.then;
-		},
-
-		catch: function (onRejection) {
-			return this.then(null, onRejection);
-		}
-	};
-
-	Promise.all = function (promises) {
-		if (!Array.isArray(promises)) {
-			throw new TypeError('You must pass an array to Promise.all().');
-		}
-
-		return new Promise(function (resolve, reject) {
-			var results = [];
-			var remaining = 0;
-
-			function resolver(index) {
-				remaining++;
-				return function (value) {
-					results[index] = value;
-					if (!--remaining) {
-						resolve(results);
-					}
-				};
-			}
-
-			for (var i = 0, promise; i < promises.length; i++) {
-				promise = promises[i];
-
-				if (promise && typeof promise.then === 'function') {
-					promise.then(resolver(i), reject);
-				} else {
-					results[i] = promise;
-				}
-			}
-
-			if (!remaining) {
-				resolve(results);
-			}
-		});
-	};
-
-	Promise.race = function (promises) {
-		if (!Array.isArray(promises)) {
-			throw new TypeError('You must pass an array to Promise.race().');
-		}
-
-		return new Promise(function (resolve, reject) {
-			for (var i = 0, promise; i < promises.length; i++) {
-				promise = promises[i];
-
-				if (promise && typeof promise.then === 'function') {
-					promise.then(resolve, reject);
-				} else {
-					resolve(promise);
-				}
-			}
-		});
-	};
-
-	Promise.resolve = function (value) {
-		if (value && typeof value === 'object' && value.constructor === Promise) {
-			return value;
-		}
-
-		return new Promise(function (resolve) {
-			resolve(value);
-		});
-	};
-
-	Promise.reject = function (reason) {
-		return new Promise(function (resolve, reject) {
-			reject(reason);
-		});
-	};
-
-	pinkie = Promise;
-	return pinkie;
-}
-
-var pinkiePromise;
-var hasRequiredPinkiePromise;
-
-function requirePinkiePromise () {
-	if (hasRequiredPinkiePromise) return pinkiePromise;
-	hasRequiredPinkiePromise = 1;
-
-	pinkiePromise = typeof Promise === 'function' ? Promise : requirePinkie();
-	return pinkiePromise;
-}
-
-var mountPoint;
-var hasRequiredMountPoint;
-
-function requireMountPoint () {
-	if (hasRequiredMountPoint) return mountPoint;
-	hasRequiredMountPoint = 1;
-	var df = requireDf();
-	var pify = requirePify();
-	var Promise = requirePinkiePromise();
-
-	mountPoint = function (file) {
-		return pify(df.file, Promise)(file).then(function (data) {
-			return data.mountpoint;
-		});
-	};
-	return mountPoint;
-}
-
-var osHomedir;
-var hasRequiredOsHomedir;
-
-function requireOsHomedir () {
-	if (hasRequiredOsHomedir) return osHomedir;
-	hasRequiredOsHomedir = 1;
-	var os = require$$0$2;
-
-	function homedir() {
-		var env = process.env;
-		var home = env.HOME;
-		var user = env.LOGNAME || env.USER || env.LNAME || env.USERNAME;
-
-		if (process.platform === 'win32') {
-			return env.USERPROFILE || env.HOMEDRIVE + env.HOMEPATH || home || null;
-		}
-
-		if (process.platform === 'darwin') {
-			return home || (user ? '/Users/' + user : null);
-		}
-
-		if (process.platform === 'linux') {
-			return home || (process.getuid() === 0 ? '/root' : (user ? '/home/' + user : null));
-		}
-
-		return home || null;
-	}
-
-	osHomedir = typeof os.homedir === 'function' ? os.homedir : homedir;
-	return osHomedir;
-}
-
-var userHome;
-var hasRequiredUserHome;
-
-function requireUserHome () {
-	if (hasRequiredUserHome) return userHome;
-	hasRequiredUserHome = 1;
-	userHome = requireOsHomedir()();
-	return userHome;
-}
-
-var xdgBasedir = {};
-
-var hasRequiredXdgBasedir;
-
-function requireXdgBasedir () {
-	if (hasRequiredXdgBasedir) return xdgBasedir;
-	hasRequiredXdgBasedir = 1;
-	(function (exports) {
-		const os = require$$0$2;
-		const path = sysPath;
-
-		const homeDirectory = os.homedir();
-		const {env} = process;
-
-		exports.data = env.XDG_DATA_HOME ||
-			(homeDirectory ? path.join(homeDirectory, '.local', 'share') : undefined);
-
-		exports.config = env.XDG_CONFIG_HOME ||
-			(homeDirectory ? path.join(homeDirectory, '.config') : undefined);
-
-		exports.cache = env.XDG_CACHE_HOME || (homeDirectory ? path.join(homeDirectory, '.cache') : undefined);
-
-		exports.runtime = env.XDG_RUNTIME_DIR || undefined;
-
-		exports.dataDirs = (env.XDG_DATA_DIRS || '/usr/local/share/:/usr/share/').split(':');
-
-		if (exports.data) {
-			exports.dataDirs.unshift(exports.data);
-		}
-
-		exports.configDirs = (env.XDG_CONFIG_DIRS || '/etc/xdg').split(':');
-
-		if (exports.config) {
-			exports.configDirs.unshift(exports.config);
-		} 
-	} (xdgBasedir));
-	return xdgBasedir;
-}
-
-var hasRequiredXdgTrashdir;
-
-function requireXdgTrashdir () {
-	if (hasRequiredXdgTrashdir) return xdgTrashdir$1.exports;
-	hasRequiredXdgTrashdir = 1;
-	const fs = require$$0.promises;
-	const path = sysPath;
-	const df = requireDf$1();
-	const mountPoint = requireMountPoint();
-	const userHome = requireUserHome();
-	const xdgBasedir = requireXdgBasedir();
-
-	const check = async filePath => {
-		const topuid = `${filePath}-${process.getuid()}`;
-		const stickyBitMode = 17407;
-
-		try {
-			const stats = await fs.lstat(filePath);
-
-			if (stats.isSymbolicLink() || stats.mode !== stickyBitMode) {
-				return topuid;
-			}
-
-			return path.join(filePath, String(process.getuid()));
-		} catch (error) {
-			if (error.code === 'ENOENT') {
-				return topuid;
-			}
-
-			return path.join(xdgBasedir.data, 'Trash');
-		}
-	};
-
-	xdgTrashdir$1.exports = async filePath => {
-		if (process.platform !== 'linux') {
-			return Promise.reject(new Error('Only Linux systems are supported'));
-		}
-
-		if (!filePath) {
-			return Promise.resolve(path.join(xdgBasedir.data, 'Trash'));
-		}
-
-		const [homeMountPoint, fileMountPoint] = await Promise.all([
-			mountPoint(userHome),
-			// Ignore errors in case `file` is a dangling symlink
-			mountPoint(filePath).catch(() => {})
-		]);
-
-		if (!fileMountPoint || fileMountPoint === homeMountPoint) {
-			return path.join(xdgBasedir.data, 'Trash');
-		}
-
-		return check(path.join(fileMountPoint, '.Trash'));
-	};
-
-	xdgTrashdir$1.exports.all = async () => {
-		if (process.platform !== 'linux') {
-			return Promise.reject(new Error('Only Linux systems are supported'));
-		}
-
-		return Promise.all((await df()).map(fileSystem => {
-			if (fileSystem.mountpoint === '/') {
-				return path.join(xdgBasedir.data, 'Trash');
-			}
-
-			return check(path.join(fileSystem.mountpoint, '.Trash'));
-		}));
-	};
-	return xdgTrashdir$1.exports;
-}
-
-var xdgTrashdirExports = requireXdgTrashdir();
-const xdgTrashdir = /*@__PURE__*/getDefaultExportFromCjs(xdgTrashdirExports);
-
-async function pMap(
-	iterable,
-	mapper,
-	{
-		concurrency = Number.POSITIVE_INFINITY,
-		stopOnError = true,
-		signal,
-	} = {},
-) {
-	return new Promise((resolve_, reject_) => {
-		if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
-			throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
-		}
-
-		if (typeof mapper !== 'function') {
-			throw new TypeError('Mapper function is required');
-		}
-
-		if (!((Number.isSafeInteger(concurrency) && concurrency >= 1) || concurrency === Number.POSITIVE_INFINITY)) {
-			throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
-		}
-
-		const result = [];
-		const errors = [];
-		const skippedIndexesMap = new Map();
-		let isRejected = false;
-		let isResolved = false;
-		let isIterableDone = false;
-		let resolvingCount = 0;
-		let currentIndex = 0;
-		const iterator = iterable[Symbol.iterator] === undefined ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
-
-		const signalListener = () => {
-			reject(signal.reason);
-		};
-
-		const cleanup = () => {
-			signal?.removeEventListener('abort', signalListener);
-		};
-
-		const resolve = value => {
-			resolve_(value);
-			cleanup();
-		};
-
-		const reject = reason => {
-			isRejected = true;
-			isResolved = true;
-			reject_(reason);
-			cleanup();
-		};
-
-		if (signal) {
-			if (signal.aborted) {
-				reject(signal.reason);
-			}
-
-			signal.addEventListener('abort', signalListener, {once: true});
-		}
-
-		const next = async () => {
-			if (isResolved) {
-				return;
-			}
-
-			const nextItem = await iterator.next();
-
-			const index = currentIndex;
-			currentIndex++;
-
-			// Note: `iterator.next()` can be called many times in parallel.
-			// This can cause multiple calls to this `next()` function to
-			// receive a `nextItem` with `done === true`.
-			// The shutdown logic that rejects/resolves must be protected
-			// so it runs only one time as the `skippedIndex` logic is
-			// non-idempotent.
-			if (nextItem.done) {
-				isIterableDone = true;
-
-				if (resolvingCount === 0 && !isResolved) {
-					if (!stopOnError && errors.length > 0) {
-						reject(new AggregateError(errors)); // eslint-disable-line unicorn/error-message
-						return;
-					}
-
-					isResolved = true;
-
-					if (skippedIndexesMap.size === 0) {
-						resolve(result);
-						return;
-					}
-
-					const pureResult = [];
-
-					// Support multiple `pMapSkip`'s.
-					for (const [index, value] of result.entries()) {
-						if (skippedIndexesMap.get(index) === pMapSkip) {
-							continue;
-						}
-
-						pureResult.push(value);
-					}
-
-					resolve(pureResult);
-				}
-
-				return;
-			}
-
-			resolvingCount++;
-
-			// Intentionally detached
-			(async () => {
-				try {
-					const element = await nextItem.value;
-
-					if (isResolved) {
-						return;
-					}
-
-					const value = await mapper(element, index);
-
-					// Use Map to stage the index of the element.
-					if (value === pMapSkip) {
-						skippedIndexesMap.set(index, value);
-					}
-
-					result[index] = value;
-
-					resolvingCount--;
-					await next();
-				} catch (error) {
-					if (stopOnError) {
-						reject(error);
-					} else {
-						errors.push(error);
-						resolvingCount--;
-
-						// In that case we can't really continue regardless of `stopOnError` state
-						// since an iterable is likely to continue throwing after it throws once.
-						// If we continue calling `next()` indefinitely we will likely end up
-						// in an infinite loop of failed iteration.
-						try {
-							await next();
-						} catch (error) {
-							reject(error);
-						}
-					}
-				}
-			})();
-		};
-
-		// Create the concurrent runners in a detached (non-awaited)
-		// promise. We need this so we can await the `next()` calls
-		// to stop creating runners before hitting the concurrency limit
-		// if the iterable has already been marked as done.
-		// NOTE: We *must* do this for async iterators otherwise we'll spin up
-		// infinite `next()` calls by default and never start the event loop.
-		(async () => {
-			for (let index = 0; index < concurrency; index++) {
-				try {
-					// eslint-disable-next-line no-await-in-loop
-					await next();
-				} catch (error) {
-					reject(error);
-					break;
-				}
-
-				if (isIterableDone || isRejected) {
-					break;
-				}
-			}
-		})();
-	});
-}
-
-const pMapSkip = Symbol('skip');
-
-var procfsError;
-var hasRequiredProcfsError;
-
-function requireProcfsError () {
-	if (hasRequiredProcfsError) return procfsError;
-	hasRequiredProcfsError = 1;
-	class ProcfsError extends Error {
-		constructor(code, message, sourceError) {
-			super(message);
-			this.name = 'ProcfsError';
-			this.code = code;
-			if (sourceError !== undefined) {
-				this.sourceError = sourceError;
-			}
-		}
-	}
-
-	ProcfsError.ERR_PARSING_FAILED = 'EPARSE';
-	ProcfsError.ERR_UNKNOWN = 'EUNKNOWN';
-	ProcfsError.ERR_NOT_FOUND = 'ENOENT';
-
-	ProcfsError.parsingError = (src, msg) => {
-		let e = new ProcfsError(ProcfsError.ERR_PARSING_FAILED, `Parsing failed: ${msg}`);
-		e.sourceText = src;
-		return e;
-	};
-
-	ProcfsError.generic = err => {
-		/* istanbul ignore next should not ever happen */
-		if (err instanceof ProcfsError) {
-			return err;
-		}
-
-		switch (err.code) {
-			case 'ENOENT':
-				return new ProcfsError(ProcfsError.ERR_NOT_FOUND, 'File not found', err);
-			/* istanbul ignore next should not ever happen*/
-			default:
-				return new ProcfsError(ProcfsError.ERR_UNKNOWN, `Unknown error: ${err.message}`, err);
-		}
-	};
-
-	procfsError = ProcfsError;
-	return procfsError;
-}
-
-var parsers_1;
-var hasRequiredParsers;
-
-function requireParsers () {
-	if (hasRequiredParsers) return parsers_1;
-	hasRequiredParsers = 1;
-	const trim = str => str.trim();
-
-	class Parsers {}
-
-	const parsers = new Parsers();
-
-	for (let name of [
-		'cgroups',
-		'config',
-		'cpuinfo',
-		'devices',
-		'diskstats',
-		'filesystems',
-		'loadavg',
-		'meminfo',
-		'partitions',
-		'processAutogroup',
-		'processCgroups',
-		'processCmdline',
-		'processEnviron',
-		'processes',
-		'processExe',
-		'processFd',
-		'processFdinfo',
-		'processFds',
-		'processGidMap',
-		'processIo',
-		'processLimits',
-		'processMountinfo',
-		'processNetDev',
-		'processNetTcp4',
-		'processNetTcp6',
-		'processNetUdp4',
-		'processNetUdp6',
-		'processNetUnix',
-		'processNetWireless',
-		'processStat',
-		'processStatm',
-		'processStatus',
-		'processThreads',
-		'processUidMap',
-		'stat',
-		'swaps',
-		'uptime',
-	]) {
-		Object.defineProperty(Parsers.prototype, name, {
-			get: function () { // eslint-disable-line object-shorthand
-				let value = commonjsRequire(`./parsers/${name}`);
-				Object.defineProperty(this, name, {value});
-				return value;
-			},
-		});
-	}
-
-	parsers.cmdline = trim;
-	parsers.processComm = trim;
-	parsers.processCpuset = trim;
-	parsers.processOomScore = src => parseInt(src);
-	parsers.processTimerslackNs = src => parseInt(src);
-	parsers.version = trim;
-	parsers.processCwd = src => src;
-	parsers.processPersonality = src => parseInt(src, 16);
-
-	parsers_1 = parsers;
-	return parsers_1;
-}
-
-var utils;
-var hasRequiredUtils;
-
-function requireUtils () {
-	if (hasRequiredUtils) return utils;
-	hasRequiredUtils = 1;
-	const {
-		readlinkSync,
-		readdirSync,
-		openSync,
-		readSync,
-		closeSync,
-		readFileSync,
-		existsSync,
-	} = require$$0;
-
-	const tmpBufMinLen = 4096 * 2;
-	const tmpBufMaxLen = 4096 * 8;
-
-	let tmpBuf = Buffer.allocUnsafeSlow(tmpBufMinLen);
-
-	const read = path => {
-		const fd = openSync(path, 'r', 0o666);
-		let pos = 0;
-		let bytesRead;
-		let buf = tmpBuf;
-		let length = buf.length;
-		do {
-			bytesRead = readSync(fd, buf, pos, buf.length - pos, null);
-			pos += bytesRead;
-			if (pos === tmpBuf.length) {
-				length = length << 1;
-				let newBuf = Buffer.allocUnsafeSlow(length);
-
-				if (length <= tmpBufMaxLen) {
-					tmpBuf = newBuf;
-				}
-
-				buf.copy(newBuf);
-				buf = newBuf;
-			}
-		} while (bytesRead !== 0);
-		closeSync(fd);
-		return buf.toString('utf8', 0, pos);
-	};
-
-	const readIdList = path => {
-		let ls = readdirSync(path);
-		for (let i = 0; i < ls.length; i++) {
-			ls[i] = parseInt(ls[i]);
-		}
-		return ls;
-	};
-
-	const readBuffer = readFileSync;
-	const exists = existsSync;
-	const readdir = readdirSync;
-
-	const devIdGetMinor = devId => (((devId >> 20) << 8) | (devId & 0xFF));
-	const devIdGetMajor = devId => ((devId >> 8) & 0xFF);
-	const devIdFromMajorMinor = (major, minor) => (((minor >> 8) << 20) | ((major & 0xFF) << 8) | (minor & 0xFF));
-
-	utils = {
-		read,
-		readLink: readlinkSync,
-		readIdList,
-		readBuffer,
-		exists,
-		readdir,
-
-		devIdGetMinor,
-		devIdGetMajor,
-		devIdFromMajorMinor,
-	};
-	return utils;
-}
-
-var procfs_1;
-var hasRequiredProcfs;
-
-function requireProcfs () {
-	if (hasRequiredProcfs) return procfs_1;
-	hasRequiredProcfs = 1;
-	const ProcfsError = requireProcfsError();
-	const parsers = requireParsers();
-	const {
-		read,
-		readLink,
-		readBuffer,
-		readdir,
-		devIdGetMinor,
-		devIdGetMajor,
-		devIdFromMajorMinor,
-	} = requireUtils();
-
-	class Procfs {
-		constructor(root) {
-			if (root === undefined) {
-				root = '/proc';
-			}
-			this.root = root;
-			this.rootSlash = `${root}/`;
-		}
-
-		processes() {
-			try {
-				return parsers.processes(readdir(this.root));
-			} catch (error) {
-				/* istanbul ignore next should not ever happen when procfs exists */
-				throw ProcfsError.generic(error);
-			}
-		}
-
-		processFds(pid) {
-			if (pid !== undefined && (!Number.isInteger(pid) || pid <= 0)) {
-				throw new TypeError('pid');
-			}
-			try {
-				return parsers.processFds(readdir(`${this.rootSlash}${pid === undefined ? 'self' : pid}/fd`));
-			} catch (error) {
-				throw ProcfsError.generic(error);
-			}
-		}
-
-		processThreads(pid) {
-			if (pid !== undefined && (!Number.isInteger(pid) || pid <= 0)) {
-				throw new TypeError('pid');
-			}
-			try {
-				return parsers.processThreads(readdir(`${this.rootSlash}${pid === undefined ? 'self' : pid}/task`));
-			} catch (error) {
-				throw ProcfsError.generic(error);
-			}
-		}
-
-		processFdinfo(fd, pid) {
-			if (pid !== undefined && !(Number.isInteger(pid) && pid >= 0)) {
-				throw new TypeError('pid');
-			}
-			if (!Number.isInteger(fd) || fd <= 0) {
-				throw new TypeError('fd');
-			}
-			try {
-				return parsers.processFdinfo(read(`${this.rootSlash}${pid === undefined ? 'self' : pid}/fdinfo/${fd}`));
-			} catch (error) {
-				throw ProcfsError.generic(error);
-			}
-		}
-
-		processFd(fd, pid) {
-			if (pid !== undefined && !(Number.isInteger(pid) && pid >= 0)) {
-				throw new TypeError('pid');
-			}
-			if (!Number.isInteger(fd) || fd <= 0) {
-				throw new TypeError('fd');
-			}
-			try {
-				return parsers.processFd(readLink(`${this.rootSlash}${pid === undefined ? 'self' : pid}/fd/${fd}`));
-			} catch (error) {
-				throw ProcfsError.generic(error);
-			}
-		}
-
-		config() {
-			try {
-				return parsers.config(readBuffer(`${this.rootSlash}config.gz`));
-			} catch (error) {
-				/* istanbul ignore next should not ever happen when procfs exists and kernel properly configured */
-				throw ProcfsError.generic(error);
-			}
-		}
-	}
-
-	Procfs.prototype.devIdGetMinor = devIdGetMinor;
-	Procfs.prototype.devIdGetMajor = devIdGetMajor;
-	Procfs.prototype.devIdFromMajorMinor = devIdFromMajorMinor;
-
-	for (let [name, path] of [
-		['processExe', '/exe'],
-		['processCwd', '/cwd'],
-	]) {
-		Procfs.prototype[name] = function (pid) {
-			if (pid !== undefined && !(Number.isInteger(pid) && pid >= 0)) {
-				throw new TypeError('pid');
-			}
-			try {
-				return parsers[name](readLink(`${this.rootSlash}${pid === undefined ? 'self' : pid}${path}`));
-			} catch (error) {
-				throw ProcfsError.generic(error);
-			}
-		};
-	}
-
-	for (let [name, path] of [
-		['processMountinfo', '/mountinfo'],
-		['processIo', '/io'],
-		['processUidMap', '/uid_map'],
-		['processGidMap', '/gid_map'],
-		['processEnviron', '/environ'],
-		['processOomScore', '/oom_score'],
-		['processTimerslackNs', '/timerslack_ns'],
-		['processCmdline', '/cmdline'],
-		['processAutogroup', '/autogroup'],
-		['processStatm', '/statm'],
-		['processComm', '/comm'],
-		['processPersonality', '/personality'],
-		['processCgroups', '/cgroup'],
-		['processCpuset', '/cpuset'],
-		['processLimits', '/limits'],
-		['processStat', '/stat'],
-		['processStatus', '/status'],
-		['processNetDev', '/net/dev'],
-		['processNetWireless', '/net/wireless'],
-		['processNetUnix', '/net/unix'],
-		['processNetTcp4', '/net/tcp'],
-		['processNetTcp6', '/net/tcp6'],
-		['processNetUdp4', '/net/udp'],
-		['processNetUdp6', '/net/udp6'],
-	]) {
-		Procfs.prototype[name] = function (pid) {
-			if (pid !== undefined && !(Number.isInteger(pid) && pid >= 0)) {
-				throw new TypeError('pid');
-			}
-			try {
-				return parsers[name](read(`${this.rootSlash}${pid === undefined ? 'self' : pid}${path}`));
-			} catch (error) {
-				throw ProcfsError.generic(error);
-			}
-		};
-	}
-
-	for (let name of [
-		'cpuinfo',
-		'loadavg',
-		'uptime',
-		'version',
-		'cmdline',
-		'swaps',
-		'stat',
-		'devices',
-		'filesystems',
-		'diskstats',
-		'partitions',
-		'meminfo',
-		'cgroups',
-	]) {
-		Procfs.prototype[name] = function () {
-			try {
-				return parsers[name](read(this.rootSlash + name));
-			} catch (error) {
-				/* istanbul ignore next should not ever happen when procfs exists */
-				throw ProcfsError.generic(error);
-			}
-		};
-	}
-
-	for (let [name, parser, path] of [
-		['netDev', 'processNetDev', 'net/dev'],
-		['netWireless', 'processNetWireless', 'net/wireless'],
-		['netUnix', 'processNetUnix', 'net/unix'],
-		['netTcp4', 'processNetTcp4', 'net/tcp'],
-		['netTcp6', 'processNetTcp6', 'net/tcp6'],
-		['netUdp4', 'processNetUdp4', 'net/udp'],
-		['netUdp6', 'processNetUdp6', 'net/udp6'],
-	]) {
-		Procfs.prototype[name] = function () {
-			try {
-				return parsers[parser](read(this.rootSlash + path));
-			} catch (error) {
-				/* istanbul ignore next should not ever happen when procfs exists */
-				throw ProcfsError.generic(error);
-			}
-		};
-	}
-
-	const procfs = new Procfs();
-	procfs_1 = {
-		procfs,
-		Procfs,
-		ProcfsError,
-	};
-	return procfs_1;
-}
-
-var procfsExports = requireProcfs();
-
-// Educated guess, values of 16 to 64 seem to be optimal for modern SSD, 8-16 and 64-128 can be a bit slower.
-// We should be ok as long as ssdCount <= cpuCount <= ssdCount*16.
-// For slower media this is not as important and we rely on OS handling it for us.
-const concurrency = os__default.availableParallelism() * 8;
-
-const formatDate = date => {
-	const pad = n => String(n).padStart(2, '0');
-	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
-};
-
-const trash = async (filePath, {filesPath, infoPath}) => {
-	const name = randomUUID();
-	const destination = path__default.join(filesPath, name);
-	const trashInfoPath = path__default.join(infoPath, `${name}.trashinfo`);
-
-	const trashInfo = [
-		'[Trash Info]',
-		`Path=${encodeURI(filePath)}`,
-		`DeletionDate=${formatDate(new Date())}`,
-	].join('\n');
-
-	await fs__default.promises.writeFile(trashInfoPath, trashInfo);
-	await moveFile(filePath, destination);
-
-	return {
-		path: destination,
-		info: trashInfoPath,
-	};
-};
-
-async function linux(paths) {
-	const mountPointMap = new Map();
-
-	for (const mountInfo of Object.values(procfsExports.procfs.processMountinfo())) {
-		// Filter out irrelevant drives
-		if (/^\/(snap|var\/snap|run|sys|proc|dev)($|\/)/.test(mountInfo.mountPoint)) {
-			continue;
-		}
-
-		// Keep the first one if there are multiple `devId`.
-		if (!mountPointMap.has(mountInfo.devId)) {
-			mountPointMap.set(mountInfo.devId, mountInfo.mountPoint);
-		}
-	}
-
-	// Get the home directory's device ID to handle systems like NixOS where
-	// multiple mount points (e.g., /nix/store and /home) share the same device ID.
-	// Per XDG spec, files on the same device as home should use ~/.local/share/Trash.
-	const homeStats = await fs__default.promises.lstat(os__default.homedir());
-	const homeDevId = homeStats.dev;
-
-	const trashPathsCache = new Map();
-
-	const getDeviceTrashPaths = async deviceId => {
-		let trashPathsPromise = trashPathsCache.get(deviceId);
-		if (!trashPathsPromise) {
-			trashPathsPromise = (async () => {
-				// For files on the same device as home, always use home trash.
-				// When xdgTrashdir is called without argument, it returns ~/.local/share/Trash.
-				const mountPoint = deviceId === homeDevId ? undefined : mountPointMap.get(deviceId);
-				const trashPath = await xdgTrashdir(mountPoint);
-				const paths = {
-					filesPath: path__default.join(trashPath, 'files'),
-					infoPath: path__default.join(trashPath, 'info'),
-				};
-				await fs__default.promises.mkdir(paths.filesPath, {mode: 0o700, recursive: true});
-				await fs__default.promises.mkdir(paths.infoPath, {mode: 0o700, recursive: true});
-				return paths;
-			})();
-			trashPathsCache.set(deviceId, trashPathsPromise);
-		}
-
-		return trashPathsPromise;
-	};
-
-	return pMap(paths, async filePath => {
-		const stats = await fs__default.promises.lstat(filePath);
-		const trashPaths = await getDeviceTrashPaths(stats.dev);
-		return trash(filePath, trashPaths);
-	}, {concurrency});
-}
-
-export { linux as default };