projen 0.91.16 → 0.91.18

package/node_modules/shelljs/src/tail.js

@@ -24,7 +24,7 @@ common.register('tail', _tail, {
 //@ var str = tail(['file1', 'file2']); // same as above
 //@ ```
 //@
-//@ Read the end of a `file`.
+//@ Read the end of a `file`. Returns a [ShellString](#shellstringstr).
 function _tail(options, files) {
   var tail = [];
   var pipe = common.readFromPipe();
@@ -32,12 +32,20 @@ function _tail(options, files) {
   if (!files && !pipe) common.error('no paths given');
 
   var idx = 1;
+  var plusOption = false;
   if (options.numLines === true) {
     idx = 2;
+    if (arguments[1][0] === '+') {
+      plusOption = true;
+    }
     options.numLines = Number(arguments[1]);
   } else if (options.numLines === false) {
     options.numLines = 10;
   }
+  // arguments[0] is a json object
+  if (arguments[0].numLines[0] === '+') {
+    plusOption = true;
+  }
   options.numLines = -1 * Math.abs(options.numLines);
   files = [].slice.call(arguments, idx);
 
@@ -69,12 +77,14 @@ function _tail(options, files) {
       shouldAppendNewline = false;
     }
 
-    tail = tail.concat(lines.slice(options.numLines));
+    tail = tail.concat(plusOption ? lines.slice(-options.numLines - 1) : lines.slice(options.numLines));
   });
 
   if (shouldAppendNewline) {
     tail.push(''); // to add a trailing newline once we join
   }
+
   return tail.join('\n');
 }
+
 module.exports = _tail;

package/node_modules/shelljs/src/test.js

@@ -35,10 +35,11 @@ common.register('test', _test, {
 //@
 //@ ```javascript
 //@ if (test('-d', path)) { /* do something with dir */ };
-//@ if (!test('-f', path)) continue; // skip if it's a regular file
+//@ if (!test('-f', path)) continue; // skip if it's not a regular file
 //@ ```
 //@
-//@ Evaluates `expression` using the available primaries and returns corresponding value.
+//@ Evaluates `expression` using the available primaries and returns
+//@ corresponding boolean value.
 function _test(options, path) {
   if (!path) common.error('no path given');
 

package/node_modules/shelljs/src/to.js

@@ -18,7 +18,8 @@ common.register('to', _to, {
 //@
 //@ Analogous to the redirection operator `>` in Unix, but works with
 //@ `ShellStrings` (such as those returned by `cat`, `grep`, etc.). _Like Unix
-//@ redirections, `to()` will overwrite any existing file!_
+//@ redirections, `to()` will overwrite any existing file!_ Returns the same
+//@ [ShellString](#shellstringstr) this operated on, to support chaining.
 function _to(options, file) {
   if (!file) common.error('wrong arguments');
 

package/node_modules/shelljs/src/toEnd.js

@@ -17,7 +17,8 @@ common.register('toEnd', _toEnd, {
 //@ ```
 //@
 //@ Analogous to the redirect-and-append operator `>>` in Unix, but works with
-//@ `ShellStrings` (such as those returned by `cat`, `grep`, etc.).
+//@ `ShellStrings` (such as those returned by `cat`, `grep`, etc.). Returns the
+//@ same [ShellString](#shellstringstr) this operated on, to support chaining.
 function _toEnd(options, file) {
   if (!file) common.error('wrong arguments');
 

package/node_modules/shelljs/src/touch.js

@@ -20,20 +20,26 @@ common.register('touch', _touch, {
 //@ + `-a`: Change only the access time
 //@ + `-c`: Do not create any files
 //@ + `-m`: Change only the modification time
-//@ + `-d DATE`: Parse `DATE` and use it instead of current time
-//@ + `-r FILE`: Use `FILE`'s times instead of current time
+//@ + `{'-d': someDate}`, `{date: someDate}`: Use a `Date` instance (ex. `someDate`)
+//@   instead of current time
+//@ + `{'-r': file}`, `{reference: file}`: Use `file`'s times instead of current
+//@   time
 //@
 //@ Examples:
 //@
 //@ ```javascript
 //@ touch('source.js');
-//@ touch('-c', '/path/to/some/dir/source.js');
-//@ touch({ '-r': FILE }, '/path/to/some/dir/source.js');
+//@ touch('-c', 'path/to/file.js');
+//@ touch({ '-r': 'referenceFile.txt' }, 'path/to/file.js');
+//@ touch({ '-d': new Date('December 17, 1995 03:24:00'), '-m': true }, 'path/to/file.js');
+//@ touch({ date: new Date('December 17, 1995 03:24:00') }, 'path/to/file.js');
 //@ ```
 //@
-//@ Update the access and modification times of each `FILE` to the current time.
-//@ A `FILE` argument that does not exist is created empty, unless `-c` is supplied.
-//@ This is a partial implementation of [`touch(1)`](http://linux.die.net/man/1/touch).
+//@ Update the access and modification times of each file to the current time.
+//@ A file argument that does not exist is created empty, unless `-c` is supplied.
+//@ This is a partial implementation of
+//@ [`touch(1)`](http://linux.die.net/man/1/touch). Returns a
+//@ [ShellString](#shellstringstr) indicating success or failure.
 function _touch(opts, files) {
   if (!files) {
     common.error('no files given');

package/node_modules/shelljs/src/uniq.js

@@ -36,7 +36,8 @@ common.register('uniq', _uniq, {
 //@ uniq('-cd', 'foo.txt', 'bar.txt');
 //@ ```
 //@
-//@ Filter adjacent matching lines from `input`.
+//@ Filter adjacent matching lines from `input`. Returns a
+//@ [ShellString](#shellstringstr).
 function _uniq(options, input, output) {
   // Check if this is coming from a pipe
   var pipe = common.readFromPipe();
@@ -54,9 +55,9 @@ function _uniq(options, input, output) {
     common.error(output + ': Is a directory');
   }
 
-  var lines = (input ? fs.readFileSync(input, 'utf8') : pipe).
-              trimRight().
-              split('\n');
+  var lines = (input ? fs.readFileSync(input, 'utf8') : pipe)
+              .trimRight()
+              .split('\n');
 
   var compare = function (a, b) {
     return options.ignoreCase ?

package/node_modules/shelljs/src/which.js

@@ -53,7 +53,8 @@ function checkPath(pathName) {
 //@
 //@ Searches for `command` in the system's `PATH`. On Windows, this uses the
 //@ `PATHEXT` variable to append the extension if it's not already executable.
-//@ Returns string containing the absolute path to `command`.
+//@ Returns a [ShellString](#shellstringstr) containing the absolute path to
+//@ `command`.
 function _which(options, cmd) {
   if (!cmd) common.error('must specify command');
 
@@ -63,7 +64,7 @@ function _which(options, cmd) {
   var queryMatches = [];
 
   // No relative/absolute paths provided?
-  if (cmd.indexOf('/') === -1) {
+  if (!cmd.includes('/')) {
     // Assume that there are no extensions to append to queries (this is the
     // case for unix)
     var pathExtArray = [''];
@@ -85,8 +86,8 @@ function _which(options, cmd) {
         attempt = attempt.toUpperCase();
       }
 
-      var match = attempt.match(/\.[^<>:"/\|?*.]+$/);
-      if (match && pathExtArray.indexOf(match[0]) >= 0) { // this is Windows-only
+      var match = attempt.match(/\.[^<>:"/|?*.]+$/);
+      if (match && pathExtArray.includes(match[0])) { // this is Windows-only
         // The user typed a query with the file extension, like
         // `which('node.exe')`
         if (checkPath(attempt)) {

package/node_modules/shx/README.md

@@ -1,7 +1,7 @@
 # Shx
 
-[![Build Status](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2Fshelljs%2Fshx%2Fbadge%3Fref%3Dmaster&style=flat-square)](https://actions-badge.atrox.dev/shelljs/shx/goto?ref=master)
-[![Codecov](https://img.shields.io/codecov/c/github/shelljs/shx/master.svg?style=flat-square&label=coverage)](https://codecov.io/gh/shelljs/shx)
+[![GitHub Actions](https://img.shields.io/github/actions/workflow/status/shelljs/shx/main.yml?style=flat-square&logo=github)](https://github.com/shelljs/shx/actions/workflows/main.yml)
+[![Codecov](https://img.shields.io/codecov/c/github/shelljs/shx/main.svg?style=flat-square&label=coverage)](https://codecov.io/gh/shelljs/shx)
 [![npm version](https://img.shields.io/npm/v/shx.svg?style=flat-square)](https://www.npmjs.com/package/shx)
 [![npm downloads](https://img.shields.io/npm/dm/shx.svg?style=flat-square)](https://www.npmjs.com/package/shx)
 
@@ -9,7 +9,7 @@
 commands, providing an easy solution for simple Unix-like, cross-platform
 commands in npm package scripts.
 
-`shx` is proudly tested on every node release since <!-- start minVersion -->`v6`<!-- stop minVersion -->!
+`shx` is proudly tested on every LTS node release since <!-- start minVersion -->`v18`<!-- stop minVersion -->!
 
 ## Difference Between ShellJS and shx
 
@@ -59,6 +59,8 @@ sub
 $ shx rm -r sub                 # options work as well
 
 $ shx --silent ls fakeFileName  # silence error output
+
+$ shx --negate test -d dir      # Negate status code output (e.g., failed commands will now have status 0)
 ```
 
 All commands internally call the ShellJS corresponding function, guaranteeing
@@ -71,19 +73,26 @@ platform-independent scripts, we recommend you go with that.
 
 However, `shx` is ideal for one-liners inside `package.json`:
 
-```javascript
+```json
 {
   "scripts": {
-    "clean": "shx rm -rf build dist && shx echo Done"
+    "clean": "shx rm -rf \"build/**/*.js\" \"build/output\" && shx echo \"Done cleaning\""
   }
 }
 ```
 
-**Tip:** because Windows treats single quotes (ex. `'some string'`) differently
-than double quotes, [we
-recommend](https://github.com/shelljs/shx/issues/165#issuecomment-563127983)
-wrapping your arguments in double quotes for cross platform compatibility (ex.
-`"some string"`).
+It's safe to use `&&` and `||` operators in npm package scripts. These will be
+interpreted by the operating system's shell (`sh` on Unix, `cmd.exe` on
+Windows). If you're using glob operators like `*` or `**`, then we recommend to
+**put these in double quotes**, which ensures that `shx` will expand the glob
+rather than the operating system shell.
+
+> [!IMPORTANT]
+> Windows treats single quotes (ex. `'some string'`) differently than double
+> quotes.
+> [We recommend](https://github.com/shelljs/shx/issues/165#issuecomment-563127983)
+> wrapping your arguments in **escaped double quotes** so that your code is
+> compatible cross platform (ex. `"clean": "shx echo \"some string\""`).
 
 ## Command reference
 
@@ -114,7 +123,7 @@ characters in the file path.
 
 ### Unsupported Commands
 
-As mentioned above, most ShellJS commands are supported in ShellJS. Due to the
+As mentioned above, most ShellJS commands are supported in `shx`. Due to the
 differences in execution environments between ShellJS and `shx` (JS vs CLI) the
 following commands are not supported:
 
@@ -136,10 +145,13 @@ supported options:
 
 | [`set`](https://github.com/shelljs/shelljs#setoptions) flag | [`shell.config`](https://github.com/shelljs/shelljs#configuration) setting | shx command | Effect |
 |:---:| --- | --- | --- |
-| `-e` | `config.fatal = true` | Not supported | Exit upon first error |
-| `-v` | `config.verbose = true` | `shx --verbose cd foo` | Log the command as it's run |
-| `-f` | `config.noglob = true` | `shx --noglob cat '*.txt'` | Don't expand wildcards |
-| N/A | `config.silent = true` | `shx --silent cd noexist` | Don't show error output |
+| `-e` | `config.fatal = true` | Not supported | Exit upon first error. |
+| `-v` | `config.verbose = true` | `shx --verbose cd foo` | Log the command as it's run. |
+| `-f` | `config.noglob = true` | `shx --noglob cat '*.txt'` | Don't expand wildcards. |
+| N/A | `config.silent = true` | `shx --silent cd noexist` | Don't show error output. |
+| N/A | N/A | `shx --negate test -d dir` | Runs the specified command but negates the exit status. Failed command = status 0, successful command = status 1. |
+| N/A | N/A | `shx --help` | Show help text. |
+| N/A | N/A | `shx --version` | Print the shx version. |
 
 ## Team
 

package/node_modules/shx/lib/help.js

@@ -13,7 +13,7 @@ var _config = require('./config');
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // Global options defined directly in shx.
-var locallyDefinedOptions = ['version'];
+var locallyDefinedOptions = ['version', 'negate'];
 
 var shxOptions = Object.keys(_shelljs2.default.config).filter(function (key) {
   return typeof _shelljs2.default.config[key] !== 'function';

package/node_modules/shx/lib/shx.js

@@ -5,14 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.shx = shx;
 
-var _shelljs = require('shelljs');
-
-var _shelljs2 = _interopRequireDefault(_shelljs);
-
-var _minimist = require('minimist');
-
-var _minimist2 = _interopRequireDefault(_minimist);
-
 var _path = require('path');
 
 var _path2 = _interopRequireDefault(_path);
@@ -21,6 +13,14 @@ var _fs = require('fs');
 
 var _fs2 = _interopRequireDefault(_fs);
 
+var _shelljs = require('shelljs');
+
+var _shelljs2 = _interopRequireDefault(_shelljs);
+
+var _minimist = require('minimist');
+
+var _minimist2 = _interopRequireDefault(_minimist);
+
 var _help = require('./help');
 
 var _help2 = _interopRequireDefault(_help);
@@ -146,6 +146,11 @@ function shx(argv) {
     code = ret ? 0 : 1;
   }
 
+  // Check for negation flag, and flip the code value
+  if (parsedArgs.negate === true) {
+    code = Number(!code);
+  }
+
   if (typeof code === 'number') {
     return code;
   } else if (_shelljs2.default.error()) {

package/node_modules/shx/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shx",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Portable Shell Commands for Node",
   "bin": {
     "shx": "lib/cli.js"
@@ -12,20 +12,14 @@
     "check-node-support": "node scripts/check-node-support",
     "prebuild": "rimraf lib",
     "build": "babel src -d lib",
-    "build:watch": "npm run build -- -w",
-    "dev": "concurrently -rk 'npm run build:watch' 'npm run lint:watch'",
     "lint": "eslint .",
-    "lint:fix": "npm run lint --silent -- --fix",
-    "lint:watch": "watch 'npm run lint --silent' src test",
     "prepublish": "npm run build",
-    "posttest": "npm run lint --silent",
+    "posttest": "npm run lint",
     "release:major": "shelljs-release major",
     "release:minor": "shelljs-release minor",
     "release:patch": "shelljs-release patch",
     "changelog": "shelljs-changelog",
-    "codecov": "codecov",
-    "test": "nyc --reporter=text --reporter=lcov mocha",
-    "test:watch": "concurrently -rk 'npm run test --silent -- -w' 'npm run lint:watch'"
+    "test": "nyc --reporter=text --reporter=lcov mocha"
   },
   "repository": {
     "type": "git",
@@ -55,26 +49,24 @@
     "babel-cli": "^6.6.5",
     "babel-preset-env": "^1.7.0",
     "babel-register": "^6.7.2",
-    "codecov": "^3.0.2",
-    "concurrently": "^2.1.0",
-    "eslint": "^5.16.0",
-    "eslint-config-airbnb-base": "^13.1.0",
-    "eslint-plugin-import": "^2.17.3",
-    "js-yaml": "^3.12.0",
-    "mocha": "^6.1.4",
-    "nyc": "^14.1.1",
-    "rimraf": "^2.5.2",
+    "eslint": "^8.57.1",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-import-resolver-node": "0.3.7",
+    "eslint-plugin-import": "^2.31.0",
+    "js-yaml": "^4.1.0",
+    "mocha": "^11.1.0",
+    "nyc": "^17.1.0",
+    "rimraf": "^5.0.10",
     "shelljs-changelog": "^0.2.6",
-    "shelljs-plugin-open": "^0.2.1",
-    "shelljs-release": "^0.5.1",
-    "should": "^13.2.3",
-    "watch": "^1.0.2"
+    "shelljs-plugin-open": "^0.3.0",
+    "shelljs-release": "^0.5.3",
+    "should": "^13.2.3"
   },
   "dependencies": {
-    "minimist": "^1.2.3",
-    "shelljs": "^0.8.5"
+    "minimist": "^1.2.8",
+    "shelljs": "^0.9.2"
   },
   "engines": {
-    "node": ">=6"
+    "node": ">=18"
   }
 }

package/node_modules/signal-exit/LICENSE.txt

@@ -0,0 +1,16 @@
+The ISC License
+
+Copyright (c) 2015, Contributors
+
+Permission to use, copy, modify, and/or distribute this software
+for any purpose with or without fee is hereby granted, provided
+that the above copyright notice and this permission notice
+appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE
+LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/node_modules/signal-exit/README.md

@@ -0,0 +1,39 @@
+# signal-exit
+
+[![Build Status](https://travis-ci.org/tapjs/signal-exit.png)](https://travis-ci.org/tapjs/signal-exit)
+[![Coverage](https://coveralls.io/repos/tapjs/signal-exit/badge.svg?branch=master)](https://coveralls.io/r/tapjs/signal-exit?branch=master)
+[![NPM version](https://img.shields.io/npm/v/signal-exit.svg)](https://www.npmjs.com/package/signal-exit)
+[![Standard Version](https://img.shields.io/badge/release-standard%20version-brightgreen.svg)](https://github.com/conventional-changelog/standard-version)
+
+When you want to fire an event no matter how a process exits:
+
+* reaching the end of execution.
+* explicitly having `process.exit(code)` called.
+* having `process.kill(pid, sig)` called.
+* receiving a fatal signal from outside the process
+
+Use `signal-exit`.
+
+```js
+var onExit = require('signal-exit')
+
+onExit(function (code, signal) {
+  console.log('process exited!')
+})
+```
+
+## API
+
+`var remove = onExit(function (code, signal) {}, options)`
+
+The return value of the function is a function that will remove the
+handler.
+
+Note that the function *only* fires for signals if the signal would
+cause the process to exit.  That is, there are no other listeners, and
+it is a fatal signal.
+
+## Options
+
+* `alwaysLast`: Run this handler after any other signal or exit
+  handlers.  This causes `process.emit` to be monkeypatched.

package/node_modules/signal-exit/index.js

@@ -0,0 +1,202 @@
+// 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 = global.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)) {
+  module.exports = function () {
+    return function () {}
+  }
+} else {
+  var assert = require('assert')
+  var signals = require('./signals.js')
+  var isWin = /^win/i.test(process.platform)
+
+  var EE = require('events')
+  /* 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
+  }
+
+  module.exports = function (cb, opts) {
+    /* istanbul ignore if */
+    if (!processOk(global.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(global.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
+  }
+  module.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(global.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)
+      }
+    }
+  })
+
+  module.exports.signals = function () {
+    return signals
+  }
+
+  var loaded = false
+
+  var load = function load () {
+    if (loaded || !processOk(global.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
+  }
+  module.exports.load = load
+
+  var originalProcessReallyExit = process.reallyExit
+  var processReallyExit = function processReallyExit (code) {
+    /* istanbul ignore if */
+    if (!processOk(global.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(global.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)
+    }
+  }
+}