projen 0.99.2 → 0.99.3

package/node_modules/shelljs/src/which.js

@@ -0,0 +1,119 @@
+var common = require('./common');
+var fs = require('fs');
+var path = require('path');
+
+common.register('which', _which, {
+  allowGlobbing: false,
+  cmdOptions: {
+    'a': 'all',
+  },
+});
+
+// XP's system default value for `PATHEXT` system variable, just in case it's not
+// set on Windows.
+var XP_DEFAULT_PATHEXT = '.com;.exe;.bat;.cmd;.vbs;.vbe;.js;.jse;.wsf;.wsh';
+
+// For earlier versions of NodeJS that doesn't have a list of constants (< v6)
+var FILE_EXECUTABLE_MODE = 1;
+
+function isWindowsPlatform() {
+  return process.platform === 'win32';
+}
+
+// Cross-platform method for splitting environment `PATH` variables
+function splitPath(p) {
+  return p ? p.split(path.delimiter) : [];
+}
+
+// Tests are running all cases for this func but it stays uncovered by codecov due to unknown reason
+/* istanbul ignore next */
+function isExecutable(pathName) {
+  try {
+    // TODO(node-support): replace with fs.constants.X_OK once remove support for node < v6
+    fs.accessSync(pathName, FILE_EXECUTABLE_MODE);
+  } catch (err) {
+    return false;
+  }
+  return true;
+}
+
+function checkPath(pathName) {
+  return fs.existsSync(pathName) && !common.statFollowLinks(pathName).isDirectory()
+    && (isWindowsPlatform() || isExecutable(pathName));
+}
+
+//@
+//@ ### which(command)
+//@
+//@ Examples:
+//@
+//@ ```javascript
+//@ var nodeExec = which('node');
+//@ ```
+//@
+//@ 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 a [ShellString](#shellstringstr) containing the absolute path to
+//@ `command`.
+function _which(options, cmd) {
+  if (!cmd) common.error('must specify command');
+
+  var isWindows = isWindowsPlatform();
+  var pathArray = splitPath(process.env.PATH);
+
+  var queryMatches = [];
+
+  // No relative/absolute paths provided?
+  if (!cmd.includes('/')) {
+    // Assume that there are no extensions to append to queries (this is the
+    // case for unix)
+    var pathExtArray = [''];
+    if (isWindows) {
+      // In case the PATHEXT variable is somehow not set (e.g.
+      // child_process.spawn with an empty environment), use the XP default.
+      var pathExtEnv = process.env.PATHEXT || XP_DEFAULT_PATHEXT;
+      pathExtArray = splitPath(pathExtEnv.toUpperCase());
+    }
+
+    // Search for command in PATH
+    for (var k = 0; k < pathArray.length; k++) {
+      // already found it
+      if (queryMatches.length > 0 && !options.all) break;
+
+      var attempt = path.resolve(pathArray[k], cmd);
+
+      if (isWindows) {
+        attempt = attempt.toUpperCase();
+      }
+
+      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)) {
+          queryMatches.push(attempt);
+          break;
+        }
+      } else { // All-platforms
+        // Cycle through the PATHEXT array, and check each extension
+        // Note: the array is always [''] on Unix
+        for (var i = 0; i < pathExtArray.length; i++) {
+          var ext = pathExtArray[i];
+          var newAttempt = attempt + ext;
+          if (checkPath(newAttempt)) {
+            queryMatches.push(newAttempt);
+            break;
+          }
+        }
+      }
+    }
+  } else if (checkPath(cmd)) { // a valid absolute or relative path
+    queryMatches.push(path.resolve(cmd));
+  }
+
+  if (queryMatches.length > 0) {
+    return options.all ? queryMatches : queryMatches[0];
+  }
+  return options.all ? [] : null;
+}
+module.exports = _which;

package/node_modules/shx/LICENSE

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

package/node_modules/shx/README.md

@@ -0,0 +1,160 @@
+# 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)
+
+`shx` is a wrapper around [ShellJS](https://github.com/shelljs/shelljs) Unix
+commands, providing an easy solution for simple Unix-like, cross-platform
+commands in npm package scripts.
+
+`shx` is proudly tested on every LTS node release since <!-- start minVersion -->`v18`<!-- stop minVersion -->!
+
+## Difference Between ShellJS and shx
+
+- **ShellJS:** Good for writing long scripts, all in JS, running via NodeJS (e.g. `node myScript.js`).
+- **shx:** Good for writing one-off commands in npm package scripts (e.g. `"clean": "shx rm -rf out/"`).
+
+## Install
+
+```shell
+npm install shx --save-dev
+```
+This will allow using `shx` in your `package.json` scripts.
+
+## Usage
+
+### Command Line
+
+If you'd like to use `shx` on the command line, install it globally with the `-g` flag.
+The following code can be run *either a Unix or Windows* command line:
+
+```Bash
+$ shx pwd                       # ShellJS commands are supported automatically
+/home/username/path/to/dir
+
+$ shx ls                        # files are outputted one per line
+file.txt
+file2.txt
+
+$ shx rm *.txt                  # a cross-platform way to delete files!
+
+$ shx ls
+
+$ shx echo "Hi there!"
+Hi there!
+
+$ shx touch helloworld.txt
+
+$ shx cp helloworld.txt foobar.txt
+
+$ shx mkdir sub
+
+$ shx ls
+foobar.txt
+helloworld.txt
+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
+cross-platform compatibility.
+
+### package.json
+
+ShellJS is good for writing long scripts. If you want to write bash-like,
+platform-independent scripts, we recommend you go with that.
+
+However, `shx` is ideal for one-liners inside `package.json`:
+
+```json
+{
+  "scripts": {
+    "clean": "shx rm -rf \"build/**/*.js\" \"build/output\" && shx echo \"Done cleaning\""
+  }
+}
+```
+
+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
+
+Shx exposes [most ShellJS
+commands](https://github.com/shelljs/shelljs#command-reference). If a command is
+not listed here, assume it's supported!
+
+### sed
+
+Shx provides unix-like syntax on top of `shell.sed()`. So ShellJS code like:
+
+```js
+shell.sed('-i', /original string/g, 'replacement', 'filename.txt');
+```
+
+would turn into the following Shx command:
+
+```sh
+shx sed -i "s/original string/replacement/g" filename.txt
+```
+
+**Note:** like unix `sed`, `shx sed` treats `/` as a special character, and
+[this must be
+escaped](https://github.com/shelljs/shx/issues/169#issuecomment-563013849) (as
+`\/` in the shell, or `\\/` in `package.json`) if you intend to use this
+character in either the regex or replacement string. Do **not** escape `/`
+characters in the file path.
+
+### Unsupported Commands
+
+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:
+
+| Unsupported command | Recommend workaround |
+| ------------------- | -------------------- |
+| `shx cd`            | Just use plain old `cd` (it's the same on windows too) |
+| `shx pushd`         | Just use plain old `pushd`. Use forward slashes and double-quote the path. (e.g. `pushd "../docs"`. This would fail on Windows without the quotes) |
+| `shx popd`          | Just use plain old `popd` |
+| `shx dirs`          | No workaround |
+| `shx set`           | See below |
+| `shx exit`          | Just use plain old `exit` |
+| `shx exec`          | Instead of `shx exec cmd`, just use plain old `cmd` |
+| `shx ShellString`   | No workaround (but why would you want this?) |
+
+### Shx options
+
+Shx allows you to modify its behavior by passing arguments. Here's a list of
+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. |
+| 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
+
+| [![Nate Fischer](https://avatars.githubusercontent.com/u/5801521?s=130)](https://github.com/nfischer) | [![Ari Porad](https://avatars1.githubusercontent.com/u/1817508?v=3&s=130)](http://github.com/ariporad) | [![Levi Thomason](https://avatars1.githubusercontent.com/u/5067638?v=3&s=130)](https://github.com/levithomason) |
+|:---:|:---:|:---:|
+| [Nate Fischer](https://github.com/nfischer) | [Ari Porad](http://github.com/ariporad) | [Levi Thomason](https://github.com/levithomason) |

package/node_modules/shx/lib/cli.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+'use strict';
+
+var _minimist = require('minimist');
+
+var _minimist2 = _interopRequireDefault(_minimist);
+
+var _shx = require('./shx');
+
+var _config = require('./config');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var parsedArgs = (0, _minimist2.default)(process.argv.slice(2), { stopEarly: true, boolean: true });
+
+// `input` is null if we're running from a TTY, or a string of all stdin if
+// running from the right-hand side of a pipe
+var run = function run(input) {
+  // Pass stdin to shx as the 'this' parameter
+  process.exitCode = _shx.shx.call(input, process.argv);
+
+  // We use process.exitCode to ensure we don't terminate the process before
+  // streams finish. See:
+  //   https://github.com/shelljs/shx/issues/85
+};
+
+// ShellJS doesn't support input streams, so we have to collect all input first
+if ((0, _config.shouldReadStdin)(parsedArgs._)) {
+  // Read all stdin first, and then pass that onto ShellJS
+  var chunks = [];
+  process.stdin.on('data', function (data) {
+    return chunks.push(data);
+  });
+  process.stdin.on('end', function () {
+    return run(chunks.join(''));
+  });
+} else {
+  // There's no stdin, so we can immediately invoke the ShellJS function
+  run(null);
+}

package/node_modules/shx/lib/config.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shouldReadStdin = exports.SHELLJS_PIPE_INFO = exports.CONFIG_FILE = exports.OPTION_BLOCKLIST = exports.CMD_BLOCKLIST = exports.EXIT_CODES = undefined;
+
+var _minimist = require('minimist');
+
+var _minimist2 = _interopRequireDefault(_minimist);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var EXIT_CODES = exports.EXIT_CODES = {
+  SHX_ERROR: 27, // https://xkcd.com/221/
+  CMD_FAILED: 1, // TODO: Once shelljs/shelljs#269 lands, use `error()`
+  SUCCESS: 0
+};
+
+var CMD_BLOCKLIST = exports.CMD_BLOCKLIST = ['cd', 'pushd', 'popd', 'dirs', 'set', 'exit', 'exec', 'ShellString'];
+
+var OPTION_BLOCKLIST = exports.OPTION_BLOCKLIST = ['globOptions', // we don't have good control over globbing in the shell
+'execPath', // we don't currently support exec
+'bufLength', // we don't use buffers in shx
+'maxdepth'];
+
+var CONFIG_FILE = exports.CONFIG_FILE = '.shxrc.json';
+
+var SHELLJS_PIPE_INFO = exports.SHELLJS_PIPE_INFO = {
+  cat: { minArgs: 1 },
+  grep: { minArgs: 2 },
+  head: { minArgs: 1 },
+  sed: { minArgs: 2 },
+  sort: { minArgs: 1 },
+  tail: { minArgs: 1 },
+  uniq: { minArgs: 1 }
+};
+
+// All valid options
+var allOptionsList = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+
+var shouldReadStdin = exports.shouldReadStdin = function shouldReadStdin(args) {
+  var cmd = args[0];
+  var cmdInfo = SHELLJS_PIPE_INFO[cmd];
+  var parsedArgs = (0, _minimist2.default)(args.slice(1), {
+    stopEarly: true,
+    boolean: allOptionsList // treat all short options as booleans
+  });
+  var requiredNumArgs = cmdInfo ? cmdInfo.minArgs : -1;
+
+  // If a non-boolean option is passed in, increment the required argument
+  // count (this is the case for `-n` for `head` and `tail`)
+  if (parsedArgs.n && (cmd === 'head' || cmd === 'tail')) {
+    requiredNumArgs++;
+  }
+
+  return Boolean(!process.stdin.isTTY && parsedArgs._.length < requiredNumArgs);
+};

package/node_modules/shx/lib/help.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _shelljs = require('shelljs');
+
+var _shelljs2 = _interopRequireDefault(_shelljs);
+
+var _config = require('./config');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Global options defined directly in shx.
+var locallyDefinedOptions = ['version', 'negate'];
+
+var shxOptions = Object.keys(_shelljs2.default.config).filter(function (key) {
+  return typeof _shelljs2.default.config[key] !== 'function';
+}).filter(function (key) {
+  return _config.OPTION_BLOCKLIST.indexOf(key) === -1;
+}).concat(locallyDefinedOptions).map(function (key) {
+  return '    * --' + key;
+});
+
+exports.default = function () {
+  // Note: compute this at runtime so that we have all plugins loaded.
+  var commandList = Object.keys(_shelljs2.default).filter(function (cmd) {
+    return typeof _shelljs2.default[cmd] === 'function';
+  }).filter(function (cmd) {
+    return _config.CMD_BLOCKLIST.indexOf(cmd) === -1;
+  }).map(function (cmd) {
+    return '    * ' + cmd;
+  });
+
+  return '\nshx: A wrapper for shelljs UNIX commands.\n\nUsage: shx [shx-options] <command> [cmd-options] [cmd-args]\n\nExample:\n\n    $ shx ls .\n    foo.txt\n    baz.js\n    $ shx rm -rf *.txt && shx ls .\n    baz.js\n\nCommands:\n\n' + commandList.join('\n') + '\n\nShx Options (please see https://github.com/shelljs/shelljs for details on each\noption):\n\n' + shxOptions.join('\n') + '\n';
+};

package/node_modules/shx/lib/plugin-true-false.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var _plugin = require('shelljs/plugin');
+
+var _plugin2 = _interopRequireDefault(_plugin);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var shellTrue = function shellTrue() {
+  return '';
+};
+
+var shellFalse = function shellFalse() {
+  _plugin2.default.error('', { silent: true });
+};
+
+_plugin2.default.register('true', shellTrue, {
+  allowGlobbing: false,
+  wrapOutput: true
+});
+
+_plugin2.default.register('false', shellFalse, {
+  allowGlobbing: false,
+  wrapOutput: true
+});

package/node_modules/shx/lib/printCmdRet.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+// This function takes the raw result of a shelljs command and figures out how to print it.
+// Invoke this *REGARDLESS* of what the command returns, it will figure it out.
+var printCmdRet = exports.printCmdRet = function printCmdRet(ret) {
+  // Don't print these types
+  if (typeof ret === 'boolean' || !ret) return;
+
+  if (typeof ret.stdout === 'string') {
+    process.stdout.write(ret.stdout);
+  } else {
+    process.stdout.write(ret);
+  }
+};

package/node_modules/shx/lib/shx.js

@@ -0,0 +1,162 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shx = shx;
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+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);
+
+var _config = require('./config');
+
+var _printCmdRet = require('./printCmdRet');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }
+
+_shelljs2.default.help = _help2.default;
+
+var convertSedRegex = function convertSedRegex(args) {
+  var newArgs = [];
+  var lookingForSubstString = true;
+  args.forEach(function (arg) {
+    // A regex or replacement string can be any sequence of zero or more
+    // (a) non-slashes or (b) escaped chars.
+    var escapedChar = '\\\\.'; // This may match an escaped slash (i.e., "\/")
+    var nonSlash = '[^/]';
+    var nonSlashSequence = '(?:' + escapedChar + '|' + nonSlash + ')*';
+    var sedPattern = '^s/(' + nonSlashSequence + ')/(' + nonSlashSequence + ')/(g?)$';
+    var match = arg.match(new RegExp(sedPattern));
+    if (match && lookingForSubstString) {
+      var regexString = match[1].replace(/\\\//g, '/');
+      var replacement = match[2].replace(/\\\//g, '/').replace(/\\./g, '.');
+      var regexFlags = match[3];
+      if (regexString === '') {
+        // Unix sed gives an error if the pattern is the empty string, so we
+        // forbid this case even though JavaScript's .replace() has well-defined
+        // behavior.
+        throw new Error('Bad sed pattern (empty regex)');
+      }
+      newArgs.push(new RegExp(regexString, regexFlags));
+      newArgs.push(replacement);
+      lookingForSubstString = false;
+    } else {
+      newArgs.push(arg);
+    }
+  });
+  return newArgs;
+};
+
+function shx(argv) {
+  var parsedArgs = (0, _minimist2.default)(argv.slice(2), { stopEarly: true, boolean: true });
+  if (parsedArgs.version) {
+    var shxVersion = require('../package.json').version;
+    var shelljsVersion = require('shelljs/package.json').version;
+    console.log('shx v' + shxVersion + ' (using ShellJS v' + shelljsVersion + ')');
+    return _config.EXIT_CODES.SUCCESS;
+  }
+
+  var _parsedArgs$_ = _toArray(parsedArgs._),
+      fnName = _parsedArgs$_[0],
+      args = _parsedArgs$_.slice(1);
+
+  if (!fnName) {
+    console.error('Error: Missing ShellJS command name');
+    console.error((0, _help2.default)());
+    return _config.EXIT_CODES.SHX_ERROR;
+  }
+
+  // Load ShellJS plugins
+  var CONFIG_PATH = _path2.default.join(process.cwd(), _config.CONFIG_FILE);
+  if (_fs2.default.existsSync(CONFIG_PATH)) {
+    var shxConfig = void 0;
+    try {
+      shxConfig = require(CONFIG_PATH);
+    } catch (e) {
+      throw new Error('Unable to read config file ' + _config.CONFIG_FILE);
+    }
+
+    (shxConfig.plugins || []).forEach(function (pluginName) {
+      try {
+        require(pluginName);
+      } catch (e) {
+        throw new Error('Unable to find plugin \'' + pluginName + '\'');
+      }
+    });
+  }
+
+  // Always load true-false plugin
+  require('./plugin-true-false');
+
+  // validate command
+  if (typeof _shelljs2.default[fnName] !== 'function') {
+    console.error('Error: Invalid ShellJS command: ' + fnName + '.');
+    console.error((0, _help2.default)());
+    return _config.EXIT_CODES.SHX_ERROR;
+  } else if (_config.CMD_BLOCKLIST.indexOf(fnName) > -1) {
+    console.error('Warning: shx ' + fnName + ' is not supported');
+    console.error('Please run `shx help` for a list of commands.');
+    return _config.EXIT_CODES.SHX_ERROR;
+  }
+
+  var input = this !== null ? new _shelljs2.default.ShellString(this) : null;
+
+  // Set shell.config with parsed options
+  Object.assign(_shelljs2.default.config, parsedArgs);
+
+  // Workaround for sed syntax
+  var ret = void 0;
+  if (fnName === 'sed') {
+    var newArgs = convertSedRegex(args);
+    ret = _shelljs2.default[fnName].apply(input, newArgs);
+  } else {
+    ret = _shelljs2.default[fnName].apply(input, args);
+  }
+  if (ret === null) ret = _shelljs2.default.ShellString('', '', 1);
+
+  /* instanbul ignore next */
+  var code = Object.prototype.hasOwnProperty.call(ret, 'code') && ret.code;
+
+  if ((fnName === 'pwd' || fnName === 'which') && !ret.match(/\n$/) && ret.length > 1) {
+    ret += '\n';
+  }
+
+  // echo already prints
+  if (fnName !== 'echo') (0, _printCmdRet.printCmdRet)(ret);
+  if (typeof ret === 'boolean') {
+    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()) {
+    /* istanbul ignore next */
+    return _config.EXIT_CODES.CMD_FAILED;
+  }
+
+  return _config.EXIT_CODES.SUCCESS;
+}