From 3bbace7735b94ed76c509643a984e4863fee7f1e Mon Sep 17 00:00:00 2001
From: Julien Gilli <jgilli@netflix.com>
Date: Tue, 26 Feb 2019 12:01:03 -0800
Subject: [PATCH 1/4] domain: allow concurrent user-land impl

Currently, only one domain-lke implementation (the core domain one) can
be used to handle uncaught exceptions or unhandled error events.

This PR aims at making it possible for different domain-like
user-land implementations to be used concurrently (including with the
core domain impl) so that the state of the core domain module (doc
deprecated) does not prevent users of domains from having a
well-maintained domain-like facility.

Ref: https://github.com/nodejs/node/issues/23348
Co-authored-by: Rich Trott <rtrott@gmail.com>
---
 doc/api/errors.md                             | 42 ++++++++------
 doc/api/repl.md                               | 29 ++++------
 lib/domain.js                                 | 35 ++++--------
 lib/events.js                                 | 56 +++++++++++++++----
 lib/internal/errors.js                        |  9 ---
 ...ad-after-set-uncaught-exception-capture.js | 11 ----
 ...t-uncaught-exception-capture-after-load.js | 28 ----------
 7 files changed, 90 insertions(+), 120 deletions(-)
 delete mode 100644 test/parallel/test-domain-set-uncaught-exception-capture-after-load.js

diff --git a/doc/api/errors.md b/doc/api/errors.md
index f0d78854703a41..ed6e4385ba43f6 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1014,23 +1014,6 @@ ongoing asynchronous operations.
 
 `c-ares` failed to set the DNS server.
 
-<a id="ERR_DOMAIN_CALLBACK_NOT_AVAILABLE"></a>
-### `ERR_DOMAIN_CALLBACK_NOT_AVAILABLE`
-
-The `domain` module was not usable since it could not establish the required
-error handling hooks, because
-[`process.setUncaughtExceptionCaptureCallback()`][] had been called at an
-earlier point in time.
-
-<a id="ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE"></a>
-### `ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`
-
-[`process.setUncaughtExceptionCaptureCallback()`][] could not be called
-because the `domain` module has been loaded at an earlier point in time.
-
-The stack trace is extended to include the point in time at which the
-`domain` module had been loaded.
-
 <a id="ERR_ENCODING_INVALID_ENCODED_DATA"></a>
 ### `ERR_ENCODING_INVALID_ENCODED_DATA`
 
@@ -2473,6 +2456,31 @@ The UTF-16 encoding was used with [`hash.digest()`][]. While the
 causing the method to return a string rather than a `Buffer`, the UTF-16
 encoding (e.g. `ucs` or `utf16le`) is not supported.
 
+<a id="ERR_DOMAIN_CALLBACK_NOT_AVAILABLE"></a>
+### `ERR_DOMAIN_CALLBACK_NOT_AVAILABLE`
+<!-- YAML
+added: v10.0.0
+removed: REPLACEME
+-->
+
+The `domain` module was not usable since it could not establish the required
+error handling hooks, because
+[`process.setUncaughtExceptionCaptureCallback()`][] had been called at an
+earlier point in time.
+
+<a id="ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE"></a>
+### `ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`
+<!-- YAML
+added: v10.0.0
+removed: REPLACEME
+-->
+
+[`process.setUncaughtExceptionCaptureCallback()`][] could not be called
+because the `domain` module has been loaded at an earlier point in time.
+
+The stack trace is extended to include the point in time at which the
+`domain` module had been loaded.
+
 <a id="ERR_HTTP2_FRAME_ERROR"></a>
 ### `ERR_HTTP2_FRAME_ERROR`
 <!-- YAML
diff --git a/doc/api/repl.md b/doc/api/repl.md
index bf5ee1efef3fee..e47ed9794d78d7 100644
--- a/doc/api/repl.md
+++ b/doc/api/repl.md
@@ -159,25 +159,19 @@ changes:
 The REPL uses the [`domain`][] module to catch all uncaught exceptions for that
 REPL session.
 
-This use of the [`domain`][] module in the REPL has these side effects:
+This use of the [`domain`][] module in the REPL has the side effect of making
+uncaught exceptions not emit the [`'uncaughtException'`][] event.
 
-* Uncaught exceptions only emit the [`'uncaughtException'`][] event in the
-  standalone REPL. Adding a listener for this event in a REPL within
-  another Node.js program results in [`ERR_INVALID_REPL_INPUT`][].
-
-  ```js
-  const r = repl.start();
-
-  r.write('process.on("uncaughtException", () => console.log("Foobar"));\n');
-  // Output stream includes:
-  //   TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`
-  //   cannot be used in the REPL
+```js
+const r = repl.start();
 
-  r.close();
-  ```
+r.write('process.on("uncaughtException", () => console.log("Foobar"));\n');
+// Output stream includes:
+//   TypeError [ERR_INVALID_REPL_INPUT]: Listeners for `uncaughtException`
+//   cannot be used in the REPL
 
-* Trying to use [`process.setUncaughtExceptionCaptureCallback()`][] throws
-  an [`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`][] error.
+r.close();
+```
 
 #### Assignment of the `_` (underscore) variable
 <!-- YAML
@@ -748,11 +742,8 @@ For an example of running a REPL instance over [`curl(1)`][], see:
 [ZSH]: https://en.wikipedia.org/wiki/Z_shell
 [`'uncaughtException'`]: process.md#process_event_uncaughtexception
 [`--experimental-repl-await`]: cli.md#cli_experimental_repl_await
-[`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`]: errors.md#errors_err_domain_cannot_set_uncaught_exception_capture
-[`ERR_INVALID_REPL_INPUT`]: errors.md#errors_err_invalid_repl_input
 [`curl(1)`]: https://curl.haxx.se/docs/manpage.html
 [`domain`]: domain.md
-[`process.setUncaughtExceptionCaptureCallback()`]: process.md#process_process_setuncaughtexceptioncapturecallback_fn
 [`readline.InterfaceCompleter`]: readline.md#readline_use_of_the_completer_function
 [`repl.ReplServer`]: #repl_class_replserver
 [`repl.start()`]: #repl_repl_start_options
diff --git a/lib/domain.js b/lib/domain.js
index acd5dc8221df31..954da31e6f1f2b 100644
--- a/lib/domain.js
+++ b/lib/domain.js
@@ -42,11 +42,7 @@ const {
 } = primordials;
 
 const EventEmitter = require('events');
-const {
-  ERR_DOMAIN_CALLBACK_NOT_AVAILABLE,
-  ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE,
-  ERR_UNHANDLED_ERROR
-} = require('internal/errors').codes;
+const { ERR_UNHANDLED_ERROR } = require('internal/errors').codes;
 const { createHook } = require('async_hooks');
 const { useDomainTrampoline } = require('internal/async_hooks');
 
@@ -54,6 +50,11 @@ const { useDomainTrampoline } = require('internal/async_hooks');
 const kWeak = Symbol('kWeak');
 const { WeakReference } = internalBinding('util');
 
+// Communicate with events module, but don't require that
+// module to have to load this one, since this module has
+// a few side effects.
+EventEmitter.usingDomains = true;
+
 // Overwrite process.domain with a getter/setter that will allow for more
 // effective optimizations
 const _domain = [null];
@@ -105,23 +106,7 @@ const asyncHook = createHook({
   }
 });
 
-// When domains are in use, they claim full ownership of the
-// uncaught exception capture callback.
-if (process.hasUncaughtExceptionCaptureCallback()) {
-  throw new ERR_DOMAIN_CALLBACK_NOT_AVAILABLE();
-}
-
-// Get the stack trace at the point where `domain` was required.
-// eslint-disable-next-line no-restricted-syntax
-const domainRequireStack = new Error('require(`domain`) at this point').stack;
-
 const { setUncaughtExceptionCaptureCallback } = process;
-process.setUncaughtExceptionCaptureCallback = function(fn) {
-  const err = new ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE();
-  err.stack = err.stack + '\n' + '-'.repeat(40) + '\n' + domainRequireStack;
-  throw err;
-};
-
 
 let sendMakeCallbackDeprecation = false;
 function emitMakeCallbackDeprecation({ target, method }) {
@@ -151,8 +136,8 @@ function topLevelDomainCallback(cb, ...args) {
   return ret;
 }
 
-// It's possible to enter one domain while already inside
-// another one. The stack is each entered domain.
+// It's possible to enter one domain while already inside another one. The stack
+// is each entered domain.
 let stack = [];
 exports._stack = stack;
 useDomainTrampoline(topLevelDomainCallback);
@@ -210,6 +195,8 @@ class Domain extends EventEmitter {
   }
 }
 
+Domain[EventEmitter.isDomainLike] = true;
+
 exports.Domain = Domain;
 
 exports.create = exports.createDomain = function createDomain() {
@@ -344,7 +331,7 @@ Domain.prototype.add = function(ee) {
   // d.add(e);
   // e.add(d);
   // e.emit('error', er); // RangeError, stack overflow!
-  if (this.domain && (ee instanceof Domain)) {
+  if (this.domain && ee[EventEmitter.isDomainLike]) {
     for (let d = this.domain; d; d = d.domain) {
       if (ee === d) return;
     }
diff --git a/lib/events.js b/lib/events.js
index 15c69c30271aa6..34fc841b55e2af 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -86,6 +86,7 @@ module.exports.getEventListeners = getEventListeners;
 EventEmitter.EventEmitter = EventEmitter;
 
 EventEmitter.usingDomains = false;
+EventEmitter.isDomainLike = Symbol('isDomainLike');
 
 EventEmitter.captureRejectionSymbol = kRejection;
 ObjectDefineProperty(EventEmitter, 'captureRejections', {
@@ -112,6 +113,7 @@ ObjectDefineProperty(EventEmitter.prototype, kCapture, {
   enumerable: false
 });
 
+EventEmitter.prototype.domain = undefined;
 EventEmitter.prototype._events = undefined;
 EventEmitter.prototype._eventsCount = 0;
 EventEmitter.prototype._maxListeners = undefined;
@@ -183,6 +185,13 @@ EventEmitter.setMaxListeners =
   };
 
 EventEmitter.init = function(opts) {
+  this.domain = null;
+  // If there is an active domain, then attach to it, except if the event
+  // emitter being constructed is itself an instance of a domain-like class.
+  // eslint-disable-next-line max-len
+  if (EventEmitter.usingDomains && !this.constructor[EventEmitter.isDomainLike]) {
+    this.domain = process.domain;
+  }
 
   if (this._events === undefined ||
       this._events === ObjectGetPrototypeOf(this)._events) {
@@ -326,12 +335,24 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
   } else if (!doError)
     return false;
 
+  const domain = this.domain;
+
   // If there is no 'error' event listener then throw.
   if (doError) {
     let er;
     if (args.length > 0)
       er = args[0];
-    if (er instanceof Error) {
+    if (domain !== null && domain !== undefined) {
+      if (!er) {
+        er = new ERR_UNHANDLED_ERROR();
+      }
+      if (typeof er === 'object' && er !== null) {
+        er.domainEmitter = this;
+        er.domain = domain;
+        er.domainThrown = false;
+      }
+      domain.emit('error', er);
+    } else if (er instanceof Error) {
       try {
         const capture = {};
         ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);
@@ -344,20 +365,22 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
       // Note: The comments on the `throw` lines are intentional, they show
       // up in Node's output if this results in an unhandled exception.
       throw er; // Unhandled 'error' event
-    }
+    } else {
+      let stringifiedEr;
+      const { inspect } = require('internal/util/inspect');
+      try {
+        stringifiedEr = inspect(er);
+      } catch {
+        stringifiedEr = er;
+      }
 
-    let stringifiedEr;
-    const { inspect } = require('internal/util/inspect');
-    try {
-      stringifiedEr = inspect(er);
-    } catch {
-      stringifiedEr = er;
+      // At least give some kind of context to the user
+      const err = new ERR_UNHANDLED_ERROR(stringifiedEr);
+      err.context = er;
+      throw err; // Unhandled 'error' event
     }
 
-    // At least give some kind of context to the user
-    const err = new ERR_UNHANDLED_ERROR(stringifiedEr);
-    err.context = er;
-    throw err; // Unhandled 'error' event
+    return false;
   }
 
   const handler = events[type];
@@ -365,6 +388,12 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
   if (handler === undefined)
     return false;
 
+  let needDomainExit = false;
+  if (domain !== null && domain !== undefined && this !== process) {
+    domain.enter();
+    needDomainExit = true;
+  }
+
   if (typeof handler === 'function') {
     const result = ReflectApply(handler, this, args);
 
@@ -391,6 +420,9 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
     }
   }
 
+  if (needDomainExit)
+    domain.exit();
+
   return true;
 };
 
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 34c168ce38ab91..a4da77d700f8a0 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -874,15 +874,6 @@ E('ERR_DIR_CONCURRENT_OPERATION',
   'asynchronous operations', Error);
 E('ERR_DNS_SET_SERVERS_FAILED', 'c-ares failed to set servers: "%s" [%s]',
   Error);
-E('ERR_DOMAIN_CALLBACK_NOT_AVAILABLE',
-  'A callback was registered through ' +
-     'process.setUncaughtExceptionCaptureCallback(), which is mutually ' +
-     'exclusive with using the `domain` module',
-  Error);
-E('ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE',
-  'The `domain` module is in use, which is mutually exclusive with calling ' +
-     'process.setUncaughtExceptionCaptureCallback()',
-  Error);
 E('ERR_ENCODING_INVALID_ENCODED_DATA', function(encoding, ret) {
   this.errno = ret;
   return `The encoded data was not valid for encoding ${encoding}`;
diff --git a/test/parallel/test-domain-load-after-set-uncaught-exception-capture.js b/test/parallel/test-domain-load-after-set-uncaught-exception-capture.js
index 4018220711517f..c941cf94210716 100644
--- a/test/parallel/test-domain-load-after-set-uncaught-exception-capture.js
+++ b/test/parallel/test-domain-load-after-set-uncaught-exception-capture.js
@@ -1,17 +1,6 @@
 'use strict';
 const common = require('../common');
-const assert = require('assert');
 
 process.setUncaughtExceptionCaptureCallback(common.mustNotCall());
 
-assert.throws(
-  () => require('domain'),
-  {
-    code: 'ERR_DOMAIN_CALLBACK_NOT_AVAILABLE',
-    name: 'Error',
-    message: /^A callback was registered.*with using the `domain` module/
-  }
-);
-
-process.setUncaughtExceptionCaptureCallback(null);
 require('domain'); // Should not throw.
diff --git a/test/parallel/test-domain-set-uncaught-exception-capture-after-load.js b/test/parallel/test-domain-set-uncaught-exception-capture-after-load.js
deleted file mode 100644
index 55e2e5368d7d17..00000000000000
--- a/test/parallel/test-domain-set-uncaught-exception-capture-after-load.js
+++ /dev/null
@@ -1,28 +0,0 @@
-'use strict';
-const common = require('../common');
-const assert = require('assert');
-
-(function foobar() {
-  require('domain');
-})();
-
-assert.throws(
-  () => process.setUncaughtExceptionCaptureCallback(common.mustNotCall()),
-  (err) => {
-    common.expectsError(
-      {
-        code: 'ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE',
-        name: 'Error',
-        message: /^The `domain` module is in use, which is mutually/
-      }
-    )(err);
-
-    assert(err.stack.includes('-'.repeat(40)),
-           `expected ${err.stack} to contain dashes`);
-
-    const location = `at foobar (${__filename}:`;
-    assert(err.stack.includes(location),
-           `expected ${err.stack} to contain ${location}`);
-    return true;
-  }
-);

From 110983c64ea3d45a38a3feaedafbf7292cbb101a Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Tue, 30 Mar 2021 10:49:27 -0700
Subject: [PATCH 2/4] event: simplify domain conditions

---
 lib/events.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/events.js b/lib/events.js
index 34fc841b55e2af..efe7bd3691c6bd 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -342,11 +342,11 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
     let er;
     if (args.length > 0)
       er = args[0];
-    if (domain !== null && domain !== undefined) {
+    if (domain) {
       if (!er) {
         er = new ERR_UNHANDLED_ERROR();
       }
-      if (typeof er === 'object' && er !== null) {
+      if (typeof er === 'object') {
         er.domainEmitter = this;
         er.domain = domain;
         er.domainThrown = false;

From 77fd57d95fb8859f497a70d9d73c7116bf995346 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Tue, 30 Mar 2021 22:00:27 -0700
Subject: [PATCH 3/4] fixup! event: simplify domain conditions

---
 lib/events.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/events.js b/lib/events.js
index efe7bd3691c6bd..91f1667fac37e1 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -389,7 +389,7 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
     return false;
 
   let needDomainExit = false;
-  if (domain !== null && domain !== undefined && this !== process) {
+  if (domain && this !== process) {
     domain.enter();
     needDomainExit = true;
   }

From f992e364cb436d95961df268b9b559419364be03 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Tue, 30 Mar 2021 22:38:01 -0700
Subject: [PATCH 4/4] fixup! fixup! event: simplify domain conditions

---
 lib/events.js                                 | 68 +++++++++----------
 .../events_unhandled_error_common_trace.out   |  4 +-
 .../events_unhandled_error_nexttick.out       |  4 +-
 .../events_unhandled_error_sameline.out       |  4 +-
 .../events_unhandled_error_subclass.out       |  4 +-
 5 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/lib/events.js b/lib/events.js
index 91f1667fac37e1..65886bb359ad39 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -335,49 +335,49 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
   } else if (!doError)
     return false;
 
-  const domain = this.domain;
-
   // If there is no 'error' event listener then throw.
   if (doError) {
     let er;
     if (args.length > 0)
       er = args[0];
-    if (domain) {
+    if (!this.domain) {
+      if (er instanceof Error) {
+        try {
+          const capture = {};
+          ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);
+          ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {
+            value: enhanceStackTrace.bind(this, er, capture),
+            configurable: true
+          });
+        } catch {}
+
+        // Note: The comments on the `throw` lines are intentional, they show
+        // up in Node's output if this results in an unhandled exception.
+        throw er; // Unhandled 'error' event
+      } else {
+        let stringifiedEr;
+        const { inspect } = require('internal/util/inspect');
+        try {
+          stringifiedEr = inspect(er);
+        } catch {
+          stringifiedEr = er;
+        }
+
+        // At least give some kind of context to the user
+        const err = new ERR_UNHANDLED_ERROR(stringifiedEr);
+        err.context = er;
+        throw err; // Unhandled 'error' event
+      }
+    } else {
       if (!er) {
         er = new ERR_UNHANDLED_ERROR();
       }
       if (typeof er === 'object') {
         er.domainEmitter = this;
-        er.domain = domain;
+        er.domain = this.domain;
         er.domainThrown = false;
       }
-      domain.emit('error', er);
-    } else if (er instanceof Error) {
-      try {
-        const capture = {};
-        ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);
-        ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {
-          value: enhanceStackTrace.bind(this, er, capture),
-          configurable: true
-        });
-      } catch {}
-
-      // Note: The comments on the `throw` lines are intentional, they show
-      // up in Node's output if this results in an unhandled exception.
-      throw er; // Unhandled 'error' event
-    } else {
-      let stringifiedEr;
-      const { inspect } = require('internal/util/inspect');
-      try {
-        stringifiedEr = inspect(er);
-      } catch {
-        stringifiedEr = er;
-      }
-
-      // At least give some kind of context to the user
-      const err = new ERR_UNHANDLED_ERROR(stringifiedEr);
-      err.context = er;
-      throw err; // Unhandled 'error' event
+      this.domain.emit('error', er);
     }
 
     return false;
@@ -389,8 +389,8 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
     return false;
 
   let needDomainExit = false;
-  if (domain && this !== process) {
-    domain.enter();
+  if (this.domain && this !== process) {
+    this.domain.enter();
     needDomainExit = true;
   }
 
@@ -421,7 +421,7 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
   }
 
   if (needDomainExit)
-    domain.exit();
+    this.domain.exit();
 
   return true;
 };
diff --git a/test/message/events_unhandled_error_common_trace.out b/test/message/events_unhandled_error_common_trace.out
index 19e89869ba74fa..566b1f710adf90 100644
--- a/test/message/events_unhandled_error_common_trace.out
+++ b/test/message/events_unhandled_error_common_trace.out
@@ -1,6 +1,6 @@
 node:events:*
-      throw er; // Unhandled 'error' event
-      ^
+        throw er; // Unhandled 'error' event
+        ^
 
 Error: foo:bar
     at bar (*events_unhandled_error_common_trace.js:*:*)
diff --git a/test/message/events_unhandled_error_nexttick.out b/test/message/events_unhandled_error_nexttick.out
index 3e0d4697504e49..956ffc8a975b1f 100644
--- a/test/message/events_unhandled_error_nexttick.out
+++ b/test/message/events_unhandled_error_nexttick.out
@@ -1,6 +1,6 @@
 node:events:*
-      throw er; // Unhandled 'error' event
-      ^
+        throw er; // Unhandled 'error' event
+        ^
 
 Error
     at Object.<anonymous> (*events_unhandled_error_nexttick.js:*:*)
diff --git a/test/message/events_unhandled_error_sameline.out b/test/message/events_unhandled_error_sameline.out
index c027275033941d..b55e77bd67019d 100644
--- a/test/message/events_unhandled_error_sameline.out
+++ b/test/message/events_unhandled_error_sameline.out
@@ -1,6 +1,6 @@
 node:events:*
-      throw er; // Unhandled 'error' event
-      ^
+        throw er; // Unhandled 'error' event
+        ^
 
 Error
     at Object.<anonymous> (*events_unhandled_error_sameline.js:*:*)
diff --git a/test/message/events_unhandled_error_subclass.out b/test/message/events_unhandled_error_subclass.out
index 5b8131970d50d5..a71c0bb9baaae1 100644
--- a/test/message/events_unhandled_error_subclass.out
+++ b/test/message/events_unhandled_error_subclass.out
@@ -1,6 +1,6 @@
 node:events:*
-      throw er; // Unhandled 'error' event
-      ^
+        throw er; // Unhandled 'error' event
+        ^
 
 Error
     at Object.<anonymous> (*events_unhandled_error_subclass.js:*:*)