nodejs
diff --git a/‎lib/internal/webstreams/readablestream.js‎
Lines changed: 11 additions & 11 deletions b/‎lib/internal/webstreams/readablestream.js‎
Lines changed: 11 additions & 11 deletions
diff --git a/‎lib/internal/webstreams/transfer.js‎
Lines changed: 2 additions & 2 deletions b/‎lib/internal/webstreams/transfer.js‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎lib/internal/webstreams/writablestream.js‎
Lines changed: 19 additions & 19 deletions b/‎lib/internal/webstreams/writablestream.js‎
Lines changed: 19 additions & 19 deletions
@@ -848,15 +848,15 @@ class DefaultReadRequest {
   }
 
   [kChunk](value) {
-    this[kState].resolve?.({ done: false, value });
+    this[kState].resolve({ done: false, value });
   }
 
   [kClose]() {
-    this[kState].resolve?.({ done: true, value: undefined });
+    this[kState].resolve({ done: true, value: undefined });
   }
 
   [kError](error) {
-    this[kState].reject?.(error);
+    this[kState].reject(error);
   }
 
   get promise() { return this[kState].promise; }
@@ -868,15 +868,15 @@ class ReadIntoRequest {
   }
 
   [kChunk](value) {
-    this[kState].resolve?.({ done: false, value });
+    this[kState].resolve({ done: false, value });
   }
 
   [kClose](value) {
-    this[kState].resolve?.({ done: true, value });
+    this[kState].resolve({ done: true, value });
   }
 
   [kError](error) {
-    this[kState].reject?.(error);
+    this[kState].reject(error);
   }
 
   get promise() { return this[kState].promise; }
@@ -2169,15 +2169,15 @@ function readableStreamCancel(stream, reason) {
 function readableStreamClose(stream) {
   assert(stream[kState].state === 'readable');
   stream[kState].state = 'closed';
-  stream[kState].closedPromise?.resolve?.();
+  stream[kState].closedPromise?.resolve();
   const {
     reader,
   } = stream[kState];
 
   if (reader === undefined)
     return;
 
-  reader[kState].close?.resolve?.();
+  reader[kState].close?.resolve();
 
   if (readableStreamHasDefaultReader(stream)) {
     for (let n = 0; n < reader[kState].readRequests.length; n++)
@@ -2193,7 +2193,7 @@ function readableStreamError(stream, error) {
   const closedPromiseCache = stream[kState].closedPromise;
   if (closedPromiseCache !== undefined) {
     setPromiseHandled(closedPromiseCache.promise);
-    closedPromiseCache.reject?.(error);
+    closedPromiseCache.reject(error);
   }
 
   const {
@@ -2206,7 +2206,7 @@ function readableStreamError(stream, error) {
   const closeCache = reader[kState].close;
   if (closeCache !== undefined) {
     setPromiseHandled(closeCache.promise);
-    closeCache.reject?.(error);
+    closeCache.reject(error);
   }
 
   if (readableStreamHasDefaultReader(stream)) {
@@ -2400,7 +2400,7 @@ function readableStreamReaderGenericRelease(reader) {
   const closeCache = reader[kState].close;
   if (stream[kState].state === 'readable') {
     if (closeCache !== undefined) {
-      closeCache.reject?.(lazyReadableReleasedError());
+      closeCache.reject(lazyReadableReleasedError());
       setPromiseHandled(closeCache.promise);
     }
   } else {
 
@@ -192,15 +192,15 @@ class CrossRealmTransformWritableSink {
       switch (type) {
         case 'pull':
           if (this[kState].backpressurePromise !== undefined)
-            this[kState].backpressurePromise.resolve?.();
+            this[kState].backpressurePromise.resolve();
           this[kState].backpressurePromise = undefined;
           break;
         case 'error':
           writableStreamDefaultControllerErrorIfNeeded(
             this[kState].controller,
             value);
           if (this[kState].backpressurePromise !== undefined)
-            this[kState].backpressurePromise.resolve?.();
+            this[kState].backpressurePromise.resolve();
           this[kState].backpressurePromise = undefined;
           break;
       }
 
@@ -749,7 +749,7 @@ function writableStreamClose(stream) {
   stream[kState].closeQueuedOrInFlight = true;
   const { promise } = stream[kState].closeRequest;
   if (writer !== undefined && backpressure && state === 'writable')
-    writer[kState].ready?.resolve?.();
+    writer[kState].ready?.resolve();
   writableStreamDefaultControllerClose(controller);
   return promise;
 }
@@ -767,7 +767,7 @@ function writableStreamUpdateBackpressure(stream, backpressure) {
       // dropping the cache lets the next observation derive it.
       writer[kState].ready = undefined;
     } else {
-      writer[kState].ready?.resolve?.();
+      writer[kState].ready?.resolve();
     }
   }
   streamState.backpressure = backpressure;
@@ -796,15 +796,15 @@ function writableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
   assert(stream[kState].state === 'errored');
   if (stream[kState].closeRequest.promise !== undefined) {
     assert(stream[kState].inFlightCloseRequest.promise === undefined);
-    stream[kState].closeRequest.reject?.(stream[kState].storedError);
+    stream[kState].closeRequest.reject(stream[kState].storedError);
     stream[kState].closeRequest = kNilRequest;
     stream[kState].closeQueuedOrInFlight = false;
   }
 
   const closedPromiseCache = stream[kState].closedPromise;
   if (closedPromiseCache !== undefined) {
     setPromiseHandled(closedPromiseCache.promise);
-    closedPromiseCache.reject?.(stream[kState].storedError);
+    closedPromiseCache.reject(stream[kState].storedError);
   }
 
   const {
@@ -814,7 +814,7 @@ function writableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
     const closeCache = writer[kState].close;
     if (closeCache !== undefined) {
       setPromiseHandled(closeCache.promise);
-      closeCache.reject?.(stream[kState].storedError);
+      closeCache.reject(stream[kState].storedError);
     }
   }
 }
@@ -847,7 +847,7 @@ function writableStreamHasOperationMarkedInFlight(stream) {
 
 function writableStreamFinishInFlightWriteWithError(stream, error) {
   assert(stream[kState].inFlightWriteRequest.promise !== undefined);
-  stream[kState].inFlightWriteRequest.reject?.(error);
+  stream[kState].inFlightWriteRequest.reject(error);
   stream[kState].inFlightWriteRequest = kNilRequest;
   assert(stream[kState].state === 'writable' ||
          stream[kState].state === 'erroring');
@@ -856,40 +856,40 @@ function writableStreamFinishInFlightWriteWithError(stream, error) {
 
 function writableStreamFinishInFlightWrite(stream) {
   assert(stream[kState].inFlightWriteRequest.promise !== undefined);
-  stream[kState].inFlightWriteRequest.resolve?.();
+  stream[kState].inFlightWriteRequest.resolve();
   stream[kState].inFlightWriteRequest = kNilRequest;
 }
 
 function writableStreamFinishInFlightCloseWithError(stream, error) {
   assert(stream[kState].inFlightCloseRequest.promise !== undefined);
-  stream[kState].inFlightCloseRequest.reject?.(error);
+  stream[kState].inFlightCloseRequest.reject(error);
   stream[kState].inFlightCloseRequest = kNilRequest;
   stream[kState].closeQueuedOrInFlight = false;
   assert(stream[kState].state === 'writable' ||
          stream[kState].state === 'erroring');
   if (stream[kState].pendingAbortRequest.abort.promise !== undefined) {
-    stream[kState].pendingAbortRequest.abort.reject?.(error);
+    stream[kState].pendingAbortRequest.abort.reject(error);
     stream[kState].pendingAbortRequest = kNilPendingAbortRequest;
   }
   writableStreamDealWithRejection(stream, error);
 }
 
 function writableStreamFinishInFlightClose(stream) {
   assert(stream[kState].inFlightCloseRequest.promise !== undefined);
-  stream[kState].inFlightCloseRequest.resolve?.();
+  stream[kState].inFlightCloseRequest.resolve();
   stream[kState].inFlightCloseRequest = kNilRequest;
   stream[kState].closeQueuedOrInFlight = false;
   if (stream[kState].state === 'erroring') {
     stream[kState].storedError = undefined;
     if (stream[kState].pendingAbortRequest.abort.promise !== undefined) {
-      stream[kState].pendingAbortRequest.abort.resolve?.();
+      stream[kState].pendingAbortRequest.abort.resolve();
       stream[kState].pendingAbortRequest = kNilPendingAbortRequest;
     }
   }
   stream[kState].state = 'closed';
   if (stream[kState].writer !== undefined)
-    stream[kState].writer[kState].close?.resolve?.();
-  stream[kState].closedPromise?.resolve?.();
+    stream[kState].writer[kState].close?.resolve();
+  stream[kState].closedPromise?.resolve();
   assert(stream[kState].pendingAbortRequest.abort.promise === undefined);
   assert(stream[kState].storedError === undefined);
 }
@@ -901,7 +901,7 @@ function writableStreamFinishErroring(stream) {
   stream[kState].controller[kError]();
   const storedError = stream[kState].storedError;
   for (let n = 0; n < stream[kState].writeRequests.length; n++)
-    stream[kState].writeRequests[n].reject?.(storedError);
+    stream[kState].writeRequests[n].reject(storedError);
   stream[kState].writeRequests = [];
 
   if (stream[kState].pendingAbortRequest.abort.promise === undefined) {
@@ -912,18 +912,18 @@ function writableStreamFinishErroring(stream) {
   const abortRequest = stream[kState].pendingAbortRequest;
   stream[kState].pendingAbortRequest = kNilPendingAbortRequest;
   if (abortRequest.wasAlreadyErroring) {
-    abortRequest.abort.reject?.(storedError);
+    abortRequest.abort.reject(storedError);
     writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
     return;
   }
   PromisePrototypeThen(
     stream[kState].controller[kAbort](abortRequest.reason),
     () => {
-      abortRequest.abort.resolve?.();
+      abortRequest.abort.resolve();
       writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
     },
     (error) => {
-      abortRequest.abort.reject?.(error);
+      abortRequest.abort.reject(error);
       writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
     });
 }
@@ -1024,7 +1024,7 @@ function writableStreamDefaultWriterGetDesiredSize(writer) {
 function writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
   const ready = writer[kState].ready;
   if (ready !== undefined && isPromisePending(ready.promise)) {
-    ready.reject?.(error);
+    ready.reject(error);
     setPromiseHandled(ready.promise);
   } else {
     // The spec replaces [[readyPromise]] with a promise rejected with the
@@ -1037,7 +1037,7 @@ function writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
 function writableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
   const close = writer[kState].close;
   if (close !== undefined && isPromisePending(close.promise)) {
-    close.reject?.(error);
+    close.reject(error);
     setPromiseHandled(close.promise);
   } else {
     // See writableStreamDefaultWriterEnsureReadyPromiseRejected.