Upgrade WebKit (#3777)

* Upgrade to latest WebKit

* Upgrade WebKit

* hm

* Fix failing tests

* Delete utf8-encoding-fixture.bin.cmp

---------

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>

13 files changed, 114 insertions, 113 deletions

diff --git a/src/js/builtins/EventSource.ts b/src/js/builtins/EventSource.ts
index 64179bc0d..a26c8d4ce 100644
--- a/src/js/builtins/EventSource.ts
+++ b/src/js/builtins/EventSource.ts
@@ -135,7 +135,7 @@ export function getEventSource() {
               id = line.substring(3).trim();
             } else if (line.startsWith("retry:")) {
               retry = parseInt(line.substring(6).trim(), 10);
-              if (isNaN(retry)) {
+              if (retry !== retry) {
                 retry = -1;
               }
             }
@@ -278,7 +278,7 @@ export function getEventSource() {
                   header_name.localeCompare("content-length", undefined, { sensitivity: "accent" }) === 0;
                 if (is_content_length) {
                   content_length = parseInt(header.substring(header_name_idx + 1).trim(), 10);
-                  if (isNaN(content_length) || content_length <= 0) {
+                  if (content_length !== content_length || content_length <= 0) {
                     self.dispatchEvent(
                       new ErrorEvent("error", {
                         error: new Error(`EventSource's Content-Length is invalid. Aborting the connection.`),
diff --git a/src/js/builtins/ImportMetaObject.ts b/src/js/builtins/ImportMetaObject.ts
index 934a37881..1f26695fc 100644
--- a/src/js/builtins/ImportMetaObject.ts
+++ b/src/js/builtins/ImportMetaObject.ts
@@ -70,8 +70,10 @@ export function loadCJS2ESM(this: ImportMetaObject, resolvedSpecifier: string) {
 
     entry.dependencies = dependencies;
     // All dependencies resolved, set instantiate and satisfy field directly.
-    entry.instantiate = Promise.resolve(entry);
-    entry.satisfy = Promise.resolve(entry);
+    entry.instantiate = Promise.$resolve(entry);
+    entry.satisfy = Promise.$resolve(entry);
+    entry.isSatisfied = true;
+
     key = queue.shift();
     while (key && (loader.registry.$get(key)?.state ?? $ModuleFetch) >= $ModuleLink) {
       key = queue.shift();
diff --git a/src/js/builtins/JSBufferPrototype.ts b/src/js/builtins/JSBufferPrototype.ts
index f5d6a7bfb..a77d6be67 100644
--- a/src/js/builtins/JSBufferPrototype.ts
+++ b/src/js/builtins/JSBufferPrototype.ts
@@ -465,7 +465,7 @@ export function slice(this: BufferExt, start, end) {
     // Use Math.trunc() to convert offset to an integer value that can be larger
     // than an Int32. Hence, don't use offset | 0 or similar techniques.
     offset = $trunc(offset);
-    if (offset === 0 || isNaN(offset)) {
+    if (offset === 0 || offset !== offset) {
       return 0;
     } else if (offset < 0) {
       offset += length;
diff --git a/src/js/builtins/ReadableByteStreamInternals.ts b/src/js/builtins/ReadableByteStreamInternals.ts
index f44c385b4..1f1853ef4 100644
--- a/src/js/builtins/ReadableByteStreamInternals.ts
+++ b/src/js/builtins/ReadableByteStreamInternals.ts
@@ -41,7 +41,7 @@ export function privateInitializeReadableByteStreamController(this, stream, unde
   $putByIdDirectPrivate(this, "closeRequested", false);
 
   let hwm = $toNumber(highWaterMark);
-  if (isNaN(hwm) || hwm < 0) throw new RangeError("highWaterMark value is negative or not a number");
+  if (hwm !== hwm || hwm < 0) throw new RangeError("highWaterMark value is negative or not a number");
   $putByIdDirectPrivate(this, "strategyHWM", hwm);
 
   let autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
@@ -372,7 +372,7 @@ export function readableByteStreamControllerRespondWithNewView(controller, view)
 export function readableByteStreamControllerRespond(controller, bytesWritten) {
   bytesWritten = $toNumber(bytesWritten);
 
-  if (isNaN(bytesWritten) || bytesWritten === Infinity || bytesWritten < 0)
+  if (bytesWritten !== bytesWritten || bytesWritten === Infinity || bytesWritten < 0)
     throw new RangeError("bytesWritten has an incorrect value");
 
   $assert($getByIdDirectPrivate(controller, "pendingPullIntos").isNotEmpty());
diff --git a/src/js/builtins/ReadableStreamBYOBReader.ts b/src/js/builtins/ReadableStreamBYOBReader.ts
index 5ebfddb19..62a04d8a3 100644
--- a/src/js/builtins/ReadableStreamBYOBReader.ts
+++ b/src/js/builtins/ReadableStreamBYOBReader.ts
@@ -76,5 +76,5 @@ export function closed(this) {
   if (!$isReadableStreamBYOBReader(this))
     return Promise.$reject($makeGetterTypeError("ReadableStreamBYOBReader", "closed"));
 
-  return $getByIdDirectPrivate(this, "closedPromiseCapability").$promise;
+  return $getByIdDirectPrivate(this, "closedPromiseCapability").promise;
 }
diff --git a/src/js/builtins/ReadableStreamDefaultReader.ts b/src/js/builtins/ReadableStreamDefaultReader.ts
index a5654d834..b4e0c2bd3 100644
--- a/src/js/builtins/ReadableStreamDefaultReader.ts
+++ b/src/js/builtins/ReadableStreamDefaultReader.ts
@@ -181,5 +181,5 @@ export function closed(this) {
   if (!$isReadableStreamDefaultReader(this))
     return Promise.$reject($makeGetterTypeError("ReadableStreamDefaultReader", "closed"));
 
-  return $getByIdDirectPrivate(this, "closedPromiseCapability").$promise;
+  return $getByIdDirectPrivate(this, "closedPromiseCapability").promise;
 }
diff --git a/src/js/builtins/ReadableStreamInternals.ts b/src/js/builtins/ReadableStreamInternals.ts
index 3bcf4f399..58fa4524a 100644
--- a/src/js/builtins/ReadableStreamInternals.ts
+++ b/src/js/builtins/ReadableStreamInternals.ts
@@ -34,12 +34,12 @@ export function readableStreamReaderGenericInitialize(reader, stream) {
     $putByIdDirectPrivate(reader, "closedPromiseCapability", $newPromiseCapability(Promise));
   else if ($getByIdDirectPrivate(stream, "state") === $streamClosed)
     $putByIdDirectPrivate(reader, "closedPromiseCapability", {
-      $promise: Promise.$resolve(),
+      promise: Promise.$resolve(),
     });
   else {
     $assert($getByIdDirectPrivate(stream, "state") === $streamErrored);
     $putByIdDirectPrivate(reader, "closedPromiseCapability", {
-      $promise: $newHandledRejectedPromise($getByIdDirectPrivate(stream, "storedError")),
+      promise: $newHandledRejectedPromise($getByIdDirectPrivate(stream, "storedError")),
     });
   }
 }
@@ -76,7 +76,7 @@ export function readableStreamPipeTo(stream, sink) {
 
   const reader = new ReadableStreamDefaultReader(stream);
 
-  $getByIdDirectPrivate(reader, "closedPromiseCapability").$promise.$then(
+  $getByIdDirectPrivate(reader, "closedPromiseCapability").promise.$then(
     () => {},
     e => {
       sink.error(e);
@@ -249,7 +249,7 @@ export function readableStreamPipeToWritableStream(
   pipeState.shuttingDown = false;
   pipeState.promiseCapability = $newPromiseCapability(Promise);
   pipeState.pendingReadPromiseCapability = $newPromiseCapability(Promise);
-  pipeState.pendingReadPromiseCapability.$resolve.$call();
+  pipeState.pendingReadPromiseCapability.resolve.$call();
   pipeState.pendingWritePromise = Promise.$resolve();
 
   if (signal !== undefined) {
@@ -278,19 +278,19 @@ export function readableStreamPipeToWritableStream(
               shouldWait = false;
               return;
             }
-            promiseCapability.$resolve.$call();
+            promiseCapability.resolve.$call();
           };
           let handleRejectedPromise = e => {
-            promiseCapability.$reject.$call(undefined, e);
+            promiseCapability.reject.$call(undefined, e);
           };
           promiseDestination.$then(handleResolvedPromise, handleRejectedPromise);
           promiseSource.$then(handleResolvedPromise, handleRejectedPromise);
-          return promiseCapability.$promise;
+          return promiseCapability.promise;
         },
         reason,
       );
     };
-    if ($whenSignalAborted(signal, algorithm)) return pipeState.promiseCapability.$promise;
+    if ($whenSignalAborted(signal, algorithm)) return pipeState.promiseCapability.promise;
   }
 
   $pipeToErrorsMustBePropagatedForward(pipeState);
@@ -300,7 +300,7 @@ export function readableStreamPipeToWritableStream(
 
   $pipeToLoop(pipeState);
 
-  return pipeState.promiseCapability.$promise;
+  return pipeState.promiseCapability.promise;
 }
 
 export function pipeToLoop(pipeState) {
@@ -315,36 +315,36 @@ export function pipeToDoReadWrite(pipeState) {
   $assert(!pipeState.shuttingDown);
 
   pipeState.pendingReadPromiseCapability = $newPromiseCapability(Promise);
-  $getByIdDirectPrivate(pipeState.writer, "readyPromise").$promise.$then(
+  $getByIdDirectPrivate(pipeState.writer, "readyPromise").promise.$then(
     () => {
       if (pipeState.shuttingDown) {
-        pipeState.pendingReadPromiseCapability.$resolve.$call(undefined, false);
+        pipeState.pendingReadPromiseCapability.resolve.$call(undefined, false);
         return;
       }
 
       $readableStreamDefaultReaderRead(pipeState.reader).$then(
         result => {
           const canWrite = !result.done && $getByIdDirectPrivate(pipeState.writer, "stream") !== undefined;
-          pipeState.pendingReadPromiseCapability.$resolve.$call(undefined, canWrite);
+          pipeState.pendingReadPromiseCapability.resolve.$call(undefined, canWrite);
           if (!canWrite) return;
 
           pipeState.pendingWritePromise = $writableStreamDefaultWriterWrite(pipeState.writer, result.value);
         },
         e => {
-          pipeState.pendingReadPromiseCapability.$resolve.$call(undefined, false);
+          pipeState.pendingReadPromiseCapability.resolve.$call(undefined, false);
         },
       );
     },
     e => {
-      pipeState.pendingReadPromiseCapability.$resolve.$call(undefined, false);
+      pipeState.pendingReadPromiseCapability.resolve.$call(undefined, false);
     },
   );
-  return pipeState.pendingReadPromiseCapability.$promise;
+  return pipeState.pendingReadPromiseCapability.promise;
 }
 
 export function pipeToErrorsMustBePropagatedForward(pipeState) {
   const action = () => {
-    pipeState.pendingReadPromiseCapability.$resolve.$call(undefined, false);
+    pipeState.pendingReadPromiseCapability.resolve.$call(undefined, false);
     const error = $getByIdDirectPrivate(pipeState.source, "storedError");
     if (!pipeState.preventAbort) {
       $pipeToShutdownWithAction(pipeState, () => $writableStreamAbort(pipeState.destination, error), error);
@@ -358,7 +358,7 @@ export function pipeToErrorsMustBePropagatedForward(pipeState) {
     return;
   }
 
-  $getByIdDirectPrivate(pipeState.reader, "closedPromiseCapability").$promise.$then(undefined, action);
+  $getByIdDirectPrivate(pipeState.reader, "closedPromiseCapability").promise.$then(undefined, action);
 }
 
 export function pipeToErrorsMustBePropagatedBackward(pipeState) {
@@ -374,12 +374,12 @@ export function pipeToErrorsMustBePropagatedBackward(pipeState) {
     action();
     return;
   }
-  $getByIdDirectPrivate(pipeState.writer, "closedPromise").$promise.$then(undefined, action);
+  $getByIdDirectPrivate(pipeState.writer, "closedPromise").promise.$then(undefined, action);
 }
 
 export function pipeToClosingMustBePropagatedForward(pipeState) {
   const action = () => {
-    pipeState.pendingReadPromiseCapability.$resolve.$call(undefined, false);
+    pipeState.pendingReadPromiseCapability.resolve.$call(undefined, false);
     // const error = $getByIdDirectPrivate(pipeState.source, "storedError");
     if (!pipeState.preventClose) {
       $pipeToShutdownWithAction(pipeState, () =>
@@ -393,7 +393,7 @@ export function pipeToClosingMustBePropagatedForward(pipeState) {
     action();
     return;
   }
-  $getByIdDirectPrivate(pipeState.reader, "closedPromiseCapability").$promise.$then(action, undefined);
+  $getByIdDirectPrivate(pipeState.reader, "closedPromiseCapability").promise.$then(action, undefined);
 }
 
 export function pipeToClosingMustBePropagatedBackward(pipeState) {
@@ -437,7 +437,7 @@ export function pipeToShutdownWithAction(pipeState, action) {
     $getByIdDirectPrivate(pipeState.destination, "state") === "writable" &&
     !$writableStreamCloseQueuedOrInFlight(pipeState.destination)
   ) {
-    pipeState.pendingReadPromiseCapability.$promise.$then(
+    pipeState.pendingReadPromiseCapability.promise.$then(
       () => {
         pipeState.pendingWritePromise.$then(finalize, finalize);
       },
@@ -465,7 +465,7 @@ export function pipeToShutdown(pipeState) {
     $getByIdDirectPrivate(pipeState.destination, "state") === "writable" &&
     !$writableStreamCloseQueuedOrInFlight(pipeState.destination)
   ) {
-    pipeState.pendingReadPromiseCapability.$promise.$then(
+    pipeState.pendingReadPromiseCapability.promise.$then(
       () => {
         pipeState.pendingWritePromise.$then(finalize, finalize);
       },
@@ -483,8 +483,8 @@ export function pipeToFinalize(pipeState) {
   // Instead of removing the abort algorithm as per spec, we make it a no-op which is equivalent.
   pipeState.finalized = true;
 
-  if (arguments.length > 1) pipeState.promiseCapability.$reject.$call(undefined, arguments[1]);
-  else pipeState.promiseCapability.$resolve.$call();
+  if (arguments.length > 1) pipeState.promiseCapability.reject.$call(undefined, arguments[1]);
+  else pipeState.promiseCapability.resolve.$call();
 }
 
 export function readableStreamTee(stream, shouldClone) {
@@ -522,12 +522,12 @@ export function readableStreamTee(stream, shouldClone) {
   const branch1 = new $ReadableStream(branch1Source);
   const branch2 = new $ReadableStream(branch2Source);
 
-  $getByIdDirectPrivate(reader, "closedPromiseCapability").$promise.$then(undefined, function (e) {
+  $getByIdDirectPrivate(reader, "closedPromiseCapability").promise.$then(undefined, function (e) {
     if (teeState.closedOrErrored) return;
     $readableStreamDefaultControllerError(branch1.$readableStreamController, e);
     $readableStreamDefaultControllerError(branch2.$readableStreamController, e);
     teeState.closedOrErrored = true;
-    if (!teeState.canceled1 || !teeState.canceled2) teeState.cancelPromiseCapability.$resolve.$call();
+    if (!teeState.canceled1 || !teeState.canceled2) teeState.cancelPromiseCapability.resolve.$call();
   });
 
   // Additional fields compared to the spec, as they are needed within pull/cancel functions.
@@ -546,7 +546,7 @@ export function readableStreamTeePullFunction(teeState, reader, shouldClone) {
         if (!teeState.canceled1) $readableStreamDefaultControllerClose(teeState.branch1.$readableStreamController);
         if (!teeState.canceled2) $readableStreamDefaultControllerClose(teeState.branch2.$readableStreamController);
         teeState.closedOrErrored = true;
-        if (!teeState.canceled1 || !teeState.canceled2) teeState.cancelPromiseCapability.$resolve.$call();
+        if (!teeState.canceled1 || !teeState.canceled2) teeState.cancelPromiseCapability.resolve.$call();
       }
       if (teeState.closedOrErrored) return;
       if (!teeState.canceled1)
@@ -570,7 +570,7 @@ export function readableStreamTeeBranch1CancelFunction(teeState, stream) {
         teeState.cancelPromiseCapability.$reject,
       );
     }
-    return teeState.cancelPromiseCapability.$promise;
+    return teeState.cancelPromiseCapability.promise;
   };
 }
 
@@ -584,7 +584,7 @@ export function readableStreamTeeBranch2CancelFunction(teeState, stream) {
         teeState.cancelPromiseCapability.$reject,
       );
     }
-    return teeState.cancelPromiseCapability.$promise;
+    return teeState.cancelPromiseCapability.promise;
   };
 }
 
@@ -1059,7 +1059,7 @@ export function createTextStream(highWaterMark) {
       calledDone = true;
       const result = sink.finishInternal();
 
-      $fulfillPromise(capability.$promise, result);
+      $fulfillPromise(capability.promise, result);
       return result;
     },
 
@@ -1143,7 +1143,7 @@ export function initializeArrayStream(underlyingSource, highWaterMark) {
 
   function fulfill() {
     calledDone = true;
-    closingPromise.$resolve.$call(undefined, array);
+    closingPromise.resolve.$call(undefined, array);
     return array;
   }
 
@@ -1252,8 +1252,8 @@ export function readableStreamError(stream, error) {
     for (var request = requests.shift(); request; request = requests.shift()) $rejectPromise(request, error);
   }
 
-  $getByIdDirectPrivate(reader, "closedPromiseCapability").$reject.$call(undefined, error);
-  const promise = $getByIdDirectPrivate(reader, "closedPromiseCapability").$promise;
+  $getByIdDirectPrivate(reader, "closedPromiseCapability").reject.$call(undefined, error);
+  const promise = $getByIdDirectPrivate(reader, "closedPromiseCapability").promise;
   $markPromiseAsHandled(promise);
 }
 
@@ -1395,7 +1395,7 @@ export function readableStreamClose(stream) {
     }
   }
 
-  $getByIdDirectPrivate($getByIdDirectPrivate(stream, "reader"), "closedPromiseCapability").$resolve.$call();
+  $getByIdDirectPrivate($getByIdDirectPrivate(stream, "reader"), "closedPromiseCapability").resolve.$call();
 }
 
 export function readableStreamFulfillReadRequest(stream, chunk, done) {
@@ -1465,16 +1465,16 @@ export function readableStreamReaderGenericRelease(reader) {
   $assert($getByIdDirectPrivate($getByIdDirectPrivate(reader, "ownerReadableStream"), "reader") === reader);
 
   if ($getByIdDirectPrivate($getByIdDirectPrivate(reader, "ownerReadableStream"), "state") === $streamReadable)
-    $getByIdDirectPrivate(reader, "closedPromiseCapability").$reject.$call(
+    $getByIdDirectPrivate(reader, "closedPromiseCapability").reject.$call(
       undefined,
       $makeTypeError("releasing lock of reader whose stream is still in readable state"),
     );
   else
     $putByIdDirectPrivate(reader, "closedPromiseCapability", {
-      $promise: $newHandledRejectedPromise($makeTypeError("reader released lock")),
+      promise: $newHandledRejectedPromise($makeTypeError("reader released lock")),
     });
 
-  const promise = $getByIdDirectPrivate(reader, "closedPromiseCapability").$promise;
+  const promise = $getByIdDirectPrivate(reader, "closedPromiseCapability").promise;
   $markPromiseAsHandled(promise);
   $putByIdDirectPrivate($getByIdDirectPrivate(reader, "ownerReadableStream"), "reader", undefined);
   $putByIdDirectPrivate(reader, "ownerReadableStream", undefined);
@@ -1668,9 +1668,9 @@ export function readableStreamIntoText(stream) {
   const [textStream, closer] = $createTextStream($getByIdDirectPrivate(stream, "highWaterMark"));
   const prom = $readStreamIntoSink(stream, textStream, false);
   if (prom && $isPromise(prom)) {
-    return Promise.$resolve(prom).$then(closer.$promise);
+    return Promise.$resolve(prom).$then(closer.promise);
   }
-  return closer.$promise;
+  return closer.promise;
 }
 
 export function readableStreamToArrayBufferDirect(stream, underlyingSource) {
@@ -1692,7 +1692,7 @@ export function readableStreamToArrayBufferDirect(stream, underlyingSource) {
           close();
         }
 
-        $fulfillPromise(capability.$promise, sink.end());
+        $fulfillPromise(capability.promise, sink.end());
       }
     },
     end() {
@@ -1701,7 +1701,7 @@ export function readableStreamToArrayBufferDirect(stream, underlyingSource) {
         if (close) {
           close();
         }
-        $fulfillPromise(capability.$promise, sink.end());
+        $fulfillPromise(capability.promise, sink.end());
       }
     },
     flush() {
@@ -1722,7 +1722,7 @@ export function readableStreamToArrayBufferDirect(stream, underlyingSource) {
       })(controller, promise, pull);
     }
 
-    return capability.$promise;
+    return capability.promise;
   } catch (e) {
     didError = true;
     $readableStreamError(stream, e);
@@ -1750,7 +1750,7 @@ export async function readableStreamToTextDirect(stream, underlyingSource) {
   reader = undefined;
   stream = undefined;
 
-  return capability.$promise;
+  return capability.promise;
 }
 
 export async function readableStreamToArrayDirect(stream, underlyingSource) {
@@ -1770,7 +1770,7 @@ export async function readableStreamToArrayDirect(stream, underlyingSource) {
     } catch (e) {}
     reader = undefined;
 
-    return Promise.$resolve(capability.$promise);
+    return Promise.$resolve(capability.promise);
   } catch (e) {
     throw e;
   } finally {
diff --git a/src/js/builtins/StreamInternals.ts b/src/js/builtins/StreamInternals.ts
index 7bb262951..34b681f1e 100644
--- a/src/js/builtins/StreamInternals.ts
+++ b/src/js/builtins/StreamInternals.ts
@@ -81,7 +81,7 @@ export function validateAndNormalizeQueuingStrategy(size, highWaterMark) {
 
   const newHighWaterMark = $toNumber(highWaterMark);
 
-  if (isNaN(newHighWaterMark) || newHighWaterMark < 0)
+  if (newHighWaterMark !== newHighWaterMark || newHighWaterMark < 0)
     throw new RangeError("highWaterMark value is negative or not a number");
 
   return { size: size, highWaterMark: newHighWaterMark };
@@ -241,7 +241,7 @@ export function extractHighWaterMark(strategy, defaultHWM) {
 
   if (highWaterMark === undefined) return defaultHWM;
 
-  if (isNaN(highWaterMark) || highWaterMark < 0)
+  if (highWaterMark !== highWaterMark || highWaterMark < 0)
     throw new RangeError("highWaterMark value is negative or not a number");
 
   return $toNumber(highWaterMark);
diff --git a/src/js/builtins/TransformStream.ts b/src/js/builtins/TransformStream.ts
index 2a124d4e1..f9d80b7cb 100644
--- a/src/js/builtins/TransformStream.ts
+++ b/src/js/builtins/TransformStream.ts
@@ -68,7 +68,7 @@ export function initializeTransformStream(this) {
   const startPromiseCapability = $newPromiseCapability(Promise);
   $initializeTransformStream(
     this,
-    startPromiseCapability.$promise,
+    startPromiseCapability.promise,
     writableHighWaterMark,
     writableSizeAlgorithm,
     readableHighWaterMark,
@@ -82,13 +82,13 @@ export function initializeTransformStream(this) {
     startAlgorithm().$then(
       () => {
         // FIXME: We probably need to resolve start promise with the result of the start algorithm.
-        startPromiseCapability.$resolve.$call();
+        startPromiseCapability.resolve.$call();
       },
       error => {
-        startPromiseCapability.$reject.$call(undefined, error);
+        startPromiseCapability.reject.$call(undefined, error);
       },
     );
-  } else startPromiseCapability.$resolve.$call();
+  } else startPromiseCapability.resolve.$call();
 
   return this;
 }
diff --git a/src/js/builtins/TransformStreamInternals.ts b/src/js/builtins/TransformStreamInternals.ts
index 9da403e71..103b0651f 100644
--- a/src/js/builtins/TransformStreamInternals.ts
+++ b/src/js/builtins/TransformStreamInternals.ts
@@ -57,7 +57,7 @@ export function createTransformStream(
   const startPromiseCapability = $newPromiseCapability(Promise);
   $initializeTransformStream(
     stream,
-    startPromiseCapability.$promise,
+    startPromiseCapability.promise,
     writableHighWaterMark,
     writableSizeAlgorithm,
     readableHighWaterMark,
@@ -69,10 +69,10 @@ export function createTransformStream(
 
   startAlgorithm().$then(
     () => {
-      startPromiseCapability.$resolve.$call();
+      startPromiseCapability.resolve.$call();
     },
     error => {
-      startPromiseCapability.$reject.$call(undefined, error);
+      startPromiseCapability.reject.$call(undefined, error);
     },
   );
 
@@ -158,7 +158,7 @@ export function transformStreamSetBackpressure(stream, backpressure) {
   $assert($getByIdDirectPrivate(stream, "backpressure") !== backpressure);
 
   const backpressureChangePromise = $getByIdDirectPrivate(stream, "backpressureChangePromise");
-  if (backpressureChangePromise !== undefined) backpressureChangePromise.$resolve.$call();
+  if (backpressureChangePromise !== undefined) backpressureChangePromise.resolve.$call();
 
   $putByIdDirectPrivate(stream, "backpressureChangePromise", $newPromiseCapability(Promise));
   $putByIdDirectPrivate(stream, "backpressure", backpressure);
@@ -245,10 +245,10 @@ export function transformStreamDefaultControllerPerformTransform(controller, chu
     },
     r => {
       $transformStreamError($getByIdDirectPrivate(controller, "stream"), r);
-      promiseCapability.$reject.$call(undefined, r);
+      promiseCapability.reject.$call(undefined, r);
     },
   );
-  return promiseCapability.$promise;
+  return promiseCapability.promise;
 }
 
 export function transformStreamDefaultControllerTerminate(controller) {
@@ -275,11 +275,11 @@ export function transformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
 
     const backpressureChangePromise = $getByIdDirectPrivate(stream, "backpressureChangePromise");
     $assert(backpressureChangePromise !== undefined);
-    backpressureChangePromise.$promise.$then(
+    backpressureChangePromise.promise.$then(
       () => {
         const state = $getByIdDirectPrivate(writable, "state");
         if (state === "erroring") {
-          promiseCapability.$reject.$call(undefined, $getByIdDirectPrivate(writable, "storedError"));
+          promiseCapability.reject.$call(undefined, $getByIdDirectPrivate(writable, "storedError"));
           return;
         }
 
@@ -289,16 +289,16 @@ export function transformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
             promiseCapability.$resolve();
           },
           e => {
-            promiseCapability.$reject.$call(undefined, e);
+            promiseCapability.reject.$call(undefined, e);
           },
         );
       },
       e => {
-        promiseCapability.$reject.$call(undefined, e);
+        promiseCapability.reject.$call(undefined, e);
       },
     );
 
-    return promiseCapability.$promise;
+    return promiseCapability.promise;
   }
   return $transformStreamDefaultControllerPerformTransform(controller, chunk);
 }
@@ -322,7 +322,7 @@ export function transformStreamDefaultSinkCloseAlgorithm(stream) {
   flushPromise.$then(
     () => {
       if ($getByIdDirectPrivate(readable, "state") === $streamErrored) {
-        promiseCapability.$reject.$call(undefined, $getByIdDirectPrivate(readable, "storedError"));
+        promiseCapability.reject.$call(undefined, $getByIdDirectPrivate(readable, "storedError"));
         return;
       }
 
@@ -333,10 +333,10 @@ export function transformStreamDefaultSinkCloseAlgorithm(stream) {
     },
     r => {
       $transformStreamError($getByIdDirectPrivate(controller, "stream"), r);
-      promiseCapability.$reject.$call(undefined, $getByIdDirectPrivate(readable, "storedError"));
+      promiseCapability.reject.$call(undefined, $getByIdDirectPrivate(readable, "storedError"));
     },
   );
-  return promiseCapability.$promise;
+  return promiseCapability.promise;
 }
 
 export function transformStreamDefaultSourcePullAlgorithm(stream) {
@@ -345,5 +345,5 @@ export function transformStreamDefaultSourcePullAlgorithm(stream) {
 
   $transformStreamSetBackpressure(stream, false);
 
-  return $getByIdDirectPrivate(stream, "backpressureChangePromise").$promise;
+  return $getByIdDirectPrivate(stream, "backpressureChangePromise").promise;
 }
diff --git a/src/js/builtins/WritableStreamDefaultWriter.ts b/src/js/builtins/WritableStreamDefaultWriter.ts
index 50b2cd13f..ff3f38f00 100644
--- a/src/js/builtins/WritableStreamDefaultWriter.ts
+++ b/src/js/builtins/WritableStreamDefaultWriter.ts
@@ -41,7 +41,7 @@ export function closed() {
   if (!$isWritableStreamDefaultWriter(this))
     return Promise.$reject($makeGetterTypeError("WritableStreamDefaultWriter", "closed"));
 
-  return $getByIdDirectPrivate(this, "closedPromise").$promise;
+  return $getByIdDirectPrivate(this, "closedPromise").promise;
 }
 
 $getter;
@@ -58,7 +58,7 @@ export function ready() {
   if (!$isWritableStreamDefaultWriter(this))
     return Promise.$reject($makeThisTypeError("WritableStreamDefaultWriter", "ready"));
 
-  return $getByIdDirectPrivate(this, "readyPromise").$promise;
+  return $getByIdDirectPrivate(this, "readyPromise").promise;
 }
 
 export function abort(reason) {
diff --git a/src/js/builtins/WritableStreamInternals.ts b/src/js/builtins/WritableStreamInternals.ts
index 2008dab1c..e14c5dee3 100644
--- a/src/js/builtins/WritableStreamInternals.ts
+++ b/src/js/builtins/WritableStreamInternals.ts
@@ -47,7 +47,7 @@ export function createWritableStream(
   highWaterMark,
   sizeAlgorithm,
 ) {
-  $assert(typeof highWaterMark === "number" && !isNaN(highWaterMark) && highWaterMark >= 0);
+  $assert(typeof highWaterMark === "number" && highWaterMark === highWaterMark && highWaterMark >= 0);
 
   const internalStream = {};
   $initializeWritableStreamSlots(internalStream, {});
@@ -162,20 +162,20 @@ export function setUpWritableStreamDefaultWriter(writer, stream) {
   const state = $getByIdDirectPrivate(stream, "state");
   if (state === "writable") {
     if ($writableStreamCloseQueuedOrInFlight(stream) || !$getByIdDirectPrivate(stream, "backpressure"))
-      readyPromiseCapability.$resolve.$call();
+      readyPromiseCapability.resolve.$call();
   } else if (state === "erroring") {
-    readyPromiseCapability.$reject.$call(undefined, $getByIdDirectPrivate(stream, "storedError"));
-    $markPromiseAsHandled(readyPromiseCapability.$promise);
+    readyPromiseCapability.reject.$call(undefined, $getByIdDirectPrivate(stream, "storedError"));
+    $markPromiseAsHandled(readyPromiseCapability.promise);
   } else if (state === "closed") {
-    readyPromiseCapability.$resolve.$call();
-    closedPromiseCapability.$resolve.$call();
+    readyPromiseCapability.resolve.$call();
+    closedPromiseCapability.resolve.$call();
   } else {
     $assert(state === "errored");
     const storedError = $getByIdDirectPrivate(stream, "storedError");
-    readyPromiseCapability.$reject.$call(undefined, storedError);
-    $markPromiseAsHandled(readyPromiseCapability.$promise);
-    closedPromiseCapability.$reject.$call(undefined, storedError);
-    $markPromiseAsHandled(closedPromiseCapability.$promise);
+    readyPromiseCapability.reject.$call(undefined, storedError);
+    $markPromiseAsHandled(readyPromiseCapability.promise);
+    closedPromiseCapability.reject.$call(undefined, storedError);
+    $markPromiseAsHandled(closedPromiseCapability.promise);
   }
 }
 
@@ -184,7 +184,7 @@ export function writableStreamAbort(stream, reason) {
   if (state === "closed" || state === "errored") return Promise.$resolve();
 
   const pendingAbortRequest = $getByIdDirectPrivate(stream, "pendingAbortRequest");
-  if (pendingAbortRequest !== undefined) return pendingAbortRequest.promise.$promise;
+  if (pendingAbortRequest !== undefined) return pendingAbortRequest.promise.promise;
 
   $assert(state === "writable" || state === "erroring");
   let wasAlreadyErroring = false;
@@ -201,7 +201,7 @@ export function writableStreamAbort(stream, reason) {
   });
 
   if (!wasAlreadyErroring) $writableStreamStartErroring(stream, reason);
-  return abortPromiseCapability.$promise;
+  return abortPromiseCapability.promise;
 }
 
 export function writableStreamClose(stream) {
@@ -217,11 +217,11 @@ export function writableStreamClose(stream) {
 
   const writer = $getByIdDirectPrivate(stream, "writer");
   if (writer !== undefined && $getByIdDirectPrivate(stream, "backpressure") && state === "writable")
-    $getByIdDirectPrivate(writer, "readyPromise").$resolve.$call();
+    $getByIdDirectPrivate(writer, "readyPromise").resolve.$call();
 
   $writableStreamDefaultControllerClose($getByIdDirectPrivate(stream, "controller"));
 
-  return closePromiseCapability.$promise;
+  return closePromiseCapability.promise;
 }
 
 export function writableStreamAddWriteRequest(stream) {
@@ -231,7 +231,7 @@ export function writableStreamAddWriteRequest(stream) {
   const writePromiseCapability = $newPromiseCapability(Promise);
   const writeRequests = $getByIdDirectPrivate(stream, "writeRequests");
   writeRequests.push(writePromiseCapability);
-  return writePromiseCapability.$promise;
+  return writePromiseCapability.promise;
 }
 
 export function writableStreamCloseQueuedOrInFlight(stream) {
@@ -264,7 +264,7 @@ export function writableStreamFinishErroring(stream) {
   const storedError = $getByIdDirectPrivate(stream, "storedError");
   const requests = $getByIdDirectPrivate(stream, "writeRequests");
   for (var request = requests.shift(); request; request = requests.shift())
-    request.$reject.$call(undefined, storedError);
+    request.reject.$call(undefined, storedError);
 
   // TODO: is this still necessary?
   $putByIdDirectPrivate(stream, "writeRequests", $createFIFO());
@@ -277,7 +277,7 @@ export function writableStreamFinishErroring(stream) {
 
   $putByIdDirectPrivate(stream, "pendingAbortRequest", undefined);
   if (abortRequest.wasAlreadyErroring) {
-    abortRequest.promise.$reject.$call(undefined, storedError);
+    abortRequest.promise.reject.$call(undefined, storedError);
     $writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
     return;
   }
@@ -286,11 +286,11 @@ export function writableStreamFinishErroring(stream) {
     .$call(undefined, abortRequest.reason)
     .$then(
       () => {
-        abortRequest.promise.$resolve.$call();
+        abortRequest.promise.resolve.$call();
         $writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
       },
       reason => {
-        abortRequest.promise.$reject.$call(undefined, reason);
+        abortRequest.promise.reject.$call(undefined, reason);
         $writableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
       },
     );
@@ -298,7 +298,7 @@ export function writableStreamFinishErroring(stream) {
 
 export function writableStreamFinishInFlightClose(stream) {
   const inFlightCloseRequest = $getByIdDirectPrivate(stream, "inFlightCloseRequest");
-  inFlightCloseRequest.$resolve.$call();
+  inFlightCloseRequest.resolve.$call();
 
   $putByIdDirectPrivate(stream, "inFlightCloseRequest", undefined);
 
@@ -309,7 +309,7 @@ export function writableStreamFinishInFlightClose(stream) {
     $putByIdDirectPrivate(stream, "storedError", undefined);
     const abortRequest = $getByIdDirectPrivate(stream, "pendingAbortRequest");
     if (abortRequest !== undefined) {
-      abortRequest.promise.$resolve.$call();
+      abortRequest.promise.resolve.$call();
       $putByIdDirectPrivate(stream, "pendingAbortRequest", undefined);
     }
   }
@@ -317,7 +317,7 @@ export function writableStreamFinishInFlightClose(stream) {
   $putByIdDirectPrivate(stream, "state", "closed");
 
   const writer = $getByIdDirectPrivate(stream, "writer");
-  if (writer !== undefined) $getByIdDirectPrivate(writer, "closedPromise").$resolve.$call();
+  if (writer !== undefined) $getByIdDirectPrivate(writer, "closedPromise").resolve.$call();
 
   $assert($getByIdDirectPrivate(stream, "pendingAbortRequest") === undefined);
   $assert($getByIdDirectPrivate(stream, "storedError") === undefined);
@@ -326,7 +326,7 @@ export function writableStreamFinishInFlightClose(stream) {
 export function writableStreamFinishInFlightCloseWithError(stream, error) {
   const inFlightCloseRequest = $getByIdDirectPrivate(stream, "inFlightCloseRequest");
   $assert(inFlightCloseRequest !== undefined);
-  inFlightCloseRequest.$reject.$call(undefined, error);
+  inFlightCloseRequest.reject.$call(undefined, error);
 
   $putByIdDirectPrivate(stream, "inFlightCloseRequest", undefined);
 
@@ -335,7 +335,7 @@ export function writableStreamFinishInFlightCloseWithError(stream, error) {
 
   const abortRequest = $getByIdDirectPrivate(stream, "pendingAbortRequest");
   if (abortRequest !== undefined) {
-    abortRequest.promise.$reject.$call(undefined, error);
+    abortRequest.promise.reject.$call(undefined, error);
     $putByIdDirectPrivate(stream, "pendingAbortRequest", undefined);
   }
 
@@ -345,7 +345,7 @@ export function writableStreamFinishInFlightCloseWithError(stream, error) {
 export function writableStreamFinishInFlightWrite(stream) {
   const inFlightWriteRequest = $getByIdDirectPrivate(stream, "inFlightWriteRequest");
   $assert(inFlightWriteRequest !== undefined);
-  inFlightWriteRequest.$resolve.$call();
+  inFlightWriteRequest.resolve.$call();
 
   $putByIdDirectPrivate(stream, "inFlightWriteRequest", undefined);
 }
@@ -353,7 +353,7 @@ export function writableStreamFinishInFlightWrite(stream) {
 export function writableStreamFinishInFlightWriteWithError(stream, error) {
   const inFlightWriteRequest = $getByIdDirectPrivate(stream, "inFlightWriteRequest");
   $assert(inFlightWriteRequest !== undefined);
-  inFlightWriteRequest.$reject.$call(undefined, error);
+  inFlightWriteRequest.reject.$call(undefined, error);
 
   $putByIdDirectPrivate(stream, "inFlightWriteRequest", undefined);
 
@@ -396,15 +396,15 @@ export function writableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
   const closeRequest = $getByIdDirectPrivate(stream, "closeRequest");
   if (closeRequest !== undefined) {
     $assert($getByIdDirectPrivate(stream, "inFlightCloseRequest") === undefined);
-    closeRequest.$reject.$call(undefined, storedError);
+    closeRequest.reject.$call(undefined, storedError);
     $putByIdDirectPrivate(stream, "closeRequest", undefined);
   }
 
   const writer = $getByIdDirectPrivate(stream, "writer");
   if (writer !== undefined) {
     const closedPromise = $getByIdDirectPrivate(writer, "closedPromise");
-    closedPromise.$reject.$call(undefined, storedError);
-    $markPromiseAsHandled(closedPromise.$promise);
+    closedPromise.reject.$call(undefined, storedError);
+    $markPromiseAsHandled(closedPromise.promise);
   }
 }
 
@@ -432,7 +432,7 @@ export function writableStreamUpdateBackpressure(stream, backpressure) {
   const writer = $getByIdDirectPrivate(stream, "writer");
   if (writer !== undefined && backpressure !== $getByIdDirectPrivate(stream, "backpressure")) {
     if (backpressure) $putByIdDirectPrivate(writer, "readyPromise", $newPromiseCapability(Promise));
-    else $getByIdDirectPrivate(writer, "readyPromise").$resolve.$call();
+    else $getByIdDirectPrivate(writer, "readyPromise").resolve.$call();
   }
   $putByIdDirectPrivate(stream, "backpressure", backpressure);
 }
@@ -465,29 +465,29 @@ export function writableStreamDefaultWriterCloseWithErrorPropagation(writer) {
 
 export function writableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
   let closedPromiseCapability = $getByIdDirectPrivate(writer, "closedPromise");
-  let closedPromise = closedPromiseCapability.$promise;
+  let closedPromise = closedPromiseCapability.promise;
 
   if (($getPromiseInternalField(closedPromise, $promiseFieldFlags) & $promiseStateMask) !== $promiseStatePending) {
     closedPromiseCapability = $newPromiseCapability(Promise);
-    closedPromise = closedPromiseCapability.$promise;
+    closedPromise = closedPromiseCapability.promise;
     $putByIdDirectPrivate(writer, "closedPromise", closedPromiseCapability);
   }
 
-  closedPromiseCapability.$reject.$call(undefined, error);
+  closedPromiseCapability.reject.$call(undefined, error);
   $markPromiseAsHandled(closedPromise);
 }
 
 export function writableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
   let readyPromiseCapability = $getByIdDirectPrivate(writer, "readyPromise");
-  let readyPromise = readyPromiseCapability.$promise;
+  let readyPromise = readyPromiseCapability.promise;
 
   if (($getPromiseInternalField(readyPromise, $promiseFieldFlags) & $promiseStateMask) !== $promiseStatePending) {
     readyPromiseCapability = $newPromiseCapability(Promise);
-    readyPromise = readyPromiseCapability.$promise;
+    readyPromise = readyPromiseCapability.promise;
     $putByIdDirectPrivate(writer, "readyPromise", readyPromiseCapability);
   }
 
-  readyPromiseCapability.$reject.$call(undefined, error);
+  readyPromiseCapability.reject.$call(undefined, error);
   $markPromiseAsHandled(readyPromise);
 }
 
diff --git a/src/js/builtins/codegen/replacements.ts b/src/js/builtins/codegen/replacements.ts
index 05c81b901..87157a587 100644
--- a/src/js/builtins/codegen/replacements.ts
+++ b/src/js/builtins/codegen/replacements.ts
@@ -45,7 +45,6 @@ export const globalsToPrefix = [
   "WritableStreamDefaultController",
   "WritableStreamDefaultWriter",
   "isFinite",
-  "isNaN",
   "undefined",
 ];