From 85f54908bfbc317cae9dc5b74c26a9e31b9bbbc2 Mon Sep 17 00:00:00 2001
From: Jan Krems <jan.krems@groupon.com>
Date: Sun, 11 Dec 2016 14:36:58 -0800
Subject: [PATCH] deps: add node-inspect 1.10.2

Squashed from:

- deps: Add node-inspect 1.10.1

This adds a reimplementation of the old CLI debugger (`node debug`)
against the new debugger protocol (`node --inspect`). This is necessary
because the old protocol won't be supported in future versions of V8.

- deps: Update node-inspect to 1.10.2

Starting with 1.10.2 the test suite should pass consistently on
windows.

- deps: Update to node-inspect 1.10.4

PR-URL: https://github.com/nodejs/node/pull/10187
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 deps/node-inspect/.editorconfig               |   11 +
 deps/node-inspect/.eslintrc                   |  147 +++
 deps/node-inspect/.gitignore                  |    4 +
 deps/node-inspect/.npmrc                      |    1 +
 deps/node-inspect/.travis.yml                 |   13 +
 deps/node-inspect/CHANGELOG.md                |  212 ++++
 deps/node-inspect/CONTRIBUTING.md             |  183 +++
 deps/node-inspect/GOVERNANCE.md               |    5 +
 deps/node-inspect/LICENSE                     |   19 +
 deps/node-inspect/README.md                   |   29 +
 deps/node-inspect/appveyor.yml                |   13 +
 deps/node-inspect/cli.js                      |    2 +
 deps/node-inspect/examples/alive.js           |    6 +
 deps/node-inspect/examples/backtrace.js       |   31 +
 deps/node-inspect/examples/break.js           |   16 +
 deps/node-inspect/examples/cjs/index.js       |    5 +
 deps/node-inspect/examples/cjs/other.js       |    4 +
 deps/node-inspect/examples/empty.js           |    0
 deps/node-inspect/examples/exceptions.js      |   11 +
 deps/node-inspect/examples/three-lines.js     |    4 +
 deps/node-inspect/lib/_inspect.js             |  283 +++++
 deps/node-inspect/lib/cli.js                  |   24 +
 .../lib/internal/inspect_client.js            |  363 ++++++
 .../node-inspect/lib/internal/inspect_repl.js | 1057 +++++++++++++++++
 deps/node-inspect/package.json                |   45 +
 deps/node-inspect/test/cli/backtrace.test.js  |   30 +
 deps/node-inspect/test/cli/break.test.js      |  195 +++
 deps/node-inspect/test/cli/exceptions.test.js |   63 +
 deps/node-inspect/test/cli/exec.test.js       |   77 ++
 deps/node-inspect/test/cli/help.test.js       |   22 +
 .../test/cli/invalid-args.test.js             |   25 +
 deps/node-inspect/test/cli/launch.test.js     |  110 ++
 deps/node-inspect/test/cli/low-level.test.js  |   31 +
 .../test/cli/preserve-breaks.test.js          |   56 +
 deps/node-inspect/test/cli/profile.test.js    |   32 +
 deps/node-inspect/test/cli/scripts.test.js    |   43 +
 deps/node-inspect/test/cli/start-cli.js       |  136 +++
 deps/node-inspect/test/cli/watchers.test.js   |   42 +
 deps/node-inspect/test/node-inspect.test.js   |    9 +
 .../eslint-rules/align-function-arguments.js  |   76 ++
 .../align-multiline-assignment.js             |   68 ++
 .../assert-fail-single-argument.js            |   30 +
 .../tools/eslint-rules/buffer-constructor.js  |   25 +
 .../tools/eslint-rules/new-with-error.js      |   31 +
 .../eslint-rules/no-let-in-for-declaration.js |   46 +
 .../eslint-rules/prefer-assert-methods.js     |   39 +
 .../tools/eslint-rules/require-buffer.js      |   19 +
 .../tools/eslint-rules/required-modules.js    |   99 ++
 48 files changed, 3792 insertions(+)
 create mode 100644 deps/node-inspect/.editorconfig
 create mode 100644 deps/node-inspect/.eslintrc
 create mode 100644 deps/node-inspect/.gitignore
 create mode 100644 deps/node-inspect/.npmrc
 create mode 100644 deps/node-inspect/.travis.yml
 create mode 100644 deps/node-inspect/CHANGELOG.md
 create mode 100644 deps/node-inspect/CONTRIBUTING.md
 create mode 100644 deps/node-inspect/GOVERNANCE.md
 create mode 100644 deps/node-inspect/LICENSE
 create mode 100644 deps/node-inspect/README.md
 create mode 100644 deps/node-inspect/appveyor.yml
 create mode 100755 deps/node-inspect/cli.js
 create mode 100644 deps/node-inspect/examples/alive.js
 create mode 100644 deps/node-inspect/examples/backtrace.js
 create mode 100644 deps/node-inspect/examples/break.js
 create mode 100644 deps/node-inspect/examples/cjs/index.js
 create mode 100644 deps/node-inspect/examples/cjs/other.js
 create mode 100644 deps/node-inspect/examples/empty.js
 create mode 100644 deps/node-inspect/examples/exceptions.js
 create mode 100644 deps/node-inspect/examples/three-lines.js
 create mode 100644 deps/node-inspect/lib/_inspect.js
 create mode 100644 deps/node-inspect/lib/cli.js
 create mode 100644 deps/node-inspect/lib/internal/inspect_client.js
 create mode 100644 deps/node-inspect/lib/internal/inspect_repl.js
 create mode 100644 deps/node-inspect/package.json
 create mode 100644 deps/node-inspect/test/cli/backtrace.test.js
 create mode 100644 deps/node-inspect/test/cli/break.test.js
 create mode 100644 deps/node-inspect/test/cli/exceptions.test.js
 create mode 100644 deps/node-inspect/test/cli/exec.test.js
 create mode 100644 deps/node-inspect/test/cli/help.test.js
 create mode 100644 deps/node-inspect/test/cli/invalid-args.test.js
 create mode 100644 deps/node-inspect/test/cli/launch.test.js
 create mode 100644 deps/node-inspect/test/cli/low-level.test.js
 create mode 100644 deps/node-inspect/test/cli/preserve-breaks.test.js
 create mode 100644 deps/node-inspect/test/cli/profile.test.js
 create mode 100644 deps/node-inspect/test/cli/scripts.test.js
 create mode 100644 deps/node-inspect/test/cli/start-cli.js
 create mode 100644 deps/node-inspect/test/cli/watchers.test.js
 create mode 100644 deps/node-inspect/test/node-inspect.test.js
 create mode 100644 deps/node-inspect/tools/eslint-rules/align-function-arguments.js
 create mode 100644 deps/node-inspect/tools/eslint-rules/align-multiline-assignment.js
 create mode 100644 deps/node-inspect/tools/eslint-rules/assert-fail-single-argument.js
 create mode 100644 deps/node-inspect/tools/eslint-rules/buffer-constructor.js
 create mode 100644 deps/node-inspect/tools/eslint-rules/new-with-error.js
 create mode 100644 deps/node-inspect/tools/eslint-rules/no-let-in-for-declaration.js
 create mode 100644 deps/node-inspect/tools/eslint-rules/prefer-assert-methods.js
 create mode 100644 deps/node-inspect/tools/eslint-rules/require-buffer.js
 create mode 100644 deps/node-inspect/tools/eslint-rules/required-modules.js

diff --git a/deps/node-inspect/.editorconfig b/deps/node-inspect/.editorconfig
new file mode 100644
index 00000000000000..beffa3084e7a69
--- /dev/null
+++ b/deps/node-inspect/.editorconfig
@@ -0,0 +1,11 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
diff --git a/deps/node-inspect/.eslintrc b/deps/node-inspect/.eslintrc
new file mode 100644
index 00000000000000..c731203df64fd7
--- /dev/null
+++ b/deps/node-inspect/.eslintrc
@@ -0,0 +1,147 @@
+root: true
+
+env:
+  node: true
+  es6: true
+
+parserOptions:
+  ecmaVersion: 2016
+
+rules:
+  # Possible Errors
+  # http://eslint.org/docs/rules/#possible-errors
+  comma-dangle: [2, only-multiline]
+  no-control-regex: 2
+  no-debugger: 2
+  no-dupe-args: 2
+  no-dupe-keys: 2
+  no-duplicate-case: 2
+  no-empty-character-class: 2
+  no-ex-assign: 2
+  no-extra-boolean-cast: 2
+  no-extra-parens: [2, functions]
+  no-extra-semi: 2
+  no-func-assign: 2
+  no-invalid-regexp: 2
+  no-irregular-whitespace: 2
+  no-obj-calls: 2
+  no-proto: 2
+  no-template-curly-in-string: 2
+  no-unexpected-multiline: 2
+  no-unreachable: 2
+  no-unsafe-negation: 2
+  use-isnan: 2
+  valid-typeof: 2
+
+  # Best Practices
+  # http://eslint.org/docs/rules/#best-practices
+  dot-location: [2, property]
+  no-fallthrough: 2
+  no-global-assign: 2
+  no-multi-spaces: 2
+  no-octal: 2
+  no-redeclare: 2
+  no-self-assign: 2
+  no-unused-labels: 2
+  no-useless-call: 2
+  no-useless-escape: 2
+  no-void: 2
+  no-with: 2
+
+  # Strict Mode
+  # http://eslint.org/docs/rules/#strict-mode
+  strict: [2, global]
+
+  # Variables
+  # http://eslint.org/docs/rules/#variables
+  no-delete-var: 2
+  no-undef: 2
+  no-unused-vars: [2, {args: none}]
+
+  # Node.js and CommonJS
+  # http://eslint.org/docs/rules/#nodejs-and-commonjs
+  no-mixed-requires: 2
+  no-new-require: 2
+  no-path-concat: 2
+  no-restricted-modules: [2, sys, _linklist]
+  no-restricted-properties: [2, {
+    object: assert,
+    property: deepEqual,
+    message: Please use assert.deepStrictEqual().
+  }, {
+    property: __defineGetter__,
+    message: __defineGetter__ is deprecated.
+  }, {
+    property: __defineSetter__,
+    message: __defineSetter__ is deprecated.
+  }]
+
+  # Stylistic Issues
+  # http://eslint.org/docs/rules/#stylistic-issues
+  brace-style: [2, 1tbs, {allowSingleLine: true}]
+  comma-spacing: 2
+  comma-style: 2
+  computed-property-spacing: 2
+  eol-last: 2
+  func-call-spacing: 2
+  func-name-matching: 2
+  indent: [2, 2, {SwitchCase: 1, MemberExpression: 1}]
+  key-spacing: [2, {mode: minimum}]
+  keyword-spacing: 2
+  linebreak-style: [2, unix]
+  max-len: [2, 80, 2]
+  new-parens: 2
+  no-mixed-spaces-and-tabs: 2
+  no-multiple-empty-lines: [2, {max: 2, maxEOF: 0, maxBOF: 0}]
+  no-tabs: 2
+  no-trailing-spaces: 2
+  quotes: [2, single, avoid-escape]
+  semi: 2
+  semi-spacing: 2
+  space-before-blocks: [2, always]
+  space-before-function-paren: [2, never]
+  space-in-parens: [2, never]
+  space-infix-ops: 2
+  space-unary-ops: 2
+
+  # ECMAScript 6
+  # http://eslint.org/docs/rules/#ecmascript-6
+  arrow-parens: [2, always]
+  arrow-spacing: [2, {before: true, after: true}]
+  constructor-super: 2
+  no-class-assign: 2
+  no-confusing-arrow: 2
+  no-const-assign: 2
+  no-dupe-class-members: 2
+  no-new-symbol: 2
+  no-this-before-super: 2
+  prefer-const: [2, {ignoreReadBeforeAssign: true}]
+  rest-spread-spacing: 2
+  template-curly-spacing: 2
+
+  # Custom rules in tools/eslint-rules
+  align-function-arguments: 2
+  align-multiline-assignment: 2
+  assert-fail-single-argument: 2
+  new-with-error: [2, Error, RangeError, TypeError, SyntaxError, ReferenceError]
+
+# Global scoped method and vars
+globals:
+  COUNTER_HTTP_CLIENT_REQUEST: false
+  COUNTER_HTTP_CLIENT_RESPONSE: false
+  COUNTER_HTTP_SERVER_REQUEST: false
+  COUNTER_HTTP_SERVER_RESPONSE: false
+  COUNTER_NET_SERVER_CONNECTION: false
+  COUNTER_NET_SERVER_CONNECTION_CLOSE: false
+  DTRACE_HTTP_CLIENT_REQUEST: false
+  DTRACE_HTTP_CLIENT_RESPONSE: false
+  DTRACE_HTTP_SERVER_REQUEST: false
+  DTRACE_HTTP_SERVER_RESPONSE: false
+  DTRACE_NET_SERVER_CONNECTION: false
+  DTRACE_NET_STREAM_END: false
+  LTTNG_HTTP_CLIENT_REQUEST: false
+  LTTNG_HTTP_CLIENT_RESPONSE: false
+  LTTNG_HTTP_SERVER_REQUEST: false
+  LTTNG_HTTP_SERVER_RESPONSE: false
+  LTTNG_NET_SERVER_CONNECTION: false
+  LTTNG_NET_STREAM_END: false
diff --git a/deps/node-inspect/.gitignore b/deps/node-inspect/.gitignore
new file mode 100644
index 00000000000000..72e2c8c18012a8
--- /dev/null
+++ b/deps/node-inspect/.gitignore
@@ -0,0 +1,4 @@
+node_modules/
+npm-debug.log
+/tmp
+/.vs
diff --git a/deps/node-inspect/.npmrc b/deps/node-inspect/.npmrc
new file mode 100644
index 00000000000000..38f11c645a0019
--- /dev/null
+++ b/deps/node-inspect/.npmrc
@@ -0,0 +1 @@
+registry=https://registry.npmjs.org
diff --git a/deps/node-inspect/.travis.yml b/deps/node-inspect/.travis.yml
new file mode 100644
index 00000000000000..07418a91eb7986
--- /dev/null
+++ b/deps/node-inspect/.travis.yml
@@ -0,0 +1,13 @@
+language: node_js
+node_js:
+  - '6.8'
+before_deploy:
+  - git config --global user.email "jan.krems@gmail.com"
+  - git config --global user.name "Jan Krems"
+deploy:
+  provider: script
+  script: ./node_modules/.bin/nlm release
+  skip_cleanup: true
+  'on':
+    branch: master
+    node: '6.8'
diff --git a/deps/node-inspect/CHANGELOG.md b/deps/node-inspect/CHANGELOG.md
new file mode 100644
index 00000000000000..0a7ba1be94fb50
--- /dev/null
+++ b/deps/node-inspect/CHANGELOG.md
@@ -0,0 +1,212 @@
+### 1.10.4
+
+* [`1c31bf7`](https://github.com/buggerjs/node-inspect/commit/1c31bf7d1b3ea1b424ae0662526596670cb506c9) **chore:** Support embedded mode
+
+
+### 1.10.3
+
+* [`7b20379`](https://github.com/buggerjs/node-inspect/commit/7b20379069af692a9038a31a4465f72db9eb532f) **chore:** Mark .eslintrc as root
+
+
+### 1.10.2
+
+* Run tests on windows - **[@jkrems](https://github.com/jkrems)** [#16](https://github.com/buggerjs/node-inspect/pull/16)
+  - [`5a57f98`](https://github.com/buggerjs/node-inspect/commit/5a57f9865e02eef0763c2a7f26236c34a632ccdd) **chore:** Run tests on windows
+  - [`0a04b50`](https://github.com/buggerjs/node-inspect/commit/0a04b50cc8b4dc6ce868927c635c479d75ce71f4) **chore:** Bump nlm to get rid of postinstall
+  - [`4a8b27c`](https://github.com/buggerjs/node-inspect/commit/4a8b27cea814a37895effd2a0c1b85dbfee3a7f4) **test:** Remove unix path assumptions
+
+
+### 1.10.1
+
+* [`4ba3c72`](https://github.com/buggerjs/node-inspect/commit/4ba3c72270fae9a71343ddca11aa27980678a67c) **refactor:** Undo weird bundling into one file
+
+
+### 1.10.0
+
+* [`3e1a66a`](https://github.com/buggerjs/node-inspect/commit/3e1a66a489bef19beaa5f859e99e027274ff43cb) **feat:** Support CPU & heap profiles
+
+
+### 1.9.3
+
+* Move back to single file - **[@jkrems](https://github.com/jkrems)** [#15](https://github.com/buggerjs/node-inspect/pull/15)
+  - [`9877660`](https://github.com/buggerjs/node-inspect/commit/9877660a73ff0ec0885ad7f939ba62020a46b4b6) **refactor:** Wrap client in IIFE
+  - [`7795c53`](https://github.com/buggerjs/node-inspect/commit/7795c533f0605eb128db610a5874b27e555251ef) **refactor:** Move more code in createRepl scope
+  - [`be34a39`](https://github.com/buggerjs/node-inspect/commit/be34a398e823612bdf5ac90bad5222af27035a00) **refactor:** Move back to single file
+  - [`ab45b62`](https://github.com/buggerjs/node-inspect/commit/ab45b6273dc0d3a49d3cf46a80cb48ab79d1caf8) **refactor:** Remove single-use functions
+  - [`37a711e`](https://github.com/buggerjs/node-inspect/commit/37a711ed5334c06ed4d85f995e567a9f176a68d5) **style:** Stop using `new Buffer`
+  - [`d669dc5`](https://github.com/buggerjs/node-inspect/commit/d669dc593f5ad5ca7a48f19f0905ef66ec0e540d) **chore:** Switch to node eslint rules
+  - [`15e7917`](https://github.com/buggerjs/node-inspect/commit/15e79177918d96dcffd2384715faf0308e97a26c) **style:** Use var in classical for loops
+
+
+### 1.9.2
+
+* [`c9dc4be`](https://github.com/buggerjs/node-inspect/commit/c9dc4beb08236e33d64f19417682cf5b3f5aeed6) **doc:** Link directly to GOVERNANCE file
+
+
+### 1.9.1
+
+* Handle big ws frames correctly - **[@jkrems](https://github.com/jkrems)** [#14](https://github.com/buggerjs/node-inspect/pull/14)
+  - [`f80100e`](https://github.com/buggerjs/node-inspect/commit/f80100e932710d232d074b239cbf8fefa564c789) **fix:** Handle big ws frames correctly - see: [#10](https://github.com/buggerjs/node-inspect/issues/10)
+
+
+### 1.9.0
+
+* Support for low-level agent access - **[@jkrems](https://github.com/jkrems)** [#13](https://github.com/buggerjs/node-inspect/pull/13)
+  - [`90ed431`](https://github.com/buggerjs/node-inspect/commit/90ed4310c62d130637c12f8ecdb752075c43ac36) **feat:** Support for low-level agent access
+
+
+### 1.8.4
+
+* Use proper path for websocket - **[@jkrems](https://github.com/jkrems)** [#12](https://github.com/buggerjs/node-inspect/pull/12)
+  - [`3405225`](https://github.com/buggerjs/node-inspect/commit/3405225979dfc2058bcc6d1b90f41c060dbd1f92) **fix:** Use proper path for websocket - see: [#11](https://github.com/buggerjs/node-inspect/issues/11)
+
+
+### 1.8.3
+
+* [`6f9883d`](https://github.com/buggerjs/node-inspect/commit/6f9883d4b29419831133988981b83e891b19739a) **fix:** Breakpoints & scripts work when not paused
+* [`ecb1362`](https://github.com/buggerjs/node-inspect/commit/ecb1362c842e6ed5bc28c091a32bfd540742db75) **chore:** Pin node to 6.8
+
+
+### 1.8.2
+
+* [`4219a98`](https://github.com/buggerjs/node-inspect/commit/4219a98d6514f1068feabce2945c21a0d5ba6561) **refactor:** Decouple source snippet from repl
+
+
+### 1.8.1
+
+* [`95402ee`](https://github.com/buggerjs/node-inspect/commit/95402ee5dff04057f074677d39db2f61ec74c151) **refactor:** Move `list` into CallFrame
+
+
+### 1.8.0
+
+* [`d0e6499`](https://github.com/buggerjs/node-inspect/commit/d0e6499084f5d656ef0c5fd470d3ab21f2e9a6b4) **feat:** `exec .scope`
+
+
+### 1.7.0
+
+* `breakOn{Exception,Uncaught,None}` - **[@jkrems](https://github.com/jkrems)** [#8](https://github.com/buggerjs/node-inspect/pull/8)
+  - [`fa8c4c7`](https://github.com/buggerjs/node-inspect/commit/fa8c4c7d7bb6972733c92da4d04fdd62c02b0e3b) **feat:** `breakOn{Exception,Uncaught,None}` - see: [#6](https://github.com/buggerjs/node-inspect/issues/6)
+
+
+### 1.6.0
+
+* Add `help` command - **[@jkrems](https://github.com/jkrems)** [#7](https://github.com/buggerjs/node-inspect/pull/7)
+  - [`09b37a0`](https://github.com/buggerjs/node-inspect/commit/09b37a02e04e16a38ce27f69538d3b098548b47c) **feat:** Add `help` command - see: [#5](https://github.com/buggerjs/node-inspect/issues/5)
+
+
+### 1.5.0
+
+* [`7e0fd99`](https://github.com/buggerjs/node-inspect/commit/7e0fd99fcfc65d8b647a2259df78f4cabf1d3d63) **feat:** Add `r` shortcut for `run`
+
+
+### 1.4.1
+
+* [`484d098`](https://github.com/buggerjs/node-inspect/commit/484d0983f06d6ff9639ab5197ba0a58313f532df) **chore:** Remove old implementation
+
+
+### 1.4.0
+
+* Properly tested implementation - **[@jkrems](https://github.com/jkrems)** [#4](https://github.com/buggerjs/node-inspect/pull/4)
+  - [`ba060d3`](https://github.com/buggerjs/node-inspect/commit/ba060d3ef65ae84df2a3a9b9f16d563f3c4b29be) **feat:** Error handling w/o args
+  - [`b39b3bc`](https://github.com/buggerjs/node-inspect/commit/b39b3bc07c13adc48fc8bb720889285c51e62548) **feat:** Launch child
+  - [`481693f`](https://github.com/buggerjs/node-inspect/commit/481693f676ee099b7787cd2426b980858e973602) **feat:** Connect debug client
+  - [`3bba0f2`](https://github.com/buggerjs/node-inspect/commit/3bba0f2416b2e3b4e6010de675003fcc328b16e8) **chore:** Disable lint for inactive code
+  - [`cc7bdfc`](https://github.com/buggerjs/node-inspect/commit/cc7bdfcf7f21ef5cd5c32c7800407238b0d4f100) **feat:** Properly fail with invalid host:port
+  - [`73f34f9`](https://github.com/buggerjs/node-inspect/commit/73f34f902634e9778597e129f46895aa8b643d72) **refactor:** Remove unused field
+  - [`6a23e0c`](https://github.com/buggerjs/node-inspect/commit/6a23e0cf3179f43ca6fc5a0fa2b1dd18ebc044b5) **refactor:** Better debug output & support node 6.6
+  - [`63b0f9b`](https://github.com/buggerjs/node-inspect/commit/63b0f9b6ef8bd9af0f7cb14a5938a45838731fc9) **test:** Add timeout to waitFor(pattern)
+  - [`cfa197b`](https://github.com/buggerjs/node-inspect/commit/cfa197bf8325a1a4ca1b296f8d6971d368bfbfbb) **refactor:** Move REPL setup into own file
+  - [`3f46c2c`](https://github.com/buggerjs/node-inspect/commit/3f46c2c43f836e1135b66871087aa74969f6b330) **feat:** Working repl eval
+  - [`6911eb1`](https://github.com/buggerjs/node-inspect/commit/6911eb1a00b964bc5683506d433fa4f665f5a82c) **feat:** Enter repeats last command
+  - [`7d20b7d`](https://github.com/buggerjs/node-inspect/commit/7d20b7deadf1b251ea8cf2cc9167c175624932c4) **chore:** Add missing license header
+  - [`23c62f8`](https://github.com/buggerjs/node-inspect/commit/23c62f8375ca7c8b71d032047e728dace02f4efa) **feat:** Print break context
+  - [`5dbc83d`](https://github.com/buggerjs/node-inspect/commit/5dbc83df31171f9c38a974c99340bde26f2e24ec) **feat:** Stepping and breakpoints
+  - [`8deb8cc`](https://github.com/buggerjs/node-inspect/commit/8deb8cc36b9fca432ab8df63a82e9de7ab5adaf0) **feat:** list for printing source
+  - [`1ed2ec9`](https://github.com/buggerjs/node-inspect/commit/1ed2ec9937070652be611dbb6b11dfb42cb840f8) **chore:** Disable verbose output on CI
+  - [`625a435`](https://github.com/buggerjs/node-inspect/commit/625a435925dd8fd980bed2dc9e3fd73dd27df4ef) **fix:** Gracefully handle delayed scriptParsed
+  - [`8823c60`](https://github.com/buggerjs/node-inspect/commit/8823c60d347600b2313cfdd8cb5e96fe02419a8a) **chore:** Run all the tests
+  - [`00506f7`](https://github.com/buggerjs/node-inspect/commit/00506f763928cc440505a81030167a11b9a84e00) **feat:** backtrace/bt
+  - [`e1ee02d`](https://github.com/buggerjs/node-inspect/commit/e1ee02d5cc389916489d387d07d5dd161230427a) **refactor:** Leverage util.inspect.custom
+  - [`5dcc319`](https://github.com/buggerjs/node-inspect/commit/5dcc31922d40f56c7435319d1538390a442e8e4b) **feat:** scripts and scripts(true)
+  - [`085cd5a`](https://github.com/buggerjs/node-inspect/commit/085cd5a76a961edfcaa342fff5eb09bf2f9c8983) **refactor:** Consistent import style
+  - [`1c60f91`](https://github.com/buggerjs/node-inspect/commit/1c60f91f233848c05d865617dc7f5aacb36270b6) **feat:** Set breakpoint before file is loaded
+  - [`bc82ecc`](https://github.com/buggerjs/node-inspect/commit/bc82eccb2a1a7c0f5332371254f6584e748216aa) **feat:** breakpoints to list breakpoints
+  - [`7f48c95`](https://github.com/buggerjs/node-inspect/commit/7f48c9510696ec400d51afaca8d23a9c292640f8) **feat:** watchers & exec
+  - [`0f8cd13`](https://github.com/buggerjs/node-inspect/commit/0f8cd13a092e5dbeb395ff04cbe2ed97cb986423) **feat:** clearBreakpoint
+  - [`0d31560`](https://github.com/buggerjs/node-inspect/commit/0d315603bdcb9f4da42fab24dc569c325151269e) **feat:** version to print v8 version
+  - [`df6b89d`](https://github.com/buggerjs/node-inspect/commit/df6b89df580a9afcb3b8883b0e4224cbcebb384f) **feat:** Paused & global exec
+  - [`9e97d73`](https://github.com/buggerjs/node-inspect/commit/9e97d73073ceffd70974d45887c84fadb9159d5c) **feat:** repl to enter exec mode
+  - [`9ee9f90`](https://github.com/buggerjs/node-inspect/commit/9ee9f903d6202f54ed2b3b3559da4006b65d39b5) **feat:** run & restart
+* [`3a752aa`](https://github.com/buggerjs/node-inspect/commit/3a752aaa773968bfe16c5f543bd739feed598bea) **feat:** kill
+* [`a67e470`](https://github.com/buggerjs/node-inspect/commit/a67e47018b20d46aeeaa7abd27eb8e7770fd0b8f) **feat:** Restore breakpoints on restart
+
+
+### 1.3.3
+
+* [`eb7a54c`](https://github.com/buggerjs/node-inspect/commit/eb7a54c6fa731ed3276072c72034046fc5ffbac6) **chore:** Switch to tap for tests
+
+
+### 1.3.2
+
+* Add notes about governance - **[@jkrems](https://github.com/jkrems)** [#3](https://github.com/buggerjs/node-inspect/pull/3)
+  - [`e94089d`](https://github.com/buggerjs/node-inspect/commit/e94089d93689cacf5c953e94563463d1e174452d) **chore:** Add notes about governance
+
+
+### 1.3.1
+
+* [`8767137`](https://github.com/buggerjs/node-inspect/commit/8767137c53a2f6b1d36970074ea95be9871e50e3) **style:** Remove rogue console.log
+
+
+### 1.3.0
+
+* [`3ac6232`](https://github.com/buggerjs/node-inspect/commit/3ac623219ba44b0af40ef66826610a26a46c7966) **feat:** Add `version` command
+
+
+### 1.2.0
+
+* [`86b5812`](https://github.com/buggerjs/node-inspect/commit/86b581218ccab44e6bde259a17ad1e71645a6137) **feat:** scripts & listScripts(true)
+
+
+### 1.1.1
+
+* [`feaea38`](https://github.com/buggerjs/node-inspect/commit/feaea385a981e6b72a8d99277fbf575c54e15fc6) **style:** Typo in comment
+
+
+### 1.1.0
+
+* [`c64155f`](https://github.com/buggerjs/node-inspect/commit/c64155faa552f71463842a26330aa5bcbfc31670) **feat:** repl command
+
+
+### 1.0.0
+
+* [`44c4c79`](https://github.com/buggerjs/node-inspect/commit/44c4c79af5a228ccfd8906f11409b2a33390b878) **chore:** Initial commit
+* [`985873c`](https://github.com/buggerjs/node-inspect/commit/985873cfb97146b38480080f9907219c473f1f6f) **feat:** Launching the example works
+* [`3d92d05`](https://github.com/buggerjs/node-inspect/commit/3d92d05cca152a2c2647aa64eefc80432638bc4d) **chore:** Proper license and passing tests
+* [`b3f99d9`](https://github.com/buggerjs/node-inspect/commit/b3f99d981038b17663fcfd984d2f5d6d9b51ee18) **feat:** Futile attempts to send a valid ws frame
+* [`465cfb7`](https://github.com/buggerjs/node-inspect/commit/465cfb7b295aebb48b285c26f6de9c4657fe590d) **feat:** Working ws connection
+* [`da9f011`](https://github.com/buggerjs/node-inspect/commit/da9f01118e2b144f2da8cd370113a608526774a1) **fix:** Fix remote connect
+* [`5ef33d7`](https://github.com/buggerjs/node-inspect/commit/5ef33d7892cc49becb4c66098fc7927bc74b014a) **feat:** Working step-by-step
+* [`534e1e4`](https://github.com/buggerjs/node-inspect/commit/534e1e46b307d61d51eb4c0aab4a3b17c17aea3d) **chore:** Add bin entry
+* [`8cff9cf`](https://github.com/buggerjs/node-inspect/commit/8cff9cfb0138b5ecff0f5f6a7839dbfddc0684fd) **style:** Use simpler key thingy
+* [`720ec53`](https://github.com/buggerjs/node-inspect/commit/720ec53a5b251ab3caf27f06b60924efb9e03a92) **doc:** Add instructions
+* [`b89ad60`](https://github.com/buggerjs/node-inspect/commit/b89ad601b885a417e6433b1609477d8453f498a1) **doc:** More helpful docs
+* [`de9243c`](https://github.com/buggerjs/node-inspect/commit/de9243c95eabe733d05952229340808c3cebf129) **feat:** Watchers
+* [`e16978f`](https://github.com/buggerjs/node-inspect/commit/e16978ff8e4b2b2bdccf88fd7d3905f525822981) **docs:** Working usage hints
+* [`2dbc204`](https://github.com/buggerjs/node-inspect/commit/2dbc2042145fd97169fc7536186a449715e27810) **refactor:** Use proxies
+* [`b8c9b14`](https://github.com/buggerjs/node-inspect/commit/b8c9b147713f63181396d5a7fe4c2f737b733b4c) **style:** Remove unused var
+* [`f6b4b20`](https://github.com/buggerjs/node-inspect/commit/f6b4b20a1d28d91cfe452b995f7dbe5f7c749e89) **feat:** Nicer inspect of remote values
+* [`36887c6`](https://github.com/buggerjs/node-inspect/commit/36887c66bbf26d540f087f80ddfec38462a33bdf) **fix:** Properly print watchers
+* [`7729442`](https://github.com/buggerjs/node-inspect/commit/77294426157a28cc76e339cb13916a205182641e) **feat:** Add pause command
+* [`e39a713`](https://github.com/buggerjs/node-inspect/commit/e39a7134873f06da37baaa9b6252cede4ad38d7a) **fix:** Properly format boolean properties
+* [`f8f51d7`](https://github.com/buggerjs/node-inspect/commit/f8f51d7a01e8d74023306a08a3d6e2da63d123e1) **fix:** Properly format numeric properties
+* [`89e6e08`](https://github.com/buggerjs/node-inspect/commit/89e6e087220f3c3cb628ac7541c44298485a2e04) **feat:** Add backtrace command
+* [`82362ac`](https://github.com/buggerjs/node-inspect/commit/82362acfc7ce22b4cccc64889ec136dedc8895ec) **feat:** Add setBreakpoint()
+* [`7064cce`](https://github.com/buggerjs/node-inspect/commit/7064ccec3b103683088d532abfe5b4e7c066948b) **feat:** Add `setBreakpoint(line)`
+* [`360580e`](https://github.com/buggerjs/node-inspect/commit/360580eba4353e81311e56df018eec0ca233da11) **feat:** Add run/kill/restart
+* [`b1b576e`](https://github.com/buggerjs/node-inspect/commit/b1b576e2645723a8575df544e0bfb672d60d9d91) **feat:** Add `help` command
+* [`2db4660`](https://github.com/buggerjs/node-inspect/commit/2db46609cd1c8543d31ebd5dc47e4c27ec254841) **feat:** Add remaining sb() variants
+* [`f2ad1ae`](https://github.com/buggerjs/node-inspect/commit/f2ad1aeedafb154043d70bb9195b10986d311d26) **fix:** Display breakpoints set into the future
+* [`73272f9`](https://github.com/buggerjs/node-inspect/commit/73272f9ace1f8546f8cad1d53627dbffba50bb4e) **refactor:** Make breakpoints more inspect friendly
+* [`507a71d`](https://github.com/buggerjs/node-inspect/commit/507a71de345a3de7fe144517e9f5ea264ff993e3) **feat:** Add breakpoints command
+* [`5fb3e5d`](https://github.com/buggerjs/node-inspect/commit/5fb3e5d17bbcfd45b264431547b3cf0b781c7640) **docs:** Link to Command Line API docs
+* [`81af501`](https://github.com/buggerjs/node-inspect/commit/81af501bbf85397e2078310c7f24a9ac5b7f02dc) **chore:** Fix license field
diff --git a/deps/node-inspect/CONTRIBUTING.md b/deps/node-inspect/CONTRIBUTING.md
new file mode 100644
index 00000000000000..08d333cce8321f
--- /dev/null
+++ b/deps/node-inspect/CONTRIBUTING.md
@@ -0,0 +1,183 @@
+# Contributing
+
+🎉🏅 Thanks for helping us improve this project! 🙏
+
+This document outlines some of the practices we care about.
+If you have any questions or suggestions about the process,
+feel free to [open an issue](#reporting-issues)
+.
+
+## Code of Conduct
+
+The [Node.js Code of Conduct][] applies to this repo.
+
+[Node.js Code of Conduct]: https://github.com/nodejs/node/blob/master/CODE_OF_CONDUCT.md
+
+## Code Contributions
+
+The nodereport project falls under the governance of the diagnostics
+working group which is documented in:
+https://github.com/nodejs/diagnostics/blob/master/GOVERNANCE.md.
+
+## Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+* (a) The contribution was created in whole or in part by me and I
+  have the right to submit it under the open source license
+  indicated in the file; or
+
+* (b) The contribution is based upon previous work that, to the best
+  of my knowledge, is covered under an appropriate open source
+  license and I have the right under that license to submit that
+  work with modifications, whether created in whole or in part
+  by me, under the same open source license (unless I am
+  permitted to submit under a different license), as indicated
+  in the file; or
+
+* (c) The contribution was provided directly to me by some other
+  person who certified (a), (b) or (c) and I have not modified
+  it.
+
+* (d) I understand and agree that this project and the contribution
+  are public and that a record of the contribution (including all
+  personal information I submit with it, including my sign-off) is
+  maintained indefinitely and may be redistributed consistent with
+  this project or the open source license(s) involved.
+
+## How Can I Contribute?
+
+### Reporting Issues
+
+If you find any mistakes in the docs or a bug in the code,
+please [open an issue in Github](https://github.com/nodejs/node-inspect/issues/new) so we can look into it.
+You can also [create a PR](#contributing-code) fixing it yourself, or course.
+
+If you report a bug, please follow these guidelines:
+
+* Make sure the bug exists in the latest version.
+* Include instructions on how to reproduce the issue.
+  The instructions should be as minimal as possible
+  and answer the three big questions:
+  1. What are the exact steps you took? This includes the exact versions of node, npm, and any packages involved.
+  1. What result are you expecting?
+  1. What is the actual result?
+
+### Improving Documentation
+
+For small documentation changes, you can use [Github's editing feature](https://help.github.com/articles/editing-files-in-another-user-s-repository/).
+The only thing to keep in mind is to prefix the commit message with "docs: ".
+The detault commit message generated by Github will lead to a failing CI build.
+
+For larger updates to the documentation
+it might be better to follow the [instructions for contributing code below](#contributing-code).
+
+### Contributing Code
+
+**Note:** If you're planning on making substantial changes,
+please [open an issue first to discuss your idea](#reporting-issues).
+Otherwise you might end up investing a lot of work
+only to discover that it conflicts with plans the maintainers might have.
+
+The general steps for creating a pull request are:
+
+1. Create a branch for your change.
+   Always start your branch from the latest `master`.
+   We often prefix the branch name with our initials, e.g. `jk-a-change`.
+1. Run `npm install` to install the dependencies.
+1. If you're fixing a bug, be sure to write a test *first*.
+   That way you can validate that the test actually catches the bug and doesn't pass.
+1. Make your changes to the code.
+   Remember to update the tests if you add new features or change behavior.
+1. Run the tests via `npm test`. This will also run style checks and other validations.
+   You might see errors about uncommitted files.
+   This is expected until you commit your changes.
+1. Once you're done, `git add .` and `git commit`.
+   Please follow the [commit message conventions](#commits--commit-messages) described below.
+1. Push your branch to Github & create a PR.
+
+#### Code Style
+
+In addition to any linting rules the project might include,
+a few general rules of thumb:
+
+* Try to match the style of the rest of the code.
+* We prefer simple code that is easy to understand over terse, expressive code.
+* We try to structure projects by semantics instead of role.
+  E.g. we'd rather have a `tree.js` module that contains tree traversal-related helpers
+  than a `helpers.js` module.
+* Actually, if you create helpers you might want to put those into a separate package.
+  That way it's easier to reuse them.
+
+#### Commits & Commit Messages
+
+Please follow the [angular commit message conventions](https://github.com/angular/angular.js/blob/master/CONTRIBUTING.md#-git-commit-guidelines).
+We use an automated tool for generating releases
+that depends on the conventions to determine the next version and the content of the changelog.
+Commit messages that don't follow the conventions will cause `npm test` (and thus CI) to fail.
+
+The short summary - a commit message should look like this:
+
+```
+<type>: <subject>
+
+<body>
+
+<references>
+
+<footer>
+```
+
+Everything but the first line is optional.
+The empty lines between the different parts are required.
+
+* `<type>`: One of the following:
+  - **feat:** Introduces a new feature. This will cause the minor version to go up.
+  - **fix:** A bug fix. Causes a patch version bump.
+  - **docs:** Changes to the documentation.
+    This will also cause an increase of the patch version so that the changes show up in the npm registry.
+  - **style:** Cleanup & lint rule fixes.
+    Note that often it's better to just amend the previous commit if it introduced lint errors.
+  - **refactor:** Changes to the code structure without fixing bugs or adding features.
+  - **perf:** Performance optimizations.
+  - **test:** Fixing existing tests or adding missing ones.
+    Just like with **style**, if you add tests to a feature you just introduced in the previous commit,
+    consider keeping the tests and the feature in the same commit instead.
+  - **chore:** Changes to the project setup and tools, dependency bumps, house-keeping.
+* `<subject>`: A [good git commit message subject](http://chris.beams.io/posts/git-commit/#limit-50).
+  - Keep it brief. If possible the whole first line should have at most 50 characters.
+  - Use imperative mood. "Create" instead of "creates" or "created".
+  - No period (".") at the end.
+* `<body>`: Motivation for the change and any context required for understanding the choices made.
+  Just like the subject, it should use imperative mood.
+* `<references>`: Any URLs relevant to the PR go here.
+  Use one line per URL and prefix it with the kind of relationship, e.g. "Closes: " or "See: ".
+  If you are referencing an issue in your commit body or PR description,
+  never use `#123` but the full URL to the issue or PR you are referencing.
+  That way the reference is easy to resolve from the git history without having to "guess" the correct link
+  even if the commit got cherry-picked or merged into a different project.
+* `<footer>`: This part only applies if your commit introduces a breaking change.
+  It's important this is present, otherwise the major version will not increase.
+  See below for an example.
+
+##### Examples
+
+A feature that introduces a breaking change:
+
+```
+feat: Support --yes CLI option
+
+For existing projects all prompts can be inferred automatically.
+Manual confirmation for each default provides no value in that case.
+
+Closes https://github.com/my/project/issues/123
+
+BREAKING CHANGE: This removes support for interactive password entry.
+Users will have to login beforehand.
+```
+
+A simple bug fix:
+
+```
+fix: Handle multi-byte characters in search logic
+```
diff --git a/deps/node-inspect/GOVERNANCE.md b/deps/node-inspect/GOVERNANCE.md
new file mode 100644
index 00000000000000..238c1b825837ac
--- /dev/null
+++ b/deps/node-inspect/GOVERNANCE.md
@@ -0,0 +1,5 @@
+# node-inspect Project Governance
+
+The node-inspect project falls under the governance of the diagnostics
+working group which is documented in:
+https://github.com/nodejs/diagnostics/blob/master/GOVERNANCE.md.
diff --git a/deps/node-inspect/LICENSE b/deps/node-inspect/LICENSE
new file mode 100644
index 00000000000000..d8d7f9437dbf5a
--- /dev/null
+++ b/deps/node-inspect/LICENSE
@@ -0,0 +1,19 @@
+Copyright Node.js contributors. All rights reserved.
+
+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.
diff --git a/deps/node-inspect/README.md b/deps/node-inspect/README.md
new file mode 100644
index 00000000000000..ecd939b3ea26a8
--- /dev/null
+++ b/deps/node-inspect/README.md
@@ -0,0 +1,29 @@
+# `node-inspect`
+
+```bash
+npm install --global node-inspect
+```
+
+For the old V8 debugger protocol,
+node has two options:
+
+1. `node --debug <file>`: Start `file` with remote debugging enabled.
+2. `node debug <file>`: Start an interactive CLI debugger for `<file>`.
+
+But for the Chrome inspector protol,
+there's only one: `node --inspect <file>`.
+
+This project tries to provide the missing second option
+by re-implementing `node debug` against the new protocol.
+
+```
+Usage: node-inspect script.js
+       node-inspect <host>:<port>
+```
+
+#### References
+
+* [Debugger Documentation](https://nodejs.org/api/debugger.html)
+* [EPS: `node inspect` CLI debugger](https://github.com/nodejs/node-eps/pull/42)
+* [Debugger Protocol Viewer](https://chromedevtools.github.io/debugger-protocol-viewer/)
+* [Command Line API](https://developers.google.com/web/tools/chrome-devtools/debug/command-line/command-line-reference?hl=en)
diff --git a/deps/node-inspect/appveyor.yml b/deps/node-inspect/appveyor.yml
new file mode 100644
index 00000000000000..c25a2d013aadbf
--- /dev/null
+++ b/deps/node-inspect/appveyor.yml
@@ -0,0 +1,13 @@
+environment:
+  nodejs_version: "6"
+
+install:
+- ps: Install-Product node $env:nodejs_version
+- npm install
+
+test_script:
+- node --version
+- npm --version
+- npm test
+
+build: off
diff --git a/deps/node-inspect/cli.js b/deps/node-inspect/cli.js
new file mode 100755
index 00000000000000..4856fd706c45c2
--- /dev/null
+++ b/deps/node-inspect/cli.js
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./lib/cli.js');
diff --git a/deps/node-inspect/examples/alive.js b/deps/node-inspect/examples/alive.js
new file mode 100644
index 00000000000000..3cf557b053981e
--- /dev/null
+++ b/deps/node-inspect/examples/alive.js
@@ -0,0 +1,6 @@
+'use strict';
+let x = 0;
+function heartbeat() {
+  ++x;
+}
+setInterval(heartbeat, 50);
diff --git a/deps/node-inspect/examples/backtrace.js b/deps/node-inspect/examples/backtrace.js
new file mode 100644
index 00000000000000..f5d71a14f96f86
--- /dev/null
+++ b/deps/node-inspect/examples/backtrace.js
@@ -0,0 +1,31 @@
+'use strict';
+const { exports: moduleScoped } = module;
+
+function topFn(a, b = false) {
+  const l1 = a;
+  let t = typeof l1;
+  var v = t.length;
+  debugger;
+  return b || t || v || moduleScoped;
+}
+
+class Ctor {
+  constructor(options) {
+    this.options = options;
+  }
+
+  m() {
+    const mLocal = this.options;
+    topFn(this);
+    return mLocal;
+  }
+}
+
+(function () {
+  const theOptions = { x: 42 };
+  const arr = [theOptions];
+  arr.forEach(options => {
+    const obj = new Ctor(options);
+    return obj.m();
+  });
+}());
diff --git a/deps/node-inspect/examples/break.js b/deps/node-inspect/examples/break.js
new file mode 100644
index 00000000000000..d5f26578814090
--- /dev/null
+++ b/deps/node-inspect/examples/break.js
@@ -0,0 +1,16 @@
+const x = 10;
+let name = 'World';
+name = 'Robin';
+function sayHello() {
+  if (x > 0) {
+    console.log(`Hello ${name}`);
+  }
+}
+sayHello();
+debugger;
+setTimeout(sayHello, 10);
+
+function otherFunction() {
+  console.log('x = %d', x);
+}
+setTimeout(otherFunction, 50);
diff --git a/deps/node-inspect/examples/cjs/index.js b/deps/node-inspect/examples/cjs/index.js
new file mode 100644
index 00000000000000..d5815e865999f7
--- /dev/null
+++ b/deps/node-inspect/examples/cjs/index.js
@@ -0,0 +1,5 @@
+'use strict';
+const { add } = require('./other');
+
+const sum = add(40, 2);
+module.exports = sum;
diff --git a/deps/node-inspect/examples/cjs/other.js b/deps/node-inspect/examples/cjs/other.js
new file mode 100644
index 00000000000000..efadaa18d26e6d
--- /dev/null
+++ b/deps/node-inspect/examples/cjs/other.js
@@ -0,0 +1,4 @@
+'use strict';
+exports.add = function add(a, b) {
+  return a + b;
+};
diff --git a/deps/node-inspect/examples/empty.js b/deps/node-inspect/examples/empty.js
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/deps/node-inspect/examples/exceptions.js b/deps/node-inspect/examples/exceptions.js
new file mode 100644
index 00000000000000..00c48ed31b5113
--- /dev/null
+++ b/deps/node-inspect/examples/exceptions.js
@@ -0,0 +1,11 @@
+'use strict';
+let error = null;
+try {
+  throw new Error('Caught');
+} catch (e) {
+  error = e;
+}
+
+if (error) {
+  throw new Error('Uncaught');
+}
diff --git a/deps/node-inspect/examples/three-lines.js b/deps/node-inspect/examples/three-lines.js
new file mode 100644
index 00000000000000..4e1cb95d1130b8
--- /dev/null
+++ b/deps/node-inspect/examples/three-lines.js
@@ -0,0 +1,4 @@
+'use strict';
+let x = 1;
+x = x + 1;
+module.exports = x;
diff --git a/deps/node-inspect/lib/_inspect.js b/deps/node-inspect/lib/_inspect.js
new file mode 100644
index 00000000000000..5cd1cc2d685a90
--- /dev/null
+++ b/deps/node-inspect/lib/_inspect.js
@@ -0,0 +1,283 @@
+/*
+ * Copyright Node.js contributors. All rights reserved.
+ *
+ * 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.
+ */
+'use strict';
+const { spawn } = require('child_process');
+const { EventEmitter } = require('events');
+const util = require('util');
+
+const [ InspectClient, createRepl ] =
+  (typeof __dirname !== 'undefined') ?
+  // This copy of node-inspect is on-disk, relative paths make sense.
+  [
+    require('./internal/inspect_client'),
+    require('./internal/inspect_repl')
+  ] :
+  // This copy of node-inspect is built into the node executable.
+  [
+    require('node-inspect/lib/internal/inspect_client'),
+    require('node-inspect/lib/internal/inspect_repl')
+  ];
+
+const debuglog = util.debuglog('inspect');
+
+exports.port = 9229;
+
+function runScript(script, scriptArgs, inspectPort, childPrint) {
+  return new Promise((resolve) => {
+    const args = [
+      '--inspect',
+      `--debug-brk=${inspectPort}`,
+    ].concat([script], scriptArgs);
+    const child = spawn(process.execPath, args);
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', childPrint);
+    child.stderr.on('data', childPrint);
+
+    let output = '';
+    function waitForListenHint(text) {
+      output += text;
+      if (/chrome-devtools:\/\//.test(output)) {
+        child.stderr.removeListener('data', waitForListenHint);
+        resolve(child);
+      }
+    }
+
+    child.stderr.on('data', waitForListenHint);
+  });
+}
+
+function createAgentProxy(domain, client) {
+  const agent = new EventEmitter();
+  agent.then = (...args) => {
+    // TODO: potentially fetch the protocol and pretty-print it here.
+    const descriptor = {
+      [util.inspect.custom](depth, { stylize }) {
+        return stylize(`[Agent ${domain}]`, 'special');
+      },
+    };
+    return Promise.resolve(descriptor).then(...args);
+  };
+
+  return new Proxy(agent, {
+    get(target, name) {
+      if (name in target) return target[name];
+      return function callVirtualMethod(params) {
+        return client.callMethod(`${domain}.${name}`, params);
+      };
+    },
+  });
+}
+
+class NodeInspector {
+  constructor(options, stdin, stdout) {
+    this.options = options;
+    this.stdin = stdin;
+    this.stdout = stdout;
+
+    this.paused = true;
+    this.child = null;
+
+    if (options.script) {
+      this._runScript = runScript.bind(null,
+                                       options.script,
+                                       options.scriptArgs,
+                                       options.port,
+                                       this.childPrint.bind(this));
+    } else {
+      this._runScript = () => Promise.resolve(null);
+    }
+
+    this.client = new InspectClient(options.port, options.host);
+
+    this.domainNames = ['Debugger', 'HeapProfiler', 'Profiler', 'Runtime'];
+    this.domainNames.forEach((domain) => {
+      this[domain] = createAgentProxy(domain, this.client);
+    });
+    this.handleDebugEvent = (fullName, params) => {
+      const [domain, name] = fullName.split('.');
+      if (domain in this) {
+        this[domain].emit(name, params);
+      }
+    };
+    this.client.on('debugEvent', this.handleDebugEvent);
+    const startRepl = createRepl(this);
+
+    // Handle all possible exits
+    process.on('exit', () => this.killChild());
+    process.once('SIGTERM', process.exit.bind(process, 0));
+    process.once('SIGHUP', process.exit.bind(process, 0));
+
+    this.run()
+      .then(() => {
+        this.repl = startRepl();
+        this.repl.on('exit', () => {
+          process.exit(0);
+        });
+        this.paused = false;
+      })
+      .then(null, (error) => process.nextTick(() => { throw error; }));
+  }
+
+  suspendReplWhile(fn) {
+    this.repl.rli.pause();
+    this.stdin.pause();
+    this.paused = true;
+    return new Promise((resolve) => {
+      resolve(fn());
+    }).then(() => {
+      this.paused = false;
+      this.repl.rli.resume();
+      this.repl.displayPrompt();
+      this.stdin.resume();
+    }).then(null, (error) => process.nextTick(() => { throw error; }));
+  }
+
+  killChild() {
+    this.client.reset();
+    if (this.child) {
+      this.child.kill();
+      this.child = null;
+    }
+  }
+
+  run() {
+    this.killChild();
+    return this._runScript().then((child) => {
+      this.child = child;
+
+      let connectionAttempts = 0;
+      const attemptConnect = () => {
+        ++connectionAttempts;
+        debuglog('connection attempt #%d', connectionAttempts);
+        this.stdout.write('.');
+        return this.client.connect()
+          .then(() => {
+            debuglog('connection established');
+          }, (error) => {
+            debuglog('connect failed', error);
+            // If it's failed to connect 10 times then print failed message
+            if (connectionAttempts >= 10) {
+              this.stdout.write(' failed to connect, please retry\n');
+              process.exit(1);
+            }
+
+            return new Promise((resolve) => setTimeout(resolve, 500))
+              .then(attemptConnect);
+          });
+      };
+
+      const { host, port } = this.options;
+      this.print(`connecting to ${host}:${port} ..`, true);
+      return attemptConnect();
+    });
+  }
+
+  clearLine() {
+    if (this.stdout.isTTY) {
+      this.stdout.cursorTo(0);
+      this.stdout.clearLine(1);
+    } else {
+      this.stdout.write('\b');
+    }
+  }
+
+  print(text, oneline = false) {
+    this.clearLine();
+    this.stdout.write(oneline ? text : `${text}\n`);
+  }
+
+  childPrint(text) {
+    this.print(
+      text.toString()
+        .split(/\r\n|\r|\n/g)
+        .filter((chunk) => !!chunk)
+        .map((chunk) => `< ${chunk}`)
+        .join('\n')
+    );
+    if (!this.paused) {
+      this.repl.displayPrompt(true);
+    }
+    if (/Waiting for the debugger to disconnect\.\.\.\n$/.test(text)) {
+      this.killChild();
+    }
+  }
+}
+
+function parseArgv([target, ...args]) {
+  let host = '127.0.0.1';
+  let port = exports.port;
+  let isRemote = false;
+  let script = target;
+  let scriptArgs = args;
+
+  const hostMatch = target.match(/^([^:]+):(\d+)$/);
+  const portMatch = target.match(/^--port=(\d+)$/);
+  if (hostMatch) {
+    // Connecting to remote debugger
+    // `node-inspect localhost:9229`
+    host = hostMatch[1];
+    port = parseInt(hostMatch[2], 10);
+    isRemote = true;
+    script = null;
+  } else if (portMatch) {
+    // Start debugger on custom port
+    // `node debug --port=8058 app.js`
+    port = parseInt(portMatch[1], 10);
+    script = args[0];
+    scriptArgs = args.slice(1);
+  }
+
+  return {
+    host, port,
+    isRemote, script, scriptArgs,
+  };
+}
+
+function startInspect(argv = process.argv.slice(2),
+                      stdin = process.stdin,
+                      stdout = process.stdout) {
+  /* eslint-disable no-console */
+  if (argv.length < 1) {
+    console.error('Usage: node-inspect script.js');
+    console.error('       node-inspect <host>:<port>');
+    process.exit(1);
+  }
+
+  const options = parseArgv(argv);
+  const inspector = new NodeInspector(options, stdin, stdout);
+
+  stdin.resume();
+
+  function handleUnexpectedError(e) {
+    console.error('There was an internal error in node-inspect. ' +
+                  'Please report this bug.');
+    console.error(e.message);
+    console.error(e.stack);
+    if (inspector.child) inspector.child.kill();
+    process.exit(1);
+  }
+
+  process.on('uncaughtException', handleUnexpectedError);
+  /* eslint-enable no-console */
+}
+exports.start = startInspect;
diff --git a/deps/node-inspect/lib/cli.js b/deps/node-inspect/lib/cli.js
new file mode 100644
index 00000000000000..a4880df2d56be8
--- /dev/null
+++ b/deps/node-inspect/lib/cli.js
@@ -0,0 +1,24 @@
+/*
+ * Copyright Node.js contributors. All rights reserved.
+ *
+ * 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.
+ */
+'use strict';
+// ~= NativeModule.require('_debugger').start();
+require('./_inspect').start();
diff --git a/deps/node-inspect/lib/internal/inspect_client.js b/deps/node-inspect/lib/internal/inspect_client.js
new file mode 100644
index 00000000000000..d5ce46db05c37d
--- /dev/null
+++ b/deps/node-inspect/lib/internal/inspect_client.js
@@ -0,0 +1,363 @@
+/*
+ * Copyright Node.js contributors. All rights reserved.
+ *
+ * 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.
+ */
+'use strict';
+const Buffer = require('buffer').Buffer;
+const crypto = require('crypto');
+const { EventEmitter } = require('events');
+const http = require('http');
+const URL = require('url');
+const util = require('util');
+
+const debuglog = util.debuglog('inspect');
+
+const kOpCodeText = 0x1;
+const kOpCodeClose = 0x8;
+
+const kFinalBit = 0x80;
+const kReserved1Bit = 0x40;
+const kReserved2Bit = 0x20;
+const kReserved3Bit = 0x10;
+const kOpCodeMask = 0xF;
+const kMaskBit = 0x80;
+const kPayloadLengthMask = 0x7F;
+
+const kMaxSingleBytePayloadLength = 125;
+const kMaxTwoBytePayloadLength = 0xFFFF;
+const kTwoBytePayloadLengthField = 126;
+const kEightBytePayloadLengthField = 127;
+const kMaskingKeyWidthInBytes = 4;
+
+function isEmpty(obj) {
+  return Object.keys(obj).length === 0;
+}
+
+function unpackError({ code, message, data }) {
+  const err = new Error(`${message} - ${data}`);
+  err.code = code;
+  Error.captureStackTrace(err, unpackError);
+  return err;
+}
+
+function encodeFrameHybi17(payload) {
+  var i;
+
+  const dataLength = payload.length;
+
+  let singleByteLength;
+  let additionalLength;
+  if (dataLength > kMaxTwoBytePayloadLength) {
+    singleByteLength = kEightBytePayloadLengthField;
+    additionalLength = Buffer.alloc(8);
+    let remaining = dataLength;
+    for (i = 0; i < 8; ++i) {
+      additionalLength[7 - i] = remaining & 0xFF;
+      remaining >>= 8;
+    }
+  } else if (dataLength > kMaxSingleBytePayloadLength) {
+    singleByteLength = kTwoBytePayloadLengthField;
+    additionalLength = Buffer.alloc(2);
+    additionalLength[0] = (dataLength & 0xFF00) >> 8;
+    additionalLength[1] = dataLength & 0xFF;
+  } else {
+    additionalLength = Buffer.alloc(0);
+    singleByteLength = dataLength;
+  }
+
+  const header = Buffer.from([
+    kFinalBit | kOpCodeText,
+    kMaskBit | singleByteLength,
+  ]);
+
+  const mask = Buffer.alloc(4);
+  const masked = Buffer.alloc(dataLength);
+  for (i = 0; i < dataLength; ++i) {
+    masked[i] = payload[i] ^ mask[i % kMaskingKeyWidthInBytes];
+  }
+
+  return Buffer.concat([header, additionalLength, mask, masked]);
+}
+
+function decodeFrameHybi17(data) {
+  const dataAvailable = data.length;
+  const notComplete = { closed: false, payload: null, rest: data };
+  let payloadOffset = 2;
+  if ((dataAvailable - payloadOffset) < 0) return notComplete;
+
+  const firstByte = data[0];
+  const secondByte = data[1];
+
+  const final = (firstByte & kFinalBit) !== 0;
+  const reserved1 = (firstByte & kReserved1Bit) !== 0;
+  const reserved2 = (firstByte & kReserved2Bit) !== 0;
+  const reserved3 = (firstByte & kReserved3Bit) !== 0;
+  const opCode = firstByte & kOpCodeMask;
+  const masked = (secondByte & kMaskBit) !== 0;
+  const compressed = reserved1;
+  if (compressed) {
+    throw new Error('Compressed frames not supported');
+  }
+  if (!final || reserved2 || reserved3) {
+    throw new Error('Only compression extension is supported');
+  }
+
+  if (masked) {
+    throw new Error('Masked server frame - not supported');
+  }
+
+  let closed = false;
+  switch (opCode) {
+    case kOpCodeClose:
+      closed = true;
+      break;
+    case kOpCodeText:
+      break;
+    default:
+      throw new Error(`Unsupported op code ${opCode}`);
+  }
+
+  let payloadLength = secondByte & kPayloadLengthMask;
+  switch (payloadLength) {
+    case kTwoBytePayloadLengthField:
+      payloadOffset += 2;
+      payloadLength = (data[2] << 8) + data[3];
+      break;
+
+    case kEightBytePayloadLengthField:
+      payloadOffset += 8;
+      payloadLength = 0;
+      for (var i = 0; i < 8; ++i) {
+        payloadLength <<= 8;
+        payloadLength |= data[2 + i];
+      }
+      break;
+
+    default:
+      // Nothing. We already have the right size.
+  }
+  if ((dataAvailable - payloadOffset - payloadLength) < 0) return notComplete;
+
+  const payloadEnd = payloadOffset + payloadLength;
+  return {
+    payload: data.slice(payloadOffset, payloadEnd),
+    rest: data.slice(payloadEnd),
+    closed,
+  };
+}
+
+class Client extends EventEmitter {
+  constructor(port, host) {
+    super();
+    this.handleChunk = this._handleChunk.bind(this);
+
+    this._port = port;
+    this._host = host;
+
+    this.reset();
+  }
+
+  _handleChunk(chunk) {
+    this._unprocessed = Buffer.concat([this._unprocessed, chunk]);
+
+    while (this._unprocessed.length > 2) {
+      const {
+        closed,
+        payload: payloadBuffer,
+        rest
+      } = decodeFrameHybi17(this._unprocessed);
+      this._unprocessed = rest;
+
+      if (closed) {
+        this.reset();
+        return;
+      }
+      if (payloadBuffer === null) break;
+
+      const payloadStr = payloadBuffer.toString();
+      debuglog('< %s', payloadStr);
+      const lastChar = payloadStr[payloadStr.length - 1];
+      if (payloadStr[0] !== '{' || lastChar !== '}') {
+        throw new Error(`Payload does not look like JSON: ${payloadStr}`);
+      }
+      let payload;
+      try {
+        payload = JSON.parse(payloadStr);
+      } catch (parseError) {
+        parseError.string = payloadStr;
+        throw parseError;
+      }
+
+      const { id, method, params, result, error } = payload;
+      if (id) {
+        const handler = this._pending[id];
+        if (handler) {
+          delete this._pending[id];
+          handler(error, result);
+        }
+      } else if (method) {
+        this.emit('debugEvent', method, params);
+        this.emit(method, params);
+      } else {
+        throw new Error(`Unsupported response: ${payloadStr}`);
+      }
+    }
+  }
+
+  reset() {
+    if (this._http) {
+      this._http.destroy();
+    }
+    this._http = null;
+    this._lastId = 0;
+    this._socket = null;
+    this._pending = {};
+    this._unprocessed = Buffer.alloc(0);
+  }
+
+  callMethod(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this._socket) {
+        reject(new Error('Use `run` to start the app again.'));
+        return;
+      }
+      const data = { id: ++this._lastId, method, params };
+      this._pending[data.id] = (error, result) => {
+        if (error) reject(unpackError(error));
+        else resolve(isEmpty(result) ? undefined : result);
+      };
+      const json = JSON.stringify(data);
+      debuglog('> %s', json);
+      this._socket.write(encodeFrameHybi17(Buffer.from(json)));
+    });
+  }
+
+  _fetchJSON(urlPath) {
+    return new Promise((resolve, reject) => {
+      const httpReq = http.get({
+        host: this._host,
+        port: this._port,
+        path: urlPath,
+      });
+
+      const chunks = [];
+
+      function onResponse(httpRes) {
+        function parseChunks() {
+          const resBody = Buffer.concat(chunks).toString();
+          if (httpRes.statusCode !== 200) {
+            reject(new Error(`Unexpected ${httpRes.statusCode}: ${resBody}`));
+            return;
+          }
+          try {
+            resolve(JSON.parse(resBody));
+          } catch (parseError) {
+            reject(new Error(`Response didn't contain JSON: ${resBody}`));
+            return;
+          }
+        }
+
+        httpRes.on('error', reject);
+        httpRes.on('data', (chunk) => chunks.push(chunk));
+        httpRes.on('end', parseChunks);
+      }
+
+      httpReq.on('error', reject);
+      httpReq.on('response', onResponse);
+    });
+  }
+
+  connect() {
+    return this._discoverWebsocketPath()
+      .then((urlPath) => this._connectWebsocket(urlPath));
+  }
+
+  _discoverWebsocketPath() {
+    return this._fetchJSON('/json')
+      .then(([{ webSocketDebuggerUrl }]) =>
+        URL.parse(webSocketDebuggerUrl).path);
+  }
+
+  _connectWebsocket(urlPath) {
+    this.reset();
+
+    const key1 = crypto.randomBytes(16).toString('base64');
+    debuglog('request websocket', key1);
+
+    const httpReq = this._http = http.request({
+      host: this._host,
+      port: this._port,
+      path: urlPath,
+      headers: {
+        Connection: 'Upgrade',
+        Upgrade: 'websocket',
+        'Sec-WebSocket-Key': key1,
+        'Sec-WebSocket-Version': '13',
+      },
+    });
+    httpReq.on('error', (e) => {
+      this.emit('error', e);
+    });
+    httpReq.on('response', (httpRes) => {
+      if (httpRes.statusCode >= 400) {
+        process.stderr.write(`Unexpected HTTP code: ${httpRes.statusCode}\n`);
+        httpRes.pipe(process.stderr);
+      } else {
+        httpRes.pipe(process.stderr);
+      }
+    });
+
+    const handshakeListener = (res, socket) => {
+      // TODO: we *could* validate res.headers[sec-websocket-accept]
+      debuglog('websocket upgrade');
+
+      this._socket = socket;
+      socket.on('data', this.handleChunk);
+      socket.on('close', () => {
+        this.emit('close');
+      });
+
+      Promise.all([
+        this.callMethod('Runtime.enable'),
+        this.callMethod('Debugger.enable'),
+        this.callMethod('Debugger.setPauseOnExceptions', { state: 'none' }),
+        this.callMethod('Debugger.setAsyncCallStackDepth', { maxDepth: 0 }),
+        this.callMethod('Profiler.enable'),
+        this.callMethod('Profiler.setSamplingInterval', { interval: 100 }),
+        this.callMethod('Debugger.setBlackboxPatterns', { patterns: [] }),
+        this.callMethod('Runtime.runIfWaitingForDebugger'),
+      ]).then(() => {
+        this.emit('ready');
+      }, (error) => {
+        this.emit('error', error);
+      });
+    };
+
+    return new Promise((resolve, reject) => {
+      this.once('error', reject);
+      this.once('ready', resolve);
+
+      httpReq.on('upgrade', handshakeListener);
+      httpReq.end();
+    });
+  }
+}
+
+module.exports = Client;
diff --git a/deps/node-inspect/lib/internal/inspect_repl.js b/deps/node-inspect/lib/internal/inspect_repl.js
new file mode 100644
index 00000000000000..c61bbc9fb8e05a
--- /dev/null
+++ b/deps/node-inspect/lib/internal/inspect_repl.js
@@ -0,0 +1,1057 @@
+/*
+ * Copyright Node.js contributors. All rights reserved.
+ *
+ * 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.
+ */
+'use strict';
+const FS = require('fs');
+const Path = require('path');
+const Repl = require('repl');
+const util = require('util');
+const vm = require('vm');
+
+const debuglog = util.debuglog('inspect');
+
+const SHORTCUTS = {
+  cont: 'c',
+  next: 'n',
+  step: 's',
+  out: 'o',
+  backtrace: 'bt',
+  setBreakpoint: 'sb',
+  clearBreakpoint: 'cb',
+  run: 'r',
+};
+
+const HELP = `
+run, restart, r       Run the application or reconnect
+kill                  Kill a running application or disconnect
+
+cont, c               Resume execution
+next, n               Continue to next line in current file
+step, s               Step into, potentially entering a function
+out, o                Step out, leaving the current function
+backtrace, bt         Print the current backtrace
+list                  Print the source around the current line where execution
+                      is currently paused
+
+setBreakpoint, sb     Set a breakpoint
+clearBreakpoint, cb   Clear a breakpoint
+breakpoints           List all known breakpoints
+breakOnException      Pause execution whenever an exception is thrown
+breakOnUncaught       Pause execution whenever an exception isn't caught
+breakOnNone           Don't pause on exceptions (this is the default)
+
+watch(expr)           Start watching the given expression
+unwatch(expr)         Stop watching an expression
+watchers              Print all watched expressions and their current values
+
+exec(expr)            Evaluate the expression and print the value
+repl                  Enter a debug repl that works like exec
+
+scripts               List application scripts that are currently loaded
+scripts(true)         List all scripts (including node-internals)
+`.trim();
+
+const FUNCTION_NAME_PATTERN = /^(?:function\*? )?([^(\s]+)\(/;
+function extractFunctionName(description) {
+  const fnNameMatch = description.match(FUNCTION_NAME_PATTERN);
+  return fnNameMatch ? `: ${fnNameMatch[1]}` : '';
+}
+
+const NATIVES = process.binding('natives');
+function isNativeUrl(url) {
+  return url.replace('.js', '') in NATIVES || url === 'bootstrap_node.js';
+}
+
+function getRelativePath(filename) {
+  const dir = Path.join(Path.resolve(), 'x').slice(0, -1);
+
+  // Change path to relative, if possible
+  if (filename.indexOf(dir) === 0) {
+    return filename.slice(dir.length);
+  }
+  return filename;
+}
+
+function toCallback(promise, callback) {
+  function forward(...args) {
+    process.nextTick(() => callback(...args));
+  }
+  promise.then(forward.bind(null, null), forward);
+}
+
+// Adds spaces and prefix to number
+// maxN is a maximum number we should have space for
+function leftPad(n, prefix, maxN) {
+  const s = n.toString();
+  const nchars = Math.max(2, String(maxN).length) + 1;
+  const nspaces = nchars - s.length - 1;
+
+  return prefix + ' '.repeat(nspaces) + s;
+}
+
+function markSourceColumn(sourceText, position, useColors) {
+  if (!sourceText) return '';
+
+  const head = sourceText.slice(0, position);
+  let tail = sourceText.slice(position);
+
+  // Colourize char if stdout supports colours
+  if (useColors) {
+    tail = tail.replace(/(.+?)([^\w]|$)/, '\u001b[32m$1\u001b[39m$2');
+  }
+
+  // Return source line with coloured char at `position`
+  return [head, tail].join('');
+}
+
+function extractErrorMessage(stack) {
+  if (!stack) return '<unknown>';
+  const m = stack.match(/^\w+: ([^\n]+)/);
+  return m ? m[1] : stack;
+}
+
+function convertResultToError(result) {
+  const { className, description } = result;
+  const err = new Error(extractErrorMessage(description));
+  err.stack = description;
+  Object.defineProperty(err, 'name', { value: className });
+  return err;
+}
+
+class RemoteObject {
+  constructor(attributes) {
+    Object.assign(this, attributes);
+    if (this.type === 'number') {
+      this.value =
+        this.unserializableValue ? +this.unserializableValue : +this.value;
+    }
+  }
+
+  [util.inspect.custom](depth, opts) {
+    function formatProperty(prop) {
+      switch (prop.type) {
+        case 'string':
+        case 'undefined':
+          return util.inspect(prop.value, opts);
+
+        case 'number':
+        case 'boolean':
+          return opts.stylize(prop.value, prop.type);
+
+        case 'object':
+        case 'symbol':
+          if (prop.subtype === 'date') {
+            return util.inspect(new Date(prop.value), opts);
+          }
+          if (prop.subtype === 'array') {
+            return opts.stylize(prop.value, 'special');
+          }
+          return opts.stylize(prop.value, prop.subtype || 'special');
+
+        default:
+          return prop.value;
+      }
+    }
+    switch (this.type) {
+      case 'boolean':
+      case 'number':
+      case 'string':
+      case 'undefined':
+        return util.inspect(this.value, opts);
+
+      case 'symbol':
+        return opts.stylize(this.description, 'special');
+
+      case 'function': {
+        const fnName = extractFunctionName(this.description);
+        const formatted = `[${this.className}${fnName}]`;
+        return opts.stylize(formatted, 'special');
+      }
+
+      case 'object':
+        switch (this.subtype) {
+          case 'date':
+            return util.inspect(new Date(this.description), opts);
+
+          case 'null':
+            return util.inspect(null, opts);
+
+          case 'regexp':
+            return opts.stylize(this.description, 'regexp');
+
+          default:
+            break;
+        }
+        if (this.preview) {
+          const props = this.preview.properties
+            .map((prop, idx) => {
+              const value = formatProperty(prop);
+              if (prop.name === `${idx}`) return value;
+              return `${prop.name}: ${value}`;
+            });
+          if (this.preview.overflow) {
+            props.push('...');
+          }
+          const singleLine = props.join(', ');
+          const propString =
+            singleLine.length > 60 ? props.join(',\n  ') : singleLine;
+
+          return this.subtype === 'array' ?
+            `[ ${propString} ]` : `{ ${propString} }`;
+        }
+        return this.description;
+
+      default:
+        return this.description;
+    }
+  }
+
+  static fromEvalResult({ result, wasThrown }) {
+    if (wasThrown) return convertResultToError(result);
+    return new RemoteObject(result);
+  }
+}
+
+class ScopeSnapshot {
+  constructor(scope, properties) {
+    Object.assign(this, scope);
+    this.properties = new Map(properties.map((prop) => {
+      // console.error(prop);
+      const value = new RemoteObject(prop.value);
+      return [prop.name, value];
+    }));
+  }
+
+  [util.inspect.custom](depth, opts) {
+    const type = `${this.type[0].toUpperCase()}${this.type.slice(1)}`;
+    const name = this.name ? `<${this.name}>` : '';
+    const prefix = `${type}${name} `;
+    return util.inspect(this.properties, opts)
+      .replace(/^Map /, prefix);
+  }
+}
+
+function copyOwnProperties(target, source) {
+  Object.getOwnPropertyNames(source).forEach((prop) => {
+    const descriptor = Object.getOwnPropertyDescriptor(source, prop);
+    Object.defineProperty(target, prop, descriptor);
+  });
+}
+
+function aliasProperties(target, mapping) {
+  Object.keys(mapping).forEach((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    Object.defineProperty(target, mapping[key], descriptor);
+  });
+}
+
+function createRepl(inspector) {
+  const { Debugger, HeapProfiler, Profiler, Runtime } = inspector;
+
+  let repl; // eslint-disable-line prefer-const
+
+  // Things we want to keep around
+  const history = { control: [], debug: [] };
+  const watchedExpressions = [];
+  const knownBreakpoints = [];
+  let pauseOnExceptionState = 'none';
+  let lastCommand;
+
+  // Things we need to reset when the app restarts
+  let knownScripts;
+  let currentBacktrace;
+  let selectedFrame;
+  let exitDebugRepl;
+
+  function resetOnStart() {
+    knownScripts = {};
+    currentBacktrace = null;
+    selectedFrame = null;
+
+    if (exitDebugRepl) exitDebugRepl();
+    exitDebugRepl = null;
+  }
+  resetOnStart();
+
+  const INSPECT_OPTIONS = { colors: inspector.stdout.isTTY };
+  function inspect(value) {
+    return util.inspect(value, INSPECT_OPTIONS);
+  }
+
+  function print(value, oneline = false) {
+    const text = typeof value === 'string' ? value : inspect(value);
+    return inspector.print(text, oneline);
+  }
+
+  function getCurrentLocation() {
+    if (!selectedFrame) {
+      throw new Error('Requires execution to be paused');
+    }
+    return selectedFrame.location;
+  }
+
+  function isCurrentScript(script) {
+    return selectedFrame && getCurrentLocation().scriptId === script.scriptId;
+  }
+
+  function formatScripts(displayNatives = false) {
+    function isVisible(script) {
+      if (displayNatives) return true;
+      return !script.isNative || isCurrentScript(script);
+    }
+
+    return Object.keys(knownScripts)
+      .map((scriptId) => knownScripts[scriptId])
+      .filter(isVisible)
+      .map((script) => {
+        const isCurrent = isCurrentScript(script);
+        const { isNative, url } = script;
+        const name = `${getRelativePath(url)}${isNative ? ' <native>' : ''}`;
+        return `${isCurrent ? '*' : ' '} ${script.scriptId}: ${name}`;
+      })
+      .join('\n');
+  }
+  function listScripts(displayNatives = false) {
+    print(formatScripts(displayNatives));
+  }
+  listScripts[util.inspect.custom] = function listWithoutInternal() {
+    return formatScripts();
+  };
+
+  const profiles = [];
+  class Profile {
+    constructor(data) {
+      this.data = data;
+    }
+
+    static createAndRegister({ profile }) {
+      const p = new Profile(profile);
+      profiles.push(p);
+      return p;
+    }
+
+    [util.inspect.custom](depth, { stylize }) {
+      const { startTime, endTime } = this.data;
+      return stylize(`[Profile ${endTime - startTime}μs]`, 'special');
+    }
+
+    save(filename = 'node.cpuprofile') {
+      const absoluteFile = Path.resolve(filename);
+      const json = JSON.stringify(this.data);
+      FS.writeFileSync(absoluteFile, json);
+      print('Saved profile to ' + absoluteFile);
+    }
+  }
+
+  class SourceSnippet {
+    constructor(location, delta, scriptSource) {
+      Object.assign(this, location);
+      this.scriptSource = scriptSource;
+      this.delta = delta;
+    }
+
+    [util.inspect.custom](depth, options) {
+      const { scriptId, lineNumber, columnNumber, delta, scriptSource } = this;
+      const start = Math.max(1, lineNumber - delta + 1);
+      const end = lineNumber + delta + 1;
+
+      const lines = scriptSource.split('\n');
+      return lines.slice(start - 1, end).map((lineText, offset) => {
+        const i = start + offset;
+        const isCurrent = i === (lineNumber + 1);
+
+        const markedLine = isCurrent
+          ? markSourceColumn(lineText, columnNumber, options.colors)
+          : lineText;
+
+        let isBreakpoint = false;
+        knownBreakpoints.forEach(({ location }) => {
+          if (!location) return;
+          if (scriptId === location.scriptId &&
+              i === (location.lineNumber + 1)) {
+            isBreakpoint = true;
+          }
+        });
+
+        let prefixChar = ' ';
+        if (isCurrent) {
+          prefixChar = '>';
+        } else if (isBreakpoint) {
+          prefixChar = '*';
+        }
+        return `${leftPad(i, prefixChar, end)} ${markedLine}`;
+      }).join('\n');
+    }
+  }
+
+  function getSourceSnippet(location, delta = 5) {
+    const { scriptId } = location;
+    return Debugger.getScriptSource({ scriptId })
+      .then(({ scriptSource }) =>
+        new SourceSnippet(location, delta, scriptSource));
+  }
+
+  class CallFrame {
+    constructor(callFrame) {
+      Object.assign(this, callFrame);
+    }
+
+    loadScopes() {
+      return Promise.all(
+        this.scopeChain
+          .filter((scope) => scope.type !== 'global')
+          .map((scope) => {
+            const { objectId } = scope.object;
+            return Runtime.getProperties({
+              objectId,
+              generatePreview: true,
+            }).then(({ result }) => new ScopeSnapshot(scope, result));
+          })
+      );
+    }
+
+    list(delta = 5) {
+      return getSourceSnippet(this.location, delta);
+    }
+  }
+
+  class Backtrace extends Array {
+    [util.inspect.custom]() {
+      return this.map((callFrame, idx) => {
+        const {
+          location: { scriptId, lineNumber, columnNumber },
+          functionName
+        } = callFrame;
+        const name = functionName || '(anonymous)';
+
+        const script = knownScripts[scriptId];
+        const relativeUrl =
+          (script && getRelativePath(script.url)) || '<unknown>';
+        const frameLocation =
+          `${relativeUrl}:${lineNumber + 1}:${columnNumber}`;
+
+        return `#${idx} ${name} ${frameLocation}`;
+      }).join('\n');
+    }
+
+    static from(callFrames) {
+      return super.from(Array.from(callFrames).map((callFrame) => {
+        if (callFrame instanceof CallFrame) {
+          return callFrame;
+        }
+        return new CallFrame(callFrame);
+      }));
+    }
+  }
+
+  function prepareControlCode(input) {
+    if (input === '\n') return lastCommand;
+    // exec process.title => exec("process.title");
+    const match = input.match(/^\s*exec\s+([^\n]*)/);
+    if (match) {
+      lastCommand = `exec(${JSON.stringify(match[1])})`;
+    } else {
+      lastCommand = input;
+    }
+    return lastCommand;
+  }
+
+  function evalInCurrentContext(code) {
+    // Repl asked for scope variables
+    if (code === '.scope') {
+      if (!selectedFrame) {
+        return Promise.reject(new Error('Requires execution to be paused'));
+      }
+      return selectedFrame.loadScopes();
+    }
+
+    if (selectedFrame) {
+      return Debugger.evaluateOnCallFrame({
+        callFrameId: selectedFrame.callFrameId,
+        expression: code,
+        objectGroup: 'node-inspect',
+        generatePreview: true,
+      }).then(RemoteObject.fromEvalResult);
+    }
+    return Runtime.evaluate({
+      expression: code,
+      objectGroup: 'node-inspect',
+      generatePreview: true,
+    }).then(RemoteObject.fromEvalResult);
+  }
+
+  function controlEval(input, context, filename, callback) {
+    debuglog('eval:', input);
+    function returnToCallback(error, result) {
+      debuglog('end-eval:', input, error);
+      callback(error, result);
+    }
+
+    try {
+      const code = prepareControlCode(input);
+      const result = vm.runInContext(code, context, filename);
+
+      if (result && typeof result.then === 'function') {
+        toCallback(result, returnToCallback);
+        return;
+      }
+      returnToCallback(null, result);
+    } catch (e) {
+      returnToCallback(e);
+    }
+  }
+
+  function debugEval(input, context, filename, callback) {
+    debuglog('eval:', input);
+    function returnToCallback(error, result) {
+      debuglog('end-eval:', input, error);
+      callback(error, result);
+    }
+
+    try {
+      const result = evalInCurrentContext(input);
+
+      if (result && typeof result.then === 'function') {
+        toCallback(result, returnToCallback);
+        return;
+      }
+      returnToCallback(null, result);
+    } catch (e) {
+      returnToCallback(e);
+    }
+  }
+
+  function formatWatchers(verbose = false) {
+    if (!watchedExpressions.length) {
+      return Promise.resolve('');
+    }
+
+    const inspectValue = (expr) =>
+      evalInCurrentContext(expr)
+        // .then(formatValue)
+        .catch((error) => `<${error.message}>`);
+    const lastIndex = watchedExpressions.length - 1;
+
+    return Promise.all(watchedExpressions.map(inspectValue))
+      .then((values) => {
+        const lines = watchedExpressions
+          .map((expr, idx) => {
+            const prefix = `${leftPad(idx, ' ', lastIndex)}: ${expr} =`;
+            const value = inspect(values[idx], { colors: true });
+            if (value.indexOf('\n') === -1) {
+              return `${prefix} ${value}`;
+            }
+            return `${prefix}\n    ${value.split('\n').join('\n    ')}`;
+          });
+        return lines.join('\n');
+      })
+      .then((valueList) => {
+        return verbose ? `Watchers:\n${valueList}\n` : valueList;
+      });
+  }
+
+  function watchers(verbose = false) {
+    return formatWatchers(verbose).then(print);
+  }
+
+  // List source code
+  function list(delta = 5) {
+    return selectedFrame.list(delta)
+      .then(null, (error) => {
+        print('You can\'t list source code right now');
+        throw error;
+      });
+  }
+
+  function handleBreakpointResolved({ breakpointId, location }) {
+    const script = knownScripts[location.scriptId];
+    const scriptUrl = script && script.url;
+    if (scriptUrl) {
+      Object.assign(location, { scriptUrl });
+    }
+    const isExisting = knownBreakpoints.some((bp) => {
+      if (bp.breakpointId === breakpointId) {
+        Object.assign(bp, { location });
+        return true;
+      }
+      return false;
+    });
+    if (!isExisting) {
+      knownBreakpoints.push({ breakpointId, location });
+    }
+  }
+
+  function listBreakpoints() {
+    if (!knownBreakpoints.length) {
+      print('No breakpoints yet');
+      return;
+    }
+
+    function formatLocation(location) {
+      if (!location) return '<unknown location>';
+      const script = knownScripts[location.scriptId];
+      const scriptUrl = script ? script.url : location.scriptUrl;
+      return `${getRelativePath(scriptUrl)}:${location.lineNumber + 1}`;
+    }
+    const breaklist = knownBreakpoints
+      .map((bp, idx) => `#${idx} ${formatLocation(bp.location)}`)
+      .join('\n');
+    print(breaklist);
+  }
+
+  function setBreakpoint(script, line, condition, silent) {
+    function registerBreakpoint({ breakpointId, actualLocation }) {
+      handleBreakpointResolved({ breakpointId, location: actualLocation });
+      if (actualLocation && actualLocation.scriptId) {
+        if (!silent) return getSourceSnippet(actualLocation, 5);
+      } else {
+        print(`Warning: script '${script}' was not loaded yet.`);
+      }
+      return undefined;
+    }
+
+    // setBreakpoint(): set breakpoint at current location
+    if (script === undefined) {
+      return Debugger
+        .setBreakpoint({ location: getCurrentLocation(), condition })
+        .then(registerBreakpoint);
+    }
+
+    // setBreakpoint(line): set breakpoint in current script at specific line
+    if (line === undefined && typeof script === 'number') {
+      const location = {
+        scriptId: getCurrentLocation().scriptId,
+        lineNumber: script - 1,
+      };
+      return Debugger.setBreakpoint({ location, condition })
+        .then(registerBreakpoint);
+    }
+
+    if (typeof script !== 'string') {
+      throw new TypeError(`setBreakpoint() expects a string, got ${script}`);
+    }
+
+    // setBreakpoint('fn()'): Break when a function is called
+    if (script.endsWith('()')) {
+      const debugExpr = `debug(${script.slice(0, -2)})`;
+      const debugCall = selectedFrame
+        ? Debugger.evaluateOnCallFrame({
+          callFrameId: selectedFrame.callFrameId,
+          expression: debugExpr,
+          includeCommandLineAPI: true,
+        })
+        : Runtime.evaluate({
+          expression: debugExpr,
+          includeCommandLineAPI: true,
+        });
+      return debugCall.then(({ result, wasThrown }) => {
+        if (wasThrown) return convertResultToError(result);
+        return undefined; // This breakpoint can't be removed the same way
+      });
+    }
+
+    // setBreakpoint('scriptname')
+    let scriptId = null;
+    let ambiguous = false;
+    if (knownScripts[script]) {
+      scriptId = script;
+    } else {
+      for (const id of Object.keys(knownScripts)) {
+        const scriptUrl = knownScripts[id].url;
+        if (scriptUrl && scriptUrl.indexOf(script) !== -1) {
+          if (scriptId !== null) {
+            ambiguous = true;
+          }
+          scriptId = id;
+        }
+      }
+    }
+
+    if (ambiguous) {
+      print('Script name is ambiguous');
+      return undefined;
+    }
+    if (line <= 0) {
+      print('Line should be a positive value');
+      return undefined;
+    }
+
+    if (scriptId !== null) {
+      const location = { scriptId, lineNumber: line - 1 };
+      return Debugger.setBreakpoint({ location, condition })
+        .then(registerBreakpoint);
+    }
+
+    const escapedPath = script.replace(/([/\\.?*()^${}|[\]])/g, '\\$1');
+    const urlRegex = `^(.*[\\/\\\\])?${escapedPath}$`;
+
+    return Debugger
+      .setBreakpointByUrl({ urlRegex, lineNumber: line - 1, condition })
+      .then((bp) => {
+        // TODO: handle bp.locations in case the regex matches existing files
+        if (!bp.location) { // Fake it for now.
+          Object.assign(bp, {
+            actualLocation: {
+              scriptUrl: `.*/${script}$`,
+              lineNumber: line - 1,
+            },
+          });
+        }
+        return registerBreakpoint(bp);
+      });
+  }
+
+  function clearBreakpoint(url, line) {
+    const breakpoint = knownBreakpoints.find(({ location }) => {
+      if (!location) return false;
+      const script = knownScripts[location.scriptId];
+      if (!script) return false;
+      return (
+        script.url.indexOf(url) !== -1 && (location.lineNumber + 1) === line
+      );
+    });
+    if (!breakpoint) {
+      print(`Could not find breakpoint at ${url}:${line}`);
+      return Promise.resolve();
+    }
+    return Debugger.removeBreakpoint({ breakpointId: breakpoint.breakpointId })
+      .then(() => {
+        const idx = knownBreakpoints.indexOf(breakpoint);
+        knownBreakpoints.splice(idx, 1);
+      });
+  }
+
+  function restoreBreakpoints() {
+    const lastBreakpoints = knownBreakpoints.slice();
+    knownBreakpoints.length = 0;
+    const newBreakpoints = lastBreakpoints
+      .filter(({ location }) => !!location.scriptUrl)
+      .map(({ location }) =>
+        setBreakpoint(location.scriptUrl, location.lineNumber + 1));
+    if (!newBreakpoints.length) return;
+    Promise.all(newBreakpoints).then((results) => {
+      print(`${results.length} breakpoints restored.`);
+    });
+  }
+
+  function setPauseOnExceptions(state) {
+    return Debugger.setPauseOnExceptions({ state })
+      .then(() => {
+        pauseOnExceptionState = state;
+      });
+  }
+
+  Debugger.on('paused', ({ callFrames, reason /* , hitBreakpoints */ }) => {
+    // Save execution context's data
+    currentBacktrace = Backtrace.from(callFrames);
+    selectedFrame = currentBacktrace[0];
+    const { scriptId, lineNumber } = selectedFrame.location;
+
+    const breakType = reason === 'other' ? 'break' : reason;
+    const script = knownScripts[scriptId];
+    const scriptUrl = script ? getRelativePath(script.url) : '[unknown]';
+    print(`${breakType} in ${scriptUrl}:${lineNumber + 1}`);
+
+    inspector.suspendReplWhile(() =>
+      Promise.all([formatWatchers(true), selectedFrame.list(2)])
+        .then(([watcherList, context]) => {
+          if (watcherList) {
+            return `${watcherList}\n${inspect(context)}`;
+          }
+          return context;
+        }).then(print));
+  });
+
+  function handleResumed() {
+    currentBacktrace = null;
+    selectedFrame = null;
+  }
+
+  Debugger.on('resumed', handleResumed);
+
+  Debugger.on('breakpointResolved', handleBreakpointResolved);
+
+  Debugger.on('scriptParsed', (script) => {
+    const { scriptId, url } = script;
+    if (url) {
+      knownScripts[scriptId] = Object.assign({
+        isNative: isNativeUrl(url),
+      }, script);
+    }
+  });
+
+  Profiler.on('consoleProfileFinished', ({ profile }) => {
+    Profile.createAndRegister({ profile });
+    print([
+      'Captured new CPU profile.',
+      `Access it with profiles[${profiles.length - 1}]`
+    ].join('\n'));
+  });
+
+  function initializeContext(context) {
+    inspector.domainNames.forEach((domain) => {
+      Object.defineProperty(context, domain, {
+        value: inspector[domain],
+        enumerable: true,
+        configurable: true,
+        writeable: false,
+      });
+    });
+
+    copyOwnProperties(context, {
+      get help() {
+        print(HELP);
+      },
+
+      get run() {
+        return inspector.run();
+      },
+
+      get kill() {
+        return inspector.killChild();
+      },
+
+      get restart() {
+        return inspector.run();
+      },
+
+      get cont() {
+        handleResumed();
+        return Debugger.resume();
+      },
+
+      get next() {
+        handleResumed();
+        return Debugger.stepOver();
+      },
+
+      get step() {
+        handleResumed();
+        return Debugger.stepInto();
+      },
+
+      get out() {
+        handleResumed();
+        return Debugger.stepOut();
+      },
+
+      get pause() {
+        return Debugger.pause();
+      },
+
+      get backtrace() {
+        return currentBacktrace;
+      },
+
+      get breakpoints() {
+        return listBreakpoints();
+      },
+
+      exec(expr) {
+        return evalInCurrentContext(expr);
+      },
+
+      get profile() {
+        return Profiler.start();
+      },
+
+      get profileEnd() {
+        return Profiler.stop()
+          .then(Profile.createAndRegister);
+      },
+
+      get profiles() {
+        return profiles;
+      },
+
+      takeHeapSnapshot(filename = 'node.heapsnapshot') {
+        return new Promise((resolve, reject) => {
+          const absoluteFile = Path.resolve(filename);
+          const writer = FS.createWriteStream(absoluteFile);
+          let totalSize;
+          let sizeWritten = 0;
+          function onProgress({ done, total, finished }) {
+            totalSize = total;
+            if (finished) {
+              print('Heap snaphost prepared.');
+            } else {
+              print(`Heap snapshot: ${done}/${total}`, true);
+            }
+          }
+          function onChunk({ chunk }) {
+            sizeWritten += chunk.length;
+            writer.write(chunk);
+            print(`Writing snapshot: ${sizeWritten}/${totalSize}`, true);
+            if (sizeWritten >= totalSize) {
+              writer.end();
+              teardown();
+              print(`Wrote snapshot: ${absoluteFile}`);
+              resolve();
+            }
+          }
+          function teardown() {
+            HeapProfiler.removeListener(
+              'reportHeapSnapshotProgress', onProgress);
+            HeapProfiler.removeListener('addHeapSnapshotChunk', onChunk);
+          }
+
+          HeapProfiler.on('reportHeapSnapshotProgress', onProgress);
+          HeapProfiler.on('addHeapSnapshotChunk', onChunk);
+
+          print('Heap snapshot: 0/0', true);
+          HeapProfiler.takeHeapSnapshot({ reportProgress: true })
+            .then(null, (error) => {
+              teardown();
+              reject(error);
+            });
+        });
+      },
+
+      get watchers() {
+        return watchers();
+      },
+
+      watch(expr) {
+        watchedExpressions.push(expr);
+      },
+
+      unwatch(expr) {
+        const index = watchedExpressions.indexOf(expr);
+
+        // Unwatch by expression
+        // or
+        // Unwatch by watcher number
+        watchedExpressions.splice(index !== -1 ? index : +expr, 1);
+      },
+
+      get repl() {
+        // Don't display any default messages
+        const listeners = repl.rli.listeners('SIGINT').slice(0);
+        repl.rli.removeAllListeners('SIGINT');
+
+        const oldContext = repl.context;
+
+        exitDebugRepl = () => {
+          // Restore all listeners
+          process.nextTick(() => {
+            listeners.forEach((listener) => {
+              repl.rli.on('SIGINT', listener);
+            });
+          });
+
+          // Exit debug repl
+          repl.eval = controlEval;
+
+          // Swap history
+          history.debug = repl.rli.history;
+          repl.rli.history = history.control;
+
+          repl.context = oldContext;
+          repl.rli.setPrompt('debug> ');
+          repl.displayPrompt();
+
+          repl.rli.removeListener('SIGINT', exitDebugRepl);
+          repl.removeListener('exit', exitDebugRepl);
+
+          exitDebugRepl = null;
+        };
+
+        // Exit debug repl on SIGINT
+        repl.rli.on('SIGINT', exitDebugRepl);
+
+        // Exit debug repl on repl exit
+        repl.on('exit', exitDebugRepl);
+
+        // Set new
+        repl.eval = debugEval;
+        repl.context = {};
+
+        // Swap history
+        history.control = repl.rli.history;
+        repl.rli.history = history.debug;
+
+        repl.rli.setPrompt('> ');
+
+        print('Press Ctrl + C to leave debug repl');
+        repl.displayPrompt();
+      },
+
+      get version() {
+        return Runtime.evaluate({
+          expression: 'process.versions.v8',
+          contextId: 1,
+          returnByValue: true,
+        }).then(({ result }) => {
+          print(result.value);
+        });
+      },
+
+      scripts: listScripts,
+
+      setBreakpoint,
+      clearBreakpoint,
+      setPauseOnExceptions,
+      get breakOnException() {
+        return setPauseOnExceptions('all');
+      },
+      get breakOnUncaught() {
+        return setPauseOnExceptions('uncaught');
+      },
+      get breakOnNone() {
+        return setPauseOnExceptions('none');
+      },
+
+      list,
+    });
+    aliasProperties(context, SHORTCUTS);
+  }
+
+  return function startRepl() {
+    const replOptions = {
+      prompt: 'debug> ',
+      input: inspector.stdin,
+      output: inspector.stdout,
+      eval: controlEval,
+      useGlobal: false,
+      ignoreUndefined: true,
+    };
+    repl = Repl.start(replOptions); // eslint-disable-line prefer-const
+    initializeContext(repl.context);
+    repl.on('reset', initializeContext);
+
+    repl.defineCommand('interrupt', () => {
+      // We want this for testing purposes where sending CTRL-C can be tricky.
+      repl.rli.emit('SIGINT');
+    });
+
+    inspector.client.on('close', () => {
+      resetOnStart();
+    });
+
+    inspector.client.on('ready', () => {
+      restoreBreakpoints();
+      Debugger.setPauseOnExceptions({ state: pauseOnExceptionState });
+    });
+
+    return repl;
+  };
+}
+module.exports = createRepl;
diff --git a/deps/node-inspect/package.json b/deps/node-inspect/package.json
new file mode 100644
index 00000000000000..f4b3aec6d94d5d
--- /dev/null
+++ b/deps/node-inspect/package.json
@@ -0,0 +1,45 @@
+{
+  "name": "node-inspect",
+  "version": "1.10.4",
+  "description": "Node Inspect",
+  "license": "MIT",
+  "main": "lib/_inspect.js",
+  "bin": "cli.js",
+  "homepage": "https://github.com/buggerjs/node-inspect",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/buggerjs/node-inspect"
+  },
+  "bugs": {
+    "url": "https://github.com/buggerjs/node-inspect/issues"
+  },
+  "scripts": {
+    "pretest": "eslint --rulesdir=tools/eslint-rules lib test",
+    "test": "tap \"test/**/*.test.js\"",
+    "posttest": "nlm verify"
+  },
+  "nlm": {
+    "license": {
+      "files": [
+        "lib"
+      ]
+    }
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "eslint": "^3.10.2",
+    "nlm": "^3.0.0",
+    "tap": "^7.1.2"
+  },
+  "author": {
+    "name": "Jan Krems",
+    "email": "jan.krems@gmail.com"
+  },
+  "files": [
+    "*.js",
+    "lib"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  }
+}
diff --git a/deps/node-inspect/test/cli/backtrace.test.js b/deps/node-inspect/test/cli/backtrace.test.js
new file mode 100644
index 00000000000000..2e2ba4a3423360
--- /dev/null
+++ b/deps/node-inspect/test/cli/backtrace.test.js
@@ -0,0 +1,30 @@
+'use strict';
+const Path = require('path');
+
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('display and navigate backtrace', (t) => {
+  const script = Path.join('examples', 'backtrace.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.stepCommand('c'))
+    .then(() => cli.command('bt'))
+    .then(() => {
+      t.match(cli.output, `#0 topFn ${script}:8:2`);
+    })
+    .then(() => cli.command('backtrace'))
+    .then(() => {
+      t.match(cli.output, `#0 topFn ${script}:8:2`);
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/cli/break.test.js b/deps/node-inspect/test/cli/break.test.js
new file mode 100644
index 00000000000000..1c662d63fcce6a
--- /dev/null
+++ b/deps/node-inspect/test/cli/break.test.js
@@ -0,0 +1,195 @@
+'use strict';
+const Path = require('path');
+
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('stepping through breakpoints', (t) => {
+  const script = Path.join('examples', 'break.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:1`,
+        'pauses in the first line of the script');
+      t.match(
+        cli.output,
+        /> 1 \(function \([^)]+\) \{ const x = 10;/,
+        'shows the source and marks the current line');
+    })
+    .then(() => cli.stepCommand('n'))
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:2`,
+        'pauses in next line of the script');
+      t.match(
+        cli.output,
+        '> 2 let name = \'World\';',
+        'marks the 2nd line');
+    })
+    .then(() => cli.stepCommand('next'))
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:3`,
+        'pauses in next line of the script');
+      t.match(
+        cli.output,
+        '> 3 name = \'Robin\';',
+        'marks the 3nd line');
+    })
+    .then(() => cli.stepCommand('cont'))
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:10`,
+        'pauses on the next breakpoint');
+      t.match(
+        cli.output,
+        '>10 debugger;',
+        'marks the debugger line');
+    })
+
+    // Prepare additional breakpoints
+    .then(() => cli.command('sb("break.js", 6)'))
+    .then(() => t.notMatch(cli.output, 'Could not resolve breakpoint'))
+    .then(() => cli.command('sb("otherFunction()")'))
+    .then(() => cli.command('sb(16)'))
+    .then(() => t.notMatch(cli.output, 'Could not resolve breakpoint'))
+    .then(() => cli.command('breakpoints'))
+    .then(() => {
+      t.match(cli.output, `#0 ${script}:6`);
+      t.match(cli.output, `#1 ${script}:16`);
+    })
+
+    .then(() => cli.command('list()'))
+    .then(() => {
+      t.match(cli.output, '>10 debugger;', 'prints and marks current line');
+      t.strictDeepEqual(
+        cli.parseSourceLines(),
+        [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+        'prints 5 lines before and after');
+    })
+    .then(() => cli.command('list(2)'))
+    .then(() => {
+      t.match(cli.output, '>10 debugger;', 'prints and marks current line');
+      t.strictDeepEqual(
+        cli.parseSourceLines(),
+        [8, 9, 10, 11, 12],
+        'prints 2 lines before and after');
+    })
+
+    .then(() => cli.stepCommand('s'))
+    .then(() => cli.stepCommand(''))
+    .then(() => {
+      t.match(
+        cli.output,
+        'break in timers.js',
+        'entered timers.js');
+    })
+    .then(() => cli.stepCommand('cont'))
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:16`,
+        'found breakpoint we set above w/ line number only');
+    })
+    .then(() => cli.stepCommand('cont'))
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:6`,
+        'found breakpoint we set above w/ line number & script');
+    })
+    .then(() => cli.stepCommand(''))
+    .then(() => {
+      t.match(
+        cli.output,
+        `debugCommand in ${script}:14`,
+        'found function breakpoint we set above');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
+
+test('sb before loading file', (t) => {
+  const script = Path.join('examples', 'cjs', 'index.js');
+  const otherScript = Path.join('examples', 'cjs', 'other.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('sb("other.js", 3)'))
+    .then(() => {
+      t.match(
+        cli.output,
+        'not loaded yet',
+        'warns that the script was not loaded yet');
+    })
+    .then(() => cli.stepCommand('cont'))
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${otherScript}:3`,
+        'found breakpoint in file that was not loaded yet');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
+
+test('clearBreakpoint', (t) => {
+  const script = Path.join('examples', 'break.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('sb("break.js", 3)'))
+    .then(() => cli.command('sb("break.js", 9)'))
+    .then(() => cli.command('breakpoints'))
+    .then(() => {
+      t.match(cli.output, `#0 ${script}:3`);
+      t.match(cli.output, `#1 ${script}:9`);
+    })
+    .then(() => cli.command('clearBreakpoint("break.js", 4)'))
+    .then(() => {
+      t.match(cli.output, 'Could not find breakpoint');
+    })
+    .then(() => cli.command('clearBreakpoint("not-such-script.js", 3)'))
+    .then(() => {
+      t.match(cli.output, 'Could not find breakpoint');
+    })
+    .then(() => cli.command('clearBreakpoint("break.js", 3)'))
+    .then(() => cli.command('breakpoints'))
+    .then(() => {
+      t.match(cli.output, `#0 ${script}:9`);
+    })
+    .then(() => cli.stepCommand('cont'))
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:9`,
+        'hits the 2nd breakpoint because the 1st was cleared');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/cli/exceptions.test.js b/deps/node-inspect/test/cli/exceptions.test.js
new file mode 100644
index 00000000000000..6d3ff68f057068
--- /dev/null
+++ b/deps/node-inspect/test/cli/exceptions.test.js
@@ -0,0 +1,63 @@
+'use strict';
+const Path = require('path');
+
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('break on (uncaught) exceptions', (t) => {
+  const script = Path.join('examples', 'exceptions.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      t.match(cli.output, `break in ${script}:1`);
+    })
+    // making sure it will die by default:
+    .then(() => cli.command('c'))
+    .then(() => cli.waitFor(/disconnect/))
+
+    // Next run: With `breakOnException` it pauses in both places
+    .then(() => cli.stepCommand('r'))
+    .then(() => {
+      t.match(cli.output, `break in ${script}:1`);
+    })
+    .then(() => cli.command('breakOnException'))
+    .then(() => cli.stepCommand('c'))
+    .then(() => {
+      t.match(cli.output, `exception in ${script}:4`);
+    })
+    .then(() => cli.stepCommand('c'))
+    .then(() => {
+      t.match(cli.output, `exception in ${script}:10`);
+    })
+
+    // Next run: With `breakOnUncaught` it only pauses on the 2nd exception
+    .then(() => cli.command('breakOnUncaught'))
+    .then(() => cli.stepCommand('r')) // also, the setting survives the restart
+    .then(() => {
+      t.match(cli.output, `break in ${script}:1`);
+    })
+    .then(() => cli.stepCommand('c'))
+    .then(() => {
+      t.match(cli.output, `exception in ${script}:10`);
+    })
+
+    // Next run: Back to the initial state! It should die again.
+    .then(() => cli.command('breakOnNone'))
+    .then(() => cli.stepCommand('r'))
+    .then(() => {
+      t.match(cli.output, `break in ${script}:1`);
+    })
+    .then(() => cli.command('c'))
+    .then(() => cli.waitFor(/disconnect/))
+
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/cli/exec.test.js b/deps/node-inspect/test/cli/exec.test.js
new file mode 100644
index 00000000000000..5c647134d7489f
--- /dev/null
+++ b/deps/node-inspect/test/cli/exec.test.js
@@ -0,0 +1,77 @@
+'use strict';
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('examples/alive.js', (t) => {
+  const cli = startCLI(['examples/alive.js']);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('exec [typeof heartbeat, typeof process.exit]'))
+    .then(() => {
+      t.match(cli.output, '[ \'function\', \'function\' ]', 'works w/o paren');
+    })
+    .then(() => cli.command('repl'))
+    .then(() => {
+      t.match(
+        cli.output,
+        'Press Ctrl + C to leave debug repl\n> ',
+        'shows hint for how to leave repl');
+      t.notMatch(cli.output, 'debug>', 'changes the repl style');
+    })
+    .then(() => cli.command('[typeof heartbeat, typeof process.exit]'))
+    .then(() => cli.waitFor(/function/))
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      t.match(
+        cli.output,
+        '[ \'function\', \'function\' ]', 'can evaluate in the repl');
+      t.match(cli.output, /> $/);
+    })
+    .then(() => cli.ctrlC())
+    .then(() => cli.waitFor(/debug> $/))
+    .then(() => cli.command('exec("[typeof heartbeat, typeof process.exit]")'))
+    .then(() => {
+      t.match(cli.output, '[ \'function\', \'function\' ]', 'works w/ paren');
+    })
+    .then(() => cli.command('cont'))
+    .then(() => cli.command('exec [typeof heartbeat, typeof process.exit]'))
+    .then(() => {
+      t.match(
+        cli.output,
+        '[ \'undefined\', \'function\' ]',
+        'non-paused exec can see global but not module-scope values');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
+
+test('exec .scope', (t) => {
+  const cli = startCLI(['examples/backtrace.js']);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.stepCommand('c'))
+    .then(() => cli.command('exec .scope'))
+    .then(() => {
+      t.match(
+        cli.output,
+        '\'moduleScoped\'', 'displays closure from module body');
+      t.match(cli.output, '\'a\'', 'displays local / function arg');
+      t.match(cli.output, '\'l1\'', 'displays local scope');
+      t.notMatch(cli.output, '\'encodeURIComponent\'', 'omits global scope');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/cli/help.test.js b/deps/node-inspect/test/cli/help.test.js
new file mode 100644
index 00000000000000..11a935883434b7
--- /dev/null
+++ b/deps/node-inspect/test/cli/help.test.js
@@ -0,0 +1,22 @@
+'use strict';
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('examples/empty.js', (t) => {
+  const cli = startCLI(['examples/empty.js']);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('help'))
+    .then(() => {
+      t.match(cli.output, /run, restart, r\s+/m);
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/cli/invalid-args.test.js b/deps/node-inspect/test/cli/invalid-args.test.js
new file mode 100644
index 00000000000000..c831d799a0bdc5
--- /dev/null
+++ b/deps/node-inspect/test/cli/invalid-args.test.js
@@ -0,0 +1,25 @@
+'use strict';
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('launch CLI w/o args', (t) => {
+  const cli = startCLI([]);
+  return cli.quit()
+    .then((code) => {
+      t.equal(code, 1, 'exits with non-zero exit code');
+      t.match(cli.output, /^Usage:/, 'Prints usage info');
+    });
+});
+
+test('launch w/ invalid host:port', (t) => {
+  const cli = startCLI(['localhost:914']);
+  return cli.quit()
+    .then((code) => {
+      t.match(
+        cli.output,
+        'failed to connect',
+        'Tells the user that the connection failed');
+      t.equal(code, 1, 'exits with non-zero exit code');
+    });
+});
diff --git a/deps/node-inspect/test/cli/launch.test.js b/deps/node-inspect/test/cli/launch.test.js
new file mode 100644
index 00000000000000..962197e84f2295
--- /dev/null
+++ b/deps/node-inspect/test/cli/launch.test.js
@@ -0,0 +1,110 @@
+'use strict';
+const Path = require('path');
+
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('examples/empty.js', (t) => {
+  const script = Path.join('examples', 'empty.js');
+  const cli = startCLI([script]);
+  return cli.waitForPrompt()
+    .then(() => {
+      t.match(cli.output, 'debug>', 'prints a prompt');
+      t.match(
+        cli.output,
+        '< Debugger listening on port 9229',
+        'forwards child output');
+    })
+    .then(() => cli.command('["hello", "world"].join(" ")'))
+    .then(() => {
+      t.match(cli.output, 'hello world', 'prints the result');
+    })
+    .then(() => cli.command(''))
+    .then(() => {
+      t.match(cli.output, 'hello world', 'repeats the last command on <enter>');
+    })
+    .then(() => cli.command('version'))
+    .then(() => {
+      t.match(cli.output, process.versions.v8, 'version prints the v8 version');
+    })
+    .then(() => cli.quit())
+    .then((code) => {
+      t.equal(code, 0, 'exits with success');
+    });
+});
+
+test('run after quit / restart', (t) => {
+  const script = Path.join('examples', 'three-lines.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.stepCommand('n'))
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:2`,
+        'steps to the 2nd line');
+    })
+    .then(() => cli.command('cont'))
+    .then(() => cli.waitFor(/disconnect/))
+    .then(() => {
+      t.match(
+        cli.output,
+        'Waiting for the debugger to disconnect',
+        'the child was done');
+    })
+    .then(() => {
+      // On windows the socket won't close by itself
+      return cli.command('kill');
+    })
+    .then(() => cli.command('cont'))
+    .then(() => cli.waitFor(/start the app/))
+    .then(() => {
+      t.match(cli.output, 'Use `run` to start the app again');
+    })
+    .then(() => cli.stepCommand('run'))
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:1`,
+        'is back at the beginning');
+    })
+    .then(() => cli.stepCommand('n'))
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:2`,
+        'steps to the 2nd line');
+    })
+    .then(() => cli.stepCommand('restart'))
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:1`,
+        'is back at the beginning');
+    })
+    .then(() => cli.command('kill'))
+    .then(() => cli.command('cont'))
+    .then(() => cli.waitFor(/start the app/))
+    .then(() => {
+      t.match(cli.output, 'Use `run` to start the app again');
+    })
+    .then(() => cli.stepCommand('run'))
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      t.match(
+        cli.output,
+        `break in ${script}:1`,
+        'is back at the beginning');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/cli/low-level.test.js b/deps/node-inspect/test/cli/low-level.test.js
new file mode 100644
index 00000000000000..b6301b2f236830
--- /dev/null
+++ b/deps/node-inspect/test/cli/low-level.test.js
@@ -0,0 +1,31 @@
+'use strict';
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('Debugger agent direct access', (t) => {
+  const cli = startCLI(['examples/empty.js']);
+  const scriptPattern = /^\* (\d+): examples(?:\/|\\)empty.js/;
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('scripts'))
+    .then(() => {
+      const [, scriptId] = cli.output.match(scriptPattern);
+      return cli.command(
+        `Debugger.getScriptSource({ scriptId: '${scriptId}' })`
+      );
+    })
+    .then(() => {
+      t.match(
+        cli.output,
+        /scriptSource: '\(function \([^)]+\) \{ \\n}\);'/);
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/cli/preserve-breaks.test.js b/deps/node-inspect/test/cli/preserve-breaks.test.js
new file mode 100644
index 00000000000000..a248b3aa25605b
--- /dev/null
+++ b/deps/node-inspect/test/cli/preserve-breaks.test.js
@@ -0,0 +1,56 @@
+'use strict';
+const Path = require('path');
+
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('run after quit / restart', (t) => {
+  const script = Path.join('examples', 'three-lines.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('breakpoints'))
+    .then(() => {
+      t.match(cli.output, 'No breakpoints yet');
+    })
+    .then(() => cli.command('sb(2)'))
+    .then(() => cli.command('sb(3)'))
+    .then(() => cli.command('breakpoints'))
+    .then(() => {
+      t.match(cli.output, `#0 ${script}:2`);
+      t.match(cli.output, `#1 ${script}:3`);
+    })
+    .then(() => cli.stepCommand('c')) // hit line 2
+    .then(() => cli.stepCommand('c')) // hit line 3
+    .then(() => {
+      t.match(cli.output, `break in ${script}:3`);
+    })
+    .then(() => cli.command('restart'))
+    .then(() => cli.waitFor([/break in examples/, /breakpoints restored/]))
+    .then(() => cli.waitForPrompt())
+    .then(() => {
+      t.match(cli.output, `break in ${script}:1`);
+    })
+    .then(() => cli.stepCommand('c'))
+    .then(() => {
+      t.match(cli.output, `break in ${script}:2`);
+    })
+    .then(() => cli.stepCommand('c'))
+    .then(() => {
+      t.match(cli.output, `break in ${script}:3`);
+    })
+    .then(() => cli.command('breakpoints'))
+    .then(() => {
+      t.match(cli.output, `#0 ${script}:2`);
+      t.match(cli.output, `#1 ${script}:3`);
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/cli/profile.test.js b/deps/node-inspect/test/cli/profile.test.js
new file mode 100644
index 00000000000000..3ef1896200ef70
--- /dev/null
+++ b/deps/node-inspect/test/cli/profile.test.js
@@ -0,0 +1,32 @@
+'use strict';
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+test('profiles', (t) => {
+  const cli = startCLI(['examples/empty.js']);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('exec console.profile()'))
+    .then(() => {
+      t.match(cli.output, 'undefined');
+    })
+    .then(() => cli.command('exec console.profileEnd()'))
+    .then(() => delay(250))
+    .then(() => {
+      t.match(cli.output, 'undefined');
+      t.match(cli.output, 'Captured new CPU profile.');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/cli/scripts.test.js b/deps/node-inspect/test/cli/scripts.test.js
new file mode 100644
index 00000000000000..cd26411790059b
--- /dev/null
+++ b/deps/node-inspect/test/cli/scripts.test.js
@@ -0,0 +1,43 @@
+'use strict';
+const Path = require('path');
+
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('list scripts', (t) => {
+  const script = Path.join('examples', 'empty.js');
+  const cli = startCLI([script]);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('scripts'))
+    .then(() => {
+      t.match(
+        cli.output,
+        /^\* \d+: examples(?:\/|\\)empty\.js/,
+        'lists the user script');
+      t.notMatch(
+        cli.output,
+        /\d+: module\.js <native>/,
+        'omits node-internal scripts');
+    })
+    .then(() => cli.command('scripts(true)'))
+    .then(() => {
+      t.match(
+        cli.output,
+        /\* \d+: examples(?:\/|\\)empty\.js/,
+        'lists the user script');
+      t.match(
+        cli.output,
+        /\d+: module\.js <native>/,
+        'includes node-internal scripts');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/cli/start-cli.js b/deps/node-inspect/test/cli/start-cli.js
new file mode 100644
index 00000000000000..267aac57f4424c
--- /dev/null
+++ b/deps/node-inspect/test/cli/start-cli.js
@@ -0,0 +1,136 @@
+'use strict';
+const spawn = require('child_process').spawn;
+
+const CLI =
+  process.env.USE_EMBEDDED_NODE_INSPECT === '1' ?
+  'inspect' :
+  require.resolve('../../cli.js');
+
+function startCLI(args) {
+  const child = spawn(process.execPath, [CLI, ...args]);
+  let isFirstStdoutChunk = true;
+
+  const outputBuffer = [];
+  function bufferOutput(chunk) {
+    if (isFirstStdoutChunk) {
+      isFirstStdoutChunk = false;
+      outputBuffer.push(chunk.replace(/^debug>\s*/, ''));
+    } else {
+      outputBuffer.push(chunk);
+    }
+  }
+
+  function getOutput() {
+    return outputBuffer.join('').toString()
+      .replace(/^[^\n]*?[\b]/mg, '');
+  }
+
+  child.stdout.setEncoding('utf8');
+  child.stdout.on('data', bufferOutput);
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', bufferOutput);
+
+  if (process.env.VERBOSE === '1') {
+    child.stdout.pipe(process.stderr);
+    child.stderr.pipe(process.stderr);
+  }
+
+  return {
+    flushOutput() {
+      const output = this.output;
+      outputBuffer.length = 0;
+      return output;
+    },
+
+    waitFor(pattern, timeout = 2000) {
+      function checkPattern(str) {
+        if (Array.isArray(pattern)) {
+          return pattern.every((p) => p.test(str));
+        }
+        return pattern.test(str);
+      }
+
+      return new Promise((resolve, reject) => {
+        function checkOutput() {
+          if (checkPattern(getOutput())) {
+            tearDown(); // eslint-disable-line no-use-before-define
+            resolve();
+          }
+        }
+
+        function onChildExit() {
+          tearDown(); // eslint-disable-line no-use-before-define
+          reject(new Error(
+            `Child quit while waiting for ${pattern}; found: ${this.output}`));
+        }
+
+        const timer = setTimeout(() => {
+          tearDown(); // eslint-disable-line no-use-before-define
+          reject(new Error([
+            `Timeout (${timeout}) while waiting for ${pattern}`,
+            `found: ${this.output}`,
+          ].join('; ')));
+        }, timeout);
+
+        function tearDown() {
+          clearTimeout(timer);
+          child.stdout.removeListener('data', checkOutput);
+          child.removeListener('exit', onChildExit);
+        }
+
+        child.on('exit', onChildExit);
+        child.stdout.on('data', checkOutput);
+        checkOutput();
+      });
+    },
+
+    waitForPrompt(timeout = 2000) {
+      return this.waitFor(/>\s+$/, timeout);
+    },
+
+    ctrlC() {
+      return this.command('.interrupt');
+    },
+
+    get output() {
+      return getOutput();
+    },
+
+    get rawOutput() {
+      return outputBuffer.join('').toString();
+    },
+
+    parseSourceLines() {
+      return getOutput().split('\n')
+        .map((line) => line.match(/(?:\*|>)?\s*(\d+)/))
+        .filter((match) => match !== null)
+        .map((match) => +match[1]);
+    },
+
+    command(input) {
+      this.flushOutput();
+      child.stdin.write(input);
+      child.stdin.write('\n');
+      return this.waitForPrompt();
+    },
+
+    stepCommand(input) {
+      this.flushOutput();
+      child.stdin.write(input);
+      child.stdin.write('\n');
+      return this
+        .waitFor(
+          /(?:assert|break|debugCommand|exception|other|promiseRejection) in/
+        )
+        .then(() => this.waitForPrompt());
+    },
+
+    quit() {
+      return new Promise((resolve) => {
+        child.stdin.end();
+        child.on('exit', resolve);
+      });
+    },
+  };
+}
+module.exports = startCLI;
diff --git a/deps/node-inspect/test/cli/watchers.test.js b/deps/node-inspect/test/cli/watchers.test.js
new file mode 100644
index 00000000000000..d66f00814c72f3
--- /dev/null
+++ b/deps/node-inspect/test/cli/watchers.test.js
@@ -0,0 +1,42 @@
+'use strict';
+const { test } = require('tap');
+
+const startCLI = require('./start-cli');
+
+test('stepping through breakpoints', (t) => {
+  const cli = startCLI(['examples/break.js']);
+
+  function onFatal(error) {
+    cli.quit();
+    throw error;
+  }
+
+  return cli.waitFor(/break/)
+    .then(() => cli.waitForPrompt())
+    .then(() => cli.command('watch("x")'))
+    .then(() => cli.command('watch("\\"Hello\\"")'))
+    .then(() => cli.command('watch("42")'))
+    .then(() => cli.command('watch("NaN")'))
+    .then(() => cli.command('watch("true")'))
+    .then(() => cli.command('watch("[1, 2]")'))
+    .then(() => cli.command('watch("process.env")'))
+    .then(() => cli.command('watchers'))
+    .then(() => {
+      t.match(cli.output, 'x is not defined');
+    })
+    .then(() => cli.command('unwatch("42")'))
+    .then(() => cli.stepCommand('n'))
+    .then(() => {
+      t.match(cli.output, '0: x = 10');
+      t.match(cli.output, '1: "Hello" = \'Hello\'');
+      t.match(cli.output, '2: NaN = NaN');
+      t.match(cli.output, '3: true = true');
+      t.match(cli.output, '4: [1, 2] = [ 1, 2 ]');
+      t.match(
+        cli.output,
+        /5: process\.env =\n\s+\{[\s\S]+,\n\s+\.\.\. \}/,
+        'shows "..." for process.env');
+    })
+    .then(() => cli.quit())
+    .then(null, onFatal);
+});
diff --git a/deps/node-inspect/test/node-inspect.test.js b/deps/node-inspect/test/node-inspect.test.js
new file mode 100644
index 00000000000000..12e7313116750c
--- /dev/null
+++ b/deps/node-inspect/test/node-inspect.test.js
@@ -0,0 +1,9 @@
+'use strict';
+const tap = require('tap');
+
+const nodeInspect = require('../');
+
+tap.equal(
+  9229,
+  nodeInspect.port,
+  'Uses the --inspect default port');
diff --git a/deps/node-inspect/tools/eslint-rules/align-function-arguments.js b/deps/node-inspect/tools/eslint-rules/align-function-arguments.js
new file mode 100644
index 00000000000000..015552489a9d44
--- /dev/null
+++ b/deps/node-inspect/tools/eslint-rules/align-function-arguments.js
@@ -0,0 +1,76 @@
+/**
+ * @fileoverview Align arguments in multiline function calls
+ * @author Rich Trott
+ */
+'use strict';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+function checkArgumentAlignment(context, node) {
+
+  function isNodeFirstInLine(node, byEndLocation) {
+    const firstToken = byEndLocation === true ? context.getLastToken(node, 1) :
+      context.getTokenBefore(node);
+    const startLine = byEndLocation === true ? node.loc.end.line :
+      node.loc.start.line;
+    const endLine = firstToken ? firstToken.loc.end.line : -1;
+
+    return startLine !== endLine;
+  }
+
+  if (node.arguments.length === 0)
+    return;
+
+  var msg = '';
+  const first = node.arguments[0];
+  var currentLine = first.loc.start.line;
+  const firstColumn = first.loc.start.column;
+
+  const ignoreTypes = [
+    'ArrowFunctionExpression',
+    'FunctionExpression',
+    'ObjectExpression',
+  ];
+
+  const args = node.arguments;
+
+  // For now, don't bother trying to validate potentially complicating things
+  // like closures. Different people will have very different ideas and it's
+  // probably best to implement configuration options.
+  if (args.some((node) => { return ignoreTypes.indexOf(node.type) !== -1; })) {
+    return;
+  }
+
+  if (!isNodeFirstInLine(node)) {
+    return;
+  }
+
+  var misaligned;
+
+  args.slice(1).forEach((argument) => {
+    if (!misaligned) {
+      if (argument.loc.start.line === currentLine + 1) {
+        if (argument.loc.start.column !== firstColumn) {
+          if (isNodeFirstInLine(argument)) {
+            msg = 'Function argument in column ' +
+                  `${argument.loc.start.column + 1}, ` +
+                  `expected in ${firstColumn + 1}`;
+            misaligned = argument;
+          }
+        }
+      }
+    }
+    currentLine = argument.loc.start.line;
+  });
+
+  if (msg)
+    context.report(misaligned, msg);
+}
+
+module.exports = function(context) {
+  return {
+    'CallExpression': (node) => checkArgumentAlignment(context, node)
+  };
+};
diff --git a/deps/node-inspect/tools/eslint-rules/align-multiline-assignment.js b/deps/node-inspect/tools/eslint-rules/align-multiline-assignment.js
new file mode 100644
index 00000000000000..80896b5e96296d
--- /dev/null
+++ b/deps/node-inspect/tools/eslint-rules/align-multiline-assignment.js
@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Align multiline variable assignments
+ * @author Rich Trott
+ */
+'use strict';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+function getBinaryExpressionStarts(binaryExpression, starts) {
+  function getStartsFromOneSide(side, starts) {
+    starts.push(side.loc.start);
+    if (side.type === 'BinaryExpression') {
+      starts = getBinaryExpressionStarts(side, starts);
+    }
+    return starts;
+  }
+
+  starts = getStartsFromOneSide(binaryExpression.left, starts);
+  starts = getStartsFromOneSide(binaryExpression.right, starts);
+  return starts;
+}
+
+function checkExpressionAlignment(expression) {
+  if (!expression)
+    return;
+
+  var msg = '';
+
+  switch (expression.type) {
+    case 'BinaryExpression':
+      var starts = getBinaryExpressionStarts(expression, []);
+      var startLine = starts[0].line;
+      const startColumn = starts[0].column;
+      starts.forEach((loc) => {
+        if (loc.line > startLine) {
+          startLine = loc.line;
+          if (loc.column !== startColumn) {
+            msg = 'Misaligned multiline assignment';
+          }
+        }
+      });
+      break;
+  }
+  return msg;
+}
+
+function testAssignment(context, node) {
+  const msg = checkExpressionAlignment(node.right);
+  if (msg)
+    context.report(node, msg);
+}
+
+function testDeclaration(context, node) {
+  node.declarations.forEach((declaration) => {
+    const msg = checkExpressionAlignment(declaration.init);
+    // const start = declaration.init.loc.start;
+    if (msg)
+      context.report(node, msg);
+  });
+}
+
+module.exports = function(context) {
+  return {
+    'AssignmentExpression': (node) => testAssignment(context, node),
+    'VariableDeclaration': (node) => testDeclaration(context, node)
+  };
+};
diff --git a/deps/node-inspect/tools/eslint-rules/assert-fail-single-argument.js b/deps/node-inspect/tools/eslint-rules/assert-fail-single-argument.js
new file mode 100644
index 00000000000000..4ce790238181cc
--- /dev/null
+++ b/deps/node-inspect/tools/eslint-rules/assert-fail-single-argument.js
@@ -0,0 +1,30 @@
+/**
+ * @fileoverview Prohibit use of a single argument only in `assert.fail()`. It
+ * is almost always an error.
+ * @author Rich Trott
+ */
+'use strict';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const msg = 'assert.fail() message should be third argument';
+
+function isAssert(node) {
+  return node.callee.object && node.callee.object.name === 'assert';
+}
+
+function isFail(node) {
+  return node.callee.property && node.callee.property.name === 'fail';
+}
+
+module.exports = function(context) {
+  return {
+    'CallExpression': function(node) {
+      if (isAssert(node) && isFail(node) && node.arguments.length === 1) {
+        context.report(node, msg);
+      }
+    }
+  };
+};
diff --git a/deps/node-inspect/tools/eslint-rules/buffer-constructor.js b/deps/node-inspect/tools/eslint-rules/buffer-constructor.js
new file mode 100644
index 00000000000000..938598e8dbf618
--- /dev/null
+++ b/deps/node-inspect/tools/eslint-rules/buffer-constructor.js
@@ -0,0 +1,25 @@
+/**
+ * @fileoverview Require use of new Buffer constructor methods in lib
+ * @author James M Snell
+ */
+'use strict';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+const msg = 'Use of the Buffer() constructor has been deprecated. ' +
+            'Please use either Buffer.alloc(), Buffer.allocUnsafe(), ' +
+            'or Buffer.from()';
+
+function test(context, node) {
+  if (node.callee.name === 'Buffer') {
+    context.report(node, msg);
+  }
+}
+
+module.exports = function(context) {
+  return {
+    'NewExpression': (node) => test(context, node),
+    'CallExpression': (node) => test(context, node)
+  };
+};
diff --git a/deps/node-inspect/tools/eslint-rules/new-with-error.js b/deps/node-inspect/tools/eslint-rules/new-with-error.js
new file mode 100644
index 00000000000000..655f34bf080956
--- /dev/null
+++ b/deps/node-inspect/tools/eslint-rules/new-with-error.js
@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Require `throw new Error()` rather than `throw Error()`
+ * @author Rich Trott
+ */
+'use strict';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+  var errorList = context.options.length !== 0 ? context.options : ['Error'];
+
+  return {
+    'ThrowStatement': function(node) {
+      if (node.argument.type === 'CallExpression' &&
+          errorList.indexOf(node.argument.callee.name) !== -1) {
+        context.report(node, 'Use new keyword when throwing.');
+      }
+    }
+  };
+};
+
+module.exports.schema = {
+  'type': 'array',
+  'additionalItems': {
+    'type': 'string'
+  },
+  'uniqueItems': true
+};
diff --git a/deps/node-inspect/tools/eslint-rules/no-let-in-for-declaration.js b/deps/node-inspect/tools/eslint-rules/no-let-in-for-declaration.js
new file mode 100644
index 00000000000000..8b1a6783e0773d
--- /dev/null
+++ b/deps/node-inspect/tools/eslint-rules/no-let-in-for-declaration.js
@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Prohibit the use of `let` as the loop variable
+ *               in the initialization of for, and the left-hand
+ *               iterator in forIn and forOf loops.
+ *
+ * @author Jessica Quynh Tran
+ */
+
+'use strict';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+  create(context) {
+
+    const msg = 'Use of `let` as the loop variable in a for-loop is ' +
+                'not recommended. Please use `var` instead.';
+
+    /**
+     * Report function to test if the for-loop is declared using `let`.
+     */
+    function testForLoop(node) {
+      if (node.init && node.init.kind === 'let') {
+        context.report(node.init, msg);
+      }
+    }
+
+    /**
+     * Report function to test if the for-in or for-of loop
+     * is declared using `let`.
+     */
+    function testForInOfLoop(node) {
+      if (node.left && node.left.kind === 'let') {
+        context.report(node.left, msg);
+      }
+    }
+
+    return {
+      'ForStatement': testForLoop,
+      'ForInStatement': testForInOfLoop,
+      'ForOfStatement': testForInOfLoop
+    };
+  }
+};
diff --git a/deps/node-inspect/tools/eslint-rules/prefer-assert-methods.js b/deps/node-inspect/tools/eslint-rules/prefer-assert-methods.js
new file mode 100644
index 00000000000000..fa345eb7c3fc33
--- /dev/null
+++ b/deps/node-inspect/tools/eslint-rules/prefer-assert-methods.js
@@ -0,0 +1,39 @@
+'use strict';
+
+function isAssert(node) {
+  return node.expression &&
+    node.expression.type === 'CallExpression' &&
+    node.expression.callee &&
+    node.expression.callee.name === 'assert';
+}
+
+function getFirstArg(expression) {
+  return expression.arguments && expression.arguments[0];
+}
+
+function parseError(method, op) {
+  return `'assert.${method}' should be used instead of '${op}'`;
+}
+
+const preferedAssertMethod = {
+  '===': 'strictEqual',
+  '!==': 'notStrictEqual',
+  '==': 'equal',
+  '!=': 'notEqual'
+};
+
+module.exports = function(context) {
+  return {
+    ExpressionStatement(node) {
+      if (isAssert(node)) {
+        const arg = getFirstArg(node.expression);
+        if (arg && arg.type === 'BinaryExpression') {
+          const assertMethod = preferedAssertMethod[arg.operator];
+          if (assertMethod) {
+            context.report(node, parseError(assertMethod, arg.operator));
+          }
+        }
+      }
+    }
+  };
+};
diff --git a/deps/node-inspect/tools/eslint-rules/require-buffer.js b/deps/node-inspect/tools/eslint-rules/require-buffer.js
new file mode 100644
index 00000000000000..c9818cb758f7bd
--- /dev/null
+++ b/deps/node-inspect/tools/eslint-rules/require-buffer.js
@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports = function(context) {
+  function flagIt(reference) {
+    const msg = 'Use const Buffer = require(\'buffer\').Buffer; ' +
+                'at the beginning of this file';
+    context.report(reference.identifier, msg);
+  }
+
+  return {
+    'Program:exit': function() {
+      const globalScope = context.getScope();
+      const variable = globalScope.set.get('Buffer');
+      if (variable) {
+        variable.references.forEach(flagIt);
+      }
+    }
+  };
+};
diff --git a/deps/node-inspect/tools/eslint-rules/required-modules.js b/deps/node-inspect/tools/eslint-rules/required-modules.js
new file mode 100644
index 00000000000000..3e4a8e8aadfc82
--- /dev/null
+++ b/deps/node-inspect/tools/eslint-rules/required-modules.js
@@ -0,0 +1,99 @@
+/**
+ * @fileoverview Require usage of specified node modules.
+ * @author Rich Trott
+ */
+'use strict';
+
+var path = require('path');
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+  // trim required module names
+  var requiredModules = context.options;
+
+  var foundModules = [];
+
+  // if no modules are required we don't need to check the CallExpressions
+  if (requiredModules.length === 0) {
+    return {};
+  }
+
+  /**
+   * Function to check if a node is a string literal.
+   * @param {ASTNode} node The node to check.
+   * @returns {boolean} If the node is a string literal.
+   */
+  function isString(node) {
+    return node && node.type === 'Literal' && typeof node.value === 'string';
+  }
+
+  /**
+   * Function to check if a node is a require call.
+   * @param {ASTNode} node The node to check.
+   * @returns {boolean} If the node is a require call.
+   */
+  function isRequireCall(node) {
+    return node.callee.type === 'Identifier' && node.callee.name === 'require';
+  }
+
+  /**
+   * Function to check if a node has an argument that is a required module and
+   * return its name.
+   * @param {ASTNode} node The node to check
+   * @returns {undefined|String} required module name or undefined
+   */
+  function getRequiredModuleName(node) {
+    var moduleName;
+
+    // node has arguments and first argument is string
+    if (node.arguments.length && isString(node.arguments[0])) {
+      var argValue = path.basename(node.arguments[0].value.trim());
+
+      // check if value is in required modules array
+      if (requiredModules.indexOf(argValue) !== -1) {
+        moduleName = argValue;
+      }
+    }
+
+    return moduleName;
+  }
+
+  return {
+    'CallExpression': function(node) {
+      if (isRequireCall(node)) {
+        var requiredModuleName = getRequiredModuleName(node);
+
+        if (requiredModuleName) {
+          foundModules.push(requiredModuleName);
+        }
+      }
+    },
+    'Program:exit': function(node) {
+      if (foundModules.length < requiredModules.length) {
+        var missingModules = requiredModules.filter(
+          function(module) {
+            return foundModules.indexOf(module === -1);
+          }
+          );
+        missingModules.forEach(function(moduleName) {
+          context.report(
+            node,
+            'Mandatory module "{{moduleName}}" must be loaded.',
+            { moduleName: moduleName }
+            );
+        });
+      }
+    }
+  };
+};
+
+module.exports.schema = {
+  'type': 'array',
+  'additionalItems': {
+    'type': 'string'
+  },
+  'uniqueItems': true
+};