basant307/AI_Governance_Project
048
1<picture>2 <source media="(prefers-color-scheme: dark)" srcset="media/logo_dark.svg">3 <img alt="execa logo" src="media/logo.svg" width="400">4</picture>5<br>6 7[](https://codecov.io/gh/sindresorhus/execa)8 9> Process execution for humans10 11<br>12 13---14 15<div align="center">16 <p>17 <p>18 <sup>19 <a href="https://github.com/sponsors/sindresorhus">Sindre's open source work is supported by the community</a>20 </sup>21 </p>22 <sup>Special thanks to:</sup>23 <br>24 <br>25 <a href="https://transloadit.com?utm_source=sindresorhus&utm_medium=referral&utm_campaign=sponsorship&utm_content=execa">26 <picture>27 <source width="360" media="(prefers-color-scheme: dark)" srcset="https://sindresorhus.com/assets/thanks/transloadit-logo-dark.svg">28 <source width="360" media="(prefers-color-scheme: light)" srcset="https://sindresorhus.com/assets/thanks/transloadit-logo.svg">29 <img width="360" src="https://sindresorhus.com/assets/thanks/transloadit-logo.svg" alt="Transloadit logo">30 </picture>31 </a>32 <br>33 <br>34 </p>35</div>36 37---38 39<br>40 41## Why42 43This package improves [`child_process`](https://nodejs.org/api/child_process.html) methods with:44 45- [Promise interface](#execacommandcommand-options).46- [Scripts interface](#scripts-interface), like `zx`.47- Improved [Windows support](https://github.com/IndigoUnited/node-cross-spawn#why), including [shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)) binaries.48- Executes [locally installed binaries](#preferlocal) without `npx`.49- [Cleans up](#cleanup) child processes when the parent process ends.50- [Graceful termination](#optionsforcekillaftertimeout).51- Get [interleaved output](#all) from `stdout` and `stderr` similar to what is printed on the terminal.52- [Strips the final newline](#stripfinalnewline) from the output so you don't have to do `stdout.trim()`.53- Convenience methods to pipe processes' [input](#input) and [output](#redirect-output-to-a-file).54- Can specify file and arguments [as a single string](#execacommandcommand-options) without a shell.55- [Verbose mode](#verbose-mode) for debugging.56- More descriptive errors.57- Higher max buffer: 100 MB instead of 1 MB.58 59## Install60 61```sh62npm install execa63```64 65## Usage66 67### Promise interface68 69```js70import {execa} from 'execa';71 72const {stdout} = await execa('echo', ['unicorns']);73console.log(stdout);74//=> 'unicorns'75```76 77### Scripts interface78 79For more information about Execa scripts, please see [this page](docs/scripts.md).80 81#### Basic82 83```js84import {$} from 'execa';85 86const branch = await $`git branch --show-current`;87await $`dep deploy --branch=${branch}`;88```89 90#### Multiple arguments91 92```js93import {$} from 'execa';94 95const args = ['unicorns', '&', 'rainbows!'];96const {stdout} = await $`echo ${args}`;97console.log(stdout);98//=> 'unicorns & rainbows!'99```100 101#### With options102 103```js104import {$} from 'execa';105 106await $({stdio: 'inherit'})`echo unicorns`;107//=> 'unicorns'108```109 110#### Shared options111 112```js113import {$} from 'execa';114 115const $$ = $({stdio: 'inherit'});116 117await $$`echo unicorns`;118//=> 'unicorns'119 120await $$`echo rainbows`;121//=> 'rainbows'122```123 124#### Verbose mode125 126```sh127> node file.js128unicorns129rainbows130 131> NODE_DEBUG=execa node file.js132[16:50:03.305] echo unicorns133unicorns134[16:50:03.308] echo rainbows135rainbows136```137 138### Input/output139 140#### Redirect output to a file141 142```js143import {execa} from 'execa';144 145// Similar to `echo unicorns > stdout.txt` in Bash146await execa('echo', ['unicorns']).pipeStdout('stdout.txt');147 148// Similar to `echo unicorns 2> stdout.txt` in Bash149await execa('echo', ['unicorns']).pipeStderr('stderr.txt');150 151// Similar to `echo unicorns &> stdout.txt` in Bash152await execa('echo', ['unicorns'], {all: true}).pipeAll('all.txt');153```154 155#### Redirect input from a file156 157```js158import {execa} from 'execa';159 160// Similar to `cat < stdin.txt` in Bash161const {stdout} = await execa('cat', {inputFile: 'stdin.txt'});162console.log(stdout);163//=> 'unicorns'164```165 166#### Save and pipe output from a child process167 168```js169import {execa} from 'execa';170 171const {stdout} = await execa('echo', ['unicorns']).pipeStdout(process.stdout);172// Prints `unicorns`173console.log(stdout);174// Also returns 'unicorns'175```176 177#### Pipe multiple processes178 179```js180import {execa} from 'execa';181 182// Similar to `echo unicorns | cat` in Bash183const {stdout} = await execa('echo', ['unicorns']).pipeStdout(execa('cat'));184console.log(stdout);185//=> 'unicorns'186```187 188### Handling Errors189 190```js191import {execa} from 'execa';192 193// Catching an error194try {195 await execa('unknown', ['command']);196} catch (error) {197 console.log(error);198 /*199 {200 message: 'Command failed with ENOENT: unknown command spawn unknown ENOENT',201 errno: -2,202 code: 'ENOENT',203 syscall: 'spawn unknown',204 path: 'unknown',205 spawnargs: ['command'],206 originalMessage: 'spawn unknown ENOENT',207 shortMessage: 'Command failed with ENOENT: unknown command spawn unknown ENOENT',208 command: 'unknown command',209 escapedCommand: 'unknown command',210 stdout: '',211 stderr: '',212 failed: true,213 timedOut: false,214 isCanceled: false,215 killed: false216 }217 */218}219```220 221### Graceful termination222 223Using SIGTERM, and after 2 seconds, kill it with SIGKILL.224 225```js226const subprocess = execa('node');227 228setTimeout(() => {229 subprocess.kill('SIGTERM', {230 forceKillAfterTimeout: 2000231 });232}, 1000);233```234 235## API236 237### Methods238 239#### execa(file, arguments?, options?)240 241Executes a command using `file ...arguments`. `arguments` are specified as an array of strings. Returns a [`childProcess`](#childprocess).242 243Arguments are [automatically escaped](#shell-syntax). They can contain any character, including spaces.244 245This is the preferred method when executing single commands.246 247#### execaNode(scriptPath, arguments?, options?)248 249Executes a Node.js file using `node scriptPath ...arguments`. `arguments` are specified as an array of strings. Returns a [`childProcess`](#childprocess).250 251Arguments are [automatically escaped](#shell-syntax). They can contain any character, including spaces.252 253This is the preferred method when executing Node.js files.254 255Like [`child_process#fork()`](https://nodejs.org/api/child_process.html#child_process_child_process_fork_modulepath_args_options):256 - the current Node version and options are used. This can be overridden using the [`nodePath`](#nodepath-for-node-only) and [`nodeOptions`](#nodeoptions-for-node-only) options.257 - the [`shell`](#shell) option cannot be used258 - an extra channel [`ipc`](https://nodejs.org/api/child_process.html#child_process_options_stdio) is passed to [`stdio`](#stdio)259 260#### $\`command\`261 262Executes a command. The `command` string includes both the `file` and its `arguments`. Returns a [`childProcess`](#childprocess).263 264Arguments are [automatically escaped](#shell-syntax). They can contain any character, but spaces must use `${}` like `` $`echo ${'has space'}` ``.265 266This is the preferred method when executing multiple commands in a script file.267 268The `command` string can inject any `${value}` with the following types: string, number, [`childProcess`](#childprocess) or an array of those types. For example: `` $`echo one ${'two'} ${3} ${['four', 'five']}` ``. For `${childProcess}`, the process's `stdout` is used.269 270For more information, please see [this section](#scripts-interface) and [this page](docs/scripts.md).271 272#### $(options)273 274Returns a new instance of [`$`](#command) but with different default `options`. Consecutive calls are merged to previous ones.275 276This can be used to either:277 - Set options for a specific command: `` $(options)`command` ``278 - Share options for multiple commands: `` const $$ = $(options); $$`command`; $$`otherCommand`; ``279 280#### execaCommand(command, options?)281 282Executes a command. The `command` string includes both the `file` and its `arguments`. Returns a [`childProcess`](#childprocess).283 284Arguments are [automatically escaped](#shell-syntax). They can contain any character, but spaces must be escaped with a backslash like `execaCommand('echo has\\ space')`.285 286This is the preferred method when executing a user-supplied `command` string, such as in a REPL.287 288### execaSync(file, arguments?, options?)289 290Same as [`execa()`](#execacommandcommand-options) but synchronous.291 292Returns or throws a [`childProcessResult`](#childProcessResult).293 294### $.sync\`command\`295 296Same as [$\`command\`](#command) but synchronous.297 298Returns or throws a [`childProcessResult`](#childProcessResult).299 300### execaCommandSync(command, options?)301 302Same as [`execaCommand()`](#execacommand-command-options) but synchronous.303 304Returns or throws a [`childProcessResult`](#childProcessResult).305 306### Shell syntax307 308For all the [methods above](#methods), no shell interpreter (Bash, cmd.exe, etc.) is used unless the [`shell` option](#shell) is set. This means shell-specific characters and expressions (`$variable`, `&&`, `||`, `;`, `|`, etc.) have no special meaning and do not need to be escaped.309 310### childProcess311 312The return value of all [asynchronous methods](#methods) is both:313 - a `Promise` resolving or rejecting with a [`childProcessResult`](#childProcessResult).314 - a [`child_process` instance](https://nodejs.org/api/child_process.html#child_process_class_childprocess) with the following additional methods and properties.315 316#### kill(signal?, options?)317 318Same as the original [`child_process#kill()`](https://nodejs.org/api/child_process.html#child_process_subprocess_kill_signal) except: if `signal` is `SIGTERM` (the default value) and the child process is not terminated after 5 seconds, force it by sending `SIGKILL`.319 320Note that this graceful termination does not work on Windows, because Windows [doesn't support signals](https://nodejs.org/api/process.html#process_signal_events) (`SIGKILL` and `SIGTERM` has the same effect of force-killing the process immediately.) If you want to achieve graceful termination on Windows, you have to use other means, such as [`taskkill`](https://github.com/sindresorhus/taskkill).321 322##### options.forceKillAfterTimeout323 324Type: `number | false`\325Default: `5000`326 327Milliseconds to wait for the child process to terminate before sending `SIGKILL`.328 329Can be disabled with `false`.330 331#### all332 333Type: `ReadableStream | undefined`334 335Stream combining/interleaving [`stdout`](https://nodejs.org/api/child_process.html#child_process_subprocess_stdout) and [`stderr`](https://nodejs.org/api/child_process.html#child_process_subprocess_stderr).336 337This is `undefined` if either:338 - the [`all` option](#all-2) is `false` (the default value)339 - both [`stdout`](#stdout-1) and [`stderr`](#stderr-1) options are set to [`'inherit'`, `'ipc'`, `Stream` or `integer`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio)340 341#### pipeStdout(target)342 343[Pipe](https://nodejs.org/api/stream.html#readablepipedestination-options) the child process's `stdout` to `target`, which can be:344 - Another [`execa()` return value](#pipe-multiple-processes)345 - A [writable stream](#save-and-pipe-output-from-a-child-process)346 - A [file path string](#redirect-output-to-a-file)347 348If the `target` is another [`execa()` return value](#execacommandcommand-options), it is returned. Otherwise, the original `execa()` return value is returned. This allows chaining `pipeStdout()` then `await`ing the [final result](#childprocessresult).349 350The [`stdout` option](#stdout-1) must be kept as `pipe`, its default value.351 352#### pipeStderr(target)353 354Like [`pipeStdout()`](#pipestdouttarget) but piping the child process's `stderr` instead.355 356The [`stderr` option](#stderr-1) must be kept as `pipe`, its default value.357 358#### pipeAll(target)359 360Combines both [`pipeStdout()`](#pipestdouttarget) and [`pipeStderr()`](#pipestderrtarget).361 362Either the [`stdout` option](#stdout-1) or the [`stderr` option](#stderr-1) must be kept as `pipe`, their default value. Also, the [`all` option](#all-2) must be set to `true`.363 364### childProcessResult365 366Type: `object`367 368Result of a child process execution. On success this is a plain object. On failure this is also an `Error` instance.369 370The child process [fails](#failed) when:371- its [exit code](#exitcode) is not `0`372- it was [killed](#killed) with a [signal](#signal)373- [timing out](#timedout)374- [being canceled](#iscanceled)375- there's not enough memory or there are already too many child processes376 377#### command378 379Type: `string`380 381The file and arguments that were run, for logging purposes.382 383This is not escaped and should not be executed directly as a process, including using [`execa()`](#execafile-arguments-options) or [`execaCommand()`](#execacommandcommand-options).384 385#### escapedCommand386 387Type: `string`388 389Same as [`command`](#command-1) but escaped.390 391This is meant to be copy and pasted into a shell, for debugging purposes.392Since the escaping is fairly basic, this should not be executed directly as a process, including using [`execa()`](#execafile-arguments-options) or [`execaCommand()`](#execacommandcommand-options).393 394#### exitCode395 396Type: `number`397 398The numeric exit code of the process that was run.399 400#### stdout401 402Type: `string | Buffer`403 404The output of the process on stdout.405 406#### stderr407 408Type: `string | Buffer`409 410The output of the process on stderr.411 412#### all413 414Type: `string | Buffer | undefined`415 416The output of the process with `stdout` and `stderr` interleaved.417 418This is `undefined` if either:419 - the [`all` option](#all-2) is `false` (the default value)420 - `execaSync()` was used421 422#### failed423 424Type: `boolean`425 426Whether the process failed to run.427 428#### timedOut429 430Type: `boolean`431 432Whether the process timed out.433 434#### isCanceled435 436Type: `boolean`437 438Whether the process was canceled.439 440You can cancel the spawned process using the [`signal`](#signal-1) option.441 442#### killed443 444Type: `boolean`445 446Whether the process was killed.447 448#### signal449 450Type: `string | undefined`451 452The name of the signal that was used to terminate the process. For example, `SIGFPE`.453 454If a signal terminated the process, this property is defined and included in the error message. Otherwise it is `undefined`.455 456#### signalDescription457 458Type: `string | undefined`459 460A human-friendly description of the signal that was used to terminate the process. For example, `Floating point arithmetic error`.461 462If a signal terminated the process, this property is defined and included in the error message. Otherwise it is `undefined`. It is also `undefined` when the signal is very uncommon which should seldomly happen.463 464#### cwd465 466Type: `string`467 468The `cwd` of the command if provided in the [command options](#cwd-1). Otherwise it is `process.cwd()`.469 470#### message471 472Type: `string`473 474Error message when the child process failed to run. In addition to the [underlying error message](#originalMessage), it also contains some information related to why the child process errored.475 476The child process [stderr](#stderr) then [stdout](#stdout) are appended to the end, separated with newlines and not interleaved.477 478#### shortMessage479 480Type: `string`481 482This is the same as the [`message` property](#message) except it does not include the child process stdout/stderr.483 484#### originalMessage485 486Type: `string | undefined`487 488Original error message. This is the same as the `message` property except it includes neither the child process stdout/stderr nor some additional information added by Execa.489 490This is `undefined` unless the child process exited due to an `error` event or a timeout.491 492### options493 494Type: `object`495 496#### cleanup497 498Type: `boolean`\499Default: `true`500 501Kill the spawned process when the parent process exits unless either:502 - the spawned process is [`detached`](https://nodejs.org/api/child_process.html#child_process_options_detached)503 - the parent process is terminated abruptly, for example, with `SIGKILL` as opposed to `SIGTERM` or a normal exit504 505#### preferLocal506 507Type: `boolean`\508Default: `true` with [`$`](#command), `false` otherwise509 510Prefer locally installed binaries when looking for a binary to execute.\511If you `$ npm install foo`, you can then `execa('foo')`.512 513#### localDir514 515Type: `string | URL`\516Default: `process.cwd()`517 518Preferred path to find locally installed binaries in (use with `preferLocal`).519 520#### execPath521 522Type: `string`\523Default: `process.execPath` (Current Node.js executable)524 525Path to the Node.js executable to use in child processes.526 527This can be either an absolute path or a path relative to the [`cwd` option](#cwd).528 529Requires [`preferLocal`](#preferlocal) to be `true`.530 531For example, this can be used together with [`get-node`](https://github.com/ehmicky/get-node) to run a specific Node.js version in a child process.532 533#### buffer534 535Type: `boolean`\536Default: `true`537 538Buffer the output from the spawned process. When set to `false`, you must read the output of [`stdout`](#stdout-1) and [`stderr`](#stderr-1) (or [`all`](#all) if the [`all`](#all-2) option is `true`). Otherwise the returned promise will not be resolved/rejected.539 540If the spawned process fails, [`error.stdout`](#stdout), [`error.stderr`](#stderr), and [`error.all`](#all) will contain the buffered data.541 542#### input543 544Type: `string | Buffer | stream.Readable`545 546Write some input to the `stdin` of your binary.\547Streams are not allowed when using the synchronous methods.548 549If the input is a file, use the [`inputFile` option](#inputfile) instead.550 551#### inputFile552 553Type: `string`554 555Use a file as input to the the `stdin` of your binary.556 557If the input is not a file, use the [`input` option](#input) instead.558 559#### stdin560 561Type: `string | number | Stream | undefined`\562Default: `inherit` with [`$`](#command), `pipe` otherwise563 564Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).565 566#### stdout567 568Type: `string | number | Stream | undefined`\569Default: `pipe`570 571Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).572 573#### stderr574 575Type: `string | number | Stream | undefined`\576Default: `pipe`577 578Same options as [`stdio`](https://nodejs.org/dist/latest-v6.x/docs/api/child_process.html#child_process_options_stdio).579 580#### all581 582Type: `boolean`\583Default: `false`584 585Add an `.all` property on the [promise](#all) and the [resolved value](#all-1). The property contains the output of the process with `stdout` and `stderr` interleaved.586 587#### reject588 589Type: `boolean`\590Default: `true`591 592Setting this to `false` resolves the promise with the error instead of rejecting it.593 594#### stripFinalNewline595 596Type: `boolean`\597Default: `true`598 599Strip the final [newline character](https://en.wikipedia.org/wiki/Newline) from the output.600 601#### extendEnv602 603Type: `boolean`\604Default: `true`605 606Set to `false` if you don't want to extend the environment variables when providing the `env` property.607 608---609 610Execa also accepts the below options which are the same as the options for [`child_process#spawn()`](https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options)/[`child_process#exec()`](https://nodejs.org/api/child_process.html#child_process_child_process_exec_command_options_callback)611 612#### cwd613 614Type: `string | URL`\615Default: `process.cwd()`616 617Current working directory of the child process.618 619#### env620 621Type: `object`\622Default: `process.env`623 624Environment key-value pairs. Extends automatically from `process.env`. Set [`extendEnv`](#extendenv) to `false` if you don't want this.625 626#### argv0627 628Type: `string`629 630Explicitly set the value of `argv[0]` sent to the child process. This will be set to `file` if not specified.631 632#### stdio633 634Type: `string | string[]`\635Default: `pipe`636 637Child's [stdio](https://nodejs.org/api/child_process.html#child_process_options_stdio) configuration.638 639#### serialization640 641Type: `string`\642Default: `'json'`643 644Specify the kind of serialization used for sending messages between processes when using the [`stdio: 'ipc'`](#stdio) option or [`execaNode()`](#execanodescriptpath-arguments-options):645 - `json`: Uses `JSON.stringify()` and `JSON.parse()`.646 - `advanced`: Uses [`v8.serialize()`](https://nodejs.org/api/v8.html#v8_v8_serialize_value)647 648[More info.](https://nodejs.org/api/child_process.html#child_process_advanced_serialization)649 650#### detached651 652Type: `boolean`653 654Prepare child to run independently of its parent process. Specific behavior [depends on the platform](https://nodejs.org/api/child_process.html#child_process_options_detached).655 656#### uid657 658Type: `number`659 660Sets the user identity of the process.661 662#### gid663 664Type: `number`665 666Sets the group identity of the process.667 668#### shell669 670Type: `boolean | string`\671Default: `false`672 673If `true`, runs `file` inside of a shell. Uses `/bin/sh` on UNIX and `cmd.exe` on Windows. A different shell can be specified as a string. The shell should understand the `-c` switch on UNIX or `/d /s /c` on Windows.674 675We recommend against using this option since it is:676- not cross-platform, encouraging shell-specific syntax.677- slower, because of the additional shell interpretation.678- unsafe, potentially allowing command injection.679 680#### encoding681 682Type: `string | null`\683Default: `utf8`684 685Specify the character encoding used to decode the `stdout` and `stderr` output. If set to `'buffer'` or `null`, then `stdout` and `stderr` will be a `Buffer` instead of a string.686 687#### timeout688 689Type: `number`\690Default: `0`691 692If timeout is greater than `0`, the parent will send the signal identified by the `killSignal` property (the default is `SIGTERM`) if the child runs longer than timeout milliseconds.693 694#### maxBuffer695 696Type: `number`\697Default: `100_000_000` (100 MB)698 699Largest amount of data in bytes allowed on `stdout` or `stderr`.700 701#### killSignal702 703Type: `string | number`\704Default: `SIGTERM`705 706Signal value to be used when the spawned process will be killed.707 708#### signal709 710Type: [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)711 712You can abort the spawned process using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).713 714When `AbortController.abort()` is called, [`.isCanceled`](#iscanceled) becomes `true`.715 716#### windowsVerbatimArguments717 718Type: `boolean`\719Default: `false`720 721If `true`, no quoting or escaping of arguments is done on Windows. Ignored on other platforms. This is set to `true` automatically when the `shell` option is `true`.722 723#### windowsHide724 725Type: `boolean`\726Default: `true`727 728On Windows, do not create a new console window. Please note this also prevents `CTRL-C` [from working](https://github.com/nodejs/node/issues/29837) on Windows.729 730#### verbose731 732Type: `boolean`\733Default: `false`734 735[Print each command](#verbose-mode) on `stderr` before executing it.736 737This can also be enabled by setting the `NODE_DEBUG=execa` environment variable in the current process.738 739#### nodePath *(For `.node()` only)*740 741Type: `string`\742Default: [`process.execPath`](https://nodejs.org/api/process.html#process_process_execpath)743 744Node.js executable used to create the child process.745 746#### nodeOptions *(For `.node()` only)*747 748Type: `string[]`\749Default: [`process.execArgv`](https://nodejs.org/api/process.html#process_process_execargv)750 751List of [CLI options](https://nodejs.org/api/cli.html#cli_options) passed to the Node.js executable.752 753## Tips754 755### Retry on error756 757Gracefully handle failures by using automatic retries and exponential backoff with the [`p-retry`](https://github.com/sindresorhus/p-retry) package:758 759```js760import pRetry from 'p-retry';761 762const run = async () => {763 const results = await execa('curl', ['-sSL', 'https://sindresorhus.com/unicorn']);764 return results;765};766 767console.log(await pRetry(run, {retries: 5}));768```769 770### Cancelling a spawned process771 772```js773import {execa} from 'execa';774 775const abortController = new AbortController();776const subprocess = execa('node', [], {signal: abortController.signal});777 778setTimeout(() => {779 abortController.abort();780}, 1000);781 782try {783 await subprocess;784} catch (error) {785 console.log(subprocess.killed); // true786 console.log(error.isCanceled); // true787}788```789 790### Execute the current package's binary791 792```js793import {getBinPath} from 'get-bin-path';794 795const binPath = await getBinPath();796await execa(binPath);797```798 799`execa` can be combined with [`get-bin-path`](https://github.com/ehmicky/get-bin-path) to test the current package's binary. As opposed to hard-coding the path to the binary, this validates that the `package.json` `bin` field is correctly set up.800 801## Related802 803- [gulp-execa](https://github.com/ehmicky/gulp-execa) - Gulp plugin for `execa`804- [nvexeca](https://github.com/ehmicky/nvexeca) - Run `execa` using any Node.js version805- [sudo-prompt](https://github.com/jorangreef/sudo-prompt) - Run commands with elevated privileges.806 807## Maintainers808 809- [Sindre Sorhus](https://github.com/sindresorhus)810- [@ehmicky](https://github.com/ehmicky)811 812---813 814<div align="center">815 <b>816 <a href="https://tidelift.com/subscription/pkg/npm-execa?utm_source=npm-execa&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>817 </b>818 <br>819 <sub>820 Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.821 </sub>822</div>823