From ad98cf04f3ae0ae17602627ebd4a934a046e707a Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Mon, 2 Nov 2020 16:34:24 +0100
Subject: [PATCH 1/7] stream: remove isPromise utility function

The function was not checking if the parameter was actually a Promise
instance, but if it has a `then` method. Removing the utility function
in favor of a clearer `typeof` check, handling the case when the
thenable throws if then method is accessed more than once.

PR-URL: https://github.com/nodejs/node/pull/35925
Reviewed-By: Robert Nagy <ronagy@icloud.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 lib/internal/streams/pipeline.js      | 20 +++++++++++---------
 test/parallel/test-stream-pipeline.js | 21 +++++++++++++++++++++
 2 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/lib/internal/streams/pipeline.js b/lib/internal/streams/pipeline.js
index c662bce8db1ab3..a73e17f1f29eed 100644
--- a/lib/internal/streams/pipeline.js
+++ b/lib/internal/streams/pipeline.js
@@ -5,8 +5,9 @@
 
 const {
   ArrayIsArray,
+  ReflectApply,
   SymbolAsyncIterator,
-  SymbolIterator
+  SymbolIterator,
 } = primordials;
 
 let eos;
@@ -77,10 +78,6 @@ function popCallback(streams) {
   return streams.pop();
 }
 
-function isPromise(obj) {
-  return !!(obj && typeof obj.then === 'function');
-}
-
 function isReadable(obj) {
   return !!(obj && typeof obj.pipe === 'function');
 }
@@ -222,14 +219,19 @@ function pipeline(...streams) {
         const pt = new PassThrough({
           objectMode: true
         });
-        if (isPromise(ret)) {
-          ret
-            .then((val) => {
+
+        // Handle Promises/A+ spec, `then` could be a getter that throws on
+        // second use.
+        const then = ret?.then;
+        if (typeof then === 'function') {
+          ReflectApply(then, ret, [
+            (val) => {
               value = val;
               pt.end(val);
             }, (err) => {
               pt.destroy(err);
-            });
+            }
+          ]);
         } else if (isIterable(ret, true)) {
           finishCount++;
           pump(ret, pt, finish);
diff --git a/test/parallel/test-stream-pipeline.js b/test/parallel/test-stream-pipeline.js
index b7d3720d0d05dd..23887122fc78d8 100644
--- a/test/parallel/test-stream-pipeline.js
+++ b/test/parallel/test-stream-pipeline.js
@@ -1240,3 +1240,24 @@ const net = require('net');
     }),
   );
 }
+{
+  function createThenable() {
+    let counter = 0;
+    return {
+      get then() {
+        if (counter++) {
+          throw new Error('Cannot access `then` more than once');
+        }
+        return Function.prototype;
+      },
+    };
+  }
+
+  pipeline(
+    function* () {
+      yield 0;
+    },
+    createThenable,
+    () => common.mustNotCall(),
+  );
+}

From 1a6d4dce6db09cb58cb77714cdcb28d84a7c7073 Mon Sep 17 00:00:00 2001
From: Benjamin Gruenbaum <benjamingr@gmail.com>
Date: Fri, 6 Nov 2020 12:05:08 +0200
Subject: [PATCH 2/7] events: getEventListeners static

PR-URL: https://github.com/nodejs/node/pull/35991
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/events.md                             | 34 ++++++++++++++++++
 lib/events.js                                 | 26 +++++++++++++-
 lib/internal/event_target.js                  |  2 ++
 .../test-events-static-geteventlisteners.js   | 36 +++++++++++++++++++
 4 files changed, 97 insertions(+), 1 deletion(-)
 create mode 100644 test/parallel/test-events-static-geteventlisteners.js

diff --git a/doc/api/events.md b/doc/api/events.md
index 17420a249be731..b593cfac44969f 100644
--- a/doc/api/events.md
+++ b/doc/api/events.md
@@ -829,6 +829,40 @@ class MyClass extends EventEmitter {
 }
 ```
 
+## `events.getEventListeners(emitterOrTarget, eventName)`
+<!-- YAML
+added:
+ - REPLACEME
+-->
+* `emitterOrTarget` {EventEmitter|EventTarget}
+* `eventName` {string|symbol}
+* Returns: {Function[]}
+
+Returns a copy of the array of listeners for the event named `eventName`.
+
+For `EventEmitter`s this behaves exactly the same as calling `.listeners` on
+the emitter.
+
+For `EventTarget`s this is the only way to get the event listeners for the
+event target. This is useful for debugging and diagnostic purposes.
+
+```js
+const { getEventListeners, EventEmitter } = require('events');
+
+{
+  const ee = new EventEmitter();
+  const listener = () => console.log('Events are fun');
+  ee.on('foo', listener);
+  getEventListeners(ee, 'foo'); // [listener]
+}
+{
+  const et = new EventTarget();
+  const listener = () => console.log('Events are fun');
+  ee.addEventListener('foo', listener);
+  getEventListeners(ee, 'foo'); // [listener]
+}
+```
+
 ## `events.once(emitter, name[, options])`
 <!-- YAML
 added:
diff --git a/lib/events.js b/lib/events.js
index f82776072b1598..cf1922f1475501 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -22,6 +22,7 @@
 'use strict';
 
 const {
+  ArrayPrototypePush,
   Boolean,
   Error,
   ErrorCaptureStackTrace,
@@ -74,13 +75,14 @@ const lazyDOMException = hideStackFrames((message, name) => {
   return new DOMException(message, name);
 });
 
+
 function EventEmitter(opts) {
   EventEmitter.init.call(this, opts);
 }
 module.exports = EventEmitter;
 module.exports.once = once;
 module.exports.on = on;
-
+module.exports.getEventListeners = getEventListeners;
 // Backwards-compat with node 0.10.x
 EventEmitter.EventEmitter = EventEmitter;
 
@@ -634,6 +636,28 @@ function unwrapListeners(arr) {
   return ret;
 }
 
+function getEventListeners(emitterOrTarget, type) {
+  // First check if EventEmitter
+  if (typeof emitterOrTarget.listeners === 'function') {
+    return emitterOrTarget.listeners(type);
+  }
+  // Require event target lazily to avoid always loading it
+  const { isEventTarget, kEvents } = require('internal/event_target');
+  if (isEventTarget(emitterOrTarget)) {
+    const root = emitterOrTarget[kEvents].get(type);
+    const listeners = [];
+    let handler = root?.next;
+    while (handler?.listener !== undefined) {
+      ArrayPrototypePush(listeners, handler.listener);
+      handler = handler.next;
+    }
+    return listeners;
+  }
+  throw new ERR_INVALID_ARG_TYPE('emitter',
+                                 ['EventEmitter', 'EventTarget'],
+                                 emitterOrTarget);
+}
+
 async function once(emitter, name, options = {}) {
   const signal = options ? options.signal : undefined;
   validateAbortSignal(signal, 'options.signal');
diff --git a/lib/internal/event_target.js b/lib/internal/event_target.js
index 3b7e6803f6ffa0..9e237af45f7c9c 100644
--- a/lib/internal/event_target.js
+++ b/lib/internal/event_target.js
@@ -636,4 +636,6 @@ module.exports = {
   kNewListener,
   kTrustEvent,
   kRemoveListener,
+  kEvents,
+  isEventTarget,
 };
diff --git a/test/parallel/test-events-static-geteventlisteners.js b/test/parallel/test-events-static-geteventlisteners.js
new file mode 100644
index 00000000000000..d717ff74242f90
--- /dev/null
+++ b/test/parallel/test-events-static-geteventlisteners.js
@@ -0,0 +1,36 @@
+'use strict';
+
+const common = require('../common');
+
+const {
+  deepStrictEqual,
+} = require('assert');
+
+const { getEventListeners, EventEmitter } = require('events');
+
+// Test getEventListeners on EventEmitter
+{
+  const fn1 = common.mustNotCall();
+  const fn2 = common.mustNotCall();
+  const emitter = new EventEmitter();
+  emitter.on('foo', fn1);
+  emitter.on('foo', fn2);
+  emitter.on('baz', fn1);
+  emitter.on('baz', fn1);
+  deepStrictEqual(getEventListeners(emitter, 'foo'), [fn1, fn2]);
+  deepStrictEqual(getEventListeners(emitter, 'bar'), []);
+  deepStrictEqual(getEventListeners(emitter, 'baz'), [fn1, fn1]);
+}
+// Test getEventListeners on EventTarget
+{
+  const fn1 = common.mustNotCall();
+  const fn2 = common.mustNotCall();
+  const target = new EventTarget();
+  target.addEventListener('foo', fn1);
+  target.addEventListener('foo', fn2);
+  target.addEventListener('baz', fn1);
+  target.addEventListener('baz', fn1);
+  deepStrictEqual(getEventListeners(target, 'foo'), [fn1, fn2]);
+  deepStrictEqual(getEventListeners(target, 'bar'), []);
+  deepStrictEqual(getEventListeners(target, 'baz'), [fn1]);
+}

From aa1eb1fd597f68c6cb67c2a4d631a8d66f2cb94e Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 6 Nov 2020 07:07:43 -0800
Subject: [PATCH 3/7] timers: cleanup abort listener on awaitable timers

Co-authored-by: Benjamin Gruenbaum <benjamingr@gmail.com>
Signed-off-by: James M Snell <jasnell@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/36006
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 lib/timers/promises.js                   | 42 +++++++++++++++---------
 test/parallel/test-timers-promisified.js | 23 ++++++++++++-
 2 files changed, 48 insertions(+), 17 deletions(-)

diff --git a/lib/timers/promises.js b/lib/timers/promises.js
index ef1e6437d4f6ca..eba8c1e5036210 100644
--- a/lib/timers/promises.js
+++ b/lib/timers/promises.js
@@ -2,6 +2,7 @@
 
 const {
   Promise,
+  PromisePrototypeFinally,
   PromiseReject,
 } = primordials;
 
@@ -24,6 +25,13 @@ const lazyDOMException = hideStackFrames((message, name) => {
   return new DOMException(message, name);
 });
 
+function cancelListenerHandler(clear, reject) {
+  if (!this._destroyed) {
+    clear(this);
+    reject(lazyDOMException('The operation was aborted', 'AbortError'));
+  }
+}
+
 function setTimeout(after, value, options = {}) {
   const args = value !== undefined ? [value] : value;
   if (options == null || typeof options !== 'object') {
@@ -58,20 +66,21 @@ function setTimeout(after, value, options = {}) {
     return PromiseReject(
       lazyDOMException('The operation was aborted', 'AbortError'));
   }
-  return new Promise((resolve, reject) => {
+  let oncancel;
+  const ret = new Promise((resolve, reject) => {
     const timeout = new Timeout(resolve, after, args, false, true);
     if (!ref) timeout.unref();
     insert(timeout, timeout._idleTimeout);
     if (signal) {
-      signal.addEventListener('abort', () => {
-        if (!timeout._destroyed) {
-          // eslint-disable-next-line no-undef
-          clearTimeout(timeout);
-          reject(lazyDOMException('The operation was aborted', 'AbortError'));
-        }
-      }, { once: true });
+      // eslint-disable-next-line no-undef
+      oncancel = cancelListenerHandler.bind(timeout, clearTimeout, reject);
+      signal.addEventListener('abort', oncancel);
     }
   });
+  return oncancel !== undefined ?
+    PromisePrototypeFinally(
+      ret,
+      () => signal.removeEventListener('abort', oncancel)) : ret;
 }
 
 function setImmediate(value, options = {}) {
@@ -107,19 +116,20 @@ function setImmediate(value, options = {}) {
     return PromiseReject(
       lazyDOMException('The operation was aborted', 'AbortError'));
   }
-  return new Promise((resolve, reject) => {
+  let oncancel;
+  const ret = new Promise((resolve, reject) => {
     const immediate = new Immediate(resolve, [value]);
     if (!ref) immediate.unref();
     if (signal) {
-      signal.addEventListener('abort', () => {
-        if (!immediate._destroyed) {
-          // eslint-disable-next-line no-undef
-          clearImmediate(immediate);
-          reject(lazyDOMException('The operation was aborted', 'AbortError'));
-        }
-      }, { once: true });
+      // eslint-disable-next-line no-undef
+      oncancel = cancelListenerHandler.bind(immediate, clearImmediate, reject);
+      signal.addEventListener('abort', oncancel);
     }
   });
+  return oncancel !== undefined ?
+    PromisePrototypeFinally(
+      ret,
+      () => signal.removeEventListener('abort', oncancel)) : ret;
 }
 
 module.exports = {
diff --git a/test/parallel/test-timers-promisified.js b/test/parallel/test-timers-promisified.js
index bd52d2166cf88a..be73984b4fa602 100644
--- a/test/parallel/test-timers-promisified.js
+++ b/test/parallel/test-timers-promisified.js
@@ -1,4 +1,4 @@
-// Flags: --no-warnings
+// Flags: --no-warnings --expose-internals
 'use strict';
 const common = require('../common');
 const assert = require('assert');
@@ -6,6 +6,9 @@ const timers = require('timers');
 const { promisify } = require('util');
 const child_process = require('child_process');
 
+// TODO(benjamingr) - refactor to use getEventListeners when #35991 lands
+const { NodeEventTarget } = require('internal/event_target');
+
 const timerPromises = require('timers/promises');
 
 /* eslint-disable no-restricted-syntax */
@@ -92,6 +95,24 @@ process.on('multipleResolves', common.mustNotCall());
   });
 }
 
+{
+  // Check that timer adding signals does not leak handlers
+  const signal = new NodeEventTarget();
+  signal.aborted = false;
+  setTimeout(0, null, { signal }).finally(common.mustCall(() => {
+    assert.strictEqual(signal.listenerCount('abort'), 0);
+  }));
+}
+
+{
+  // Check that timer adding signals does not leak handlers
+  const signal = new NodeEventTarget();
+  signal.aborted = false;
+  setImmediate(0, { signal }).finally(common.mustCall(() => {
+    assert.strictEqual(signal.listenerCount('abort'), 0);
+  }));
+}
+
 {
   Promise.all(
     [1, '', false, Infinity].map((i) => assert.rejects(setImmediate(10, i)), {

From c925e24ae7c884d22b02304b20c709cc0b25914a Mon Sep 17 00:00:00 2001
From: ExE Boss <3889017+ExE-Boss@users.noreply.github.com>
Date: Sat, 7 Nov 2020 08:40:00 +0100
Subject: [PATCH 4/7] =?UTF-8?q?lib:=20add=C2=A0%TypedArray%=20abstract?=
 =?UTF-8?q?=C2=A0constructor=20to=C2=A0primordials?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Refs: https://github.com/nodejs/node/pull/35448
Refs: https://github.com/nodejs/node/pull/36003
Refs: https://tc39.es/ecma262/#sec-%typedarray%-intrinsic-object

Co-authored-by: Antoine du Hamel <duhamelantoine1995@gmail.com>

PR-URL: https://github.com/nodejs/node/pull/36016
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Shingo Inoue <leko.noor@gmail.com>
---
 lib/internal/freeze_intrinsics.js       |  6 ++++--
 lib/internal/per_context/primordials.js | 13 +++++++++++++
 lib/internal/util/inspect.js            |  5 ++---
 lib/internal/util/types.js              |  5 +----
 4 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/lib/internal/freeze_intrinsics.js b/lib/internal/freeze_intrinsics.js
index 21612790ce749c..5e99af2d9ad0bb 100644
--- a/lib/internal/freeze_intrinsics.js
+++ b/lib/internal/freeze_intrinsics.js
@@ -65,6 +65,8 @@ const {
   SymbolIterator,
   SyntaxError,
   TypeError,
+  TypedArray,
+  TypedArrayPrototype,
   Uint16Array,
   Uint32Array,
   Uint8Array,
@@ -105,7 +107,7 @@ module.exports = function() {
     // AsyncGeneratorFunction
     ObjectGetPrototypeOf(async function* () {}),
     // TypedArray
-    ObjectGetPrototypeOf(Uint8Array),
+    TypedArrayPrototype,
 
     // 19 Fundamental Objects
     Object.prototype, // 19.1
@@ -189,7 +191,7 @@ module.exports = function() {
     // AsyncGeneratorFunction
     ObjectGetPrototypeOf(async function* () {}),
     // TypedArray
-    ObjectGetPrototypeOf(Uint8Array),
+    TypedArray,
 
     // 18 The Global Object
     eval,
diff --git a/lib/internal/per_context/primordials.js b/lib/internal/per_context/primordials.js
index ddecb18861c258..e8e64baf0c6429 100644
--- a/lib/internal/per_context/primordials.js
+++ b/lib/internal/per_context/primordials.js
@@ -175,5 +175,18 @@ primordials.SafePromise = makeSafe(
   copyPrototype(original.prototype, primordials, `${name}Prototype`);
 });
 
+// Create copies of abstract intrinsic objects that are not directly exposed
+// on the global object.
+// Refs: https://tc39.es/ecma262/#sec-%typedarray%-intrinsic-object
+[
+  { name: 'TypedArray', original: Reflect.getPrototypeOf(Uint8Array) },
+].forEach(({ name, original }) => {
+  primordials[name] = original;
+  // The static %TypedArray% methods require a valid `this`, but can't be bound,
+  // as they need a subclass constructor as the receiver:
+  copyPrototype(original, primordials, name);
+  copyPrototype(original.prototype, primordials, `${name}Prototype`);
+});
+
 Object.setPrototypeOf(primordials, null);
 Object.freeze(primordials);
diff --git a/lib/internal/util/inspect.js b/lib/internal/util/inspect.js
index e6787760fea392..4e1ed55c81cd98 100644
--- a/lib/internal/util/inspect.js
+++ b/lib/internal/util/inspect.js
@@ -57,10 +57,10 @@ const {
   SymbolPrototypeValueOf,
   SymbolIterator,
   SymbolToStringTag,
+  TypedArrayPrototype,
   Uint16Array,
   Uint32Array,
   Uint8Array,
-  Uint8ArrayPrototype,
   Uint8ClampedArray,
   uncurryThis,
 } = primordials;
@@ -141,8 +141,7 @@ const setSizeGetter = uncurryThis(
 const mapSizeGetter = uncurryThis(
   ObjectGetOwnPropertyDescriptor(MapPrototype, 'size').get);
 const typedArraySizeGetter = uncurryThis(
-  ObjectGetOwnPropertyDescriptor(
-    ObjectGetPrototypeOf(Uint8ArrayPrototype), 'length').get);
+  ObjectGetOwnPropertyDescriptor(TypedArrayPrototype, 'length').get);
 
 let hexSlice;
 
diff --git a/lib/internal/util/types.js b/lib/internal/util/types.js
index 4b9eeb469b2d19..115c473ae221d4 100644
--- a/lib/internal/util/types.js
+++ b/lib/internal/util/types.js
@@ -3,14 +3,11 @@
 const {
   ArrayBufferIsView,
   ObjectGetOwnPropertyDescriptor,
-  ObjectGetPrototypeOf,
   SymbolToStringTag,
-  Uint8ArrayPrototype,
+  TypedArrayPrototype,
   uncurryThis,
 } = primordials;
 
-const TypedArrayPrototype = ObjectGetPrototypeOf(Uint8ArrayPrototype);
-
 const TypedArrayProto_toStringTag =
     uncurryThis(
       ObjectGetOwnPropertyDescriptor(TypedArrayPrototype,

From 1bba8c81118425e2bc5457e408f398870255d26a Mon Sep 17 00:00:00 2001
From: Daniel Bevenius <daniel.bevenius@gmail.com>
Date: Tue, 3 Nov 2020 05:51:45 +0100
Subject: [PATCH 5/7] deps: cherry-pick 9a49b22 from V8 upstream
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Original commit message:
  Fix alloc/dealloc size mismatch for v8::BackingStore

  On newer compilers the {operator delete} with explicit {size_t}
  argument would be instantiated for {v8::BackingStore} and used
  in the destructor of {std::unique_ptr<v8::BackingStore>}. The {size_t}
  argument is wrong though, since the pointer actually points
  to a {v8::internal::BackingStore} object.
  The solution is to explicitly provide a {operator delete}, preventing
  an implicitly generated {size_t} operator.

  Bug:v8:11081

  Change-Id: Iee0aa47a67f0e41000bea628942f7e3d70198b83
  Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2506712
  Commit-Queue: Ulan Degenbaev <ulan@chromium.org>
  Reviewed-by: Camillo Bruni <cbruni@chromium.org>
  Cr-Commit-Position: refs/heads/master@{#70916}

PR-URL: https://github.com/nodejs/node/pull/35939
Fixes: https://github.com/nodejs/node/issues/35669
Refs: https://github.com/v8/v8/commit/9a49b2298f65f6b18c5245f3681aca04e5fe4e46
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Richard Lau <rlau@redhat.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
---
 common.gypi          | 2 +-
 deps/v8/include/v8.h | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/common.gypi b/common.gypi
index 33b1325eb513ea..4745bb5ac77639 100644
--- a/common.gypi
+++ b/common.gypi
@@ -36,7 +36,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.16',
+    'v8_embedder_string': '-node.17',
 
     ##### V8 defaults for Node.js #####
 
diff --git a/deps/v8/include/v8.h b/deps/v8/include/v8.h
index 0991d0ab6e4132..261d3b3f06064d 100644
--- a/deps/v8/include/v8.h
+++ b/deps/v8/include/v8.h
@@ -5020,6 +5020,13 @@ class V8_EXPORT BackingStore : public v8::internal::BackingStoreBase {
    */
   bool IsShared() const;
 
+  /**
+   * Prevent implicit instantiation of operator delete with size_t argument.
+   * The size_t argument would be incorrect because ptr points to the
+   * internal BackingStore object.
+   */
+  void operator delete(void* ptr) { ::operator delete(ptr); }
+
   /**
    * Wrapper around ArrayBuffer::Allocator::Reallocate that preserves IsShared.
    * Assumes that the backing_store was allocated by the ArrayBuffer allocator

From 642174a31f7c2d3a8352002095d35a2b34c1126c Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Thu, 5 Nov 2020 08:43:29 -0800
Subject: [PATCH 6/7] dns: fix trace_events name for resolveCaa()

A test was added for this in 6f34498 but because it was a test in the
`internet` directory, it was not run on CI and it was not noticed that
the test was failing. This fixes the error that was causing the test to
fail.

PR-URL: https://github.com/nodejs/node/pull/35979
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 src/cares_wrap.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index 6d7a8e66a9d2ce..71766fa39171af 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -1493,7 +1493,7 @@ class QueryAaaaWrap: public QueryWrap {
 class QueryCaaWrap: public QueryWrap {
  public:
   QueryCaaWrap(ChannelWrap* channel, Local<Object> req_wrap_obj)
-      : QueryWrap(channel, req_wrap_obj, "resolve6") {
+      : QueryWrap(channel, req_wrap_obj, "resolveCaa") {
   }
 
   int Send(const char* name) override {

From 8f954388ed80fd25fc74e0e10bc02e1691801a86 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sat, 7 Nov 2020 11:44:36 +0100
Subject: [PATCH 7/7] tools,lib: tighten prefer-primordials rules for Error
 statics

PR-URL: https://github.com/nodejs/node/pull/36017
Reviewed-By: Shingo Inoue <leko.noor@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 lib/.eslintrc.yaml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/lib/.eslintrc.yaml b/lib/.eslintrc.yaml
index 37a43a223af2fd..f1acc06b40cf7f 100644
--- a/lib/.eslintrc.yaml
+++ b/lib/.eslintrc.yaml
@@ -40,10 +40,8 @@ rules:
     - name: Date
     - name: Error
       ignore:
-        - stackTraceLimit
-        - captureStackTrace
         - prepareStackTrace
-        - isPrototypeOf
+        - stackTraceLimit
     - name: EvalError
     - name: Float32Array
     - name: Float64Array