diff --git a/.gitignore b/.gitignore
index d60603514c801f..f652a2c74c37d6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,6 +15,7 @@
 !.mailmap
 !.nycrc
 !.travis.yml
+!.eslintrc.yaml
 
 core
 vgcore.*
@@ -38,14 +39,15 @@ icu_config.gypi
 .eslintcache
 node_trace.*.log
 coverage/
+!**/node_modules/**/coverage
 
 /out
 
 # various stuff that VC++ produces/uses
 Debug/
 !**/node_modules/debug/
-!deps/v8/src/debug/
 Release/
+!**/node_modules/**/release
 !doc/blog/**
 *.sln
 !nodemsi.sln
@@ -64,7 +66,6 @@ ipch/
 *.VC.opendb
 .vs/
 .vscode/
-/deps/v8/src/debug/obj
 /*.exe
 
 /config.mk
@@ -98,6 +99,7 @@ deps/openssl/openssl.xml
 deps/openssl/openssl.target.mk
 deps/zlib/zlib.target.mk
 
+!deps/npm/node_modules
 # not needed and causes issues for distro packagers
 deps/npm/node_modules/.bin/
 
@@ -130,8 +132,4 @@ deps/uv/docs/src/guide/
 # ignore VS compiler output unhandled by V8's .gitignore
 deps/v8/gypfiles/Debug/
 deps/v8/gypfiles/Release/
-deps/v8/src/Debug/
-deps/v8/src/Release/
-deps/v8/src/inspector/Debug/
-deps/v8/src/inspector/Release/
 deps/v8/third_party/eu-strip/
diff --git a/COLLABORATOR_GUIDE.md b/COLLABORATOR_GUIDE.md
index 513faa46c8ab34..75b3c5e6c2e068 100644
--- a/COLLABORATOR_GUIDE.md
+++ b/COLLABORATOR_GUIDE.md
@@ -171,10 +171,10 @@ agenda.
 ### Waiting for Approvals
 
 Before landing pull requests, sufficient time should be left for input
-from other Collaborators. In general, leave at least 48 hours during the
-week and 72 hours over weekends to account for international time
-differences and work schedules. However, certain types of pull requests
-can be fast-tracked and may be landed after a shorter delay. For example:
+from other Collaborators. In general, leave at least 72 hours to account for
+international time differences and work schedules. However, certain types of
+pull requests can be fast-tracked and may be landed after a shorter delay. For
+example:
 
 * Focused changes that affect only documentation and/or the test suite:
   * `code-and-learn` tasks typically fall into this category.
diff --git a/Makefile b/Makefile
index c5a6b19da06732..05d3056f27973e 100644
--- a/Makefile
+++ b/Makefile
@@ -1181,19 +1181,25 @@ else
 	@echo "To install (requires internet access) run: $ make format-cpp-build"
 endif
 
+ifeq ($(V),1)
+  CPPLINT_QUIET =
+else
+  CPPLINT_QUIET = --quiet
+endif
 .PHONY: lint-cpp
 # Lints the C++ code with cpplint.py and check-imports.py.
 lint-cpp: tools/.cpplintstamp
 
 tools/.cpplintstamp: $(LINT_CPP_FILES)
 	@echo "Running C++ linter..."
-	@$(PYTHON) tools/cpplint.py --quiet $?
+	@$(PYTHON) tools/cpplint.py $(CPPLINT_QUIET) $?
 	@$(PYTHON) tools/check-imports.py
 	@touch $@
 
 lint-addon-docs: test/addons/.docbuildstamp
 	@echo "Running C++ linter on addon docs..."
-	@$(PYTHON) tools/cpplint.py --filter=$(ADDON_DOC_LINT_FLAGS) $(LINT_CPP_ADDON_DOC_FILES_GLOB)
+	@$(PYTHON) tools/cpplint.py $(CPPLINT_QUIET) --filter=$(ADDON_DOC_LINT_FLAGS) \
+		$(LINT_CPP_ADDON_DOC_FILES_GLOB)
 
 cpplint: lint-cpp
 	@echo "Please use lint-cpp instead of cpplint"
diff --git a/common.gypi b/common.gypi
index 084bca14e0abaa..2621b5e327d5d8 100644
--- a/common.gypi
+++ b/common.gypi
@@ -9,6 +9,8 @@
     'library%': 'static_library',     # allow override to 'shared_library' for DLL/.so builds
     'component%': 'static_library',   # NB. these names match with what V8 expects
     'msvs_multi_core_compile': '0',   # we do enable multicore compiles, but not using the V8 way
+    'enable_pgo_generate%': '0',
+    'enable_pgo_use%': '0',
     'python%': 'python',
 
     'node_shared%': 'false',
diff --git a/configure.py b/configure.py
index da696a92b48c1a..4c2bd4d0bbcc7e 100755
--- a/configure.py
+++ b/configure.py
@@ -1226,7 +1226,6 @@ def configure_static(o):
 
 
 def write(filename, data):
-  filename = filename
   print_verbose('creating %s' % filename)
   with open(filename, 'w+') as f:
     f.write(data)
diff --git a/deps/v8/include/libplatform/libplatform.h b/deps/v8/include/libplatform/libplatform.h
index 2c830bf834b786..d001514f9883be 100644
--- a/deps/v8/include/libplatform/libplatform.h
+++ b/deps/v8/include/libplatform/libplatform.h
@@ -41,7 +41,7 @@ V8_PLATFORM_EXPORT std::unique_ptr<v8::Platform> NewDefaultPlatform(
         InProcessStackDumping::kDisabled,
     std::unique_ptr<v8::TracingController> tracing_controller = {});
 
-V8_PLATFORM_EXPORT V8_DEPRECATE_SOON(
+V8_PLATFORM_EXPORT V8_DEPRECATED(
     "Use NewDefaultPlatform instead",
     v8::Platform* CreateDefaultPlatform(
         int thread_pool_size = 0,
diff --git a/deps/v8/include/v8.h b/deps/v8/include/v8.h
index 05ab9b05210ab4..55ad7c8cf220cc 100644
--- a/deps/v8/include/v8.h
+++ b/deps/v8/include/v8.h
@@ -1019,8 +1019,12 @@ class V8_EXPORT PrimitiveArray {
  public:
   static Local<PrimitiveArray> New(Isolate* isolate, int length);
   int Length() const;
-  void Set(int index, Local<Primitive> item);
-  Local<Primitive> Get(int index);
+  V8_DEPRECATED("Use Isolate* version",
+      void Set(int index, Local<Primitive> item));
+  V8_DEPRECATED("Use Isolate* version",
+      Local<Primitive> Get(int index));
+  void Set(Isolate* isolate, int index, Local<Primitive> item);
+  Local<Primitive> Get(Isolate* isolate, int index);
 };
 
 /**
@@ -1735,8 +1739,8 @@ class V8_EXPORT StackTrace {
   /**
    * Returns a StackFrame at a particular index.
    */
-  V8_DEPRECATE_SOON("Use Isolate version",
-                    Local<StackFrame> GetFrame(uint32_t index) const);
+  V8_DEPRECATED("Use Isolate version",
+                Local<StackFrame> GetFrame(uint32_t index) const);
   Local<StackFrame> GetFrame(Isolate* isolate, uint32_t index) const;
 
   /**
@@ -2432,25 +2436,25 @@ class V8_EXPORT Value : public Data {
       Local<Context> context) const;
   V8_WARN_UNUSED_RESULT MaybeLocal<Int32> ToInt32(Local<Context> context) const;
 
-  V8_DEPRECATE_SOON("Use maybe version",
-                    Local<Boolean> ToBoolean(Isolate* isolate) const);
-  V8_DEPRECATE_SOON("Use maybe version",
-                    Local<Number> ToNumber(Isolate* isolate) const);
-  V8_DEPRECATE_SOON("Use maybe version",
-                    Local<String> ToString(Isolate* isolate) const);
-  V8_DEPRECATE_SOON("Use maybe version",
-                    Local<Object> ToObject(Isolate* isolate) const);
-  V8_DEPRECATE_SOON("Use maybe version",
-                    Local<Integer> ToInteger(Isolate* isolate) const);
-  V8_DEPRECATE_SOON("Use maybe version",
-                    Local<Int32> ToInt32(Isolate* isolate) const);
-
-  inline V8_DEPRECATE_SOON("Use maybe version",
-                           Local<Boolean> ToBoolean() const);
-  inline V8_DEPRECATE_SOON("Use maybe version", Local<String> ToString() const);
-  inline V8_DEPRECATE_SOON("Use maybe version", Local<Object> ToObject() const);
-  inline V8_DEPRECATE_SOON("Use maybe version",
-                           Local<Integer> ToInteger() const);
+  V8_DEPRECATED("Use maybe version",
+                Local<Boolean> ToBoolean(Isolate* isolate) const);
+  V8_DEPRECATED("Use maybe version",
+                Local<Number> ToNumber(Isolate* isolate) const);
+  V8_DEPRECATED("Use maybe version",
+                Local<String> ToString(Isolate* isolate) const);
+  V8_DEPRECATED("Use maybe version",
+                Local<Object> ToObject(Isolate* isolate) const);
+  V8_DEPRECATED("Use maybe version",
+                Local<Integer> ToInteger(Isolate* isolate) const);
+  V8_DEPRECATED("Use maybe version",
+                Local<Int32> ToInt32(Isolate* isolate) const);
+
+  inline V8_DEPRECATED("Use maybe version",
+                       Local<Boolean> ToBoolean() const);
+  inline V8_DEPRECATED("Use maybe version", Local<String> ToString() const);
+  inline V8_DEPRECATED("Use maybe version", Local<Object> ToObject() const);
+  inline V8_DEPRECATED("Use maybe version",
+                       Local<Integer> ToInteger() const);
 
   /**
    * Attempts to convert a string to an array index.
@@ -2467,14 +2471,14 @@ class V8_EXPORT Value : public Data {
       Local<Context> context) const;
   V8_WARN_UNUSED_RESULT Maybe<int32_t> Int32Value(Local<Context> context) const;
 
-  V8_DEPRECATE_SOON("Use maybe version", bool BooleanValue() const);
-  V8_DEPRECATE_SOON("Use maybe version", double NumberValue() const);
-  V8_DEPRECATE_SOON("Use maybe version", int64_t IntegerValue() const);
-  V8_DEPRECATE_SOON("Use maybe version", uint32_t Uint32Value() const);
-  V8_DEPRECATE_SOON("Use maybe version", int32_t Int32Value() const);
+  V8_DEPRECATED("Use maybe version", bool BooleanValue() const);
+  V8_DEPRECATED("Use maybe version", double NumberValue() const);
+  V8_DEPRECATED("Use maybe version", int64_t IntegerValue() const);
+  V8_DEPRECATED("Use maybe version", uint32_t Uint32Value() const);
+  V8_DEPRECATED("Use maybe version", int32_t Int32Value() const);
 
   /** JS == */
-  V8_DEPRECATE_SOON("Use maybe version", bool Equals(Local<Value> that) const);
+  V8_DEPRECATED("Use maybe version", bool Equals(Local<Value> that) const);
   V8_WARN_UNUSED_RESULT Maybe<bool> Equals(Local<Context> context,
                                            Local<Value> that) const;
   bool StrictEquals(Local<Value> that) const;
@@ -2580,7 +2584,7 @@ class V8_EXPORT String : public Name {
    * Returns the number of bytes in the UTF-8 encoded
    * representation of this string.
    */
-  V8_DEPRECATE_SOON("Use Isolate version instead", int Utf8Length() const);
+  V8_DEPRECATED("Use Isolate version instead", int Utf8Length() const);
 
   int Utf8Length(Isolate* isolate) const;
 
@@ -2638,23 +2642,23 @@ class V8_EXPORT String : public Name {
   // 16-bit character codes.
   int Write(Isolate* isolate, uint16_t* buffer, int start = 0, int length = -1,
             int options = NO_OPTIONS) const;
-  V8_DEPRECATE_SOON("Use Isolate* version",
-                    int Write(uint16_t* buffer, int start = 0, int length = -1,
-                              int options = NO_OPTIONS) const);
+  V8_DEPRECATED("Use Isolate* version",
+                int Write(uint16_t* buffer, int start = 0, int length = -1,
+                          int options = NO_OPTIONS) const);
   // One byte characters.
   int WriteOneByte(Isolate* isolate, uint8_t* buffer, int start = 0,
                    int length = -1, int options = NO_OPTIONS) const;
-  V8_DEPRECATE_SOON("Use Isolate* version",
-                    int WriteOneByte(uint8_t* buffer, int start = 0,
-                                     int length = -1, int options = NO_OPTIONS)
-                        const);
+  V8_DEPRECATED("Use Isolate* version",
+                int WriteOneByte(uint8_t* buffer, int start = 0,
+                                 int length = -1, int options = NO_OPTIONS)
+                    const);
   // UTF-8 encoded characters.
   int WriteUtf8(Isolate* isolate, char* buffer, int length = -1,
                 int* nchars_ref = NULL, int options = NO_OPTIONS) const;
-  V8_DEPRECATE_SOON("Use Isolate* version",
-                    int WriteUtf8(char* buffer, int length = -1,
-                                  int* nchars_ref = NULL,
-                                  int options = NO_OPTIONS) const);
+  V8_DEPRECATED("Use Isolate* version",
+                int WriteUtf8(char* buffer, int length = -1,
+                              int* nchars_ref = NULL,
+                              int options = NO_OPTIONS) const);
 
   /**
    * A zero length string.
@@ -2818,9 +2822,9 @@ class V8_EXPORT String : public Name {
    */
   static Local<String> Concat(Isolate* isolate, Local<String> left,
                               Local<String> right);
-  static V8_DEPRECATE_SOON("Use Isolate* version",
-                           Local<String> Concat(Local<String> left,
-                                                Local<String> right));
+  static V8_DEPRECATED("Use Isolate* version",
+                       Local<String> Concat(Local<String> left,
+                                            Local<String> right));
 
   /**
    * Creates a new external string using the data defined in the given
@@ -5044,7 +5048,9 @@ class V8_EXPORT BooleanObject : public Object {
  */
 class V8_EXPORT StringObject : public Object {
  public:
-  static Local<Value> New(Local<String> value);
+  static Local<Value> New(Isolate* isolate, Local<String> value);
+  V8_DEPRECATED("Use Isolate* version",
+                static Local<Value> New(Local<String> value));
 
   Local<String> ValueOf() const;
 
diff --git a/deps/v8/src/api.cc b/deps/v8/src/api.cc
index 09b2ae92dc8b1b..f68759f33bb16e 100644
--- a/deps/v8/src/api.cc
+++ b/deps/v8/src/api.cc
@@ -2227,6 +2227,10 @@ int PrimitiveArray::Length() const {
   return array->length();
 }
 
+void PrimitiveArray::Set(Isolate* isolate, int index, Local<Primitive> item) {
+  return Set(index, item);
+}
+
 void PrimitiveArray::Set(int index, Local<Primitive> item) {
   i::Handle<i::FixedArray> array = Utils::OpenHandle(this);
   i::Isolate* isolate = array->GetIsolate();
@@ -2239,6 +2243,10 @@ void PrimitiveArray::Set(int index, Local<Primitive> item) {
   array->set(index, *i_item);
 }
 
+Local<Primitive> PrimitiveArray::Get(Isolate* isolate, int index) {
+  return Get(index);
+}
+
 Local<Primitive> PrimitiveArray::Get(int index) {
   i::Handle<i::FixedArray> array = Utils::OpenHandle(this);
   i::Isolate* isolate = array->GetIsolate();
@@ -6880,6 +6888,11 @@ bool v8::BooleanObject::ValueOf() const {
 }
 
 
+Local<v8::Value> v8::StringObject::New(Isolate* isolate, Local<String> value) {
+  return New(value);
+}
+
+
 Local<v8::Value> v8::StringObject::New(Local<String> value) {
   i::Handle<i::String> string = Utils::OpenHandle(*value);
   i::Isolate* isolate = string->GetIsolate();
diff --git a/doc/api/errors.md b/doc/api/errors.md
index dcb2c77a7bf353..8aa4f0c2dc7c2f 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1555,18 +1555,6 @@ An attempt was made to operate on an already closed socket.
 
 A call was made and the UDP subsystem was not running.
 
-<a id="ERR_STDERR_CLOSE"></a>
-### ERR_STDERR_CLOSE
-
-An attempt was made to close the `process.stderr` stream. By design, Node.js
-does not allow `stdout` or `stderr` streams to be closed by user code.
-
-<a id="ERR_STDOUT_CLOSE"></a>
-### ERR_STDOUT_CLOSE
-
-An attempt was made to close the `process.stdout` stream. By design, Node.js
-does not allow `stdout` or `stderr` streams to be closed by user code.
-
 <a id="ERR_STREAM_CANNOT_PIPE"></a>
 ### ERR_STREAM_CANNOT_PIPE
 
@@ -1952,6 +1940,37 @@ removed: v10.0.0
 
 The `repl` module was unable to parse data from the REPL history file.
 
+
+<a id="ERR_STDERR_CLOSE"></a>
+### ERR_STDERR_CLOSE
+<!-- YAML
+removed: REPLACEME
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/23053
+    description: Rather than emitting an error, `process.stderr.end()` now
+                 only closes the stream side but not the underlying resource,
+                 making this error obsolete.
+-->
+
+An attempt was made to close the `process.stderr` stream. By design, Node.js
+does not allow `stdout` or `stderr` streams to be closed by user code.
+
+<a id="ERR_STDOUT_CLOSE"></a>
+### ERR_STDOUT_CLOSE
+<!-- YAML
+removed: REPLACEME
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/23053
+    description: Rather than emitting an error, `process.stderr.end()` now
+                 only closes the stream side but not the underlying resource,
+                 making this error obsolete.
+-->
+
+An attempt was made to close the `process.stdout` stream. By design, Node.js
+does not allow `stdout` or `stderr` streams to be closed by user code.
+
 <a id="ERR_STREAM_READ_NOT_IMPLEMENTED"></a>
 ### ERR_STREAM_READ_NOT_IMPLEMENTED
 <!-- YAML
@@ -2059,6 +2078,13 @@ instance.setEncoding('utf8');
 An attempt has been made to create a string larger than the maximum allowed
 size.
 
+<a id="ERR_TTY_WRITABLE_NOT_READABLE"></a>
+#### ERR_TTY_WRITABLE_NOT_READABLE
+
+This `Error` is thrown when a read is attempted on a TTY `WriteStream`,
+such as `process.stdout.on('data')`.
+
+
 [`--force-fips`]: cli.html#cli_force_fips
 [`'uncaughtException'`]: process.html#process_event_uncaughtexception
 [`child_process`]: child_process.html
diff --git a/doc/api/process.md b/doc/api/process.md
index 07d9b43b55b8c5..0eaeef8ba3e4f6 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1907,9 +1907,7 @@ important ways:
 
 1. They are used internally by [`console.log()`][] and [`console.error()`][],
    respectively.
-2. They cannot be closed ([`end()`][] will throw).
-3. They will never emit the [`'finish'`][] event.
-4. Writes may be synchronous depending on what the stream is connected to
+2. Writes may be synchronous depending on what the stream is connected to
    and whether the system is Windows or POSIX:
    - Files: *synchronous* on Windows and POSIX
    - TTYs (Terminals): *asynchronous* on Windows, *synchronous* on POSIX
@@ -2134,7 +2132,6 @@ cases:
   code will be `128` + `6`, or `134`.
 
 [`'exit'`]: #process_event_exit
-[`'finish'`]: stream.html#stream_event_finish
 [`'message'`]: child_process.html#child_process_event_message
 [`'rejectionHandled'`]: #process_event_rejectionhandled
 [`'uncaughtException'`]: #process_event_uncaughtexception
@@ -2148,7 +2145,6 @@ cases:
 [`console.error()`]: console.html#console_console_error_data_args
 [`console.log()`]: console.html#console_console_log_data_args
 [`domain`]: domain.html
-[`end()`]: stream.html#stream_writable_end_chunk_encoding_callback
 [`net.Server`]: net.html#net_class_net_server
 [`net.Socket`]: net.html#net_class_net_socket
 [`NODE_OPTIONS`]: cli.html#cli_node_options_options
diff --git a/doc/onboarding.md b/doc/onboarding.md
index 3a03edb17e8169..bd9418fd91f9c1 100644
--- a/doc/onboarding.md
+++ b/doc/onboarding.md
@@ -138,8 +138,7 @@ onboarding session.
   * There is a minimum waiting time which we try to respect for non-trivial
     changes so that people who may have important input in such a distributed
     project are able to respond.
-  * For non-trivial changes, leave the pull request open for at least 48 hours
-    (72 hours on a weekend).
+  * For non-trivial changes, leave the pull request open for at least 72 hours.
   * If a pull request is abandoned, check if they'd mind if you took it over
     (especially if it just has nits left).
 * Approving a change
@@ -215,7 +214,7 @@ needs to be pointed out separately during the onboarding.
 * Run CI on the PR. Because the PR does not affect any code, use the
   `node-test-pull-request-lite-pipeline` CI task.
 * After one or two approvals, land the PR (PRs of this type do not need to wait
-  for 48/72 hours to land).
+  for 72 hours to land).
   * Be sure to add the `PR-URL: <full-pr-url>` and appropriate `Reviewed-By:`
     metadata.
   * [`node-core-utils`][] automates the generation of metadata and the landing
diff --git a/lib/internal/assert.js b/lib/internal/assert.js
index 74f7e3f7c053c4..2e91b08006b242 100644
--- a/lib/internal/assert.js
+++ b/lib/internal/assert.js
@@ -43,7 +43,8 @@ function inspectValue(val) {
       // comparison.
       breakLength: Infinity,
       // Assert does not detect proxies currently.
-      showProxy: false
+      showProxy: false,
+      sorted: true
     }
   ).split('\n');
 }
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 6153f7e2994605..656c7e2c6c5a5b 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -817,8 +817,6 @@ E('ERR_SOCKET_BUFFER_SIZE',
 E('ERR_SOCKET_CANNOT_SEND', 'Unable to send data', Error);
 E('ERR_SOCKET_CLOSED', 'Socket is closed', Error);
 E('ERR_SOCKET_DGRAM_NOT_RUNNING', 'Not running', Error);
-E('ERR_STDERR_CLOSE', 'process.stderr cannot be closed', Error);
-E('ERR_STDOUT_CLOSE', 'process.stdout cannot be closed', Error);
 E('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable', Error);
 E('ERR_STREAM_DESTROYED', 'Cannot call %s after a stream was destroyed', Error);
 E('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
diff --git a/lib/internal/process/stdio.js b/lib/internal/process/stdio.js
index e4207a1aa768bd..ca09f4ff821a00 100644
--- a/lib/internal/process/stdio.js
+++ b/lib/internal/process/stdio.js
@@ -1,8 +1,6 @@
 'use strict';
 
 const {
-  ERR_STDERR_CLOSE,
-  ERR_STDOUT_CLOSE,
   ERR_UNKNOWN_STDIN_TYPE,
   ERR_UNKNOWN_STREAM_TYPE
 } = require('internal/errors').codes;
@@ -10,6 +8,8 @@ const {
 exports.setupProcessStdio = setupProcessStdio;
 exports.getMainThreadStdio = getMainThreadStdio;
 
+function dummyDestroy(err, cb) { cb(err); }
+
 function getMainThreadStdio() {
   var stdin;
   var stdout;
@@ -19,11 +19,8 @@ function getMainThreadStdio() {
     if (stdout) return stdout;
     stdout = createWritableStdioStream(1);
     stdout.destroySoon = stdout.destroy;
-    stdout._destroy = function(er, cb) {
-      // Avoid errors if we already emitted
-      er = er || new ERR_STDOUT_CLOSE();
-      cb(er);
-    };
+    // Override _destroy so that the fd is never actually closed.
+    stdout._destroy = dummyDestroy;
     if (stdout.isTTY) {
       process.on('SIGWINCH', () => stdout._refreshSize());
     }
@@ -34,11 +31,8 @@ function getMainThreadStdio() {
     if (stderr) return stderr;
     stderr = createWritableStdioStream(2);
     stderr.destroySoon = stderr.destroy;
-    stderr._destroy = function(er, cb) {
-      // Avoid errors if we already emitted
-      er = er || new ERR_STDERR_CLOSE();
-      cb(er);
-    };
+    // Override _destroy so that the fd is never actually closed.
+    stdout._destroy = dummyDestroy;
     if (stderr.isTTY) {
       process.on('SIGWINCH', () => stderr._refreshSize());
     }
diff --git a/lib/internal/util/inspect.js b/lib/internal/util/inspect.js
new file mode 100644
index 00000000000000..104944eb19ef3a
--- /dev/null
+++ b/lib/internal/util/inspect.js
@@ -0,0 +1,1100 @@
+'use strict';
+
+const { internalBinding } = require('internal/bootstrap/loaders');
+
+const {
+  getOwnNonIndexProperties,
+  getPromiseDetails,
+  getProxyDetails,
+  kPending,
+  kRejected,
+  previewEntries,
+  propertyFilter: {
+    ALL_PROPERTIES,
+    ONLY_ENUMERABLE
+  }
+} = process.binding('util');
+
+const {
+  customInspectSymbol,
+  deprecate,
+  isError,
+  join,
+  removeColors
+} = require('internal/util');
+
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE
+  },
+  isStackOverflowError
+} = require('internal/errors');
+
+const types = internalBinding('types');
+Object.assign(types, require('internal/util/types'));
+const {
+  isAnyArrayBuffer,
+  isArrayBuffer,
+  isArgumentsObject,
+  isBoxedPrimitive,
+  isDataView,
+  isExternal,
+  isMap,
+  isMapIterator,
+  isPromise,
+  isSet,
+  isSetIterator,
+  isWeakMap,
+  isWeakSet,
+  isRegExp,
+  isDate,
+  isTypedArray,
+  isStringObject,
+  isNumberObject,
+  isBooleanObject,
+  isBigIntObject,
+  isUint8Array,
+  isUint8ClampedArray,
+  isUint16Array,
+  isUint32Array,
+  isInt8Array,
+  isInt16Array,
+  isInt32Array,
+  isFloat32Array,
+  isFloat64Array,
+  isBigInt64Array,
+  isBigUint64Array
+} = types;
+
+const ReflectApply = Reflect.apply;
+
+// This function is borrowed from the function with the same name on V8 Extras'
+// `utils` object. V8 implements Reflect.apply very efficiently in conjunction
+// with the spread syntax, such that no additional special case is needed for
+// function calls w/o arguments.
+// Refs: https://github.com/v8/v8/blob/d6ead37d265d7215cf9c5f768f279e21bd170212/src/js/prologue.js#L152-L156
+function uncurryThis(func) {
+  return (thisArg, ...args) => ReflectApply(func, thisArg, args);
+}
+
+const propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);
+const regExpToString = uncurryThis(RegExp.prototype.toString);
+const dateToISOString = uncurryThis(Date.prototype.toISOString);
+const errorToString = uncurryThis(Error.prototype.toString);
+
+const bigIntValueOf = uncurryThis(BigInt.prototype.valueOf);
+const booleanValueOf = uncurryThis(Boolean.prototype.valueOf);
+const numberValueOf = uncurryThis(Number.prototype.valueOf);
+const symbolValueOf = uncurryThis(Symbol.prototype.valueOf);
+const stringValueOf = uncurryThis(String.prototype.valueOf);
+
+const setValues = uncurryThis(Set.prototype.values);
+const mapEntries = uncurryThis(Map.prototype.entries);
+const dateGetTime = uncurryThis(Date.prototype.getTime);
+const hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
+
+const inspectDefaultOptions = Object.seal({
+  showHidden: false,
+  depth: 2,
+  colors: false,
+  customInspect: true,
+  showProxy: false,
+  maxArrayLength: 100,
+  breakLength: 60,
+  compact: true,
+  sorted: false
+});
+
+const kObjectType = 0;
+const kArrayType = 1;
+const kArrayExtrasType = 2;
+
+/* eslint-disable no-control-regex */
+const strEscapeSequencesRegExp = /[\x00-\x1f\x27\x5c]/;
+const strEscapeSequencesReplacer = /[\x00-\x1f\x27\x5c]/g;
+/* eslint-enable no-control-regex */
+
+const keyStrRegExp = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
+const numberRegExp = /^(0|[1-9][0-9]*)$/;
+
+const readableRegExps = {};
+
+const kMinLineLength = 16;
+
+// Constants to map the iterator state.
+const kWeak = 0;
+const kIterator = 1;
+const kMapEntries = 2;
+
+// Escaped special characters. Use empty strings to fill up unused entries.
+const meta = [
+  '\\u0000', '\\u0001', '\\u0002', '\\u0003', '\\u0004',
+  '\\u0005', '\\u0006', '\\u0007', '\\b', '\\t',
+  '\\n', '\\u000b', '\\f', '\\r', '\\u000e',
+  '\\u000f', '\\u0010', '\\u0011', '\\u0012', '\\u0013',
+  '\\u0014', '\\u0015', '\\u0016', '\\u0017', '\\u0018',
+  '\\u0019', '\\u001a', '\\u001b', '\\u001c', '\\u001d',
+  '\\u001e', '\\u001f', '', '', '',
+  '', '', '', '', "\\'", '', '', '', '', '',
+  '', '', '', '', '', '', '', '', '', '',
+  '', '', '', '', '', '', '', '', '', '',
+  '', '', '', '', '', '', '', '', '', '',
+  '', '', '', '', '', '', '', '', '', '',
+  '', '', '', '', '', '', '', '\\\\'
+];
+
+/**
+ * Echos the value of any input. Tries to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {any} value The value to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* Legacy: value, showHidden, depth, colors */
+function inspect(value, opts) {
+  // Default options
+  const ctx = {
+    budget: {},
+    indentationLvl: 0,
+    seen: [],
+    stylize: stylizeNoColor,
+    showHidden: inspectDefaultOptions.showHidden,
+    depth: inspectDefaultOptions.depth,
+    colors: inspectDefaultOptions.colors,
+    customInspect: inspectDefaultOptions.customInspect,
+    showProxy: inspectDefaultOptions.showProxy,
+    // TODO(BridgeAR): Deprecate `maxArrayLength` and replace it with
+    // `maxEntries`.
+    maxArrayLength: inspectDefaultOptions.maxArrayLength,
+    breakLength: inspectDefaultOptions.breakLength,
+    compact: inspectDefaultOptions.compact,
+    sorted: inspectDefaultOptions.sorted
+  };
+  // Legacy...
+  if (arguments.length > 2) {
+    if (arguments[2] !== undefined) {
+      ctx.depth = arguments[2];
+    }
+    if (arguments.length > 3 && arguments[3] !== undefined) {
+      ctx.colors = arguments[3];
+    }
+  }
+  // Set user-specified options
+  if (typeof opts === 'boolean') {
+    ctx.showHidden = opts;
+  } else if (opts) {
+    const optKeys = Object.keys(opts);
+    for (var i = 0; i < optKeys.length; i++) {
+      ctx[optKeys[i]] = opts[optKeys[i]];
+    }
+  }
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  if (ctx.maxArrayLength === null) ctx.maxArrayLength = Infinity;
+  return formatValue(ctx, value, ctx.depth);
+}
+inspect.custom = customInspectSymbol;
+
+Object.defineProperty(inspect, 'defaultOptions', {
+  get() {
+    return inspectDefaultOptions;
+  },
+  set(options) {
+    if (options === null || typeof options !== 'object') {
+      throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
+    }
+    return Object.assign(inspectDefaultOptions, options);
+  }
+});
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = Object.assign(Object.create(null), {
+  'bold': [1, 22],
+  'italic': [3, 23],
+  'underline': [4, 24],
+  'inverse': [7, 27],
+  'white': [37, 39],
+  'grey': [90, 39],
+  'black': [30, 39],
+  'blue': [34, 39],
+  'cyan': [36, 39],
+  'green': [32, 39],
+  'magenta': [35, 39],
+  'red': [31, 39],
+  'yellow': [33, 39]
+});
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = Object.assign(Object.create(null), {
+  'special': 'cyan',
+  'number': 'yellow',
+  'bigint': 'yellow',
+  'boolean': 'yellow',
+  'undefined': 'grey',
+  'null': 'bold',
+  'string': 'green',
+  'symbol': 'green',
+  'date': 'magenta',
+  // "name": intentionally not styling
+  'regexp': 'red'
+});
+
+const escapeFn = (str) => meta[str.charCodeAt(0)];
+
+// Escape control characters, single quotes and the backslash.
+// This is similar to JSON stringify escaping.
+function strEscape(str) {
+  // Some magic numbers that worked out fine while benchmarking with v8 6.0
+  if (str.length < 5000 && !strEscapeSequencesRegExp.test(str))
+    return `'${str}'`;
+  if (str.length > 100)
+    return `'${str.replace(strEscapeSequencesReplacer, escapeFn)}'`;
+  let result = '';
+  let last = 0;
+  for (var i = 0; i < str.length; i++) {
+    const point = str.charCodeAt(i);
+    if (point === 39 || point === 92 || point < 32) {
+      if (last === i) {
+        result += meta[point];
+      } else {
+        result += `${str.slice(last, i)}${meta[point]}`;
+      }
+      last = i + 1;
+    }
+  }
+  if (last === 0) {
+    result = str;
+  } else if (last !== i) {
+    result += str.slice(last);
+  }
+  return `'${result}'`;
+}
+
+function stylizeWithColor(str, styleType) {
+  const style = inspect.styles[styleType];
+  if (style !== undefined) {
+    const color = inspect.colors[style];
+    return `\u001b[${color[0]}m${str}\u001b[${color[1]}m`;
+  }
+  return str;
+}
+
+function stylizeNoColor(str) {
+  return str;
+}
+
+// Return a new empty array to push in the results of the default formatter.
+function getEmptyFormatArray() {
+  return [];
+}
+
+function getConstructorName(obj) {
+  while (obj) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, 'constructor');
+    if (descriptor !== undefined &&
+        typeof descriptor.value === 'function' &&
+        descriptor.value.name !== '') {
+      return descriptor.value.name;
+    }
+
+    obj = Object.getPrototypeOf(obj);
+  }
+
+  return '';
+}
+
+function getPrefix(constructor, tag, fallback) {
+  if (constructor !== '') {
+    if (tag !== '' && constructor !== tag) {
+      return `${constructor} [${tag}] `;
+    }
+    return `${constructor} `;
+  }
+
+  if (tag !== '')
+    return `[${tag}] `;
+
+  if (fallback !== undefined)
+    return `${fallback} `;
+
+  return '';
+}
+
+const getBoxedValue = formatPrimitive.bind(null, stylizeNoColor);
+
+// Look up the keys of the object.
+function getKeys(value, showHidden) {
+  let keys;
+  const symbols = Object.getOwnPropertySymbols(value);
+  if (showHidden) {
+    keys = Object.getOwnPropertyNames(value);
+    if (symbols.length !== 0)
+      keys.push(...symbols);
+  } else {
+    // This might throw if `value` is a Module Namespace Object from an
+    // unevaluated module, but we don't want to perform the actual type
+    // check because it's expensive.
+    // TODO(devsnek): track https://github.com/tc39/ecma262/issues/1209
+    // and modify this logic as needed.
+    try {
+      keys = Object.keys(value);
+    } catch (err) {
+      if (types.isNativeError(err) &&
+          err.name === 'ReferenceError' &&
+          types.isModuleNamespaceObject(value)) {
+        keys = Object.getOwnPropertyNames(value);
+      } else {
+        throw err;
+      }
+    }
+    if (symbols.length !== 0) {
+      keys.push(...symbols.filter((key) => propertyIsEnumerable(value, key)));
+    }
+  }
+  return keys;
+}
+
+function formatProxy(ctx, proxy, recurseTimes) {
+  if (recurseTimes != null) {
+    if (recurseTimes < 0)
+      return ctx.stylize('Proxy [Array]', 'special');
+    recurseTimes -= 1;
+  }
+  ctx.indentationLvl += 2;
+  const res = [
+    formatValue(ctx, proxy[0], recurseTimes),
+    formatValue(ctx, proxy[1], recurseTimes)
+  ];
+  ctx.indentationLvl -= 2;
+  const str = reduceToSingleString(ctx, res, '', ['[', ']']);
+  return `Proxy ${str}`;
+}
+
+function findTypedConstructor(value) {
+  for (const [check, clazz] of [
+    [isUint8Array, Uint8Array],
+    [isUint8ClampedArray, Uint8ClampedArray],
+    [isUint16Array, Uint16Array],
+    [isUint32Array, Uint32Array],
+    [isInt8Array, Int8Array],
+    [isInt16Array, Int16Array],
+    [isInt32Array, Int32Array],
+    [isFloat32Array, Float32Array],
+    [isFloat64Array, Float64Array],
+    [isBigInt64Array, BigInt64Array],
+    [isBigUint64Array, BigUint64Array]
+  ]) {
+    if (check(value)) {
+      return clazz;
+    }
+  }
+}
+
+function noPrototypeIterator(ctx, value, recurseTimes) {
+  let newVal;
+  // TODO: Create a Subclass in case there's no prototype and show
+  // `null-prototype`.
+  if (isSet(value)) {
+    const clazz = Object.getPrototypeOf(value) || Set;
+    newVal = new clazz(setValues(value));
+  } else if (isMap(value)) {
+    const clazz = Object.getPrototypeOf(value) || Map;
+    newVal = new clazz(mapEntries(value));
+  } else if (Array.isArray(value)) {
+    const clazz = Object.getPrototypeOf(value) || Array;
+    newVal = new clazz(value.length || 0);
+  } else if (isTypedArray(value)) {
+    const clazz = findTypedConstructor(value) || Uint8Array;
+    newVal = new clazz(value);
+  }
+  if (newVal) {
+    Object.defineProperties(newVal, Object.getOwnPropertyDescriptors(value));
+    return formatValue(ctx, newVal, recurseTimes);
+  }
+}
+
+// Note: using `formatValue` directly requires the indentation level to be
+// corrected by setting `ctx.indentationLvL += diff` and then to decrease the
+// value afterwards again.
+function formatValue(ctx, value, recurseTimes) {
+  // Primitive types cannot have properties
+  if (typeof value !== 'object' && typeof value !== 'function') {
+    return formatPrimitive(ctx.stylize, value, ctx);
+  }
+  if (value === null) {
+    return ctx.stylize('null', 'null');
+  }
+
+  if (ctx.showProxy) {
+    const proxy = getProxyDetails(value);
+    if (proxy !== undefined) {
+      return formatProxy(ctx, proxy, recurseTimes);
+    }
+  }
+
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it
+  if (ctx.customInspect) {
+    let maybeCustom = value[customInspectSymbol];
+
+    if (!maybeCustom && value.inspect !== inspect &&
+        typeof value.inspect === 'function') {
+      maybeCustom = deprecate(
+        value.inspect,
+        'Custom inspection function on Objects via .inspect() is deprecated',
+        'DEP0079'
+      );
+    }
+
+    if (typeof maybeCustom === 'function' &&
+        // Filter out the util module, its inspect function is special
+        maybeCustom !== inspect &&
+        // Also filter out any prototype objects using the circular check.
+        !(value.constructor && value.constructor.prototype === value)) {
+      const ret = maybeCustom.call(value, recurseTimes, ctx);
+
+      // If the custom inspection method returned `this`, don't go into
+      // infinite recursion.
+      if (ret !== value) {
+        if (typeof ret !== 'string') {
+          return formatValue(ctx, ret, recurseTimes);
+        }
+        return ret;
+      }
+    }
+  }
+
+  // Using an array here is actually better for the average case than using
+  // a Set. `seen` will only check for the depth and will never grow too large.
+  if (ctx.seen.indexOf(value) !== -1)
+    return ctx.stylize('[Circular]', 'special');
+
+  return formatRaw(ctx, value, recurseTimes);
+}
+
+function formatRaw(ctx, value, recurseTimes) {
+  let keys;
+
+  const constructor = getConstructorName(value);
+  let tag = value[Symbol.toStringTag];
+  if (typeof tag !== 'string')
+    tag = '';
+  let base = '';
+  let formatter = getEmptyFormatArray;
+  let braces;
+  let noIterator = true;
+  let i = 0;
+  let skip = false;
+  const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
+
+  let extrasType = kObjectType;
+
+  // Iterators and the rest are split to reduce checks
+  if (value[Symbol.iterator]) {
+    noIterator = false;
+    if (Array.isArray(value)) {
+      keys = getOwnNonIndexProperties(value, filter);
+      // Only set the constructor for non ordinary ("Array [...]") arrays.
+      const prefix = getPrefix(constructor, tag);
+      braces = [`${prefix === 'Array ' ? '' : prefix}[`, ']'];
+      if (value.length === 0 && keys.length === 0)
+        return `${braces[0]}]`;
+      extrasType = kArrayExtrasType;
+      formatter = formatArray;
+    } else if (isSet(value)) {
+      keys = getKeys(value, ctx.showHidden);
+      const prefix = getPrefix(constructor, tag);
+      if (value.size === 0 && keys.length === 0)
+        return `${prefix}{}`;
+      braces = [`${prefix}{`, '}'];
+      formatter = formatSet;
+    } else if (isMap(value)) {
+      keys = getKeys(value, ctx.showHidden);
+      const prefix = getPrefix(constructor, tag);
+      if (value.size === 0 && keys.length === 0)
+        return `${prefix}{}`;
+      braces = [`${prefix}{`, '}'];
+      formatter = formatMap;
+    } else if (isTypedArray(value)) {
+      keys = getOwnNonIndexProperties(value, filter);
+      braces = [`${getPrefix(constructor, tag)}[`, ']'];
+      if (value.length === 0 && keys.length === 0 && !ctx.showHidden)
+        return `${braces[0]}]`;
+      formatter = formatTypedArray;
+      extrasType = kArrayExtrasType;
+    } else if (isMapIterator(value)) {
+      keys = getKeys(value, ctx.showHidden);
+      braces = [`[${tag}] {`, '}'];
+      formatter = formatMapIterator;
+    } else if (isSetIterator(value)) {
+      keys = getKeys(value, ctx.showHidden);
+      braces = [`[${tag}] {`, '}'];
+      formatter = formatSetIterator;
+    } else {
+      noIterator = true;
+    }
+  }
+  if (noIterator) {
+    keys = getKeys(value, ctx.showHidden);
+    braces = ['{', '}'];
+    if (constructor === 'Object') {
+      if (isArgumentsObject(value)) {
+        if (keys.length === 0)
+          return '[Arguments] {}';
+        braces[0] = '[Arguments] {';
+      } else if (tag !== '') {
+        braces[0] = `${getPrefix(constructor, tag)}{`;
+        if (keys.length === 0) {
+          return `${braces[0]}}`;
+        }
+      } else if (keys.length === 0) {
+        return '{}';
+      }
+    } else if (typeof value === 'function') {
+      const type = constructor || tag || 'Function';
+      const name = `${type}${value.name ? `: ${value.name}` : ''}`;
+      if (keys.length === 0)
+        return ctx.stylize(`[${name}]`, 'special');
+      base = `[${name}]`;
+    } else if (isRegExp(value)) {
+      // Make RegExps say that they are RegExps
+      if (keys.length === 0 || recurseTimes < 0)
+        return ctx.stylize(regExpToString(value), 'regexp');
+      base = `${regExpToString(value)}`;
+    } else if (isDate(value)) {
+      // Make dates with properties first say the date
+      if (keys.length === 0) {
+        if (Number.isNaN(dateGetTime(value)))
+          return ctx.stylize(String(value), 'date');
+        return ctx.stylize(dateToISOString(value), 'date');
+      }
+      base = dateToISOString(value);
+    } else if (isError(value)) {
+      // Make error with message first say the error
+      base = formatError(value);
+      // Wrap the error in brackets in case it has no stack trace.
+      const stackStart = base.indexOf('\n    at');
+      if (stackStart === -1) {
+        base = `[${base}]`;
+      }
+      // The message and the stack have to be indented as well!
+      if (ctx.indentationLvl !== 0) {
+        const indentation = ' '.repeat(ctx.indentationLvl);
+        base = formatError(value).replace(/\n/g, `\n${indentation}`);
+      }
+      if (keys.length === 0)
+        return base;
+
+      if (ctx.compact === false && stackStart !== -1) {
+        braces[0] += `${base.slice(stackStart)}`;
+        base = `[${base.slice(0, stackStart)}]`;
+      }
+    } else if (isAnyArrayBuffer(value)) {
+      let prefix = getPrefix(constructor, tag);
+      if (prefix === '') {
+        prefix = isArrayBuffer(value) ? 'ArrayBuffer ' : 'SharedArrayBuffer ';
+      }
+      // Fast path for ArrayBuffer and SharedArrayBuffer.
+      // Can't do the same for DataView because it has a non-primitive
+      // .buffer property that we need to recurse for.
+      if (keys.length === 0)
+        return prefix +
+              `{ byteLength: ${formatNumber(ctx.stylize, value.byteLength)} }`;
+      braces[0] = `${prefix}{`;
+      keys.unshift('byteLength');
+    } else if (isDataView(value)) {
+      braces[0] = `${getPrefix(constructor, tag, 'DataView')}{`;
+      // .buffer goes last, it's not a primitive like the others.
+      keys.unshift('byteLength', 'byteOffset', 'buffer');
+    } else if (isPromise(value)) {
+      braces[0] = `${getPrefix(constructor, tag, 'Promise')}{`;
+      formatter = formatPromise;
+    } else if (isWeakSet(value)) {
+      braces[0] = `${getPrefix(constructor, tag, 'WeakSet')}{`;
+      formatter = ctx.showHidden ? formatWeakSet : formatWeakCollection;
+    } else if (isWeakMap(value)) {
+      braces[0] = `${getPrefix(constructor, tag, 'WeakMap')}{`;
+      formatter = ctx.showHidden ? formatWeakMap : formatWeakCollection;
+    } else if (types.isModuleNamespaceObject(value)) {
+      braces[0] = `[${tag}] {`;
+      formatter = formatNamespaceObject;
+      skip = true;
+    } else if (isBoxedPrimitive(value)) {
+      let type;
+      if (isNumberObject(value)) {
+        base = `[Number: ${getBoxedValue(numberValueOf(value))}]`;
+        type = 'number';
+      } else if (isStringObject(value)) {
+        base = `[String: ${getBoxedValue(stringValueOf(value), ctx)}]`;
+        type = 'string';
+        // For boxed Strings, we have to remove the 0-n indexed entries,
+        // since they just noisy up the output and are redundant
+        // Make boxed primitive Strings look like such
+        keys = keys.slice(value.length);
+      } else if (isBooleanObject(value)) {
+        base = `[Boolean: ${getBoxedValue(booleanValueOf(value))}]`;
+        type = 'boolean';
+      } else if (isBigIntObject(value)) {
+        base = `[BigInt: ${getBoxedValue(bigIntValueOf(value))}]`;
+        type = 'bigint';
+      } else {
+        base = `[Symbol: ${getBoxedValue(symbolValueOf(value))}]`;
+        type = 'symbol';
+      }
+      if (keys.length === 0) {
+        return ctx.stylize(base, type);
+      }
+    } else {
+      // The input prototype got manipulated. Special handle these. We have to
+      // rebuild the information so we are able to display everything.
+      const specialIterator = noPrototypeIterator(ctx, value, recurseTimes);
+      if (specialIterator) {
+        return specialIterator;
+      }
+      if (isMapIterator(value)) {
+        braces = [`[${tag || 'Map Iterator'}] {`, '}'];
+        formatter = formatMapIterator;
+      } else if (isSetIterator(value)) {
+        braces = [`[${tag || 'Set Iterator'}] {`, '}'];
+        formatter = formatSetIterator;
+      // Handle other regular objects again.
+      } else if (keys.length === 0) {
+        if (isExternal(value))
+          return ctx.stylize('[External]', 'special');
+        return `${getPrefix(constructor, tag)}{}`;
+      } else {
+        braces[0] = `${getPrefix(constructor, tag)}{`;
+      }
+    }
+  }
+
+  if (recurseTimes != null) {
+    if (recurseTimes < 0)
+      return ctx.stylize(`[${constructor || tag || 'Object'}]`, 'special');
+    recurseTimes -= 1;
+  }
+
+  ctx.seen.push(value);
+  let output;
+  const indentationLvl = ctx.indentationLvl;
+  try {
+    output = formatter(ctx, value, recurseTimes, keys);
+    if (skip === false) {
+      for (i = 0; i < keys.length; i++) {
+        output.push(
+          formatProperty(ctx, value, recurseTimes, keys[i], extrasType));
+      }
+    }
+  } catch (err) {
+    return handleMaxCallStackSize(ctx, err, constructor, tag, indentationLvl);
+  }
+  ctx.seen.pop();
+
+  if (ctx.sorted) {
+    const comparator = ctx.sorted === true ? undefined : ctx.sorted;
+    if (extrasType === kObjectType) {
+      output = output.sort(comparator);
+    } else if (keys.length > 1) {
+      const sorted = output.slice(output.length - keys.length).sort(comparator);
+      output.splice(output.length - keys.length, keys.length, ...sorted);
+    }
+  }
+
+  return reduceToSingleString(ctx, output, base, braces);
+}
+
+function handleMaxCallStackSize(ctx, err, constructor, tag, indentationLvl) {
+  if (isStackOverflowError(err)) {
+    ctx.seen.pop();
+    ctx.indentationLvl = indentationLvl;
+    return ctx.stylize(
+      `[${constructor || tag || 'Object'}: Inspection interrupted ` +
+        'prematurely. Maximum call stack size exceeded.]',
+      'special'
+    );
+  }
+  throw err;
+}
+
+function formatNumber(fn, value) {
+  // Format -0 as '-0'. Checking `value === -0` won't distinguish 0 from -0.
+  if (Object.is(value, -0))
+    return fn('-0', 'number');
+  return fn(`${value}`, 'number');
+}
+
+function formatPrimitive(fn, value, ctx) {
+  if (typeof value === 'string') {
+    if (ctx.compact === false &&
+      ctx.indentationLvl + value.length > ctx.breakLength &&
+      value.length > kMinLineLength) {
+      // eslint-disable-next-line max-len
+      const minLineLength = Math.max(ctx.breakLength - ctx.indentationLvl, kMinLineLength);
+      // eslint-disable-next-line max-len
+      const averageLineLength = Math.ceil(value.length / Math.ceil(value.length / minLineLength));
+      const divisor = Math.max(averageLineLength, kMinLineLength);
+      let res = '';
+      if (readableRegExps[divisor] === undefined) {
+        // Build a new RegExp that naturally breaks text into multiple lines.
+        //
+        // Rules
+        // 1. Greedy match all text up the max line length that ends with a
+        //    whitespace or the end of the string.
+        // 2. If none matches, non-greedy match any text up to a whitespace or
+        //    the end of the string.
+        //
+        // eslint-disable-next-line max-len, node-core/no-unescaped-regexp-dot
+        readableRegExps[divisor] = new RegExp(`(.|\\n){1,${divisor}}(\\s|$)|(\\n|.)+?(\\s|$)`, 'gm');
+      }
+      const matches = value.match(readableRegExps[divisor]);
+      if (matches.length > 1) {
+        const indent = ' '.repeat(ctx.indentationLvl);
+        res += `${fn(strEscape(matches[0]), 'string')} +\n`;
+        for (var i = 1; i < matches.length - 1; i++) {
+          res += `${indent}  ${fn(strEscape(matches[i]), 'string')} +\n`;
+        }
+        res += `${indent}  ${fn(strEscape(matches[i]), 'string')}`;
+        return res;
+      }
+    }
+    return fn(strEscape(value), 'string');
+  }
+  if (typeof value === 'number')
+    return formatNumber(fn, value);
+  // eslint-disable-next-line valid-typeof
+  if (typeof value === 'bigint')
+    return fn(`${value}n`, 'bigint');
+  if (typeof value === 'boolean')
+    return fn(`${value}`, 'boolean');
+  if (typeof value === 'undefined')
+    return fn('undefined', 'undefined');
+  // es6 symbol primitive
+  return fn(value.toString(), 'symbol');
+}
+
+function formatError(value) {
+  return value.stack || errorToString(value);
+}
+
+function formatNamespaceObject(ctx, value, recurseTimes, keys) {
+  const len = keys.length;
+  const output = new Array(len);
+  for (var i = 0; i < len; i++) {
+    try {
+      output[i] = formatProperty(ctx, value, recurseTimes, keys[i],
+                                 kObjectType);
+    } catch (err) {
+      if (!(types.isNativeError(err) && err.name === 'ReferenceError')) {
+        throw err;
+      }
+      // Use the existing functionality. This makes sure the indentation and
+      // line breaks are always correct. Otherwise it is very difficult to keep
+      // this aligned, even though this is a hacky way of dealing with this.
+      const tmp = { [keys[i]]: '' };
+      output[i] = formatProperty(ctx, tmp, recurseTimes, keys[i], kObjectType);
+      const pos = output[i].lastIndexOf(' ');
+      // We have to find the last whitespace and have to replace that value as
+      // it will be visualized as a regular string.
+      output[i] = output[i].slice(0, pos + 1) +
+                  ctx.stylize('<uninitialized>', 'special');
+    }
+  }
+  return output;
+}
+
+// The array is sparse and/or has extra keys
+function formatSpecialArray(ctx, value, recurseTimes, maxLength, output, i) {
+  const keys = Object.keys(value);
+  let index = i;
+  for (; i < keys.length && output.length < maxLength; i++) {
+    const key = keys[i];
+    const tmp = +key;
+    // Arrays can only have up to 2^32 - 1 entries
+    if (tmp > 2 ** 32 - 2) {
+      break;
+    }
+    if (`${index}` !== key) {
+      if (!numberRegExp.test(key)) {
+        break;
+      }
+      const emptyItems = tmp - index;
+      const ending = emptyItems > 1 ? 's' : '';
+      const message = `<${emptyItems} empty item${ending}>`;
+      output.push(ctx.stylize(message, 'undefined'));
+      index = tmp;
+      if (output.length === maxLength) {
+        break;
+      }
+    }
+    output.push(formatProperty(ctx, value, recurseTimes, key, kArrayType));
+    index++;
+  }
+  const remaining = value.length - index;
+  if (output.length !== maxLength) {
+    if (remaining > 0) {
+      const ending = remaining > 1 ? 's' : '';
+      const message = `<${remaining} empty item${ending}>`;
+      output.push(ctx.stylize(message, 'undefined'));
+    }
+  } else if (remaining > 0) {
+    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);
+  }
+  return output;
+}
+
+function formatArray(ctx, value, recurseTimes) {
+  const valLen = value.length;
+  const len = Math.min(Math.max(0, ctx.maxArrayLength), valLen);
+
+  const remaining = valLen - len;
+  const output = [];
+  for (var i = 0; i < len; i++) {
+    // Special handle sparse arrays.
+    if (!hasOwnProperty(value, i)) {
+      return formatSpecialArray(ctx, value, recurseTimes, len, output, i);
+    }
+    output.push(formatProperty(ctx, value, recurseTimes, i, kArrayType));
+  }
+  if (remaining > 0)
+    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);
+  return output;
+}
+
+function formatTypedArray(ctx, value, recurseTimes) {
+  const maxLength = Math.min(Math.max(0, ctx.maxArrayLength), value.length);
+  const remaining = value.length - maxLength;
+  const output = new Array(maxLength);
+  for (var i = 0; i < maxLength; ++i)
+    output[i] = formatNumber(ctx.stylize, value[i]);
+  if (remaining > 0)
+    output[i] = `... ${remaining} more item${remaining > 1 ? 's' : ''}`;
+  if (ctx.showHidden) {
+    // .buffer goes last, it's not a primitive like the others.
+    ctx.indentationLvl += 2;
+    for (const key of [
+      'BYTES_PER_ELEMENT',
+      'length',
+      'byteLength',
+      'byteOffset',
+      'buffer'
+    ]) {
+      const str = formatValue(ctx, value[key], recurseTimes);
+      output.push(`[${key}]: ${str}`);
+    }
+    ctx.indentationLvl -= 2;
+  }
+  return output;
+}
+
+function formatSet(ctx, value, recurseTimes) {
+  const output = [];
+  ctx.indentationLvl += 2;
+  for (const v of value) {
+    output.push(formatValue(ctx, v, recurseTimes));
+  }
+  ctx.indentationLvl -= 2;
+  // With `showHidden`, `length` will display as a hidden property for
+  // arrays. For consistency's sake, do the same for `size`, even though this
+  // property isn't selected by Object.getOwnPropertyNames().
+  if (ctx.showHidden)
+    output.push(`[size]: ${ctx.stylize(`${value.size}`, 'number')}`);
+  return output;
+}
+
+function formatMap(ctx, value, recurseTimes) {
+  const output = [];
+  ctx.indentationLvl += 2;
+  for (const [k, v] of value) {
+    output.push(`${formatValue(ctx, k, recurseTimes)} => ` +
+                formatValue(ctx, v, recurseTimes));
+  }
+  ctx.indentationLvl -= 2;
+  // See comment in formatSet
+  if (ctx.showHidden)
+    output.push(`[size]: ${ctx.stylize(`${value.size}`, 'number')}`);
+  return output;
+}
+
+function formatSetIterInner(ctx, recurseTimes, entries, state) {
+  const maxArrayLength = Math.max(ctx.maxArrayLength, 0);
+  const maxLength = Math.min(maxArrayLength, entries.length);
+  let output = new Array(maxLength);
+  ctx.indentationLvl += 2;
+  for (var i = 0; i < maxLength; i++) {
+    output[i] = formatValue(ctx, entries[i], recurseTimes);
+  }
+  ctx.indentationLvl -= 2;
+  if (state === kWeak) {
+    // Sort all entries to have a halfway reliable output (if more entries than
+    // retrieved ones exist, we can not reliably return the same output).
+    output = output.sort();
+  }
+  const remaining = entries.length - maxLength;
+  if (remaining > 0) {
+    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);
+  }
+  return output;
+}
+
+function formatMapIterInner(ctx, recurseTimes, entries, state) {
+  const maxArrayLength = Math.max(ctx.maxArrayLength, 0);
+  // Entries exist as [key1, val1, key2, val2, ...]
+  const len = entries.length / 2;
+  const remaining = len - maxArrayLength;
+  const maxLength = Math.min(maxArrayLength, len);
+  let output = new Array(maxLength);
+  let start = '';
+  let end = '';
+  let middle = ' => ';
+  let i = 0;
+  if (state === kMapEntries) {
+    start = '[ ';
+    end = ' ]';
+    middle = ', ';
+  }
+  ctx.indentationLvl += 2;
+  for (; i < maxLength; i++) {
+    const pos = i * 2;
+    output[i] = `${start}${formatValue(ctx, entries[pos], recurseTimes)}` +
+      `${middle}${formatValue(ctx, entries[pos + 1], recurseTimes)}${end}`;
+  }
+  ctx.indentationLvl -= 2;
+  if (state === kWeak) {
+    // Sort all entries to have a halfway reliable output (if more entries
+    // than retrieved ones exist, we can not reliably return the same output).
+    output = output.sort();
+  }
+  if (remaining > 0) {
+    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);
+  }
+  return output;
+}
+
+function formatWeakCollection(ctx) {
+  return [ctx.stylize('[items unknown]', 'special')];
+}
+
+function formatWeakSet(ctx, value, recurseTimes) {
+  const entries = previewEntries(value);
+  return formatSetIterInner(ctx, recurseTimes, entries, kWeak);
+}
+
+function formatWeakMap(ctx, value, recurseTimes) {
+  const entries = previewEntries(value);
+  return formatMapIterInner(ctx, recurseTimes, entries, kWeak);
+}
+
+function formatSetIterator(ctx, value, recurseTimes) {
+  const entries = previewEntries(value);
+  return formatSetIterInner(ctx, recurseTimes, entries, kIterator);
+}
+
+function formatMapIterator(ctx, value, recurseTimes) {
+  const [entries, isKeyValue] = previewEntries(value, true);
+  if (isKeyValue) {
+    return formatMapIterInner(ctx, recurseTimes, entries, kMapEntries);
+  }
+
+  return formatSetIterInner(ctx, recurseTimes, entries, kIterator);
+}
+
+function formatPromise(ctx, value, recurseTimes) {
+  let output;
+  const [state, result] = getPromiseDetails(value);
+  if (state === kPending) {
+    output = [ctx.stylize('<pending>', 'special')];
+  } else {
+    // Using `formatValue` is correct here without the need to fix the
+    // indentation level.
+    ctx.indentationLvl += 2;
+    const str = formatValue(ctx, result, recurseTimes);
+    ctx.indentationLvl -= 2;
+    output = [
+      state === kRejected ?
+        `${ctx.stylize('<rejected>', 'special')} ${str}` :
+        str
+    ];
+  }
+  return output;
+}
+
+function formatProperty(ctx, value, recurseTimes, key, type) {
+  let name, str;
+  let extra = ' ';
+  const desc = Object.getOwnPropertyDescriptor(value, key) ||
+    { value: value[key], enumerable: true };
+  if (desc.value !== undefined) {
+    const diff = (type !== kObjectType || ctx.compact === false) ? 2 : 3;
+    ctx.indentationLvl += diff;
+    str = formatValue(ctx, desc.value, recurseTimes);
+    if (diff === 3) {
+      const len = ctx.colors ? removeColors(str).length : str.length;
+      if (ctx.breakLength < len) {
+        extra = `\n${' '.repeat(ctx.indentationLvl)}`;
+      }
+    }
+    ctx.indentationLvl -= diff;
+  } else if (desc.get !== undefined) {
+    if (desc.set !== undefined) {
+      str = ctx.stylize('[Getter/Setter]', 'special');
+    } else {
+      str = ctx.stylize('[Getter]', 'special');
+    }
+  } else if (desc.set !== undefined) {
+    str = ctx.stylize('[Setter]', 'special');
+  } else {
+    str = ctx.stylize('undefined', 'undefined');
+  }
+  if (type === kArrayType) {
+    return str;
+  }
+  if (typeof key === 'symbol') {
+    const tmp = key.toString().replace(strEscapeSequencesReplacer, escapeFn);
+    name = `[${ctx.stylize(tmp, 'symbol')}]`;
+  } else if (desc.enumerable === false) {
+    name = `[${key.replace(strEscapeSequencesReplacer, escapeFn)}]`;
+  } else if (keyStrRegExp.test(key)) {
+    name = ctx.stylize(key, 'name');
+  } else {
+    name = ctx.stylize(strEscape(key), 'string');
+  }
+  return `${name}:${extra}${str}`;
+}
+
+function reduceToSingleString(ctx, output, base, braces) {
+  const breakLength = ctx.breakLength;
+  let i = 0;
+  if (ctx.compact === false) {
+    const indentation = ' '.repeat(ctx.indentationLvl);
+    let res = `${base ? `${base} ` : ''}${braces[0]}\n${indentation}  `;
+    for (; i < output.length - 1; i++) {
+      res += `${output[i]},\n${indentation}  `;
+    }
+    res += `${output[i]}\n${indentation}${braces[1]}`;
+    return res;
+  }
+  if (output.length * 2 <= breakLength) {
+    let length = 0;
+    for (; i < output.length && length <= breakLength; i++) {
+      if (ctx.colors) {
+        length += removeColors(output[i]).length + 1;
+      } else {
+        length += output[i].length + 1;
+      }
+    }
+    if (length <= breakLength)
+      return `${braces[0]}${base ? ` ${base}` : ''} ${join(output, ', ')} ` +
+        braces[1];
+  }
+  // If the opening "brace" is too large, like in the case of "Set {",
+  // we need to force the first item to be on the next line or the
+  // items will not line up correctly.
+  const indentation = ' '.repeat(ctx.indentationLvl);
+  const ln = base === '' && braces[0].length === 1 ?
+    ' ' : `${base ? ` ${base}` : ''}\n${indentation}  `;
+  const str = join(output, `,\n${indentation}  `);
+  return `${braces[0]}${ln}${str} ${braces[1]}`;
+}
+
+module.exports = {
+  inspect
+};
diff --git a/lib/util.js b/lib/util.js
index 17cf314ee96626..63285412752324 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -22,6 +22,7 @@
 'use strict';
 
 const errors = require('internal/errors');
+const { inspect } = require('internal/util/inspect');
 const {
   ERR_FALSY_VALUE_REJECTION,
   ERR_INVALID_ARG_TYPE,
@@ -31,176 +32,24 @@ const { validateNumber } = require('internal/validators');
 const { TextDecoder, TextEncoder } = require('internal/encoding');
 const { isBuffer } = require('buffer').Buffer;
 
-const {
-  getOwnNonIndexProperties,
-  getPromiseDetails,
-  getProxyDetails,
-  kPending,
-  kRejected,
-  previewEntries,
-  propertyFilter: {
-    ALL_PROPERTIES,
-    ONLY_ENUMERABLE
-  }
-} = process.binding('util');
-
 const { internalBinding } = require('internal/bootstrap/loaders');
 const types = internalBinding('types');
 Object.assign(types, require('internal/util/types'));
 const {
-  isAnyArrayBuffer,
-  isArrayBuffer,
-  isArgumentsObject,
-  isBoxedPrimitive,
-  isDataView,
-  isExternal,
-  isMap,
-  isMapIterator,
-  isPromise,
-  isSet,
-  isSetIterator,
-  isWeakMap,
-  isWeakSet,
   isRegExp,
   isDate,
-  isTypedArray,
-  isStringObject,
-  isNumberObject,
-  isBooleanObject,
-  isBigIntObject,
-  isUint8Array,
-  isUint8ClampedArray,
-  isUint16Array,
-  isUint32Array,
-  isInt8Array,
-  isInt16Array,
-  isInt32Array,
-  isFloat32Array,
-  isFloat64Array,
-  isBigInt64Array,
-  isBigUint64Array
 } = types;
 
 const {
-  customInspectSymbol,
   deprecate,
   getSystemErrorName: internalErrorName,
   isError,
   promisify,
-  join,
-  removeColors
 } = require('internal/util');
 
-const inspectDefaultOptions = Object.seal({
-  showHidden: false,
-  depth: 2,
-  colors: false,
-  customInspect: true,
-  showProxy: false,
-  maxArrayLength: 100,
-  breakLength: 60,
-  compact: true,
-  sorted: false
-});
-
-const kObjectType = 0;
-const kArrayType = 1;
-const kArrayExtrasType = 2;
-
-const ReflectApply = Reflect.apply;
-
-// This function is borrowed from the function with the same name on V8 Extras'
-// `utils` object. V8 implements Reflect.apply very efficiently in conjunction
-// with the spread syntax, such that no additional special case is needed for
-// function calls w/o arguments.
-// Refs: https://github.com/v8/v8/blob/d6ead37d265d7215cf9c5f768f279e21bd170212/src/js/prologue.js#L152-L156
-function uncurryThis(func) {
-  return (thisArg, ...args) => ReflectApply(func, thisArg, args);
-}
-
-const propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);
-const regExpToString = uncurryThis(RegExp.prototype.toString);
-const dateToISOString = uncurryThis(Date.prototype.toISOString);
-const errorToString = uncurryThis(Error.prototype.toString);
-
-const bigIntValueOf = uncurryThis(BigInt.prototype.valueOf);
-const booleanValueOf = uncurryThis(Boolean.prototype.valueOf);
-const numberValueOf = uncurryThis(Number.prototype.valueOf);
-const symbolValueOf = uncurryThis(Symbol.prototype.valueOf);
-const stringValueOf = uncurryThis(String.prototype.valueOf);
-
-const setValues = uncurryThis(Set.prototype.values);
-const mapEntries = uncurryThis(Map.prototype.entries);
-const dateGetTime = uncurryThis(Date.prototype.getTime);
-const hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
-
 let CIRCULAR_ERROR_MESSAGE;
 let internalDeepEqual;
 
-/* eslint-disable no-control-regex */
-const strEscapeSequencesRegExp = /[\x00-\x1f\x27\x5c]/;
-const strEscapeSequencesReplacer = /[\x00-\x1f\x27\x5c]/g;
-/* eslint-enable no-control-regex */
-
-const keyStrRegExp = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
-const numberRegExp = /^(0|[1-9][0-9]*)$/;
-
-const readableRegExps = {};
-
-const MIN_LINE_LENGTH = 16;
-
-// Escaped special characters. Use empty strings to fill up unused entries.
-const meta = [
-  '\\u0000', '\\u0001', '\\u0002', '\\u0003', '\\u0004',
-  '\\u0005', '\\u0006', '\\u0007', '\\b', '\\t',
-  '\\n', '\\u000b', '\\f', '\\r', '\\u000e',
-  '\\u000f', '\\u0010', '\\u0011', '\\u0012', '\\u0013',
-  '\\u0014', '\\u0015', '\\u0016', '\\u0017', '\\u0018',
-  '\\u0019', '\\u001a', '\\u001b', '\\u001c', '\\u001d',
-  '\\u001e', '\\u001f', '', '', '',
-  '', '', '', '', "\\'", '', '', '', '', '',
-  '', '', '', '', '', '', '', '', '', '',
-  '', '', '', '', '', '', '', '', '', '',
-  '', '', '', '', '', '', '', '', '', '',
-  '', '', '', '', '', '', '', '', '', '',
-  '', '', '', '', '', '', '', '\\\\'
-];
-// Constants to map the iterator state.
-const kWeak = 0;
-const kIterator = 1;
-const kMapEntries = 2;
-
-const escapeFn = (str) => meta[str.charCodeAt(0)];
-
-// Escape control characters, single quotes and the backslash.
-// This is similar to JSON stringify escaping.
-function strEscape(str) {
-  // Some magic numbers that worked out fine while benchmarking with v8 6.0
-  if (str.length < 5000 && !strEscapeSequencesRegExp.test(str))
-    return `'${str}'`;
-  if (str.length > 100)
-    return `'${str.replace(strEscapeSequencesReplacer, escapeFn)}'`;
-  let result = '';
-  let last = 0;
-  for (var i = 0; i < str.length; i++) {
-    const point = str.charCodeAt(i);
-    if (point === 39 || point === 92 || point < 32) {
-      if (last === i) {
-        result += meta[point];
-      } else {
-        result += `${str.slice(last, i)}${meta[point]}`;
-      }
-      last = i + 1;
-    }
-  }
-  if (last === 0) {
-    result = str;
-  } else if (last !== i) {
-    result += str.slice(last);
-  }
-  return `'${result}'`;
-}
-
 function tryStringify(arg) {
   try {
     return JSON.stringify(arg);
@@ -334,927 +183,6 @@ function debuglog(set) {
   return debugs[set];
 }
 
-/**
- * Echos the value of any input. Tries to print the value out
- * in the best way possible given the different types.
- *
- * @param {any} value The value to print out.
- * @param {Object} opts Optional options object that alters the output.
- */
-/* Legacy: value, showHidden, depth, colors */
-function inspect(value, opts) {
-  // Default options
-  const ctx = {
-    budget: {},
-    indentationLvl: 0,
-    seen: [],
-    stylize: stylizeNoColor,
-    showHidden: inspectDefaultOptions.showHidden,
-    depth: inspectDefaultOptions.depth,
-    colors: inspectDefaultOptions.colors,
-    customInspect: inspectDefaultOptions.customInspect,
-    showProxy: inspectDefaultOptions.showProxy,
-    // TODO(BridgeAR): Deprecate `maxArrayLength` and replace it with
-    // `maxEntries`.
-    maxArrayLength: inspectDefaultOptions.maxArrayLength,
-    breakLength: inspectDefaultOptions.breakLength,
-    compact: inspectDefaultOptions.compact,
-    sorted: inspectDefaultOptions.sorted
-  };
-  // Legacy...
-  if (arguments.length > 2) {
-    if (arguments[2] !== undefined) {
-      ctx.depth = arguments[2];
-    }
-    if (arguments.length > 3 && arguments[3] !== undefined) {
-      ctx.colors = arguments[3];
-    }
-  }
-  // Set user-specified options
-  if (typeof opts === 'boolean') {
-    ctx.showHidden = opts;
-  } else if (opts) {
-    const optKeys = Object.keys(opts);
-    for (var i = 0; i < optKeys.length; i++) {
-      ctx[optKeys[i]] = opts[optKeys[i]];
-    }
-  }
-  if (ctx.colors) ctx.stylize = stylizeWithColor;
-  if (ctx.maxArrayLength === null) ctx.maxArrayLength = Infinity;
-  return formatValue(ctx, value, ctx.depth);
-}
-inspect.custom = customInspectSymbol;
-
-Object.defineProperty(inspect, 'defaultOptions', {
-  get() {
-    return inspectDefaultOptions;
-  },
-  set(options) {
-    if (options === null || typeof options !== 'object') {
-      throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
-    }
-    return _extend(inspectDefaultOptions, options);
-  }
-});
-
-// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
-inspect.colors = Object.assign(Object.create(null), {
-  'bold': [1, 22],
-  'italic': [3, 23],
-  'underline': [4, 24],
-  'inverse': [7, 27],
-  'white': [37, 39],
-  'grey': [90, 39],
-  'black': [30, 39],
-  'blue': [34, 39],
-  'cyan': [36, 39],
-  'green': [32, 39],
-  'magenta': [35, 39],
-  'red': [31, 39],
-  'yellow': [33, 39]
-});
-
-// Don't use 'blue' not visible on cmd.exe
-inspect.styles = Object.assign(Object.create(null), {
-  'special': 'cyan',
-  'number': 'yellow',
-  'bigint': 'yellow',
-  'boolean': 'yellow',
-  'undefined': 'grey',
-  'null': 'bold',
-  'string': 'green',
-  'symbol': 'green',
-  'date': 'magenta',
-  // "name": intentionally not styling
-  'regexp': 'red'
-});
-
-function stylizeWithColor(str, styleType) {
-  const style = inspect.styles[styleType];
-  if (style !== undefined) {
-    const color = inspect.colors[style];
-    return `\u001b[${color[0]}m${str}\u001b[${color[1]}m`;
-  }
-  return str;
-}
-
-function stylizeNoColor(str) {
-  return str;
-}
-
-// Return a new empty array to push in the results of the default formatter.
-function getEmptyFormatArray() {
-  return [];
-}
-
-function getConstructorName(obj) {
-  while (obj) {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, 'constructor');
-    if (descriptor !== undefined &&
-        typeof descriptor.value === 'function' &&
-        descriptor.value.name !== '') {
-      return descriptor.value.name;
-    }
-
-    obj = Object.getPrototypeOf(obj);
-  }
-
-  return '';
-}
-
-function getPrefix(constructor, tag, fallback) {
-  if (constructor !== '') {
-    if (tag !== '' && constructor !== tag) {
-      return `${constructor} [${tag}] `;
-    }
-    return `${constructor} `;
-  }
-
-  if (tag !== '')
-    return `[${tag}] `;
-
-  if (fallback !== undefined)
-    return `${fallback} `;
-
-  return '';
-}
-
-const getBoxedValue = formatPrimitive.bind(null, stylizeNoColor);
-
-// Look up the keys of the object.
-function getKeys(value, showHidden) {
-  let keys;
-  const symbols = Object.getOwnPropertySymbols(value);
-  if (showHidden) {
-    keys = Object.getOwnPropertyNames(value);
-    if (symbols.length !== 0)
-      keys.push(...symbols);
-  } else {
-    // This might throw if `value` is a Module Namespace Object from an
-    // unevaluated module, but we don't want to perform the actual type
-    // check because it's expensive.
-    // TODO(devsnek): track https://github.com/tc39/ecma262/issues/1209
-    // and modify this logic as needed.
-    try {
-      keys = Object.keys(value);
-    } catch (err) {
-      if (types.isNativeError(err) &&
-          err.name === 'ReferenceError' &&
-          types.isModuleNamespaceObject(value)) {
-        keys = Object.getOwnPropertyNames(value);
-      } else {
-        throw err;
-      }
-    }
-    if (symbols.length !== 0) {
-      keys.push(...symbols.filter((key) => propertyIsEnumerable(value, key)));
-    }
-  }
-  return keys;
-}
-
-function formatProxy(ctx, proxy, recurseTimes) {
-  if (recurseTimes != null) {
-    if (recurseTimes < 0)
-      return ctx.stylize('Proxy [Array]', 'special');
-    recurseTimes -= 1;
-  }
-  ctx.indentationLvl += 2;
-  const res = [
-    formatValue(ctx, proxy[0], recurseTimes),
-    formatValue(ctx, proxy[1], recurseTimes)
-  ];
-  ctx.indentationLvl -= 2;
-  const str = reduceToSingleString(ctx, res, '', ['[', ']']);
-  return `Proxy ${str}`;
-}
-
-function findTypedConstructor(value) {
-  for (const [check, clazz] of [
-    [isUint8Array, Uint8Array],
-    [isUint8ClampedArray, Uint8ClampedArray],
-    [isUint16Array, Uint16Array],
-    [isUint32Array, Uint32Array],
-    [isInt8Array, Int8Array],
-    [isInt16Array, Int16Array],
-    [isInt32Array, Int32Array],
-    [isFloat32Array, Float32Array],
-    [isFloat64Array, Float64Array],
-    [isBigInt64Array, BigInt64Array],
-    [isBigUint64Array, BigUint64Array]
-  ]) {
-    if (check(value)) {
-      return clazz;
-    }
-  }
-}
-
-function noPrototypeIterator(ctx, value, recurseTimes) {
-  let newVal;
-  // TODO: Create a Subclass in case there's no prototype and show
-  // `null-prototype`.
-  if (isSet(value)) {
-    const clazz = Object.getPrototypeOf(value) || Set;
-    newVal = new clazz(setValues(value));
-  } else if (isMap(value)) {
-    const clazz = Object.getPrototypeOf(value) || Map;
-    newVal = new clazz(mapEntries(value));
-  } else if (Array.isArray(value)) {
-    const clazz = Object.getPrototypeOf(value) || Array;
-    newVal = new clazz(value.length || 0);
-  } else if (isTypedArray(value)) {
-    const clazz = findTypedConstructor(value) || Uint8Array;
-    newVal = new clazz(value);
-  }
-  if (newVal) {
-    Object.defineProperties(newVal, Object.getOwnPropertyDescriptors(value));
-    return formatValue(ctx, newVal, recurseTimes);
-  }
-}
-
-// Note: using `formatValue` directly requires the indentation level to be
-// corrected by setting `ctx.indentationLvL += diff` and then to decrease the
-// value afterwards again.
-function formatValue(ctx, value, recurseTimes) {
-  // Primitive types cannot have properties
-  if (typeof value !== 'object' && typeof value !== 'function') {
-    return formatPrimitive(ctx.stylize, value, ctx);
-  }
-  if (value === null) {
-    return ctx.stylize('null', 'null');
-  }
-
-  if (ctx.showProxy) {
-    const proxy = getProxyDetails(value);
-    if (proxy !== undefined) {
-      return formatProxy(ctx, proxy, recurseTimes);
-    }
-  }
-
-  // Provide a hook for user-specified inspect functions.
-  // Check that value is an object with an inspect function on it
-  if (ctx.customInspect) {
-    let maybeCustom = value[customInspectSymbol];
-
-    if (!maybeCustom && value.inspect !== exports.inspect &&
-        typeof value.inspect === 'function') {
-      maybeCustom = deprecate(
-        value.inspect,
-        'Custom inspection function on Objects via .inspect() is deprecated',
-        'DEP0079'
-      );
-    }
-
-    if (typeof maybeCustom === 'function' &&
-        // Filter out the util module, its inspect function is special
-        maybeCustom !== exports.inspect &&
-        // Also filter out any prototype objects using the circular check.
-        !(value.constructor && value.constructor.prototype === value)) {
-      const ret = maybeCustom.call(value, recurseTimes, ctx);
-
-      // If the custom inspection method returned `this`, don't go into
-      // infinite recursion.
-      if (ret !== value) {
-        if (typeof ret !== 'string') {
-          return formatValue(ctx, ret, recurseTimes);
-        }
-        return ret;
-      }
-    }
-  }
-
-  // Using an array here is actually better for the average case than using
-  // a Set. `seen` will only check for the depth and will never grow too large.
-  if (ctx.seen.indexOf(value) !== -1)
-    return ctx.stylize('[Circular]', 'special');
-
-  return formatRaw(ctx, value, recurseTimes);
-}
-
-function formatRaw(ctx, value, recurseTimes) {
-  let keys;
-
-  const constructor = getConstructorName(value);
-  let tag = value[Symbol.toStringTag];
-  if (typeof tag !== 'string')
-    tag = '';
-  let base = '';
-  let formatter = getEmptyFormatArray;
-  let braces;
-  let noIterator = true;
-  let i = 0;
-  let skip = false;
-  const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
-
-  let extrasType = kObjectType;
-
-  // Iterators and the rest are split to reduce checks
-  if (value[Symbol.iterator]) {
-    noIterator = false;
-    if (Array.isArray(value)) {
-      keys = getOwnNonIndexProperties(value, filter);
-      // Only set the constructor for non ordinary ("Array [...]") arrays.
-      const prefix = getPrefix(constructor, tag);
-      braces = [`${prefix === 'Array ' ? '' : prefix}[`, ']'];
-      if (value.length === 0 && keys.length === 0)
-        return `${braces[0]}]`;
-      extrasType = kArrayExtrasType;
-      formatter = formatArray;
-    } else if (isSet(value)) {
-      keys = getKeys(value, ctx.showHidden);
-      const prefix = getPrefix(constructor, tag);
-      if (value.size === 0 && keys.length === 0)
-        return `${prefix}{}`;
-      braces = [`${prefix}{`, '}'];
-      formatter = formatSet;
-    } else if (isMap(value)) {
-      keys = getKeys(value, ctx.showHidden);
-      const prefix = getPrefix(constructor, tag);
-      if (value.size === 0 && keys.length === 0)
-        return `${prefix}{}`;
-      braces = [`${prefix}{`, '}'];
-      formatter = formatMap;
-    } else if (isTypedArray(value)) {
-      keys = getOwnNonIndexProperties(value, filter);
-      braces = [`${getPrefix(constructor, tag)}[`, ']'];
-      if (value.length === 0 && keys.length === 0 && !ctx.showHidden)
-        return `${braces[0]}]`;
-      formatter = formatTypedArray;
-      extrasType = kArrayExtrasType;
-    } else if (isMapIterator(value)) {
-      keys = getKeys(value, ctx.showHidden);
-      braces = [`[${tag}] {`, '}'];
-      formatter = formatMapIterator;
-    } else if (isSetIterator(value)) {
-      keys = getKeys(value, ctx.showHidden);
-      braces = [`[${tag}] {`, '}'];
-      formatter = formatSetIterator;
-    } else {
-      noIterator = true;
-    }
-  }
-  if (noIterator) {
-    keys = getKeys(value, ctx.showHidden);
-    braces = ['{', '}'];
-    if (constructor === 'Object') {
-      if (isArgumentsObject(value)) {
-        if (keys.length === 0)
-          return '[Arguments] {}';
-        braces[0] = '[Arguments] {';
-      } else if (tag !== '') {
-        braces[0] = `${getPrefix(constructor, tag)}{`;
-        if (keys.length === 0) {
-          return `${braces[0]}}`;
-        }
-      } else if (keys.length === 0) {
-        return '{}';
-      }
-    } else if (typeof value === 'function') {
-      const type = constructor || tag || 'Function';
-      const name = `${type}${value.name ? `: ${value.name}` : ''}`;
-      if (keys.length === 0)
-        return ctx.stylize(`[${name}]`, 'special');
-      base = `[${name}]`;
-    } else if (isRegExp(value)) {
-      // Make RegExps say that they are RegExps
-      if (keys.length === 0 || recurseTimes < 0)
-        return ctx.stylize(regExpToString(value), 'regexp');
-      base = `${regExpToString(value)}`;
-    } else if (isDate(value)) {
-      // Make dates with properties first say the date
-      if (keys.length === 0) {
-        if (Number.isNaN(dateGetTime(value)))
-          return ctx.stylize(String(value), 'date');
-        return ctx.stylize(dateToISOString(value), 'date');
-      }
-      base = dateToISOString(value);
-    } else if (isError(value)) {
-      // Make error with message first say the error
-      base = formatError(value);
-      // Wrap the error in brackets in case it has no stack trace.
-      const stackStart = base.indexOf('\n    at');
-      if (stackStart === -1) {
-        base = `[${base}]`;
-      }
-      // The message and the stack have to be indented as well!
-      if (ctx.indentationLvl !== 0) {
-        const indentation = ' '.repeat(ctx.indentationLvl);
-        base = formatError(value).replace(/\n/g, `\n${indentation}`);
-      }
-      if (keys.length === 0)
-        return base;
-
-      if (ctx.compact === false && stackStart !== -1) {
-        braces[0] += `${base.slice(stackStart)}`;
-        base = `[${base.slice(0, stackStart)}]`;
-      }
-    } else if (isAnyArrayBuffer(value)) {
-      let prefix = getPrefix(constructor, tag);
-      if (prefix === '') {
-        prefix = isArrayBuffer(value) ? 'ArrayBuffer ' : 'SharedArrayBuffer ';
-      }
-      // Fast path for ArrayBuffer and SharedArrayBuffer.
-      // Can't do the same for DataView because it has a non-primitive
-      // .buffer property that we need to recurse for.
-      if (keys.length === 0)
-        return prefix +
-              `{ byteLength: ${formatNumber(ctx.stylize, value.byteLength)} }`;
-      braces[0] = `${prefix}{`;
-      keys.unshift('byteLength');
-    } else if (isDataView(value)) {
-      braces[0] = `${getPrefix(constructor, tag, 'DataView')}{`;
-      // .buffer goes last, it's not a primitive like the others.
-      keys.unshift('byteLength', 'byteOffset', 'buffer');
-    } else if (isPromise(value)) {
-      braces[0] = `${getPrefix(constructor, tag, 'Promise')}{`;
-      formatter = formatPromise;
-    } else if (isWeakSet(value)) {
-      braces[0] = `${getPrefix(constructor, tag, 'WeakSet')}{`;
-      formatter = ctx.showHidden ? formatWeakSet : formatWeakCollection;
-    } else if (isWeakMap(value)) {
-      braces[0] = `${getPrefix(constructor, tag, 'WeakMap')}{`;
-      formatter = ctx.showHidden ? formatWeakMap : formatWeakCollection;
-    } else if (types.isModuleNamespaceObject(value)) {
-      braces[0] = `[${tag}] {`;
-      formatter = formatNamespaceObject;
-      skip = true;
-    } else if (isBoxedPrimitive(value)) {
-      let type;
-      if (isNumberObject(value)) {
-        base = `[Number: ${getBoxedValue(numberValueOf(value))}]`;
-        type = 'number';
-      } else if (isStringObject(value)) {
-        base = `[String: ${getBoxedValue(stringValueOf(value), ctx)}]`;
-        type = 'string';
-        // For boxed Strings, we have to remove the 0-n indexed entries,
-        // since they just noisy up the output and are redundant
-        // Make boxed primitive Strings look like such
-        keys = keys.slice(value.length);
-      } else if (isBooleanObject(value)) {
-        base = `[Boolean: ${getBoxedValue(booleanValueOf(value))}]`;
-        type = 'boolean';
-      } else if (isBigIntObject(value)) {
-        base = `[BigInt: ${getBoxedValue(bigIntValueOf(value))}]`;
-        type = 'bigint';
-      } else {
-        base = `[Symbol: ${getBoxedValue(symbolValueOf(value))}]`;
-        type = 'symbol';
-      }
-      if (keys.length === 0) {
-        return ctx.stylize(base, type);
-      }
-    } else {
-      // The input prototype got manipulated. Special handle these. We have to
-      // rebuild the information so we are able to display everything.
-      const specialIterator = noPrototypeIterator(ctx, value, recurseTimes);
-      if (specialIterator) {
-        return specialIterator;
-      }
-      if (isMapIterator(value)) {
-        braces = [`[${tag || 'Map Iterator'}] {`, '}'];
-        formatter = formatMapIterator;
-      } else if (isSetIterator(value)) {
-        braces = [`[${tag || 'Set Iterator'}] {`, '}'];
-        formatter = formatSetIterator;
-      // Handle other regular objects again.
-      } else if (keys.length === 0) {
-        if (isExternal(value))
-          return ctx.stylize('[External]', 'special');
-        return `${getPrefix(constructor, tag)}{}`;
-      } else {
-        braces[0] = `${getPrefix(constructor, tag)}{`;
-      }
-    }
-  }
-
-  if (recurseTimes != null) {
-    if (recurseTimes < 0)
-      return ctx.stylize(`[${constructor || tag || 'Object'}]`, 'special');
-    recurseTimes -= 1;
-  }
-
-  ctx.seen.push(value);
-  let output;
-  const indentationLvl = ctx.indentationLvl;
-  try {
-    output = formatter(ctx, value, recurseTimes, keys);
-    if (skip === false) {
-      for (i = 0; i < keys.length; i++) {
-        output.push(
-          formatProperty(ctx, value, recurseTimes, keys[i], extrasType));
-      }
-    }
-  } catch (err) {
-    return handleMaxCallStackSize(ctx, err, constructor, tag, indentationLvl);
-  }
-  ctx.seen.pop();
-
-  if (ctx.sorted) {
-    const comparator = ctx.sorted === true ? undefined : ctx.sorted;
-    if (extrasType === kObjectType) {
-      output = output.sort(comparator);
-    } else if (keys.length > 1) {
-      const sorted = output.slice(output.length - keys.length).sort(comparator);
-      output.splice(output.length - keys.length, keys.length, ...sorted);
-    }
-  }
-
-  return reduceToSingleString(ctx, output, base, braces);
-}
-
-function handleMaxCallStackSize(ctx, err, constructor, tag, indentationLvl) {
-  if (errors.isStackOverflowError(err)) {
-    ctx.seen.pop();
-    ctx.indentationLvl = indentationLvl;
-    return ctx.stylize(
-      `[${constructor || tag || 'Object'}: Inspection interrupted ` +
-        'prematurely. Maximum call stack size exceeded.]',
-      'special'
-    );
-  }
-  throw err;
-}
-
-function formatNumber(fn, value) {
-  // Format -0 as '-0'. Checking `value === -0` won't distinguish 0 from -0.
-  if (Object.is(value, -0))
-    return fn('-0', 'number');
-  return fn(`${value}`, 'number');
-}
-
-function formatPrimitive(fn, value, ctx) {
-  if (typeof value === 'string') {
-    if (ctx.compact === false &&
-      ctx.indentationLvl + value.length > ctx.breakLength &&
-      value.length > MIN_LINE_LENGTH) {
-      // eslint-disable-next-line max-len
-      const minLineLength = Math.max(ctx.breakLength - ctx.indentationLvl, MIN_LINE_LENGTH);
-      // eslint-disable-next-line max-len
-      const averageLineLength = Math.ceil(value.length / Math.ceil(value.length / minLineLength));
-      const divisor = Math.max(averageLineLength, MIN_LINE_LENGTH);
-      let res = '';
-      if (readableRegExps[divisor] === undefined) {
-        // Build a new RegExp that naturally breaks text into multiple lines.
-        //
-        // Rules
-        // 1. Greedy match all text up the max line length that ends with a
-        //    whitespace or the end of the string.
-        // 2. If none matches, non-greedy match any text up to a whitespace or
-        //    the end of the string.
-        //
-        // eslint-disable-next-line max-len, node-core/no-unescaped-regexp-dot
-        readableRegExps[divisor] = new RegExp(`(.|\\n){1,${divisor}}(\\s|$)|(\\n|.)+?(\\s|$)`, 'gm');
-      }
-      const matches = value.match(readableRegExps[divisor]);
-      if (matches.length > 1) {
-        const indent = ' '.repeat(ctx.indentationLvl);
-        res += `${fn(strEscape(matches[0]), 'string')} +\n`;
-        for (var i = 1; i < matches.length - 1; i++) {
-          res += `${indent}  ${fn(strEscape(matches[i]), 'string')} +\n`;
-        }
-        res += `${indent}  ${fn(strEscape(matches[i]), 'string')}`;
-        return res;
-      }
-    }
-    return fn(strEscape(value), 'string');
-  }
-  if (typeof value === 'number')
-    return formatNumber(fn, value);
-  // eslint-disable-next-line valid-typeof
-  if (typeof value === 'bigint')
-    return fn(`${value}n`, 'bigint');
-  if (typeof value === 'boolean')
-    return fn(`${value}`, 'boolean');
-  if (typeof value === 'undefined')
-    return fn('undefined', 'undefined');
-  // es6 symbol primitive
-  return fn(value.toString(), 'symbol');
-}
-
-function formatError(value) {
-  return value.stack || errorToString(value);
-}
-
-function formatNamespaceObject(ctx, value, recurseTimes, keys) {
-  const len = keys.length;
-  const output = new Array(len);
-  for (var i = 0; i < len; i++) {
-    try {
-      output[i] = formatProperty(ctx, value, recurseTimes, keys[i],
-                                 kObjectType);
-    } catch (err) {
-      if (!(types.isNativeError(err) && err.name === 'ReferenceError')) {
-        throw err;
-      }
-      // Use the existing functionality. This makes sure the indentation and
-      // line breaks are always correct. Otherwise it is very difficult to keep
-      // this aligned, even though this is a hacky way of dealing with this.
-      const tmp = { [keys[i]]: '' };
-      output[i] = formatProperty(ctx, tmp, recurseTimes, keys[i], kObjectType);
-      const pos = output[i].lastIndexOf(' ');
-      // We have to find the last whitespace and have to replace that value as
-      // it will be visualized as a regular string.
-      output[i] = output[i].slice(0, pos + 1) +
-                  ctx.stylize('<uninitialized>', 'special');
-    }
-  }
-  return output;
-}
-
-// The array is sparse and/or has extra keys
-function formatSpecialArray(ctx, value, recurseTimes, maxLength, output, i) {
-  const keys = Object.keys(value);
-  let index = i;
-  for (; i < keys.length && output.length < maxLength; i++) {
-    const key = keys[i];
-    const tmp = +key;
-    // Arrays can only have up to 2^32 - 1 entries
-    if (tmp > 2 ** 32 - 2) {
-      break;
-    }
-    if (`${index}` !== key) {
-      if (!numberRegExp.test(key)) {
-        break;
-      }
-      const emptyItems = tmp - index;
-      const ending = emptyItems > 1 ? 's' : '';
-      const message = `<${emptyItems} empty item${ending}>`;
-      output.push(ctx.stylize(message, 'undefined'));
-      index = tmp;
-      if (output.length === maxLength) {
-        break;
-      }
-    }
-    output.push(formatProperty(ctx, value, recurseTimes, key, kArrayType));
-    index++;
-  }
-  const remaining = value.length - index;
-  if (output.length !== maxLength) {
-    if (remaining > 0) {
-      const ending = remaining > 1 ? 's' : '';
-      const message = `<${remaining} empty item${ending}>`;
-      output.push(ctx.stylize(message, 'undefined'));
-    }
-  } else if (remaining > 0) {
-    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);
-  }
-  return output;
-}
-
-function formatArray(ctx, value, recurseTimes) {
-  const valLen = value.length;
-  const len = Math.min(Math.max(0, ctx.maxArrayLength), valLen);
-
-  const remaining = valLen - len;
-  const output = [];
-  for (var i = 0; i < len; i++) {
-    // Special handle sparse arrays.
-    if (!hasOwnProperty(value, i)) {
-      return formatSpecialArray(ctx, value, recurseTimes, len, output, i);
-    }
-    output.push(formatProperty(ctx, value, recurseTimes, i, kArrayType));
-  }
-  if (remaining > 0)
-    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);
-  return output;
-}
-
-function formatTypedArray(ctx, value, recurseTimes) {
-  const maxLength = Math.min(Math.max(0, ctx.maxArrayLength), value.length);
-  const remaining = value.length - maxLength;
-  const output = new Array(maxLength);
-  for (var i = 0; i < maxLength; ++i)
-    output[i] = formatNumber(ctx.stylize, value[i]);
-  if (remaining > 0)
-    output[i] = `... ${remaining} more item${remaining > 1 ? 's' : ''}`;
-  if (ctx.showHidden) {
-    // .buffer goes last, it's not a primitive like the others.
-    ctx.indentationLvl += 2;
-    for (const key of [
-      'BYTES_PER_ELEMENT',
-      'length',
-      'byteLength',
-      'byteOffset',
-      'buffer'
-    ]) {
-      const str = formatValue(ctx, value[key], recurseTimes);
-      output.push(`[${key}]: ${str}`);
-    }
-    ctx.indentationLvl -= 2;
-  }
-  return output;
-}
-
-function formatSet(ctx, value, recurseTimes) {
-  const output = [];
-  ctx.indentationLvl += 2;
-  for (const v of value) {
-    output.push(formatValue(ctx, v, recurseTimes));
-  }
-  ctx.indentationLvl -= 2;
-  // With `showHidden`, `length` will display as a hidden property for
-  // arrays. For consistency's sake, do the same for `size`, even though this
-  // property isn't selected by Object.getOwnPropertyNames().
-  if (ctx.showHidden)
-    output.push(`[size]: ${ctx.stylize(`${value.size}`, 'number')}`);
-  return output;
-}
-
-function formatMap(ctx, value, recurseTimes) {
-  const output = [];
-  ctx.indentationLvl += 2;
-  for (const [k, v] of value) {
-    output.push(`${formatValue(ctx, k, recurseTimes)} => ` +
-                formatValue(ctx, v, recurseTimes));
-  }
-  ctx.indentationLvl -= 2;
-  // See comment in formatSet
-  if (ctx.showHidden)
-    output.push(`[size]: ${ctx.stylize(`${value.size}`, 'number')}`);
-  return output;
-}
-
-function formatSetIterInner(ctx, recurseTimes, entries, state) {
-  const maxArrayLength = Math.max(ctx.maxArrayLength, 0);
-  const maxLength = Math.min(maxArrayLength, entries.length);
-  let output = new Array(maxLength);
-  ctx.indentationLvl += 2;
-  for (var i = 0; i < maxLength; i++) {
-    output[i] = formatValue(ctx, entries[i], recurseTimes);
-  }
-  ctx.indentationLvl -= 2;
-  if (state === kWeak) {
-    // Sort all entries to have a halfway reliable output (if more entries than
-    // retrieved ones exist, we can not reliably return the same output).
-    output = output.sort();
-  }
-  const remaining = entries.length - maxLength;
-  if (remaining > 0) {
-    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);
-  }
-  return output;
-}
-
-function formatMapIterInner(ctx, recurseTimes, entries, state) {
-  const maxArrayLength = Math.max(ctx.maxArrayLength, 0);
-  // Entries exist as [key1, val1, key2, val2, ...]
-  const len = entries.length / 2;
-  const remaining = len - maxArrayLength;
-  const maxLength = Math.min(maxArrayLength, len);
-  let output = new Array(maxLength);
-  let start = '';
-  let end = '';
-  let middle = ' => ';
-  let i = 0;
-  if (state === kMapEntries) {
-    start = '[ ';
-    end = ' ]';
-    middle = ', ';
-  }
-  ctx.indentationLvl += 2;
-  for (; i < maxLength; i++) {
-    const pos = i * 2;
-    output[i] = `${start}${formatValue(ctx, entries[pos], recurseTimes)}` +
-      `${middle}${formatValue(ctx, entries[pos + 1], recurseTimes)}${end}`;
-  }
-  ctx.indentationLvl -= 2;
-  if (state === kWeak) {
-    // Sort all entries to have a halfway reliable output (if more entries
-    // than retrieved ones exist, we can not reliably return the same output).
-    output = output.sort();
-  }
-  if (remaining > 0) {
-    output.push(`... ${remaining} more item${remaining > 1 ? 's' : ''}`);
-  }
-  return output;
-}
-
-function formatWeakCollection(ctx) {
-  return [ctx.stylize('[items unknown]', 'special')];
-}
-
-function formatWeakSet(ctx, value, recurseTimes) {
-  const entries = previewEntries(value);
-  return formatSetIterInner(ctx, recurseTimes, entries, kWeak);
-}
-
-function formatWeakMap(ctx, value, recurseTimes) {
-  const entries = previewEntries(value);
-  return formatMapIterInner(ctx, recurseTimes, entries, kWeak);
-}
-
-function formatSetIterator(ctx, value, recurseTimes) {
-  const entries = previewEntries(value);
-  return formatSetIterInner(ctx, recurseTimes, entries, kIterator);
-}
-
-function formatMapIterator(ctx, value, recurseTimes) {
-  const [entries, isKeyValue] = previewEntries(value, true);
-  if (isKeyValue) {
-    return formatMapIterInner(ctx, recurseTimes, entries, kMapEntries);
-  }
-
-  return formatSetIterInner(ctx, recurseTimes, entries, kIterator);
-}
-
-function formatPromise(ctx, value, recurseTimes) {
-  let output;
-  const [state, result] = getPromiseDetails(value);
-  if (state === kPending) {
-    output = [ctx.stylize('<pending>', 'special')];
-  } else {
-    // Using `formatValue` is correct here without the need to fix the
-    // indentation level.
-    ctx.indentationLvl += 2;
-    const str = formatValue(ctx, result, recurseTimes);
-    ctx.indentationLvl -= 2;
-    output = [
-      state === kRejected ?
-        `${ctx.stylize('<rejected>', 'special')} ${str}` :
-        str
-    ];
-  }
-  return output;
-}
-
-function formatProperty(ctx, value, recurseTimes, key, type) {
-  let name, str;
-  let extra = ' ';
-  const desc = Object.getOwnPropertyDescriptor(value, key) ||
-    { value: value[key], enumerable: true };
-  if (desc.value !== undefined) {
-    const diff = (type !== kObjectType || ctx.compact === false) ? 2 : 3;
-    ctx.indentationLvl += diff;
-    str = formatValue(ctx, desc.value, recurseTimes);
-    if (diff === 3) {
-      const len = ctx.colors ? removeColors(str).length : str.length;
-      if (ctx.breakLength < len) {
-        extra = `\n${' '.repeat(ctx.indentationLvl)}`;
-      }
-    }
-    ctx.indentationLvl -= diff;
-  } else if (desc.get !== undefined) {
-    if (desc.set !== undefined) {
-      str = ctx.stylize('[Getter/Setter]', 'special');
-    } else {
-      str = ctx.stylize('[Getter]', 'special');
-    }
-  } else if (desc.set !== undefined) {
-    str = ctx.stylize('[Setter]', 'special');
-  } else {
-    str = ctx.stylize('undefined', 'undefined');
-  }
-  if (type === kArrayType) {
-    return str;
-  }
-  if (typeof key === 'symbol') {
-    const tmp = key.toString().replace(strEscapeSequencesReplacer, escapeFn);
-    name = `[${ctx.stylize(tmp, 'symbol')}]`;
-  } else if (desc.enumerable === false) {
-    name = `[${key.replace(strEscapeSequencesReplacer, escapeFn)}]`;
-  } else if (keyStrRegExp.test(key)) {
-    name = ctx.stylize(key, 'name');
-  } else {
-    name = ctx.stylize(strEscape(key), 'string');
-  }
-  return `${name}:${extra}${str}`;
-}
-
-function reduceToSingleString(ctx, output, base, braces) {
-  const breakLength = ctx.breakLength;
-  let i = 0;
-  if (ctx.compact === false) {
-    const indentation = ' '.repeat(ctx.indentationLvl);
-    let res = `${base ? `${base} ` : ''}${braces[0]}\n${indentation}  `;
-    for (; i < output.length - 1; i++) {
-      res += `${output[i]},\n${indentation}  `;
-    }
-    res += `${output[i]}\n${indentation}${braces[1]}`;
-    return res;
-  }
-  if (output.length * 2 <= breakLength) {
-    let length = 0;
-    for (; i < output.length && length <= breakLength; i++) {
-      if (ctx.colors) {
-        length += removeColors(output[i]).length + 1;
-      } else {
-        length += output[i].length + 1;
-      }
-    }
-    if (length <= breakLength)
-      return `${braces[0]}${base ? ` ${base}` : ''} ${join(output, ', ')} ` +
-        braces[1];
-  }
-  // If the opening "brace" is too large, like in the case of "Set {",
-  // we need to force the first item to be on the next line or the
-  // items will not line up correctly.
-  const indentation = ' '.repeat(ctx.indentationLvl);
-  const ln = base === '' && braces[0].length === 1 ?
-    ' ' : `${base ? ` ${base}` : ''}\n${indentation}  `;
-  const str = join(output, `,\n${indentation}  `);
-  return `${braces[0]}${ln}${str} ${braces[1]}`;
-}
-
 function isBoolean(arg) {
   return typeof arg === 'boolean';
 }
diff --git a/node.gyp b/node.gyp
index 72b045e31aa7e9..4dcfbd16fa26ec 100644
--- a/node.gyp
+++ b/node.gyp
@@ -161,6 +161,7 @@
       'lib/internal/url.js',
       'lib/internal/util.js',
       'lib/internal/util/comparisons.js',
+      'lib/internal/util/inspect.js',
       'lib/internal/util/inspector.js',
       'lib/internal/util/types.js',
       'lib/internal/http2/core.js',
diff --git a/src/inspector/worker_inspector.h b/src/inspector/worker_inspector.h
index e3c96cf62f01b0..c1d3b8a5711740 100644
--- a/src/inspector/worker_inspector.h
+++ b/src/inspector/worker_inspector.h
@@ -21,6 +21,7 @@ class WorkerDelegate {
                              const std::string& url,
                              bool waiting,
                              std::shared_ptr<MainThreadHandle> worker) = 0;
+  virtual ~WorkerDelegate() {}
 };
 
 class WorkerManagerEventHandle {
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index 1e5328f3d7afb3..23c5baebeda5b8 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -4845,6 +4845,7 @@ class KeyPairGenerationConfig {
   virtual bool Configure(const EVPKeyCtxPointer& ctx) {
     return true;
   }
+  virtual ~KeyPairGenerationConfig() {}
 };
 
 class RSAKeyPairGenerationConfig : public KeyPairGenerationConfig {
diff --git a/src/node_options.h b/src/node_options.h
index 32189dacfb080a..0e8af86218b641 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -24,6 +24,7 @@ struct HostPort {
 class Options {
  public:
   virtual void CheckOptions(std::vector<std::string>* errors) {}
+  virtual ~Options() {}
 };
 
 // These options are currently essentially per-Environment, but it can be nice
diff --git a/test/parallel/test-assert.js b/test/parallel/test-assert.js
index 920d7cea659644..48224eb6b1deb3 100644
--- a/test/parallel/test-assert.js
+++ b/test/parallel/test-assert.js
@@ -285,7 +285,7 @@ testAssertionMessage(/abc/gim, '/abc/gim');
 testAssertionMessage(function f() {}, '[Function: f]');
 testAssertionMessage(function() {}, '[Function]');
 testAssertionMessage({}, '{}');
-testAssertionMessage(circular, '{\n-   y: 1,\n-   x: [Circular]\n- }');
+testAssertionMessage(circular, '{\n-   x: [Circular],\n-   y: 1\n- }');
 testAssertionMessage({ a: undefined, b: null },
                      '{\n-   a: undefined,\n-   b: null\n- }');
 testAssertionMessage({ a: NaN, b: Infinity, c: -Infinity },
@@ -593,8 +593,8 @@ assert.throws(
     '\n' +
     '- {}\n' +
     '+ {\n' +
-    "+   loop: 'forever',\n" +
-    '+   [Symbol(nodejs.util.inspect.custom)]: [Function]\n' +
+    '+   [Symbol(nodejs.util.inspect.custom)]: [Function],\n' +
+    "+   loop: 'forever'\n" +
     '+ }'
   });
 
@@ -858,9 +858,12 @@ common.expectsError(
       code: 'ERR_ASSERTION',
       name: 'AssertionError [ERR_ASSERTION]',
       message: `${start}\n${actExp}\n\n` +
-               "  Comparison {\n    name: 'TypeError',\n" +
-               "    message: 'Wrong value',\n-   code: 404\n" +
-               '+   code: 404,\n+   foo: undefined\n  }'
+               '  Comparison {\n' +
+               '    code: 404,\n' +
+               '+   foo: undefined,\n' +
+               "    message: 'Wrong value',\n" +
+               "    name: 'TypeError'\n" +
+               '  }'
     }
   );
 
@@ -872,9 +875,13 @@ common.expectsError(
       code: 'ERR_ASSERTION',
       name: 'AssertionError [ERR_ASSERTION]',
       message: `${start}\n${actExp}\n\n` +
-               "  Comparison {\n    name: 'TypeError',\n" +
-               "    message: 'Wrong value',\n-   code: 404\n" +
-               "+   code: '404',\n+   foo: undefined\n  }"
+               '  Comparison {\n' +
+               '-   code: 404,\n' +
+               "+   code: '404',\n" +
+               '+   foo: undefined,\n' +
+               "    message: 'Wrong value',\n" +
+               "    name: 'TypeError'\n" +
+               '  }'
     }
   );
 
@@ -904,8 +911,11 @@ common.expectsError(
       name: 'AssertionError [ERR_ASSERTION]',
       code: 'ERR_ASSERTION',
       message: `${start}\n${actExp}\n\n` +
-               "  Comparison {\n-   name: 'TypeError',\n+   name: 'Error'," +
-               "\n    message: 'e'\n  }"
+               '  Comparison {\n' +
+               "    message: 'e',\n" +
+               "-   name: 'TypeError'\n" +
+               "+   name: 'Error'\n" +
+               '  }'
     }
   );
   assert.throws(
@@ -915,8 +925,11 @@ common.expectsError(
       code: 'ERR_ASSERTION',
       generatedMessage: true,
       message: `${start}\n${actExp}\n\n` +
-               "  Comparison {\n    name: 'Error',\n-   message: 'foo'" +
-               "\n+   message: ''\n  }"
+               '  Comparison {\n' +
+               "-   message: 'foo',\n" +
+               "+   message: '',\n" +
+               "    name: 'Error'\n" +
+               '  }'
     }
   );
 
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index fdd651d3eeed84..e2e5075f6b2b48 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -11,4 +11,4 @@ const list = process.moduleLoadList.slice();
 
 const assert = require('assert');
 
-assert(list.length <= 75, list);
+assert(list.length <= 76, list);
diff --git a/test/parallel/test-internal-errors.js b/test/parallel/test-internal-errors.js
index d4f6a443d82f4c..de5d6ed3b9bb8e 100644
--- a/test/parallel/test-internal-errors.js
+++ b/test/parallel/test-internal-errors.js
@@ -92,7 +92,7 @@ common.expectsError(() => {
 }, {
   code: 'ERR_ASSERTION',
   type: assert.AssertionError,
-  message: /-   message: 'Error for testing purposes: a'\n\+   message: \/\^Error/
+  message: /-   message: 'Error for testing purposes: a',\n\+   message: \/\^Error/
 });
 
 // Test ERR_INVALID_FD_TYPE
diff --git a/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js b/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js
index d19b522e290ba9..7cd4b90c008a2f 100644
--- a/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js
+++ b/test/parallel/test-stdout-cannot-be-closed-child-process-pipe.js
@@ -24,9 +24,9 @@ function parent() {
   });
 
   child.on('close', function(code, signal) {
-    assert(code);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(err, '');
     assert.strictEqual(out, 'foo');
-    assert(/process\.stdout cannot be closed/.test(err));
     console.log('ok');
   });
 }
diff --git a/test/pseudo-tty/test-stdin-write.js b/test/pseudo-tty/test-stdin-write.js
new file mode 100644
index 00000000000000..39091f20bbb745
--- /dev/null
+++ b/test/pseudo-tty/test-stdin-write.js
@@ -0,0 +1,3 @@
+'use strict';
+require('../common');
+process.stdin.end('foobar\n');
diff --git a/test/pseudo-tty/test-stdin-write.out b/test/pseudo-tty/test-stdin-write.out
new file mode 100644
index 00000000000000..323fae03f4606e
--- /dev/null
+++ b/test/pseudo-tty/test-stdin-write.out
@@ -0,0 +1 @@
+foobar
diff --git a/test/pseudo-tty/test-stdout-read.in b/test/pseudo-tty/test-stdout-read.in
new file mode 100644
index 00000000000000..10ddd6d257e013
--- /dev/null
+++ b/test/pseudo-tty/test-stdout-read.in
@@ -0,0 +1 @@
+Hello!
diff --git a/test/pseudo-tty/test-stdout-read.js b/test/pseudo-tty/test-stdout-read.js
new file mode 100644
index 00000000000000..90f017ed77b7be
--- /dev/null
+++ b/test/pseudo-tty/test-stdout-read.js
@@ -0,0 +1,3 @@
+'use strict';
+const common = require('../common');
+process.stderr.on('data', common.mustCall(console.log));
diff --git a/test/pseudo-tty/test-stdout-read.out b/test/pseudo-tty/test-stdout-read.out
new file mode 100644
index 00000000000000..3b7fda223d0e6c
--- /dev/null
+++ b/test/pseudo-tty/test-stdout-read.out
@@ -0,0 +1 @@
+<Buffer 48 65 6c 6c 6f 21 0a>
diff --git a/test/pseudo-tty/testcfg.py b/test/pseudo-tty/testcfg.py
index 41a536104d7cba..920789844583de 100644
--- a/test/pseudo-tty/testcfg.py
+++ b/test/pseudo-tty/testcfg.py
@@ -35,10 +35,11 @@
 
 class TTYTestCase(test.TestCase):
 
-  def __init__(self, path, file, expected, arch, mode, context, config):
+  def __init__(self, path, file, expected, input, arch, mode, context, config):
     super(TTYTestCase, self).__init__(context, path, arch, mode)
     self.file = file
     self.expected = expected
+    self.input = input
     self.config = config
     self.arch = arch
     self.mode = mode
@@ -104,12 +105,16 @@ def GetSource(self):
           + open(self.expected).read())
 
   def RunCommand(self, command, env):
+    input = None
+    if self.input is not None and exists(self.input):
+      input = open(self.input).read()
     full_command = self.context.processor(command)
     output = test.Execute(full_command,
                      self.context,
                      self.context.GetTimeout(self.mode),
                      env,
-                     True)
+                     faketty=True,
+                     input=input)
     return test.TestOutput(self,
                       full_command,
                       output,
@@ -139,11 +144,12 @@ def ListTests(self, current_path, path, arch, mode):
       if self.Contains(path, test):
         file_prefix = join(self.root, reduce(join, test[1:], ""))
         file_path = file_prefix + ".js"
+        input_path = file_prefix + ".in"
         output_path = file_prefix + ".out"
         if not exists(output_path):
           raise Exception("Could not find %s" % output_path)
         result.append(TTYTestCase(test, file_path, output_path,
-                                      arch, mode, self.context, self))
+                                  input_path, arch, mode, self.context, self))
     return result
 
   def GetBuildRequirements(self):
diff --git a/tools/icu/README.md b/tools/icu/README.md
index 223990bc4549c2..01c12279311441 100644
--- a/tools/icu/README.md
+++ b/tools/icu/README.md
@@ -92,7 +92,7 @@ make clean
 tools/license-builder.sh
 ```
 
-- Now, fix the default URL for the `full-icu` build in `/configure`, in
+- Now, fix the default URL for the `full-icu` build in `/configure.py`, in
 the `configure_intl()` function. It should match the ICU URL used in the
 first step.  When this is done, the following should build with full ICU.
 
@@ -104,7 +104,7 @@ make
 make test-ci
 ```
 
-- commit the change to `configure` along with the updated `LICENSE` file.
+- commit the change to `configure.py` along with the updated `LICENSE` file.
 
   - Note: To simplify review, I often will “pre-land” this patch, meaning that
   I run the patch through `curl -L https://github.com/nodejs/node/pull/xxx.patch
diff --git a/tools/icu/shrink-icu-src.py b/tools/icu/shrink-icu-src.py
index 63080603ad16e6..e18243542408a5 100644
--- a/tools/icu/shrink-icu-src.py
+++ b/tools/icu/shrink-icu-src.py
@@ -22,7 +22,7 @@
 parser.add_option('--icutmp',
     action='store',
     dest='icutmp',
-    default='out/Release/gen/icutmp',
+    default='out/Release/obj/gen/icutmp',
     help='path to icutmp dir.')
 
 
diff --git a/tools/test.py b/tools/test.py
index b6f91aa1ebdf59..c5c9fb53c07626 100755
--- a/tools/test.py
+++ b/tools/test.py
@@ -705,12 +705,23 @@ def CheckedUnlink(name):
       PrintError("os.unlink() " + str(e))
     break
 
-def Execute(args, context, timeout=None, env={}, faketty=False, disable_core_files=False):
+def Execute(args, context, timeout=None, env={}, faketty=False, disable_core_files=False, input=None):
   if faketty:
     import pty
     (out_master, fd_out) = pty.openpty()
     fd_in = fd_err = fd_out
     pty_out = out_master
+
+    if input is not None:
+      # Before writing input data, disable echo so the input doesn't show
+      # up as part of the output.
+      import termios
+      attr = termios.tcgetattr(fd_in)
+      attr[3] = attr[3] & ~termios.ECHO
+      termios.tcsetattr(fd_in, termios.TCSADRAIN, attr)
+
+      os.write(pty_out, input)
+      os.write(pty_out, '\x04') # End-of-file marker (Ctrl+D)
   else:
     (fd_out, outname) = tempfile.mkstemp()
     (fd_err, errname) = tempfile.mkstemp()