lib: prefer iterable weak set than WeakRefs in AbortSignal.any

The dom spec specified "weak sets" for dependent and source signals.
This was not captured due to the early implementation of AbortSignal.any
prior to the spec PR getting landed. This commit fixes that behaviour,
which could save us from WeakRef and deref everytime for these siganls.

Author: jazelly

lib/internal/abort_controller.js

@@ -4,15 +4,20 @@
 // in https://github.com/mysticatea/abort-controller (MIT license)
 
 const {
+  ArrayPrototypePush,
   ObjectAssign,
   ObjectDefineProperties,
   ObjectDefineProperty,
   PromiseResolve,
   SafeFinalizationRegistry,
   SafeSet,
   SafeWeakRef,
+  SafeWeakSet,
   Symbol,
   SymbolToStringTag,
+  WeakRefPrototypeDeref,
+  WeakSetPrototypeAdd,
+  WeakSetPrototypeHas,
 } = primordials;
 
 const {
@@ -100,6 +105,33 @@ const kComposite = Symbol('kComposite');
 const kSourceSignals = Symbol('kSourceSignals');
 const kDependantSignals = Symbol('kDependantSignals');
 
+// Since WeakSet is not iterable, we must use another iterable
+// data structure to make it "iterable".
+class IterableWeakSet {
+  #weakSet = new SafeWeakSet();
+  #weakRefs = [];
+
+  add(value) {
+    if (!this.has(value)) {
+      WeakSetPrototypeAdd(this.#weakSet, value);
+      ArrayPrototypePush(this.#weakRefs, new SafeWeakRef(value));
+    }
+  }
+
+  has(value) {
+    return WeakSetPrototypeHas(this.#weakSet, value);
+  }
+
+  getIterable() {
+    const iterable = [];
+    for (let i = 0; i < this.#weakRefs.length; i++) {
+      const item = WeakRefPrototypeDeref(this.#weakRefs[i]);
+      ArrayPrototypePush(iterable, item);
+    }
+    return iterable;
+  }
+}
+
 function customInspect(self, obj, depth, options) {
   if (depth < 0)
     return self;
@@ -238,34 +270,32 @@ class AbortSignal extends EventTarget {
     if (!signalsArray.length) {
       return resultSignal;
     }
-    const resultSignalWeakRef = new SafeWeakRef(resultSignal);
-    resultSignal[kSourceSignals] = new SafeSet();
+    resultSignal[kSourceSignals] = new IterableWeakSet();
     for (let i = 0; i < signalsArray.length; i++) {
       const signal = signalsArray[i];
       if (signal.aborted) {
         abortSignal(resultSignal, signal.reason);
         return resultSignal;
       }
-      signal[kDependantSignals] ??= new SafeSet();
+      signal[kDependantSignals] ??= new IterableWeakSet();
       if (!signal[kComposite]) {
-        resultSignal[kSourceSignals].add(new SafeWeakRef(signal));
-        signal[kDependantSignals].add(resultSignalWeakRef);
+        resultSignal[kSourceSignals].add(signal);
+        signal[kDependantSignals].add(resultSignal);
       } else if (!signal[kSourceSignals]) {
         continue;
       } else {
-        for (const sourceSignal of signal[kSourceSignals]) {
-          const sourceSignalRef = sourceSignal.deref();
-          if (!sourceSignalRef) {
+        for (const sourceSignal of signal[kSourceSignals].getIterable()) {
+          if (!sourceSignal) {
             continue;
           }
-          assert(!sourceSignalRef.aborted);
-          assert(!sourceSignalRef[kComposite]);
+          assert(!sourceSignal.aborted);
+          assert(!sourceSignal[kComposite]);
 
           if (resultSignal[kSourceSignals].has(sourceSignal)) {
             continue;
           }
           resultSignal[kSourceSignals].add(sourceSignal);
-          sourceSignalRef[kDependantSignals].add(resultSignalWeakRef);
+          sourceSignal[kDependantSignals].add(resultSignal);
         }
       }
     }
@@ -380,9 +410,8 @@ function abortSignal(signal, reason) {
     [kTrustEvent]: true,
   });
   signal.dispatchEvent(event);
-  signal[kDependantSignals]?.forEach((s) => {
-    const signalRef = s.deref();
-    if (signalRef) abortSignal(signalRef, reason);
+  signal[kDependantSignals]?.getIterable()?.forEach((s) => {
+    if (s) abortSignal(s, reason);
   });
 }