diff --git a/core/01_core.js b/core/01_core.js
index 66530f7d57..d9a110eea5 100644
--- a/core/01_core.js
+++ b/core/01_core.js
@@ -195,6 +195,7 @@
       this.name = "BadResource";
     }
   }
+  const BadResourcePrototype = BadResource.prototype;
 
   class Interrupted extends Error {
     constructor(msg) {
@@ -202,6 +203,7 @@
       this.name = "Interrupted";
     }
   }
+  const InterruptedPrototype = Interrupted.prototype;
 
   // Extra Deno.core.* exports
   const core = ObjectAssign(globalThis.Deno.core, {
@@ -221,7 +223,9 @@
     opresolve,
     syncOpsCache,
     BadResource,
+    BadResourcePrototype,
     Interrupted,
+    InterruptedPrototype,
   });
 
   ObjectAssign(globalThis.__bootstrap, { core });
diff --git a/ext/broadcast_channel/01_broadcast_channel.js b/ext/broadcast_channel/01_broadcast_channel.js
index d89b19a1b9..dad94860d5 100644
--- a/ext/broadcast_channel/01_broadcast_channel.js
+++ b/ext/broadcast_channel/01_broadcast_channel.js
@@ -98,7 +98,7 @@
     }
 
     postMessage(message) {
-      webidl.assertBranded(this, BroadcastChannel);
+      webidl.assertBranded(this, BroadcastChannelPrototype);
 
       const prefix = "Failed to execute 'postMessage' on 'BroadcastChannel'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -121,7 +121,7 @@
     }
 
     close() {
-      webidl.assertBranded(this, BroadcastChannel);
+      webidl.assertBranded(this, BroadcastChannelPrototype);
       this[_closed] = true;
 
       const index = ArrayPrototypeIndexOf(channels, this);
@@ -134,6 +134,7 @@
 
   defineEventHandler(BroadcastChannel.prototype, "message");
   defineEventHandler(BroadcastChannel.prototype, "messageerror");
+  const BroadcastChannelPrototype = BroadcastChannel.prototype;
 
   window.__bootstrap.broadcastChannel = { BroadcastChannel };
 })(this);
diff --git a/ext/console/02_console.js b/ext/console/02_console.js
index 0ebf5a4d94..4dab799b96 100644
--- a/ext/console/02_console.js
+++ b/ext/console/02_console.js
@@ -10,12 +10,13 @@
   const {
     ArrayBufferIsView,
     isNaN,
-    DataView,
-    Date,
+    DataViewPrototype,
+    DatePrototype,
     DateNow,
     DatePrototypeGetTime,
     DatePrototypeToISOString,
     Boolean,
+    BooleanPrototype,
     BooleanPrototypeToString,
     ObjectKeys,
     ObjectCreate,
@@ -27,9 +28,11 @@
     ObjectGetOwnPropertyDescriptor,
     ObjectGetOwnPropertySymbols,
     ObjectPrototypeHasOwnProperty,
+    ObjectPrototypeIsPrototypeOf,
     ObjectPrototypePropertyIsEnumerable,
-    Promise,
+    PromisePrototype,
     String,
+    StringPrototype,
     StringPrototypeRepeat,
     StringPrototypeReplace,
     StringPrototypeReplaceAll,
@@ -47,11 +50,13 @@
     TypeError,
     NumberParseInt,
     RegExp,
+    RegExpPrototype,
     RegExpPrototypeTest,
     RegExpPrototypeToString,
-    Set,
+    SetPrototype,
     SetPrototypeEntries,
     Symbol,
+    SymbolPrototype,
     SymbolPrototypeToString,
     SymbolPrototypeValueOf,
     SymbolToStringTag,
@@ -73,6 +78,7 @@
     ArrayPrototypeFind,
     FunctionPrototypeBind,
     Map,
+    MapPrototype,
     MapPrototypeHas,
     MapPrototypeGet,
     MapPrototypeSet,
@@ -80,6 +86,7 @@
     MapPrototypeEntries,
     MapPrototypeForEach,
     Error,
+    ErrorPrototype,
     ErrorCaptureStackTrace,
     MathAbs,
     MathMax,
@@ -88,16 +95,17 @@
     MathRound,
     MathFloor,
     Number,
+    NumberPrototype,
     NumberPrototypeToString,
     NumberPrototypeValueOf,
-    BigInt,
+    BigIntPrototype,
     BigIntPrototypeToString,
     Proxy,
     ReflectGet,
     ReflectGetOwnPropertyDescriptor,
     ReflectGetPrototypeOf,
-    WeakMap,
-    WeakSet,
+    WeakMapPrototype,
+    WeakSetPrototype,
   } = window.__bootstrap.primordials;
 
   function isInvalidDate(x) {
@@ -126,7 +134,8 @@
   // Forked from Node's lib/internal/cli_table.js
 
   function isTypedArray(x) {
-    return ArrayBufferIsView(x) && !(x instanceof DataView);
+    return ArrayBufferIsView(x) &&
+      !ObjectPrototypeIsPrototypeOf(DataViewPrototype, x);
   }
 
   const tableChars = {
@@ -888,7 +897,8 @@
 
     let err = value;
     while (
-      err.cause instanceof Error && err.cause !== value &&
+      ObjectPrototypeIsPrototypeOf(ErrorPrototype, err.cause) &&
+      err.cause !== value &&
       !ArrayPrototypeIncludes(causes, err.cause) // circular check
     ) {
       ArrayPrototypePush(causes, err.cause);
@@ -1160,33 +1170,33 @@
       // namespace is always enabled.
       return String(value[privateCustomInspect](inspect));
     }
-    if (value instanceof Error) {
+    if (ObjectPrototypeIsPrototypeOf(ErrorPrototype, value)) {
       return inspectError(value);
     } else if (ArrayIsArray(value)) {
       return inspectArray(value, level, inspectOptions);
-    } else if (value instanceof Number) {
+    } else if (ObjectPrototypeIsPrototypeOf(NumberPrototype, value)) {
       return inspectNumberObject(value, inspectOptions);
-    } else if (value instanceof BigInt) {
+    } else if (ObjectPrototypeIsPrototypeOf(BigIntPrototype, value)) {
       return inspectBigIntObject(value, inspectOptions);
-    } else if (value instanceof Boolean) {
+    } else if (ObjectPrototypeIsPrototypeOf(BooleanPrototype, value)) {
       return inspectBooleanObject(value, inspectOptions);
-    } else if (value instanceof String) {
+    } else if (ObjectPrototypeIsPrototypeOf(StringPrototype, value)) {
       return inspectStringObject(value, inspectOptions);
-    } else if (value instanceof Symbol) {
+    } else if (ObjectPrototypeIsPrototypeOf(SymbolPrototype, value)) {
       return inspectSymbolObject(value, inspectOptions);
-    } else if (value instanceof Promise) {
+    } else if (ObjectPrototypeIsPrototypeOf(PromisePrototype, value)) {
       return inspectPromise(value, level, inspectOptions);
-    } else if (value instanceof RegExp) {
+    } else if (ObjectPrototypeIsPrototypeOf(RegExpPrototype, value)) {
       return inspectRegExp(value, inspectOptions);
-    } else if (value instanceof Date) {
+    } else if (ObjectPrototypeIsPrototypeOf(DatePrototype, value)) {
       return inspectDate(value, inspectOptions);
-    } else if (value instanceof Set) {
+    } else if (ObjectPrototypeIsPrototypeOf(SetPrototype, value)) {
       return inspectSet(value, level, inspectOptions);
-    } else if (value instanceof Map) {
+    } else if (ObjectPrototypeIsPrototypeOf(MapPrototype, value)) {
       return inspectMap(value, level, inspectOptions);
-    } else if (value instanceof WeakSet) {
+    } else if (ObjectPrototypeIsPrototypeOf(WeakSetPrototype, value)) {
       return inspectWeakSet(inspectOptions);
-    } else if (value instanceof WeakMap) {
+    } else if (ObjectPrototypeIsPrototypeOf(WeakMapPrototype, value)) {
       return inspectWeakMap(inspectOptions);
     } else if (isTypedArray(value)) {
       return inspectTypedArray(
@@ -1911,14 +1921,14 @@
       const toTable = (header, body) => this.log(cliTable(header, body));
 
       let resultData;
-      const isSet = data instanceof Set;
-      const isMap = data instanceof Map;
+      const isSet = ObjectPrototypeIsPrototypeOf(SetPrototype, data);
+      const isMap = ObjectPrototypeIsPrototypeOf(MapPrototype, data);
       const valuesKey = "Values";
       const indexKey = isSet || isMap ? "(iter idx)" : "(idx)";
 
-      if (data instanceof Set) {
+      if (isSet) {
         resultData = [...data];
-      } else if (data instanceof Map) {
+      } else if (isMap) {
         let idx = 0;
         resultData = {};
 
diff --git a/ext/crypto/00_crypto.js b/ext/crypto/00_crypto.js
index aa328d1d70..5a42efbfd0 100644
--- a/ext/crypto/00_crypto.js
+++ b/ext/crypto/00_crypto.js
@@ -15,18 +15,20 @@
   const { TextEncoder, TextDecoder } = window.__bootstrap.encoding;
 
   const {
-    ArrayBuffer,
+    ArrayBufferPrototype,
     ArrayBufferIsView,
     ArrayPrototypeEvery,
     ArrayPrototypeFind,
     ArrayPrototypeIncludes,
-    BigInt64Array,
-    Int16Array,
-    Int32Array,
-    Int8Array,
+    BigInt64ArrayPrototype,
+    BigUint64ArrayPrototype,
+    Int16ArrayPrototype,
+    Int32ArrayPrototype,
+    Int8ArrayPrototype,
     JSONParse,
     JSONStringify,
     ObjectAssign,
+    ObjectPrototypeIsPrototypeOf,
     StringPrototypeToLowerCase,
     StringPrototypeToUpperCase,
     Symbol,
@@ -34,10 +36,11 @@
     SyntaxError,
     TypedArrayPrototypeSlice,
     TypeError,
-    Uint16Array,
-    Uint32Array,
+    Uint16ArrayPrototype,
+    Uint32ArrayPrototype,
     Uint8Array,
-    Uint8ClampedArray,
+    Uint8ArrayPrototype,
+    Uint8ClampedArrayPrototype,
     WeakMap,
     WeakMapPrototypeGet,
     WeakMapPrototypeSet,
@@ -286,26 +289,26 @@
 
     /** @returns {string} */
     get type() {
-      webidl.assertBranded(this, CryptoKey);
+      webidl.assertBranded(this, CryptoKeyPrototype);
       return this[_type];
     }
 
     /** @returns {boolean} */
     get extractable() {
-      webidl.assertBranded(this, CryptoKey);
+      webidl.assertBranded(this, CryptoKeyPrototype);
       return this[_extractable];
     }
 
     /** @returns {string[]} */
     get usages() {
-      webidl.assertBranded(this, CryptoKey);
+      webidl.assertBranded(this, CryptoKeyPrototype);
       // TODO(lucacasonato): return a SameObject copy
       return this[_usages];
     }
 
     /** @returns {object} */
     get algorithm() {
-      webidl.assertBranded(this, CryptoKey);
+      webidl.assertBranded(this, CryptoKeyPrototype);
       // TODO(lucacasonato): return a SameObject copy
       return this[_algorithm];
     }
@@ -323,6 +326,7 @@
   }
 
   webidl.configurePrototype(CryptoKey);
+  const CryptoKeyPrototype = CryptoKey.prototype;
 
   /**
    * @param {string} type
@@ -429,7 +433,7 @@
      * @returns {Promise<Uint8Array>}
      */
     async digest(algorithm, data) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'digest' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
       algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@@ -461,7 +465,7 @@
      * @returns {Promise<any>}
      */
     async encrypt(algorithm, key, data) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'encrypt' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 3, { prefix });
       algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@@ -509,7 +513,7 @@
      * @returns {Promise<any>}
      */
     async decrypt(algorithm, key, data) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'decrypt' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 3, { prefix });
       algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@@ -705,7 +709,7 @@
      * @returns {Promise<any>}
      */
     async sign(algorithm, key, data) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'sign' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 3, { prefix });
       algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@@ -837,7 +841,7 @@
      */
     // deno-lint-ignore require-await
     async importKey(format, keyData, algorithm, extractable, keyUsages) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'importKey' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 4, { prefix });
       format = webidl.converters.KeyFormat(format, {
@@ -863,13 +867,19 @@
 
       // 2.
       if (format !== "jwk") {
-        if (ArrayBufferIsView(keyData) || keyData instanceof ArrayBuffer) {
+        if (
+          ArrayBufferIsView(keyData) ||
+          ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, keyData)
+        ) {
           keyData = copyBuffer(keyData);
         } else {
           throw new TypeError("keyData is a JsonWebKey");
         }
       } else {
-        if (ArrayBufferIsView(keyData) || keyData instanceof ArrayBuffer) {
+        if (
+          ArrayBufferIsView(keyData) ||
+          ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, keyData)
+        ) {
           throw new TypeError("keyData is not a JsonWebKey");
         }
       }
@@ -949,7 +959,7 @@
      */
     // deno-lint-ignore require-await
     async exportKey(format, key) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'exportKey' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
       format = webidl.converters.KeyFormat(format, {
@@ -999,7 +1009,7 @@
      * @returns {Promise<ArrayBuffer>}
      */
     async deriveBits(algorithm, baseKey, length) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'deriveBits' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 3, { prefix });
       algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@@ -1047,7 +1057,7 @@
       extractable,
       keyUsages,
     ) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'deriveKey' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 5, { prefix });
       algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@@ -1142,7 +1152,7 @@
      * @returns {Promise<boolean>}
      */
     async verify(algorithm, key, signature, data) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'verify' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 4, { prefix });
       algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@@ -1263,7 +1273,7 @@
      * @returns {Promise<any>}
      */
     async wrapKey(format, key, wrappingKey, wrapAlgorithm) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'wrapKey' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 4, { prefix });
       format = webidl.converters.KeyFormat(format, {
@@ -1396,7 +1406,7 @@
       extractable,
       keyUsages,
     ) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'unwrapKey' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 7, { prefix });
       format = webidl.converters.KeyFormat(format, {
@@ -1554,7 +1564,7 @@
      * @returns {Promise<any>}
      */
     async generateKey(algorithm, extractable, keyUsages) {
-      webidl.assertBranded(this, SubtleCrypto);
+      webidl.assertBranded(this, SubtleCryptoPrototype);
       const prefix = "Failed to execute 'generateKey' on 'SubtleCrypto'";
       webidl.requiredArguments(arguments.length, 3, { prefix });
       algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@@ -1580,12 +1590,14 @@
         usages,
       );
 
-      if (result instanceof CryptoKey) {
+      if (ObjectPrototypeIsPrototypeOf(CryptoKeyPrototype, result)) {
         const type = result[_type];
         if ((type === "secret" || type === "private") && usages.length === 0) {
           throw new DOMException("Invalid key usages", "SyntaxError");
         }
-      } else if (result.privateKey instanceof CryptoKey) {
+      } else if (
+        ObjectPrototypeIsPrototypeOf(CryptoKeyPrototype, result.privateKey)
+      ) {
         if (result.privateKey[_usages].length === 0) {
           throw new DOMException("Invalid key usages", "SyntaxError");
         }
@@ -1594,6 +1606,7 @@
       return result;
     }
   }
+  const SubtleCryptoPrototype = SubtleCrypto.prototype;
 
   async function generateKey(normalizedAlgorithm, extractable, usages) {
     const algorithmName = normalizedAlgorithm.name;
@@ -3826,7 +3839,7 @@
     }
 
     getRandomValues(arrayBufferView) {
-      webidl.assertBranded(this, Crypto);
+      webidl.assertBranded(this, CryptoPrototype);
       const prefix = "Failed to execute 'getRandomValues' on 'Crypto'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       arrayBufferView = webidl.converters.ArrayBufferView(arrayBufferView, {
@@ -3835,15 +3848,21 @@
       });
       if (
         !(
-          arrayBufferView instanceof Int8Array ||
-          arrayBufferView instanceof Uint8Array ||
-          arrayBufferView instanceof Uint8ClampedArray ||
-          arrayBufferView instanceof Int16Array ||
-          arrayBufferView instanceof Uint16Array ||
-          arrayBufferView instanceof Int32Array ||
-          arrayBufferView instanceof Uint32Array ||
-          arrayBufferView instanceof BigInt64Array ||
-          arrayBufferView instanceof BigUint64Array
+          ObjectPrototypeIsPrototypeOf(Int8ArrayPrototype, arrayBufferView) ||
+          ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, arrayBufferView) ||
+          ObjectPrototypeIsPrototypeOf(
+            Uint8ClampedArrayPrototype,
+            arrayBufferView,
+          ) ||
+          ObjectPrototypeIsPrototypeOf(Int16ArrayPrototype, arrayBufferView) ||
+          ObjectPrototypeIsPrototypeOf(Uint16ArrayPrototype, arrayBufferView) ||
+          ObjectPrototypeIsPrototypeOf(Int32ArrayPrototype, arrayBufferView) ||
+          ObjectPrototypeIsPrototypeOf(Uint32ArrayPrototype, arrayBufferView) ||
+          ObjectPrototypeIsPrototypeOf(
+            BigInt64ArrayPrototype,
+            arrayBufferView,
+          ) ||
+          ObjectPrototypeIsPrototypeOf(BigUint64ArrayPrototype, arrayBufferView)
         )
       ) {
         throw new DOMException(
@@ -3861,12 +3880,12 @@
     }
 
     randomUUID() {
-      webidl.assertBranded(this, Crypto);
+      webidl.assertBranded(this, CryptoPrototype);
       return core.opSync("op_crypto_random_uuid");
     }
 
     get subtle() {
-      webidl.assertBranded(this, Crypto);
+      webidl.assertBranded(this, CryptoPrototype);
       return subtle;
     }
 
@@ -3876,6 +3895,7 @@
   }
 
   webidl.configurePrototype(Crypto);
+  const CryptoPrototype = Crypto.prototype;
 
   window.__bootstrap.crypto = {
     SubtleCrypto,
diff --git a/ext/crypto/01_webidl.js b/ext/crypto/01_webidl.js
index 67156ce3a6..7396487668 100644
--- a/ext/crypto/01_webidl.js
+++ b/ext/crypto/01_webidl.js
@@ -9,7 +9,11 @@
 ((window) => {
   const webidl = window.__bootstrap.webidl;
   const { CryptoKey } = window.__bootstrap.crypto;
-  const { ArrayBufferIsView, ArrayBuffer } = window.__bootstrap.primordials;
+  const {
+    ArrayBufferIsView,
+    ArrayBufferPrototype,
+    ObjectPrototypeIsPrototypeOf,
+  } = window.__bootstrap.primordials;
 
   webidl.converters.AlgorithmIdentifier = (V, opts) => {
     // Union for (object or DOMString)
@@ -21,7 +25,10 @@
 
   webidl.converters["BufferSource or JsonWebKey"] = (V, opts) => {
     // Union for (BufferSource or JsonWebKey)
-    if (ArrayBufferIsView(V) || V instanceof ArrayBuffer) {
+    if (
+      ArrayBufferIsView(V) ||
+      ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, V)
+    ) {
       return webidl.converters.BufferSource(V, opts);
     }
     return webidl.converters.JsonWebKey(V, opts);
@@ -460,7 +467,7 @@
 
   webidl.converters.CryptoKey = webidl.createInterfaceConverter(
     "CryptoKey",
-    CryptoKey,
+    CryptoKey.prototype,
   );
 
   const dictCryptoKeyPair = [
diff --git a/ext/fetch/20_headers.js b/ext/fetch/20_headers.js
index b1299fb1ba..94f68df420 100644
--- a/ext/fetch/20_headers.js
+++ b/ext/fetch/20_headers.js
@@ -263,7 +263,7 @@
      * @param {string} value
      */
     append(name, value) {
-      webidl.assertBranded(this, Headers);
+      webidl.assertBranded(this, HeadersPrototype);
       const prefix = "Failed to execute 'append' on 'Headers'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
       name = webidl.converters["ByteString"](name, {
@@ -354,7 +354,7 @@
      * @param {string} value
      */
     set(name, value) {
-      webidl.assertBranded(this, Headers);
+      webidl.assertBranded(this, HeadersPrototype);
       const prefix = "Failed to execute 'set' on 'Headers'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
       name = webidl.converters["ByteString"](name, {
@@ -411,6 +411,7 @@
   webidl.mixinPairIterable("Headers", Headers, _iterableHeaders, 0, 1);
 
   webidl.configurePrototype(Headers);
+  const HeadersPrototype = Headers.prototype;
 
   webidl.converters["HeadersInit"] = (V, opts) => {
     // Union for (sequence<sequence<ByteString>> or record<ByteString, ByteString>)
@@ -428,7 +429,7 @@
   };
   webidl.converters["Headers"] = webidl.createInterfaceConverter(
     "Headers",
-    Headers,
+    Headers.prototype,
   );
 
   /**
diff --git a/ext/fetch/21_formdata.js b/ext/fetch/21_formdata.js
index cc338de729..a134fe5f73 100644
--- a/ext/fetch/21_formdata.js
+++ b/ext/fetch/21_formdata.js
@@ -13,7 +13,8 @@
 ((window) => {
   const core = window.Deno.core;
   const webidl = globalThis.__bootstrap.webidl;
-  const { Blob, File } = globalThis.__bootstrap.file;
+  const { Blob, BlobPrototype, File, FilePrototype } =
+    globalThis.__bootstrap.file;
   const {
     ArrayPrototypeMap,
     ArrayPrototypePush,
@@ -25,6 +26,7 @@
     MapPrototypeGet,
     MapPrototypeSet,
     MathRandom,
+    ObjectPrototypeIsPrototypeOf,
     Symbol,
     StringFromCharCode,
     StringPrototypeTrim,
@@ -48,10 +50,16 @@
    * @returns {FormDataEntry}
    */
   function createEntry(name, value, filename) {
-    if (value instanceof Blob && !(value instanceof File)) {
+    if (
+      ObjectPrototypeIsPrototypeOf(BlobPrototype, value) &&
+      !ObjectPrototypeIsPrototypeOf(FilePrototype, value)
+    ) {
       value = new File([value], "blob", { type: value.type });
     }
-    if (value instanceof File && filename !== undefined) {
+    if (
+      ObjectPrototypeIsPrototypeOf(FilePrototype, value) &&
+      filename !== undefined
+    ) {
       value = new File([value], filename, {
         type: value.type,
         lastModified: value.lastModified,
@@ -89,7 +97,7 @@
      * @returns {void}
      */
     append(name, valueOrBlobValue, filename) {
-      webidl.assertBranded(this, FormData);
+      webidl.assertBranded(this, FormDataPrototype);
       const prefix = "Failed to execute 'append' on 'FormData'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
 
@@ -97,7 +105,7 @@
         prefix,
         context: "Argument 1",
       });
-      if (valueOrBlobValue instanceof Blob) {
+      if (ObjectPrototypeIsPrototypeOf(BlobPrototype, valueOrBlobValue)) {
         valueOrBlobValue = webidl.converters["Blob"](valueOrBlobValue, {
           prefix,
           context: "Argument 2",
@@ -125,7 +133,7 @@
      * @returns {void}
      */
     delete(name) {
-      webidl.assertBranded(this, FormData);
+      webidl.assertBranded(this, FormDataPrototype);
       const prefix = "Failed to execute 'name' on 'FormData'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
 
@@ -148,7 +156,7 @@
      * @returns {FormDataEntryValue | null}
      */
     get(name) {
-      webidl.assertBranded(this, FormData);
+      webidl.assertBranded(this, FormDataPrototype);
       const prefix = "Failed to execute 'get' on 'FormData'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
 
@@ -168,7 +176,7 @@
      * @returns {FormDataEntryValue[]}
      */
     getAll(name) {
-      webidl.assertBranded(this, FormData);
+      webidl.assertBranded(this, FormDataPrototype);
       const prefix = "Failed to execute 'getAll' on 'FormData'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
 
@@ -189,7 +197,7 @@
      * @returns {boolean}
      */
     has(name) {
-      webidl.assertBranded(this, FormData);
+      webidl.assertBranded(this, FormDataPrototype);
       const prefix = "Failed to execute 'has' on 'FormData'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
 
@@ -211,7 +219,7 @@
      * @returns {void}
      */
     set(name, valueOrBlobValue, filename) {
-      webidl.assertBranded(this, FormData);
+      webidl.assertBranded(this, FormDataPrototype);
       const prefix = "Failed to execute 'set' on 'FormData'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
 
@@ -219,7 +227,7 @@
         prefix,
         context: "Argument 1",
       });
-      if (valueOrBlobValue instanceof Blob) {
+      if (ObjectPrototypeIsPrototypeOf(BlobPrototype, valueOrBlobValue)) {
         valueOrBlobValue = webidl.converters["Blob"](valueOrBlobValue, {
           prefix,
           context: "Argument 2",
@@ -261,6 +269,7 @@
   webidl.mixinPairIterable("FormData", FormData, entryList, "name", "value");
 
   webidl.configurePrototype(FormData);
+  const FormDataPrototype = FormData.prototype;
 
   const escape = (str, isFilename) =>
     StringPrototypeReplace(
@@ -491,10 +500,11 @@
   }
 
   webidl.converters["FormData"] = webidl
-    .createInterfaceConverter("FormData", FormData);
+    .createInterfaceConverter("FormData", FormDataPrototype);
 
   globalThis.__bootstrap.formData = {
     FormData,
+    FormDataPrototype,
     formDataToBlob,
     parseFormData,
     formDataFromEntries,
diff --git a/ext/fetch/22_body.js b/ext/fetch/22_body.js
index acfd06b0f7..f33097033f 100644
--- a/ext/fetch/22_body.js
+++ b/ext/fetch/22_body.js
@@ -16,23 +16,35 @@
   const core = window.Deno.core;
   const webidl = globalThis.__bootstrap.webidl;
   const { parseUrlEncoded } = globalThis.__bootstrap.url;
-  const { parseFormData, formDataFromEntries, formDataToBlob } =
-    globalThis.__bootstrap.formData;
-  const mimesniff = globalThis.__bootstrap.mimesniff;
-  const { isReadableStreamDisturbed, errorReadableStream, createProxy } =
-    globalThis.__bootstrap.streams;
+  const { URLSearchParamsPrototype } = globalThis.__bootstrap.url;
   const {
-    ArrayBuffer,
+    parseFormData,
+    formDataFromEntries,
+    formDataToBlob,
+    FormDataPrototype,
+  } = globalThis.__bootstrap.formData;
+  const mimesniff = globalThis.__bootstrap.mimesniff;
+  const { BlobPrototype } = globalThis.__bootstrap.file;
+  const {
+    isReadableStreamDisturbed,
+    errorReadableStream,
+    createProxy,
+    ReadableStreamPrototype,
+  } = globalThis.__bootstrap.streams;
+  const {
+    ArrayBufferPrototype,
     ArrayBufferIsView,
     ArrayPrototypePush,
     ArrayPrototypeMap,
     JSONParse,
     ObjectDefineProperties,
+    ObjectPrototypeIsPrototypeOf,
     PromiseResolve,
     TypedArrayPrototypeSet,
     TypedArrayPrototypeSlice,
     TypeError,
     Uint8Array,
+    Uint8ArrayPrototype,
   } = window.__bootstrap.primordials;
 
   /**
@@ -66,7 +78,12 @@
     }
 
     get stream() {
-      if (!(this.streamOrStatic instanceof ReadableStream)) {
+      if (
+        !ObjectPrototypeIsPrototypeOf(
+          ReadableStreamPrototype,
+          this.streamOrStatic,
+        )
+      ) {
         const { body, consumed } = this.streamOrStatic;
         if (consumed) {
           this.streamOrStatic = new ReadableStream();
@@ -88,7 +105,12 @@
      * @returns {boolean}
      */
     unusable() {
-      if (this.streamOrStatic instanceof ReadableStream) {
+      if (
+        ObjectPrototypeIsPrototypeOf(
+          ReadableStreamPrototype,
+          this.streamOrStatic,
+        )
+      ) {
         return this.streamOrStatic.locked ||
           isReadableStreamDisturbed(this.streamOrStatic);
       }
@@ -99,7 +121,12 @@
      * @returns {boolean}
      */
     consumed() {
-      if (this.streamOrStatic instanceof ReadableStream) {
+      if (
+        ObjectPrototypeIsPrototypeOf(
+          ReadableStreamPrototype,
+          this.streamOrStatic,
+        )
+      ) {
         return isReadableStreamDisturbed(this.streamOrStatic);
       }
       return this.streamOrStatic.consumed;
@@ -111,7 +138,12 @@
      */
     async consume() {
       if (this.unusable()) throw new TypeError("Body already consumed.");
-      if (this.streamOrStatic instanceof ReadableStream) {
+      if (
+        ObjectPrototypeIsPrototypeOf(
+          ReadableStreamPrototype,
+          this.streamOrStatic,
+        )
+      ) {
         const reader = this.stream.getReader();
         /** @type {Uint8Array[]} */
         const chunks = [];
@@ -136,7 +168,12 @@
     }
 
     cancel(error) {
-      if (this.streamOrStatic instanceof ReadableStream) {
+      if (
+        ObjectPrototypeIsPrototypeOf(
+          ReadableStreamPrototype,
+          this.streamOrStatic,
+        )
+      ) {
         this.streamOrStatic.cancel(error);
       } else {
         this.streamOrStatic.consumed = true;
@@ -144,7 +181,12 @@
     }
 
     error(error) {
-      if (this.streamOrStatic instanceof ReadableStream) {
+      if (
+        ObjectPrototypeIsPrototypeOf(
+          ReadableStreamPrototype,
+          this.streamOrStatic,
+        )
+      ) {
         errorReadableStream(this.streamOrStatic, error);
       } else {
         this.streamOrStatic.consumed = true;
@@ -168,7 +210,12 @@
      */
     createProxy() {
       let proxyStreamOrStatic;
-      if (this.streamOrStatic instanceof ReadableStream) {
+      if (
+        ObjectPrototypeIsPrototypeOf(
+          ReadableStreamPrototype,
+          this.streamOrStatic,
+        )
+      ) {
         proxyStreamOrStatic = createProxy(this.streamOrStatic);
       } else {
         proxyStreamOrStatic = { ...this.streamOrStatic };
@@ -282,7 +329,7 @@
         enumerable: true,
       },
     };
-    return ObjectDefineProperties(prototype.prototype, mixin);
+    return ObjectDefineProperties(prototype, mixin);
   }
 
   /**
@@ -341,18 +388,21 @@
     let source = null;
     let length = null;
     let contentType = null;
-    if (object instanceof Blob) {
+    if (ObjectPrototypeIsPrototypeOf(BlobPrototype, object)) {
       stream = object.stream();
       source = object;
       length = object.size;
       if (object.type.length !== 0) {
         contentType = object.type;
       }
-    } else if (object instanceof Uint8Array) {
+    } else if (ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, object)) {
       // Fast(er) path for common case of Uint8Array
       const copy = TypedArrayPrototypeSlice(object, 0, object.byteLength);
       source = copy;
-    } else if (ArrayBufferIsView(object) || object instanceof ArrayBuffer) {
+    } else if (
+      ArrayBufferIsView(object) ||
+      ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, object)
+    ) {
       const u8 = ArrayBufferIsView(object)
         ? new Uint8Array(
           object.buffer,
@@ -362,26 +412,28 @@
         : new Uint8Array(object);
       const copy = TypedArrayPrototypeSlice(u8, 0, u8.byteLength);
       source = copy;
-    } else if (object instanceof FormData) {
+    } else if (ObjectPrototypeIsPrototypeOf(FormDataPrototype, object)) {
       const res = formDataToBlob(object);
       stream = res.stream();
       source = res;
       length = res.size;
       contentType = res.type;
-    } else if (object instanceof URLSearchParams) {
+    } else if (
+      ObjectPrototypeIsPrototypeOf(URLSearchParamsPrototype, object)
+    ) {
       // TODO(@satyarohith): not sure what primordial here.
       source = object.toString();
       contentType = "application/x-www-form-urlencoded;charset=UTF-8";
     } else if (typeof object === "string") {
       source = object;
       contentType = "text/plain;charset=UTF-8";
-    } else if (object instanceof ReadableStream) {
+    } else if (ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, object)) {
       stream = object;
       if (object.locked || isReadableStreamDisturbed(object)) {
         throw new TypeError("ReadableStream is locked or disturbed");
       }
     }
-    if (source instanceof Uint8Array) {
+    if (ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, source)) {
       stream = { body: source, consumed: false };
       length = source.byteLength;
     } else if (typeof source === "string") {
@@ -399,19 +451,22 @@
 
   webidl.converters["BodyInit_DOMString"] = (V, opts) => {
     // Union for (ReadableStream or Blob or ArrayBufferView or ArrayBuffer or FormData or URLSearchParams or USVString)
-    if (V instanceof ReadableStream) {
+    if (ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, V)) {
       // TODO(lucacasonato): ReadableStream is not branded
       return V;
-    } else if (V instanceof Blob) {
+    } else if (ObjectPrototypeIsPrototypeOf(BlobPrototype, V)) {
       return webidl.converters["Blob"](V, opts);
-    } else if (V instanceof FormData) {
+    } else if (ObjectPrototypeIsPrototypeOf(FormDataPrototype, V)) {
       return webidl.converters["FormData"](V, opts);
-    } else if (V instanceof URLSearchParams) {
+    } else if (ObjectPrototypeIsPrototypeOf(URLSearchParamsPrototype, V)) {
       // TODO(lucacasonato): URLSearchParams is not branded
       return V;
     }
     if (typeof V === "object") {
-      if (V instanceof ArrayBuffer || V instanceof SharedArrayBuffer) {
+      if (
+        ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, V) ||
+        ObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype, V)
+      ) {
         return webidl.converters["ArrayBuffer"](V, opts);
       }
       if (ArrayBufferIsView(V)) {
diff --git a/ext/fetch/22_http_client.js b/ext/fetch/22_http_client.js
index 44159de07b..15690b7d4a 100644
--- a/ext/fetch/22_http_client.js
+++ b/ext/fetch/22_http_client.js
@@ -34,8 +34,10 @@
       core.close(this.rid);
     }
   }
+  const HttpClientPrototype = HttpClient.prototype;
 
   window.__bootstrap.fetch ??= {};
   window.__bootstrap.fetch.createHttpClient = createHttpClient;
   window.__bootstrap.fetch.HttpClient = HttpClient;
+  window.__bootstrap.fetch.HttpClientPrototype = HttpClientPrototype;
 })(globalThis);
diff --git a/ext/fetch/23_request.js b/ext/fetch/23_request.js
index 5783cac9e4..5294009ffb 100644
--- a/ext/fetch/23_request.js
+++ b/ext/fetch/23_request.js
@@ -26,7 +26,7 @@
     fillHeaders,
     getDecodeSplitHeader,
   } = window.__bootstrap.headers;
-  const { HttpClient } = window.__bootstrap.fetch;
+  const { HttpClientPrototype } = window.__bootstrap.fetch;
   const abortSignal = window.__bootstrap.abortSignal;
   const {
     ArrayPrototypeMap,
@@ -36,6 +36,7 @@
     MapPrototypeGet,
     MapPrototypeSet,
     ObjectKeys,
+    ObjectPrototypeIsPrototypeOf,
     RegExpPrototypeTest,
     Symbol,
     SymbolFor,
@@ -241,7 +242,9 @@
         const parsedURL = new URL(input, baseURL);
         request = newInnerRequest("GET", parsedURL.href, [], null, true);
       } else { // 6.
-        if (!(input instanceof Request)) throw new TypeError("Unreachable");
+        if (!ObjectPrototypeIsPrototypeOf(RequestPrototype, input)) {
+          throw new TypeError("Unreachable");
+        }
         request = input[_request];
         signal = input[_signal];
       }
@@ -268,7 +271,10 @@
 
       // NOTE: non standard extension. This handles Deno.HttpClient parameter
       if (init.client !== undefined) {
-        if (init.client !== null && !(init.client instanceof HttpClient)) {
+        if (
+          init.client !== null &&
+          !ObjectPrototypeIsPrototypeOf(HttpClientPrototype, init.client)
+        ) {
           throw webidl.makeException(
             TypeError,
             "`client` must be a Deno.HttpClient",
@@ -312,7 +318,7 @@
 
       // 33.
       let inputBody = null;
-      if (input instanceof Request) {
+      if (ObjectPrototypeIsPrototypeOf(RequestPrototype, input)) {
         inputBody = input[_body];
       }
 
@@ -356,32 +362,32 @@
     }
 
     get method() {
-      webidl.assertBranded(this, Request);
+      webidl.assertBranded(this, RequestPrototype);
       return this[_request].method;
     }
 
     get url() {
-      webidl.assertBranded(this, Request);
+      webidl.assertBranded(this, RequestPrototype);
       return this[_request].url();
     }
 
     get headers() {
-      webidl.assertBranded(this, Request);
+      webidl.assertBranded(this, RequestPrototype);
       return this[_headers];
     }
 
     get redirect() {
-      webidl.assertBranded(this, Request);
+      webidl.assertBranded(this, RequestPrototype);
       return this[_request].redirectMode;
     }
 
     get signal() {
-      webidl.assertBranded(this, Request);
+      webidl.assertBranded(this, RequestPrototype);
       return this[_signal];
     }
 
     clone() {
-      webidl.assertBranded(this, Request);
+      webidl.assertBranded(this, RequestPrototype);
       if (this[_body] && this[_body].unusable()) {
         throw new TypeError("Body is unusable.");
       }
@@ -398,7 +404,7 @@
     [SymbolFor("Deno.customInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof Request,
+        evaluate: ObjectPrototypeIsPrototypeOf(RequestPrototype, this),
         keys: [
           "bodyUsed",
           "headers",
@@ -410,18 +416,18 @@
     }
   }
 
-  mixinBody(Request, _body, _mimeType);
-
   webidl.configurePrototype(Request);
+  const RequestPrototype = Request.prototype;
+  mixinBody(RequestPrototype, _body, _mimeType);
 
   webidl.converters["Request"] = webidl.createInterfaceConverter(
     "Request",
-    Request,
+    RequestPrototype,
   );
   webidl.converters["RequestInfo_DOMString"] = (V, opts) => {
     // Union for (Request or USVString)
     if (typeof V == "object") {
-      if (V instanceof Request) {
+      if (ObjectPrototypeIsPrototypeOf(RequestPrototype, V)) {
         return webidl.converters["Request"](V, opts);
       }
     }
diff --git a/ext/fetch/23_response.js b/ext/fetch/23_response.js
index e7b2054185..14aadbaf24 100644
--- a/ext/fetch/23_response.js
+++ b/ext/fetch/23_response.js
@@ -33,6 +33,7 @@
     MapPrototypeHas,
     MapPrototypeGet,
     MapPrototypeSet,
+    ObjectPrototypeIsPrototypeOf,
     RangeError,
     RegExp,
     RegExpPrototypeTest,
@@ -297,7 +298,7 @@
      * @returns {"basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect"}
      */
     get type() {
-      webidl.assertBranded(this, Response);
+      webidl.assertBranded(this, ResponsePrototype);
       return this[_response].type;
     }
 
@@ -305,7 +306,7 @@
      * @returns {string}
      */
     get url() {
-      webidl.assertBranded(this, Response);
+      webidl.assertBranded(this, ResponsePrototype);
       const url = this[_response].url();
       if (url === null) return "";
       const newUrl = new URL(url);
@@ -317,7 +318,7 @@
      * @returns {boolean}
      */
     get redirected() {
-      webidl.assertBranded(this, Response);
+      webidl.assertBranded(this, ResponsePrototype);
       return this[_response].urlList.length > 1;
     }
 
@@ -325,7 +326,7 @@
      * @returns {number}
      */
     get status() {
-      webidl.assertBranded(this, Response);
+      webidl.assertBranded(this, ResponsePrototype);
       return this[_response].status;
     }
 
@@ -333,7 +334,7 @@
      * @returns {boolean}
      */
     get ok() {
-      webidl.assertBranded(this, Response);
+      webidl.assertBranded(this, ResponsePrototype);
       const status = this[_response].status;
       return status >= 200 && status <= 299;
     }
@@ -342,7 +343,7 @@
      * @returns {string}
      */
     get statusText() {
-      webidl.assertBranded(this, Response);
+      webidl.assertBranded(this, ResponsePrototype);
       return this[_response].statusMessage;
     }
 
@@ -350,7 +351,7 @@
      * @returns {Headers}
      */
     get headers() {
-      webidl.assertBranded(this, Response);
+      webidl.assertBranded(this, ResponsePrototype);
       return this[_headers];
     }
 
@@ -358,7 +359,7 @@
      * @returns {Response}
      */
     clone() {
-      webidl.assertBranded(this, Response);
+      webidl.assertBranded(this, ResponsePrototype);
       if (this[_body] && this[_body].unusable()) {
         throw new TypeError("Body is unusable.");
       }
@@ -375,7 +376,7 @@
     [SymbolFor("Deno.customInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof Response,
+        evaluate: ObjectPrototypeIsPrototypeOf(ResponsePrototype, this),
         keys: [
           "body",
           "bodyUsed",
@@ -390,13 +391,13 @@
     }
   }
 
-  mixinBody(Response, _body, _mimeType);
-
   webidl.configurePrototype(Response);
+  const ResponsePrototype = Response.prototype;
+  mixinBody(ResponsePrototype, _body, _mimeType);
 
   webidl.converters["Response"] = webidl.createInterfaceConverter(
     "Response",
-    Response,
+    ResponsePrototype,
   );
   webidl.converters["ResponseInit"] = webidl.createDictionaryConverter(
     "ResponseInit",
@@ -457,6 +458,7 @@
 
   window.__bootstrap.fetch ??= {};
   window.__bootstrap.fetch.Response = Response;
+  window.__bootstrap.fetch.ResponsePrototype = ResponsePrototype;
   window.__bootstrap.fetch.newInnerResponse = newInnerResponse;
   window.__bootstrap.fetch.toInnerResponse = toInnerResponse;
   window.__bootstrap.fetch.fromInnerResponse = fromInnerResponse;
diff --git a/ext/fetch/26_fetch.js b/ext/fetch/26_fetch.js
index c6fc9197b2..0c58bbf97f 100644
--- a/ext/fetch/26_fetch.js
+++ b/ext/fetch/26_fetch.js
@@ -15,7 +15,9 @@
   const core = window.Deno.core;
   const webidl = window.__bootstrap.webidl;
   const { byteLowerCase } = window.__bootstrap.infra;
-  const { errorReadableStream } = window.__bootstrap.streams;
+  const { BlobPrototype } = window.__bootstrap.file;
+  const { errorReadableStream, ReadableStreamPrototype } =
+    window.__bootstrap.streams;
   const { InnerBody, extractBody } = window.__bootstrap.fetchBody;
   const {
     toInnerRequest,
@@ -32,6 +34,7 @@
     ArrayPrototypeSplice,
     ArrayPrototypeFilter,
     ArrayPrototypeIncludes,
+    ObjectPrototypeIsPrototypeOf,
     Promise,
     PromisePrototypeThen,
     PromisePrototypeCatch,
@@ -41,6 +44,7 @@
     TypedArrayPrototypeSubarray,
     TypeError,
     Uint8Array,
+    Uint8ArrayPrototype,
     WeakMap,
     WeakMapPrototypeDelete,
     WeakMapPrototypeGet,
@@ -172,8 +176,16 @@
     let reqBody = null;
 
     if (req.body !== null) {
-      if (req.body.streamOrStatic instanceof ReadableStream) {
-        if (req.body.length === null || req.body.source instanceof Blob) {
+      if (
+        ObjectPrototypeIsPrototypeOf(
+          ReadableStreamPrototype,
+          req.body.streamOrStatic,
+        )
+      ) {
+        if (
+          req.body.length === null ||
+          ObjectPrototypeIsPrototypeOf(BlobPrototype, req.body.source)
+        ) {
           reqBody = req.body.stream;
         } else {
           const reader = req.body.stream.getReader();
@@ -196,14 +208,19 @@
       }
     }
 
-    const { requestRid, requestBodyRid, cancelHandleRid } = opFetch({
-      method: req.method,
-      url: req.currentUrl(),
-      headers: req.headerList,
-      clientRid: req.clientRid,
-      hasBody: reqBody !== null,
-      bodyLength: req.body?.length,
-    }, reqBody instanceof Uint8Array ? reqBody : null);
+    const { requestRid, requestBodyRid, cancelHandleRid } = opFetch(
+      {
+        method: req.method,
+        url: req.currentUrl(),
+        headers: req.headerList,
+        clientRid: req.clientRid,
+        hasBody: reqBody !== null,
+        bodyLength: req.body?.length,
+      },
+      ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, reqBody)
+        ? reqBody
+        : null,
+    );
 
     function onAbort() {
       if (cancelHandleRid !== null) {
@@ -216,7 +233,10 @@
     terminator[abortSignal.add](onAbort);
 
     if (requestBodyRid !== null) {
-      if (reqBody === null || !(reqBody instanceof ReadableStream)) {
+      if (
+        reqBody === null ||
+        !ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, reqBody)
+      ) {
         throw new TypeError("Unreachable");
       }
       const reader = reqBody.getReader();
@@ -231,7 +251,7 @@
             },
           );
           if (done) break;
-          if (!(value instanceof Uint8Array)) {
+          if (!ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, value)) {
             await reader.cancel("value not a Uint8Array");
             break;
           }
diff --git a/ext/ffi/00_ffi.js b/ext/ffi/00_ffi.js
index abe806cc08..b979c73d42 100644
--- a/ext/ffi/00_ffi.js
+++ b/ext/ffi/00_ffi.js
@@ -5,10 +5,11 @@
   const core = window.Deno.core;
   const __bootstrap = window.__bootstrap;
   const {
-    ArrayBuffer,
+    ArrayBufferPrototype,
     Uint8Array,
     BigInt,
     Number,
+    ObjectPrototypeIsPrototypeOf,
     TypeError,
   } = window.__bootstrap.primordials;
 
@@ -141,6 +142,7 @@
       return this.value;
     }
   }
+  const UnsafePointerPrototype = UnsafePointer.prototype;
 
   function prepareArgs(types, args) {
     const parameters = [];
@@ -152,12 +154,12 @@
 
       if (type === "pointer") {
         if (
-          arg?.buffer instanceof ArrayBuffer &&
+          ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, arg?.buffer) &&
           arg.byteLength !== undefined
         ) {
           parameters.push(buffers.length);
           buffers.push(arg);
-        } else if (arg instanceof UnsafePointer) {
+        } else if (ObjectPrototypeIsPrototypeOf(UnsafePointerPrototype, arg)) {
           parameters.push(packU64(arg.value));
           buffers.push(undefined);
         } else if (arg === null) {
diff --git a/ext/http/01_http.js b/ext/http/01_http.js
index f04ba84948..eae7429906 100644
--- a/ext/http/01_http.js
+++ b/ext/http/01_http.js
@@ -5,8 +5,9 @@
   const webidl = window.__bootstrap.webidl;
   const { InnerBody } = window.__bootstrap.fetchBody;
   const { setEventTargetData } = window.__bootstrap.eventTarget;
+  const { BlobPrototype } = window.__bootstrap.file;
   const {
-    Response,
+    ResponsePrototype,
     fromInnerRequest,
     toInnerResponse,
     newInnerRequest,
@@ -14,8 +15,9 @@
     fromInnerResponse,
   } = window.__bootstrap.fetch;
   const core = window.Deno.core;
-  const { BadResource, Interrupted } = core;
-  const { ReadableStream } = window.__bootstrap.streams;
+  const { BadResourcePrototype, InterruptedPrototype } = core;
+  const { ReadableStream, ReadableStreamPrototype } =
+    window.__bootstrap.streams;
   const abortSignal = window.__bootstrap.abortSignal;
   const {
     WebSocket,
@@ -32,7 +34,8 @@
     ArrayPrototypeIncludes,
     ArrayPrototypePush,
     ArrayPrototypeSome,
-    Promise,
+    ObjectPrototypeIsPrototypeOf,
+    PromisePrototype,
     Set,
     SetPrototypeAdd,
     SetPrototypeDelete,
@@ -46,6 +49,7 @@
     TypedArrayPrototypeSubarray,
     TypeError,
     Uint8Array,
+    Uint8ArrayPrototype,
   } = window.__bootstrap.primordials;
 
   const connErrorSymbol = Symbol("connError");
@@ -81,8 +85,8 @@
         // those with it.
         this[connErrorSymbol] = error;
         if (
-          error instanceof BadResource ||
-          error instanceof Interrupted ||
+          ObjectPrototypeIsPrototypeOf(BadResourcePrototype, error) ||
+          ObjectPrototypeIsPrototypeOf(InterruptedPrototype, error) ||
           StringPrototypeIncludes(error.message, "connection closed")
         ) {
           return null;
@@ -158,11 +162,11 @@
   function createRespondWith(httpConn, streamRid) {
     return async function respondWith(resp) {
       try {
-        if (resp instanceof Promise) {
+        if (ObjectPrototypeIsPrototypeOf(PromisePrototype, resp)) {
           resp = await resp;
         }
 
-        if (!(resp instanceof Response)) {
+        if (!(ObjectPrototypeIsPrototypeOf(ResponsePrototype, resp))) {
           throw new TypeError(
             "First argument to respondWith must be a Response or a promise resolving to a Response.",
           );
@@ -179,10 +183,18 @@
           if (innerResp.body.unusable()) {
             throw new TypeError("Body is unusable.");
           }
-          if (innerResp.body.streamOrStatic instanceof ReadableStream) {
+          if (
+            ObjectPrototypeIsPrototypeOf(
+              ReadableStreamPrototype,
+              innerResp.body.streamOrStatic,
+            )
+          ) {
             if (
               innerResp.body.length === null ||
-              innerResp.body.source instanceof Blob
+              ObjectPrototypeIsPrototypeOf(
+                BlobPrototype,
+                innerResp.body.source,
+              )
             ) {
               respBody = innerResp.body.stream;
             } else {
@@ -204,7 +216,8 @@
           respBody = new Uint8Array(0);
         }
         const isStreamingResponseBody = !(
-          typeof respBody === "string" || respBody instanceof Uint8Array
+          typeof respBody === "string" ||
+          ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, respBody)
         );
 
         try {
@@ -215,25 +228,34 @@
           );
         } catch (error) {
           const connError = httpConn[connErrorSymbol];
-          if (error instanceof BadResource && connError != null) {
+          if (
+            ObjectPrototypeIsPrototypeOf(BadResourcePrototype, error) &&
+            connError != null
+          ) {
             // deno-lint-ignore no-ex-assign
             error = new connError.constructor(connError.message);
           }
-          if (respBody !== null && respBody instanceof ReadableStream) {
+          if (
+            respBody !== null &&
+            ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, respBody)
+          ) {
             await respBody.cancel(error);
           }
           throw error;
         }
 
         if (isStreamingResponseBody) {
-          if (respBody === null || !(respBody instanceof ReadableStream)) {
+          if (
+            respBody === null ||
+            !ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, respBody)
+          ) {
             throw new TypeError("Unreachable");
           }
           const reader = respBody.getReader();
           while (true) {
             const { value, done } = await reader.read();
             if (done) break;
-            if (!(value instanceof Uint8Array)) {
+            if (!ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, value)) {
               await reader.cancel(new TypeError("Value not a Uint8Array"));
               break;
             }
@@ -241,7 +263,10 @@
               await core.opAsync("op_http_write", streamRid, value);
             } catch (error) {
               const connError = httpConn[connErrorSymbol];
-              if (error instanceof BadResource && connError != null) {
+              if (
+                ObjectPrototypeIsPrototypeOf(BadResourcePrototype, error) &&
+                connError != null
+              ) {
                 // deno-lint-ignore no-ex-assign
                 error = new connError.constructor(connError.message);
               }
diff --git a/ext/net/01_net.js b/ext/net/01_net.js
index 4a4005954b..145a89b4f3 100644
--- a/ext/net/01_net.js
+++ b/ext/net/01_net.js
@@ -3,8 +3,9 @@
 
 ((window) => {
   const core = window.Deno.core;
-  const { BadResource, Interrupted } = core;
+  const { BadResourcePrototype, InterruptedPrototype } = core;
   const {
+    ObjectPrototypeIsPrototypeOf,
     PromiseResolve,
     SymbolAsyncIterator,
     Uint8Array,
@@ -124,7 +125,10 @@
       try {
         conn = await this.accept();
       } catch (error) {
-        if (error instanceof BadResource || error instanceof Interrupted) {
+        if (
+          ObjectPrototypeIsPrototypeOf(BadResourcePrototype, error) ||
+          ObjectPrototypeIsPrototypeOf(InterruptedPrototype, error)
+        ) {
           return { value: undefined, done: true };
         }
         throw error;
@@ -191,7 +195,10 @@
         try {
           yield await this.receive();
         } catch (err) {
-          if (err instanceof BadResource || err instanceof Interrupted) {
+          if (
+            ObjectPrototypeIsPrototypeOf(BadResourcePrototype, err) ||
+            ObjectPrototypeIsPrototypeOf(InterruptedPrototype, err)
+          ) {
             break;
           }
           throw err;
diff --git a/ext/timers/01_timers.js b/ext/timers/01_timers.js
index 6ef2e6654a..caa490e614 100644
--- a/ext/timers/01_timers.js
+++ b/ext/timers/01_timers.js
@@ -16,6 +16,7 @@
     // deno-lint-ignore camelcase
     NumberPOSITIVE_INFINITY,
     PromisePrototypeThen,
+    ObjectPrototypeIsPrototypeOf,
     SymbolFor,
     TypeError,
   } = window.__bootstrap.primordials;
@@ -287,7 +288,7 @@
         }
       },
       (err) => {
-        if (err instanceof core.Interrupted) {
+        if (ObjectPrototypeIsPrototypeOf(core.InterruptedPrototype, err)) {
           // The timer was cancelled.
           removeFromScheduledTimers(timerObject);
         } else {
diff --git a/ext/timers/02_performance.js b/ext/timers/02_performance.js
index ce04c8dccc..c48a3d8882 100644
--- a/ext/timers/02_performance.js
+++ b/ext/timers/02_performance.js
@@ -9,6 +9,7 @@
     ArrayPrototypeReverse,
     ArrayPrototypeSlice,
     ObjectKeys,
+    ObjectPrototypeIsPrototypeOf,
     Symbol,
     SymbolFor,
     TypeError,
@@ -127,22 +128,22 @@
     [_duration] = 0;
 
     get name() {
-      webidl.assertBranded(this, PerformanceEntry);
+      webidl.assertBranded(this, PerformanceEntryPrototype);
       return this[_name];
     }
 
     get entryType() {
-      webidl.assertBranded(this, PerformanceEntry);
+      webidl.assertBranded(this, PerformanceEntryPrototype);
       return this[_entryType];
     }
 
     get startTime() {
-      webidl.assertBranded(this, PerformanceEntry);
+      webidl.assertBranded(this, PerformanceEntryPrototype);
       return this[_startTime];
     }
 
     get duration() {
-      webidl.assertBranded(this, PerformanceEntry);
+      webidl.assertBranded(this, PerformanceEntryPrototype);
       return this[_duration];
     }
 
@@ -165,7 +166,7 @@
     }
 
     toJSON() {
-      webidl.assertBranded(this, PerformanceEntry);
+      webidl.assertBranded(this, PerformanceEntryPrototype);
       return {
         name: this[_name],
         entryType: this[_entryType],
@@ -177,7 +178,10 @@
     [customInspect](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof PerformanceEntry,
+        evaluate: ObjectPrototypeIsPrototypeOf(
+          PerformanceEntryPrototype,
+          this,
+        ),
         keys: [
           "name",
           "entryType",
@@ -188,18 +192,19 @@
     }
   }
   webidl.configurePrototype(PerformanceEntry);
+  const PerformanceEntryPrototype = PerformanceEntry.prototype;
 
   const _detail = Symbol("[[detail]]");
   class PerformanceMark extends PerformanceEntry {
     [_detail] = null;
 
     get detail() {
-      webidl.assertBranded(this, PerformanceMark);
+      webidl.assertBranded(this, PerformanceMarkPrototype);
       return this[_detail];
     }
 
     get entryType() {
-      webidl.assertBranded(this, PerformanceMark);
+      webidl.assertBranded(this, PerformanceMarkPrototype);
       return "mark";
     }
 
@@ -231,7 +236,7 @@
     }
 
     toJSON() {
-      webidl.assertBranded(this, PerformanceMark);
+      webidl.assertBranded(this, PerformanceMarkPrototype);
       return {
         name: this.name,
         entryType: this.entryType,
@@ -244,7 +249,7 @@
     [customInspect](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof PerformanceMark,
+        evaluate: ObjectPrototypeIsPrototypeOf(PerformanceMarkPrototype, this),
         keys: [
           "name",
           "entryType",
@@ -256,17 +261,17 @@
     }
   }
   webidl.configurePrototype(PerformanceMark);
-
+  const PerformanceMarkPrototype = PerformanceMark.prototype;
   class PerformanceMeasure extends PerformanceEntry {
     [_detail] = null;
 
     get detail() {
-      webidl.assertBranded(this, PerformanceMeasure);
+      webidl.assertBranded(this, PerformanceMeasurePrototype);
       return this[_detail];
     }
 
     get entryType() {
-      webidl.assertBranded(this, PerformanceMeasure);
+      webidl.assertBranded(this, PerformanceMeasurePrototype);
       return "measure";
     }
 
@@ -287,7 +292,7 @@
     }
 
     toJSON() {
-      webidl.assertBranded(this, PerformanceMeasure);
+      webidl.assertBranded(this, PerformanceMeasurePrototype);
       return {
         name: this.name,
         entryType: this.entryType,
@@ -300,7 +305,10 @@
     [customInspect](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof PerformanceMeasure,
+        evaluate: ObjectPrototypeIsPrototypeOf(
+          PerformanceMeasurePrototype,
+          this,
+        ),
         keys: [
           "name",
           "entryType",
@@ -312,14 +320,14 @@
     }
   }
   webidl.configurePrototype(PerformanceMeasure);
-
+  const PerformanceMeasurePrototype = PerformanceMeasure.prototype;
   class Performance {
     constructor() {
       webidl.illegalConstructor();
     }
 
     clearMarks(markName = undefined) {
-      webidl.assertBranded(this, Performance);
+      webidl.assertBranded(this, PerformancePrototype);
       if (markName !== undefined) {
         markName = webidl.converters.DOMString(markName, {
           prefix: "Failed to execute 'clearMarks' on 'Performance'",
@@ -339,7 +347,7 @@
     }
 
     clearMeasures(measureName = undefined) {
-      webidl.assertBranded(this, Performance);
+      webidl.assertBranded(this, PerformancePrototype);
       if (measureName !== undefined) {
         measureName = webidl.converters.DOMString(measureName, {
           prefix: "Failed to execute 'clearMeasures' on 'Performance'",
@@ -360,7 +368,7 @@
     }
 
     getEntries() {
-      webidl.assertBranded(this, Performance);
+      webidl.assertBranded(this, PerformancePrototype);
       return filterByNameType();
     }
 
@@ -368,7 +376,7 @@
       name,
       type = undefined,
     ) {
-      webidl.assertBranded(this, Performance);
+      webidl.assertBranded(this, PerformancePrototype);
       const prefix = "Failed to execute 'getEntriesByName' on 'Performance'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
 
@@ -388,7 +396,7 @@
     }
 
     getEntriesByType(type) {
-      webidl.assertBranded(this, Performance);
+      webidl.assertBranded(this, PerformancePrototype);
       const prefix = "Failed to execute 'getEntriesByName' on 'Performance'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
 
@@ -404,7 +412,7 @@
       markName,
       markOptions = {},
     ) {
-      webidl.assertBranded(this, Performance);
+      webidl.assertBranded(this, PerformancePrototype);
       const prefix = "Failed to execute 'mark' on 'Performance'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
 
@@ -432,7 +440,7 @@
       startOrMeasureOptions = {},
       endMark = undefined,
     ) {
-      webidl.assertBranded(this, Performance);
+      webidl.assertBranded(this, PerformancePrototype);
       const prefix = "Failed to execute 'measure' on 'Performance'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
 
@@ -531,24 +539,25 @@
     }
 
     now() {
-      webidl.assertBranded(this, Performance);
+      webidl.assertBranded(this, PerformancePrototype);
       return now();
     }
 
     toJSON() {
-      webidl.assertBranded(this, Performance);
+      webidl.assertBranded(this, PerformancePrototype);
       return {};
     }
 
     [customInspect](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof Performance,
+        evaluate: ObjectPrototypeIsPrototypeOf(PerformancePrototype, this),
         keys: [],
       }));
     }
   }
   webidl.configurePrototype(Performance);
+  const PerformancePrototype = Performance.prototype;
 
   window.__bootstrap.performance = {
     PerformanceEntry,
diff --git a/ext/url/00_url.js b/ext/url/00_url.js
index 4bba06ce15..110890b7fa 100644
--- a/ext/url/00_url.js
+++ b/ext/url/00_url.js
@@ -134,7 +134,7 @@
      * @param {string} value
      */
     append(name, value) {
-      webidl.assertBranded(this, URLSearchParams);
+      webidl.assertBranded(this, URLSearchParamsPrototype);
       const prefix = "Failed to execute 'append' on 'URLSearchParams'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
       name = webidl.converters.USVString(name, {
@@ -153,7 +153,7 @@
      * @param {string} name
      */
     delete(name) {
-      webidl.assertBranded(this, URLSearchParams);
+      webidl.assertBranded(this, URLSearchParamsPrototype);
       const prefix = "Failed to execute 'append' on 'URLSearchParams'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       name = webidl.converters.USVString(name, {
@@ -177,7 +177,7 @@
      * @returns {string[]}
      */
     getAll(name) {
-      webidl.assertBranded(this, URLSearchParams);
+      webidl.assertBranded(this, URLSearchParamsPrototype);
       const prefix = "Failed to execute 'getAll' on 'URLSearchParams'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       name = webidl.converters.USVString(name, {
@@ -198,7 +198,7 @@
      * @return {string | null}
      */
     get(name) {
-      webidl.assertBranded(this, URLSearchParams);
+      webidl.assertBranded(this, URLSearchParamsPrototype);
       const prefix = "Failed to execute 'get' on 'URLSearchParams'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       name = webidl.converters.USVString(name, {
@@ -218,7 +218,7 @@
      * @return {boolean}
      */
     has(name) {
-      webidl.assertBranded(this, URLSearchParams);
+      webidl.assertBranded(this, URLSearchParamsPrototype);
       const prefix = "Failed to execute 'has' on 'URLSearchParams'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       name = webidl.converters.USVString(name, {
@@ -233,7 +233,7 @@
      * @param {string} value
      */
     set(name, value) {
-      webidl.assertBranded(this, URLSearchParams);
+      webidl.assertBranded(this, URLSearchParamsPrototype);
       const prefix = "Failed to execute 'set' on 'URLSearchParams'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
       name = webidl.converters.USVString(name, {
@@ -276,7 +276,7 @@
     }
 
     sort() {
-      webidl.assertBranded(this, URLSearchParams);
+      webidl.assertBranded(this, URLSearchParamsPrototype);
       ArrayPrototypeSort(
         this[_list],
         (a, b) => (a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1),
@@ -288,7 +288,7 @@
      * @return {string}
      */
     toString() {
-      webidl.assertBranded(this, URLSearchParams);
+      webidl.assertBranded(this, URLSearchParamsPrototype);
       return core.opSync("op_url_stringify_search_params", this[_list]);
     }
   }
@@ -296,6 +296,7 @@
   webidl.mixinPairIterable("URLSearchParams", URLSearchParams, _list, 0, 1);
 
   webidl.configurePrototype(URLSearchParams);
+  const URLSearchParamsPrototype = URLSearchParams.prototype;
 
   const _url = Symbol("url");
 
@@ -350,13 +351,13 @@
 
     /** @return {string} */
     get hash() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].hash;
     }
 
     /** @param {string} value */
     set hash(value) {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       const prefix = "Failed to set 'hash' on 'URL'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       value = webidl.converters.DOMString(value, {
@@ -372,13 +373,13 @@
 
     /** @return {string} */
     get host() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].host;
     }
 
     /** @param {string} value */
     set host(value) {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       const prefix = "Failed to set 'host' on 'URL'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       value = webidl.converters.DOMString(value, {
@@ -394,13 +395,13 @@
 
     /** @return {string} */
     get hostname() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].hostname;
     }
 
     /** @param {string} value */
     set hostname(value) {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       const prefix = "Failed to set 'hostname' on 'URL'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       value = webidl.converters.DOMString(value, {
@@ -416,13 +417,13 @@
 
     /** @return {string} */
     get href() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].href;
     }
 
     /** @param {string} value */
     set href(value) {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       const prefix = "Failed to set 'href' on 'URL'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       value = webidl.converters.DOMString(value, {
@@ -435,19 +436,19 @@
 
     /** @return {string} */
     get origin() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].origin;
     }
 
     /** @return {string} */
     get password() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].password;
     }
 
     /** @param {string} value */
     set password(value) {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       const prefix = "Failed to set 'password' on 'URL'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       value = webidl.converters.DOMString(value, {
@@ -463,13 +464,13 @@
 
     /** @return {string} */
     get pathname() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].pathname;
     }
 
     /** @param {string} value */
     set pathname(value) {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       const prefix = "Failed to set 'pathname' on 'URL'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       value = webidl.converters.DOMString(value, {
@@ -485,13 +486,13 @@
 
     /** @return {string} */
     get port() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].port;
     }
 
     /** @param {string} value */
     set port(value) {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       const prefix = "Failed to set 'port' on 'URL'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       value = webidl.converters.DOMString(value, {
@@ -507,13 +508,13 @@
 
     /** @return {string} */
     get protocol() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].protocol;
     }
 
     /** @param {string} value */
     set protocol(value) {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       const prefix = "Failed to set 'protocol' on 'URL'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       value = webidl.converters.DOMString(value, {
@@ -529,13 +530,13 @@
 
     /** @return {string} */
     get search() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].search;
     }
 
     /** @param {string} value */
     set search(value) {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       const prefix = "Failed to set 'search' on 'URL'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       value = webidl.converters.DOMString(value, {
@@ -552,13 +553,13 @@
 
     /** @return {string} */
     get username() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].username;
     }
 
     /** @param {string} value */
     set username(value) {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       const prefix = "Failed to set 'username' on 'URL'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       value = webidl.converters.DOMString(value, {
@@ -583,18 +584,19 @@
 
     /** @return {string} */
     toString() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].href;
     }
 
     /** @return {string} */
     toJSON() {
-      webidl.assertBranded(this, URL);
+      webidl.assertBranded(this, URLPrototype);
       return this[_url].href;
     }
   }
 
   webidl.configurePrototype(URL);
+  const URLPrototype = URL.prototype;
 
   /**
    * This function implements application/x-www-form-urlencoded parsing.
@@ -622,7 +624,9 @@
 
   window.__bootstrap.url = {
     URL,
+    URLPrototype,
     URLSearchParams,
+    URLSearchParamsPrototype,
     parseUrlEncoded,
   };
 })(this);
diff --git a/ext/url/01_urlpattern.js b/ext/url/01_urlpattern.js
index 19883311f1..51968e68a4 100644
--- a/ext/url/01_urlpattern.js
+++ b/ext/url/01_urlpattern.js
@@ -85,42 +85,42 @@
     }
 
     get protocol() {
-      webidl.assertBranded(this, URLPattern);
+      webidl.assertBranded(this, URLPatternPrototype);
       return this[_components].protocol.patternString;
     }
 
     get username() {
-      webidl.assertBranded(this, URLPattern);
+      webidl.assertBranded(this, URLPatternPrototype);
       return this[_components].username.patternString;
     }
 
     get password() {
-      webidl.assertBranded(this, URLPattern);
+      webidl.assertBranded(this, URLPatternPrototype);
       return this[_components].password.patternString;
     }
 
     get hostname() {
-      webidl.assertBranded(this, URLPattern);
+      webidl.assertBranded(this, URLPatternPrototype);
       return this[_components].hostname.patternString;
     }
 
     get port() {
-      webidl.assertBranded(this, URLPattern);
+      webidl.assertBranded(this, URLPatternPrototype);
       return this[_components].port.patternString;
     }
 
     get pathname() {
-      webidl.assertBranded(this, URLPattern);
+      webidl.assertBranded(this, URLPatternPrototype);
       return this[_components].pathname.patternString;
     }
 
     get search() {
-      webidl.assertBranded(this, URLPattern);
+      webidl.assertBranded(this, URLPatternPrototype);
       return this[_components].search.patternString;
     }
 
     get hash() {
-      webidl.assertBranded(this, URLPattern);
+      webidl.assertBranded(this, URLPatternPrototype);
       return this[_components].hash.patternString;
     }
 
@@ -130,7 +130,7 @@
      * @returns {boolean}
      */
     test(input, baseURL = undefined) {
-      webidl.assertBranded(this, URLPattern);
+      webidl.assertBranded(this, URLPatternPrototype);
       const prefix = "Failed to execute 'test' on 'URLPattern'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       input = webidl.converters.URLPatternInput(input, {
@@ -170,7 +170,7 @@
      * @returns {URLPatternResult | null}
      */
     exec(input, baseURL = undefined) {
-      webidl.assertBranded(this, URLPattern);
+      webidl.assertBranded(this, URLPatternPrototype);
       const prefix = "Failed to execute 'exec' on 'URLPattern'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       input = webidl.converters.URLPatternInput(input, {
@@ -241,6 +241,7 @@
   }
 
   webidl.configurePrototype(URLPattern);
+  const URLPatternPrototype = URLPattern.prototype;
 
   webidl.converters.URLPatternInit = webidl
     .createDictionaryConverter("URLPatternInit", [
diff --git a/ext/web/01_dom_exception.js b/ext/web/01_dom_exception.js
index 44aa72abe1..a3beb30642 100644
--- a/ext/web/01_dom_exception.js
+++ b/ext/web/01_dom_exception.js
@@ -16,6 +16,7 @@
     ErrorPrototype,
     ObjectDefineProperty,
     ObjectEntries,
+    ObjectPrototypeIsPrototypeOf,
     ObjectSetPrototypeOf,
     SymbolFor,
   } = window.__bootstrap.primordials;
@@ -126,7 +127,7 @@
     }
 
     [SymbolFor("Deno.customInspect")](inspect) {
-      if (this instanceof DOMException) {
+      if (ObjectPrototypeIsPrototypeOf(DOMExceptionPrototype, this)) {
         return `DOMException: ${this.#message}`;
       } else {
         return inspect(consoleInternal.createFilteredInspectProxy({
@@ -145,6 +146,7 @@
   ObjectSetPrototypeOf(DOMException.prototype, ErrorPrototype);
 
   webidl.configurePrototype(DOMException);
+  const DOMExceptionPrototype = DOMException.prototype;
 
   for (
     const [key, value] of ObjectEntries({
diff --git a/ext/web/02_event.js b/ext/web/02_event.js
index 7ba5afa276..b32bb01b85 100644
--- a/ext/web/02_event.js
+++ b/ext/web/02_event.js
@@ -29,6 +29,7 @@
     ObjectCreate,
     ObjectDefineProperty,
     ObjectGetOwnPropertyDescriptor,
+    ObjectPrototypeIsPrototypeOf,
     ReflectDefineProperty,
     Symbol,
     SymbolFor,
@@ -174,7 +175,7 @@
     [SymbolFor("Deno.privateCustomInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof Event,
+        evaluate: ObjectPrototypeIsPrototypeOf(Event.prototype, this),
         keys: EVENT_PROPS,
       }));
     }
@@ -1058,7 +1059,7 @@
     [SymbolFor("Deno.privateCustomInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof ErrorEvent,
+        evaluate: ObjectPrototypeIsPrototypeOf(ErrorEvent.prototype, this),
         keys: [
           ...EVENT_PROPS,
           "message",
@@ -1119,7 +1120,7 @@
     [SymbolFor("Deno.privateCustomInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof CloseEvent,
+        evaluate: ObjectPrototypeIsPrototypeOf(CloseEvent.prototype, this),
         keys: [
           ...EVENT_PROPS,
           "wasClean",
@@ -1151,7 +1152,7 @@
     [SymbolFor("Deno.privateCustomInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof MessageEvent,
+        evaluate: ObjectPrototypeIsPrototypeOf(MessageEvent.prototype, this),
         keys: [
           ...EVENT_PROPS,
           "data",
@@ -1184,7 +1185,7 @@
     [SymbolFor("Deno.privateCustomInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof CustomEvent,
+        evaluate: ObjectPrototypeIsPrototypeOf(CustomEvent.prototype, this),
         keys: [
           ...EVENT_PROPS,
           "detail",
@@ -1214,7 +1215,7 @@
     [SymbolFor("Deno.privateCustomInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof ProgressEvent,
+        evaluate: ObjectPrototypeIsPrototypeOf(ProgressEvent.prototype, this),
         keys: [
           ...EVENT_PROPS,
           "lengthComputable",
@@ -1238,7 +1239,8 @@
 
       if (
         isSpecialErrorEventHandler &&
-        evt instanceof ErrorEvent && evt.type === "error"
+        ObjectPrototypeIsPrototypeOf(ErrorEvent.prototype, evt) &&
+        evt.type === "error"
       ) {
         const ret = FunctionPrototypeCall(
           wrappedHandler.handler,
diff --git a/ext/web/02_structured_clone.js b/ext/web/02_structured_clone.js
index 005b668af8..058390cfee 100644
--- a/ext/web/02_structured_clone.js
+++ b/ext/web/02_structured_clone.js
@@ -13,10 +13,12 @@
   const { DOMException } = window.__bootstrap.domException;
   const {
     ArrayBuffer,
+    ArrayBufferPrototype,
     ArrayBufferIsView,
-    DataView,
+    DataViewPrototype,
+    ObjectPrototypeIsPrototypeOf,
     TypedArrayPrototypeSlice,
-    TypeError,
+    TypeErrorPrototype,
     WeakMap,
     WeakMapPrototypeSet,
   } = window.__bootstrap.primordials;
@@ -42,7 +44,7 @@
   function structuredClone(value) {
     // Performance optimization for buffers, otherwise
     // `serialize/deserialize` will allocate new buffer.
-    if (value instanceof ArrayBuffer) {
+    if (ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, value)) {
       const cloned = cloneArrayBuffer(
         value,
         0,
@@ -59,7 +61,7 @@
       // only DataView has a length in bytes and TypedArrays use a length in
       // terms of elements, so we adjust for that.
       let length;
-      if (value instanceof DataView) {
+      if (ObjectPrototypeIsPrototypeOf(DataViewPrototype, view)) {
         length = value.byteLength;
       } else {
         length = value.length;
@@ -74,7 +76,7 @@
     try {
       return core.deserialize(core.serialize(value));
     } catch (e) {
-      if (e instanceof TypeError) {
+      if (ObjectPrototypeIsPrototypeOf(TypeErrorPrototype, e)) {
         throw new DOMException("Uncloneable value", "DataCloneError");
       }
       throw e;
diff --git a/ext/web/03_abort_signal.js b/ext/web/03_abort_signal.js
index cd9b11d4bd..8b089d0317 100644
--- a/ext/web/03_abort_signal.js
+++ b/ext/web/03_abort_signal.js
@@ -77,17 +77,17 @@
     }
 
     get aborted() {
-      webidl.assertBranded(this, AbortSignal);
+      webidl.assertBranded(this, AbortSignalPrototype);
       return this[abortReason] !== undefined;
     }
 
     get reason() {
-      webidl.assertBranded(this, AbortSignal);
+      webidl.assertBranded(this, AbortSignalPrototype);
       return this[abortReason];
     }
 
     throwIfAborted() {
-      webidl.assertBranded(this, AbortSignal);
+      webidl.assertBranded(this, AbortSignalPrototype);
       if (this[abortReason] !== undefined) {
         throw this[abortReason];
       }
@@ -96,6 +96,7 @@
   defineEventHandler(AbortSignal.prototype, "abort");
 
   webidl.configurePrototype(AbortSignal);
+  const AbortSignalPrototype = AbortSignal.prototype;
 
   class AbortController {
     [signal] = new AbortSignal(illegalConstructorKey);
@@ -105,21 +106,22 @@
     }
 
     get signal() {
-      webidl.assertBranded(this, AbortController);
+      webidl.assertBranded(this, AbortControllerPrototype);
       return this[signal];
     }
 
     abort(reason) {
-      webidl.assertBranded(this, AbortController);
+      webidl.assertBranded(this, AbortControllerPrototype);
       this[signal][signalAbort](reason);
     }
   }
 
   webidl.configurePrototype(AbortController);
+  const AbortControllerPrototype = AbortController.prototype;
 
   webidl.converters["AbortSignal"] = webidl.createInterfaceConverter(
     "AbortSignal",
-    AbortSignal,
+    AbortSignal.prototype,
   );
 
   function newSignal() {
@@ -142,6 +144,7 @@
   window.AbortSignal = AbortSignal;
   window.AbortController = AbortController;
   window.__bootstrap.abortSignal = {
+    AbortSignalPrototype,
     add,
     signalAbort,
     remove,
diff --git a/ext/web/06_streams.js b/ext/web/06_streams.js
index d32a72c6e0..777ad152b7 100644
--- a/ext/web/06_streams.js
+++ b/ext/web/06_streams.js
@@ -9,21 +9,22 @@
 
 ((window) => {
   const webidl = window.__bootstrap.webidl;
-  const { add, remove, signalAbort, newSignal } =
+  const { add, remove, signalAbort, newSignal, AbortSignalPrototype } =
     window.__bootstrap.abortSignal;
   const {
     ArrayBuffer,
+    ArrayBufferPrototype,
     ArrayBufferIsView,
     ArrayPrototypeMap,
     ArrayPrototypePush,
     ArrayPrototypeShift,
-    BigInt64Array,
-    BigUint64Array,
+    BigInt64ArrayPrototype,
+    BigUint64ArrayPrototype,
     DataView,
     Error,
-    Int8Array,
-    Int16Array,
-    Int32Array,
+    Int8ArrayPrototype,
+    Int16ArrayPrototype,
+    Int32ArrayPrototype,
     NumberIsInteger,
     NumberIsNaN,
     MathMin,
@@ -31,6 +32,7 @@
     ObjectDefineProperties,
     ObjectDefineProperty,
     ObjectGetPrototypeOf,
+    ObjectPrototypeIsPrototypeOf,
     ObjectSetPrototypeOf,
     Promise,
     PromiseAll,
@@ -46,9 +48,10 @@
     SymbolFor,
     TypeError,
     Uint8Array,
-    Uint16Array,
-    Uint32Array,
-    Uint8ClampedArray,
+    Uint8ArrayPrototype,
+    Uint16ArrayPrototype,
+    Uint32ArrayPrototype,
+    Uint8ClampedArrayPrototype,
     WeakMap,
     WeakMapPrototypeGet,
     WeakMapPrototypeHas,
@@ -134,7 +137,7 @@
 
   /** @param {any} e */
   function rethrowAssertionErrorRejection(e) {
-    if (e && e instanceof AssertionError) {
+    if (e && ObjectPrototypeIsPrototypeOf(AssertionError.prototype, e)) {
       queueMicrotask(() => {
         console.error(`Internal Error: ${e.stack}`);
       });
@@ -214,7 +217,10 @@
    */
   function canTransferArrayBuffer(O) {
     assert(typeof O === "object");
-    assert(O instanceof ArrayBuffer || O instanceof SharedArrayBuffer);
+    assert(
+      ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, O) ||
+        ObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype, O),
+    );
     if (isDetachedBuffer(O)) {
       return false;
     }
@@ -1364,15 +1370,15 @@
     let ctor = DataView;
 
     if (
-      view instanceof Int8Array ||
-      view instanceof Uint8Array ||
-      view instanceof Uint8ClampedArray ||
-      view instanceof Int16Array ||
-      view instanceof Uint16Array ||
-      view instanceof Int32Array ||
-      view instanceof Uint32Array ||
-      view instanceof BigInt64Array ||
-      view instanceof BigUint64Array
+      ObjectPrototypeIsPrototypeOf(Int8ArrayPrototype, view) ||
+      ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, view) ||
+      ObjectPrototypeIsPrototypeOf(Uint8ClampedArrayPrototype, view) ||
+      ObjectPrototypeIsPrototypeOf(Int16ArrayPrototype, view) ||
+      ObjectPrototypeIsPrototypeOf(Uint16ArrayPrototype, view) ||
+      ObjectPrototypeIsPrototypeOf(Int32ArrayPrototype, view) ||
+      ObjectPrototypeIsPrototypeOf(Uint32ArrayPrototype, view) ||
+      ObjectPrototypeIsPrototypeOf(BigInt64ArrayPrototype, view) ||
+      ObjectPrototypeIsPrototypeOf(BigUint64ArrayPrototype, view)
     ) {
       elementSize = view.constructor.BYTES_PER_ELEMENT;
       ctor = view.constructor;
@@ -1983,7 +1989,10 @@
       typeof preventClose === "boolean" && typeof preventAbort === "boolean" &&
         typeof preventCancel === "boolean",
     );
-    assert(signal === undefined || signal instanceof AbortSignal);
+    assert(
+      signal === undefined ||
+        ObjectPrototypeIsPrototypeOf(AbortSignalPrototype, signal),
+    );
     assert(!isReadableStreamLocked(source));
     assert(!isWritableStreamLocked(dest));
     // We use acquireReadableStreamDefaultReader even in case of ReadableByteStreamController
@@ -2327,7 +2336,12 @@
   function readableStreamTee(stream, cloneForBranch2) {
     assert(isReadableStream(stream));
     assert(typeof cloneForBranch2 === "boolean");
-    if (stream[_controller] instanceof ReadableByteStreamController) {
+    if (
+      ObjectPrototypeIsPrototypeOf(
+        ReadableByteStreamControllerPrototype,
+        stream[_controller],
+      )
+    ) {
       return readableByteStreamTee(stream);
     } else {
       return readableStreamDefaultTee(stream, cloneForBranch2);
@@ -2491,7 +2505,12 @@
    */
   function readableByteStreamTee(stream) {
     assert(isReadableStream(stream));
-    assert(stream[_controller] instanceof ReadableByteStreamController);
+    assert(
+      ObjectPrototypeIsPrototypeOf(
+        ReadableByteStreamControllerPrototype,
+        stream[_controller],
+      ),
+    );
     let reader = acquireReadableStreamDefaultReader(stream);
     let reading = false;
     let readAgainForBranch1 = false;
@@ -2999,7 +3018,12 @@
     if (isReadableStreamLocked(stream)) {
       throw new TypeError("ReadableStream is locked.");
     }
-    if (!(stream[_controller] instanceof ReadableByteStreamController)) {
+    if (
+      !(ObjectPrototypeIsPrototypeOf(
+        ReadableByteStreamControllerPrototype,
+        stream[_controller],
+      ))
+    ) {
       throw new TypeError("Cannot use a BYOB reader with a non-byte stream");
     }
     readableStreamReaderGenericInitialize(reader, stream);
@@ -3032,7 +3056,7 @@
     transformAlgorithm,
     flushAlgorithm,
   ) {
-    assert(stream instanceof TransformStream);
+    assert(ObjectPrototypeIsPrototypeOf(TransformStreamPrototype, stream));
     assert(stream[_controller] === undefined);
     controller[_stream] = stream;
     stream[_controller] = controller;
@@ -4174,13 +4198,13 @@
 
     /** @returns {number} */
     get highWaterMark() {
-      webidl.assertBranded(this, ByteLengthQueuingStrategy);
+      webidl.assertBranded(this, ByteLengthQueuingStrategyPrototype);
       return this[_highWaterMark];
     }
 
     /** @returns {(chunk: ArrayBufferView) => number} */
     get size() {
-      webidl.assertBranded(this, ByteLengthQueuingStrategy);
+      webidl.assertBranded(this, ByteLengthQueuingStrategyPrototype);
       initializeByteLengthSizeFunction(this[_globalObject]);
       return WeakMapPrototypeGet(byteSizeFunctionWeakMap, this[_globalObject]);
     }
@@ -4188,7 +4212,10 @@
     [SymbolFor("Deno.customInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof ByteLengthQueuingStrategy,
+        evaluate: ObjectPrototypeIsPrototypeOf(
+          ByteLengthQueuingStrategyPrototype,
+          this,
+        ),
         keys: [
           "highWaterMark",
           "size",
@@ -4198,6 +4225,8 @@
   }
 
   webidl.configurePrototype(ByteLengthQueuingStrategy);
+  const ByteLengthQueuingStrategyPrototype =
+    ByteLengthQueuingStrategy.prototype;
 
   /** @type {WeakMap<typeof globalThis, (chunk: ArrayBufferView) => number>} */
   const byteSizeFunctionWeakMap = new WeakMap();
@@ -4226,13 +4255,13 @@
 
     /** @returns {number} */
     get highWaterMark() {
-      webidl.assertBranded(this, CountQueuingStrategy);
+      webidl.assertBranded(this, CountQueuingStrategyPrototype);
       return this[_highWaterMark];
     }
 
     /** @returns {(chunk: any) => 1} */
     get size() {
-      webidl.assertBranded(this, CountQueuingStrategy);
+      webidl.assertBranded(this, CountQueuingStrategyPrototype);
       initializeCountSizeFunction(this[_globalObject]);
       return WeakMapPrototypeGet(countSizeFunctionWeakMap, this[_globalObject]);
     }
@@ -4240,7 +4269,10 @@
     [SymbolFor("Deno.customInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof CountQueuingStrategy,
+        evaluate: ObjectPrototypeIsPrototypeOf(
+          CountQueuingStrategyPrototype,
+          this,
+        ),
         keys: [
           "highWaterMark",
           "size",
@@ -4250,6 +4282,7 @@
   }
 
   webidl.configurePrototype(CountQueuingStrategy);
+  const CountQueuingStrategyPrototype = CountQueuingStrategy.prototype;
 
   /** @type {WeakMap<typeof globalThis, () => 1>} */
   const countSizeFunctionWeakMap = new WeakMap();
@@ -4333,7 +4366,7 @@
 
     /** @returns {boolean} */
     get locked() {
-      webidl.assertBranded(this, ReadableStream);
+      webidl.assertBranded(this, ReadableStreamPrototype);
       return isReadableStreamLocked(this);
     }
 
@@ -4343,7 +4376,7 @@
      */
     cancel(reason = undefined) {
       try {
-        webidl.assertBranded(this, ReadableStream);
+        webidl.assertBranded(this, ReadableStreamPrototype);
         if (reason !== undefined) {
           reason = webidl.converters.any(reason);
         }
@@ -4363,7 +4396,7 @@
      * @returns {ReadableStreamDefaultReader<R> | ReadableStreamBYOBReader}
      */
     getReader(options = {}) {
-      webidl.assertBranded(this, ReadableStream);
+      webidl.assertBranded(this, ReadableStreamPrototype);
       const prefix = "Failed to execute 'getReader' on 'ReadableStream'";
       options = webidl.converters.ReadableStreamGetReaderOptions(options, {
         prefix,
@@ -4384,7 +4417,7 @@
      * @returns {ReadableStream<T>}
      */
     pipeThrough(transform, options = {}) {
-      webidl.assertBranded(this, ReadableStream);
+      webidl.assertBranded(this, ReadableStreamPrototype);
       const prefix = "Failed to execute 'pipeThrough' on 'ReadableStream'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       transform = webidl.converters.ReadableWritablePair(transform, {
@@ -4422,7 +4455,7 @@
      */
     pipeTo(destination, options = {}) {
       try {
-        webidl.assertBranded(this, ReadableStream);
+        webidl.assertBranded(this, ReadableStreamPrototype);
         const prefix = "Failed to execute 'pipeTo' on 'ReadableStream'";
         webidl.requiredArguments(arguments.length, 1, { prefix });
         destination = webidl.converters.WritableStream(destination, {
@@ -4459,7 +4492,7 @@
 
     /** @returns {[ReadableStream<R>, ReadableStream<R>]} */
     tee() {
-      webidl.assertBranded(this, ReadableStream);
+      webidl.assertBranded(this, ReadableStreamPrototype);
       return readableStreamTee(this, false);
     }
 
@@ -4469,7 +4502,7 @@
      * @returns {AsyncIterableIterator<R>}
      */
     values(options = {}) {
-      webidl.assertBranded(this, ReadableStream);
+      webidl.assertBranded(this, ReadableStreamPrototype);
       const prefix = "Failed to execute 'values' on 'ReadableStream'";
       options = webidl.converters.ReadableStreamIteratorOptions(options, {
         prefix,
@@ -4498,6 +4531,7 @@
   });
 
   webidl.configurePrototype(ReadableStream);
+  const ReadableStreamPrototype = ReadableStream.prototype;
 
   function errorReadableStream(stream, e) {
     readableStreamDefaultControllerError(stream[_controller], e);
@@ -4527,7 +4561,7 @@
     /** @returns {Promise<ReadableStreamReadResult<R>>} */
     read() {
       try {
-        webidl.assertBranded(this, ReadableStreamDefaultReader);
+        webidl.assertBranded(this, ReadableStreamDefaultReaderPrototype);
       } catch (err) {
         return PromiseReject(err);
       }
@@ -4556,7 +4590,7 @@
 
     /** @returns {void} */
     releaseLock() {
-      webidl.assertBranded(this, ReadableStreamDefaultReader);
+      webidl.assertBranded(this, ReadableStreamDefaultReaderPrototype);
       if (this[_stream] === undefined) {
         return;
       }
@@ -4565,7 +4599,7 @@
 
     get closed() {
       try {
-        webidl.assertBranded(this, ReadableStreamDefaultReader);
+        webidl.assertBranded(this, ReadableStreamDefaultReaderPrototype);
       } catch (err) {
         return PromiseReject(err);
       }
@@ -4578,7 +4612,7 @@
      */
     cancel(reason = undefined) {
       try {
-        webidl.assertBranded(this, ReadableStreamDefaultReader);
+        webidl.assertBranded(this, ReadableStreamDefaultReaderPrototype);
         if (reason !== undefined) {
           reason = webidl.converters.any(reason);
         }
@@ -4600,6 +4634,8 @@
   }
 
   webidl.configurePrototype(ReadableStreamDefaultReader);
+  const ReadableStreamDefaultReaderPrototype =
+    ReadableStreamDefaultReader.prototype;
 
   /** @template R */
   class ReadableStreamBYOBReader {
@@ -4628,7 +4664,7 @@
      */
     read(view) {
       try {
-        webidl.assertBranded(this, ReadableStreamBYOBReader);
+        webidl.assertBranded(this, ReadableStreamBYOBReaderPrototype);
         const prefix = "Failed to execute 'read' on 'ReadableStreamBYOBReader'";
         view = webidl.converters.ArrayBufferView(view, {
           prefix,
@@ -4678,7 +4714,7 @@
 
     /** @returns {void} */
     releaseLock() {
-      webidl.assertBranded(this, ReadableStreamBYOBReader);
+      webidl.assertBranded(this, ReadableStreamBYOBReaderPrototype);
       if (this[_stream] === undefined) {
         return;
       }
@@ -4687,7 +4723,7 @@
 
     get closed() {
       try {
-        webidl.assertBranded(this, ReadableStreamBYOBReader);
+        webidl.assertBranded(this, ReadableStreamBYOBReaderPrototype);
       } catch (err) {
         return PromiseReject(err);
       }
@@ -4700,7 +4736,7 @@
      */
     cancel(reason = undefined) {
       try {
-        webidl.assertBranded(this, ReadableStreamBYOBReader);
+        webidl.assertBranded(this, ReadableStreamBYOBReaderPrototype);
         if (reason !== undefined) {
           reason = webidl.converters.any(reason);
         }
@@ -4722,6 +4758,7 @@
   }
 
   webidl.configurePrototype(ReadableStreamBYOBReader);
+  const ReadableStreamBYOBReaderPrototype = ReadableStreamBYOBReader.prototype;
 
   class ReadableStreamBYOBRequest {
     /** @type {ReadableByteStreamController} */
@@ -4731,7 +4768,7 @@
 
     /** @returns {ArrayBufferView | null} */
     get view() {
-      webidl.assertBranded(this, ReadableStreamBYOBRequest);
+      webidl.assertBranded(this, ReadableStreamBYOBRequestPrototype);
       return this[_view];
     }
 
@@ -4740,7 +4777,7 @@
     }
 
     respond(bytesWritten) {
-      webidl.assertBranded(this, ReadableStreamBYOBRequest);
+      webidl.assertBranded(this, ReadableStreamBYOBRequestPrototype);
       const prefix =
         "Failed to execute 'respond' on 'ReadableStreamBYOBRequest'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4764,7 +4801,7 @@
     }
 
     respondWithNewView(view) {
-      webidl.assertBranded(this, ReadableStreamBYOBRequest);
+      webidl.assertBranded(this, ReadableStreamBYOBRequestPrototype);
       const prefix =
         "Failed to execute 'respondWithNewView' on 'ReadableStreamBYOBRequest'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4786,6 +4823,8 @@
   }
 
   webidl.configurePrototype(ReadableStreamBYOBRequest);
+  const ReadableStreamBYOBRequestPrototype =
+    ReadableStreamBYOBRequest.prototype;
 
   class ReadableByteStreamController {
     /** @type {number | undefined} */
@@ -4821,19 +4860,19 @@
 
     /** @returns {ReadableStreamBYOBRequest | null} */
     get byobRequest() {
-      webidl.assertBranded(this, ReadableByteStreamController);
+      webidl.assertBranded(this, ReadableByteStreamControllerPrototype);
       return readableByteStreamControllerGetBYOBRequest(this);
     }
 
     /** @returns {number | null} */
     get desiredSize() {
-      webidl.assertBranded(this, ReadableByteStreamController);
+      webidl.assertBranded(this, ReadableByteStreamControllerPrototype);
       return readableByteStreamControllerGetDesiredSize(this);
     }
 
     /** @returns {void} */
     close() {
-      webidl.assertBranded(this, ReadableByteStreamController);
+      webidl.assertBranded(this, ReadableByteStreamControllerPrototype);
       if (this[_closeRequested] === true) {
         throw new TypeError("Closed already requested.");
       }
@@ -4850,7 +4889,7 @@
      * @returns {void}
      */
     enqueue(chunk) {
-      webidl.assertBranded(this, ReadableByteStreamController);
+      webidl.assertBranded(this, ReadableByteStreamControllerPrototype);
       const prefix =
         "Failed to execute 'enqueue' on 'ReadableByteStreamController'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4890,7 +4929,7 @@
      * @returns {void}
      */
     error(e = undefined) {
-      webidl.assertBranded(this, ReadableByteStreamController);
+      webidl.assertBranded(this, ReadableByteStreamControllerPrototype);
       if (e !== undefined) {
         e = webidl.converters.any(e);
       }
@@ -4900,7 +4939,10 @@
     [SymbolFor("Deno.customInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof ReadableByteStreamController,
+        evaluate: ObjectPrototypeIsPrototypeOf(
+          ReadableByteStreamControllerPrototype,
+          this,
+        ),
         keys: ["desiredSize"],
       }));
     }
@@ -4967,6 +5009,8 @@
   }
 
   webidl.configurePrototype(ReadableByteStreamController);
+  const ReadableByteStreamControllerPrototype =
+    ReadableByteStreamController.prototype;
 
   /** @template R */
   class ReadableStreamDefaultController {
@@ -4999,13 +5043,13 @@
 
     /** @returns {number | null} */
     get desiredSize() {
-      webidl.assertBranded(this, ReadableStreamDefaultController);
+      webidl.assertBranded(this, ReadableStreamDefaultControllerPrototype);
       return readableStreamDefaultControllerGetDesiredSize(this);
     }
 
     /** @returns {void} */
     close() {
-      webidl.assertBranded(this, ReadableStreamDefaultController);
+      webidl.assertBranded(this, ReadableStreamDefaultControllerPrototype);
       if (readableStreamDefaultControllerCanCloseOrEnqueue(this) === false) {
         throw new TypeError("The stream controller cannot close or enqueue.");
       }
@@ -5017,7 +5061,7 @@
      * @returns {void}
      */
     enqueue(chunk = undefined) {
-      webidl.assertBranded(this, ReadableStreamDefaultController);
+      webidl.assertBranded(this, ReadableStreamDefaultControllerPrototype);
       if (chunk !== undefined) {
         chunk = webidl.converters.any(chunk);
       }
@@ -5032,7 +5076,7 @@
      * @returns {void}
      */
     error(e = undefined) {
-      webidl.assertBranded(this, ReadableStreamDefaultController);
+      webidl.assertBranded(this, ReadableStreamDefaultControllerPrototype);
       if (e !== undefined) {
         e = webidl.converters.any(e);
       }
@@ -5042,7 +5086,10 @@
     [SymbolFor("Deno.customInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof ReadableStreamDefaultController,
+        evaluate: ObjectPrototypeIsPrototypeOf(
+          ReadableStreamDefaultController.prototype,
+          this,
+        ),
         keys: ["desiredSize"],
       }));
     }
@@ -5085,6 +5132,8 @@
   }
 
   webidl.configurePrototype(ReadableStreamDefaultController);
+  const ReadableStreamDefaultControllerPrototype =
+    ReadableStreamDefaultController.prototype;
 
   /**
    * @template I
@@ -5186,13 +5235,13 @@
 
     /** @returns {ReadableStream<O>} */
     get readable() {
-      webidl.assertBranded(this, TransformStream);
+      webidl.assertBranded(this, TransformStreamPrototype);
       return this[_readable];
     }
 
     /** @returns {WritableStream<I>} */
     get writable() {
-      webidl.assertBranded(this, TransformStream);
+      webidl.assertBranded(this, TransformStreamPrototype);
       return this[_writable];
     }
 
@@ -5204,6 +5253,7 @@
   }
 
   webidl.configurePrototype(TransformStream);
+  const TransformStreamPrototype = TransformStream.prototype;
 
   /** @template O */
   class TransformStreamDefaultController {
@@ -5220,7 +5270,7 @@
 
     /** @returns {number | null} */
     get desiredSize() {
-      webidl.assertBranded(this, TransformStreamDefaultController);
+      webidl.assertBranded(this, TransformStreamDefaultController.prototype);
       const readableController = this[_stream][_readable][_controller];
       return readableStreamDefaultControllerGetDesiredSize(
         /** @type {ReadableStreamDefaultController<O>} */ readableController,
@@ -5232,7 +5282,7 @@
      * @returns {void}
      */
     enqueue(chunk = undefined) {
-      webidl.assertBranded(this, TransformStreamDefaultController);
+      webidl.assertBranded(this, TransformStreamDefaultController.prototype);
       if (chunk !== undefined) {
         chunk = webidl.converters.any(chunk);
       }
@@ -5244,7 +5294,7 @@
      * @returns {void}
      */
     error(reason = undefined) {
-      webidl.assertBranded(this, TransformStreamDefaultController);
+      webidl.assertBranded(this, TransformStreamDefaultController.prototype);
       if (reason !== undefined) {
         reason = webidl.converters.any(reason);
       }
@@ -5253,20 +5303,25 @@
 
     /** @returns {void} */
     terminate() {
-      webidl.assertBranded(this, TransformStreamDefaultController);
+      webidl.assertBranded(this, TransformStreamDefaultControllerPrototype);
       transformStreamDefaultControllerTerminate(this);
     }
 
     [SymbolFor("Deno.customInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof TransformStreamDefaultController,
+        evaluate: ObjectPrototypeIsPrototypeOf(
+          TransformStreamDefaultController.prototype,
+          this,
+        ),
         keys: ["desiredSize"],
       }));
     }
   }
 
   webidl.configurePrototype(TransformStreamDefaultController);
+  const TransformStreamDefaultControllerPrototype =
+    TransformStreamDefaultController.prototype;
 
   /** @template W */
   class WritableStream {
@@ -5336,7 +5391,7 @@
 
     /** @returns {boolean} */
     get locked() {
-      webidl.assertBranded(this, WritableStream);
+      webidl.assertBranded(this, WritableStreamPrototype);
       return isWritableStreamLocked(this);
     }
 
@@ -5346,7 +5401,7 @@
      */
     abort(reason = undefined) {
       try {
-        webidl.assertBranded(this, WritableStream);
+        webidl.assertBranded(this, WritableStreamPrototype);
       } catch (err) {
         return PromiseReject(err);
       }
@@ -5366,7 +5421,7 @@
     /** @returns {Promise<void>} */
     close() {
       try {
-        webidl.assertBranded(this, WritableStream);
+        webidl.assertBranded(this, WritableStreamPrototype);
       } catch (err) {
         return PromiseReject(err);
       }
@@ -5387,7 +5442,7 @@
 
     /** @returns {WritableStreamDefaultWriter<W>} */
     getWriter() {
-      webidl.assertBranded(this, WritableStream);
+      webidl.assertBranded(this, WritableStreamPrototype);
       return acquireWritableStreamDefaultWriter(this);
     }
 
@@ -5397,6 +5452,7 @@
   }
 
   webidl.configurePrototype(WritableStream);
+  const WritableStreamPrototype = WritableStream.prototype;
 
   /** @template W */
   class WritableStreamDefaultWriter {
@@ -5426,7 +5482,7 @@
     /** @returns {Promise<void>} */
     get closed() {
       try {
-        webidl.assertBranded(this, WritableStreamDefaultWriter);
+        webidl.assertBranded(this, WritableStreamDefaultWriterPrototype);
       } catch (err) {
         return PromiseReject(err);
       }
@@ -5435,7 +5491,7 @@
 
     /** @returns {number} */
     get desiredSize() {
-      webidl.assertBranded(this, WritableStreamDefaultWriter);
+      webidl.assertBranded(this, WritableStreamDefaultWriterPrototype);
       if (this[_stream] === undefined) {
         throw new TypeError(
           "A writable stream is not associated with the writer.",
@@ -5447,7 +5503,7 @@
     /** @returns {Promise<void>} */
     get ready() {
       try {
-        webidl.assertBranded(this, WritableStreamDefaultWriter);
+        webidl.assertBranded(this, WritableStreamDefaultWriterPrototype);
       } catch (err) {
         return PromiseReject(err);
       }
@@ -5460,7 +5516,7 @@
      */
     abort(reason = undefined) {
       try {
-        webidl.assertBranded(this, WritableStreamDefaultWriter);
+        webidl.assertBranded(this, WritableStreamDefaultWriterPrototype);
       } catch (err) {
         return PromiseReject(err);
       }
@@ -5478,7 +5534,7 @@
     /** @returns {Promise<void>} */
     close() {
       try {
-        webidl.assertBranded(this, WritableStreamDefaultWriter);
+        webidl.assertBranded(this, WritableStreamDefaultWriterPrototype);
       } catch (err) {
         return PromiseReject(err);
       }
@@ -5498,7 +5554,7 @@
 
     /** @returns {void} */
     releaseLock() {
-      webidl.assertBranded(this, WritableStreamDefaultWriter);
+      webidl.assertBranded(this, WritableStreamDefaultWriterPrototype);
       const stream = this[_stream];
       if (stream === undefined) {
         return;
@@ -5513,7 +5569,7 @@
      */
     write(chunk = undefined) {
       try {
-        webidl.assertBranded(this, WritableStreamDefaultWriter);
+        webidl.assertBranded(this, WritableStreamDefaultWriterPrototype);
         if (chunk !== undefined) {
           chunk = webidl.converters.any(chunk);
         }
@@ -5531,7 +5587,10 @@
     [SymbolFor("Deno.customInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof WritableStreamDefaultWriter,
+        evaluate: ObjectPrototypeIsPrototypeOf(
+          WritableStreamDefaultWriter.prototype,
+          this,
+        ),
         keys: [
           "closed",
           "desiredSize",
@@ -5542,6 +5601,8 @@
   }
 
   webidl.configurePrototype(WritableStreamDefaultWriter);
+  const WritableStreamDefaultWriterPrototype =
+    WritableStreamDefaultWriter.prototype;
 
   /** @template W */
   class WritableStreamDefaultController {
@@ -5567,7 +5628,7 @@
     [_signal];
 
     get signal() {
-      webidl.assertBranded(this, WritableStreamDefaultController);
+      webidl.assertBranded(this, WritableStreamDefaultControllerPrototype);
       return this[_signal];
     }
 
@@ -5580,7 +5641,7 @@
      * @returns {void}
      */
     error(e = undefined) {
-      webidl.assertBranded(this, WritableStreamDefaultController);
+      webidl.assertBranded(this, WritableStreamDefaultControllerPrototype);
       if (e !== undefined) {
         e = webidl.converters.any(e);
       }
@@ -5594,7 +5655,10 @@
     [SymbolFor("Deno.customInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof WritableStreamDefaultController,
+        evaluate: ObjectPrototypeIsPrototypeOf(
+          WritableStreamDefaultController.prototype,
+          this,
+        ),
         keys: [],
       }));
     }
@@ -5615,6 +5679,8 @@
   }
 
   webidl.configurePrototype(WritableStreamDefaultController);
+  const WritableStreamDefaultControllerPrototype =
+    WritableStreamDefaultController.prototype;
 
   /**
    * @param {ReadableStream} stream
@@ -5624,9 +5690,9 @@
   }
 
   webidl.converters.ReadableStream = webidl
-    .createInterfaceConverter("ReadableStream", ReadableStream);
+    .createInterfaceConverter("ReadableStream", ReadableStream.prototype);
   webidl.converters.WritableStream = webidl
-    .createInterfaceConverter("WritableStream", WritableStream);
+    .createInterfaceConverter("WritableStream", WritableStream.prototype);
 
   webidl.converters.ReadableStreamType = webidl.createEnumConverter(
     "ReadableStreamType",
@@ -5787,6 +5853,7 @@
     ByteLengthQueuingStrategy,
     CountQueuingStrategy,
     ReadableStream,
+    ReadableStreamPrototype,
     ReadableStreamDefaultReader,
     TransformStream,
     WritableStream,
diff --git a/ext/web/08_text_encoding.js b/ext/web/08_text_encoding.js
index cf7b7e12f3..4f26089b1d 100644
--- a/ext/web/08_text_encoding.js
+++ b/ext/web/08_text_encoding.js
@@ -16,6 +16,7 @@
   const webidl = window.__bootstrap.webidl;
   const {
     ArrayBufferIsView,
+    ObjectPrototypeIsPrototypeOf,
     PromiseReject,
     PromiseResolve,
     StringPrototypeCharCodeAt,
@@ -59,19 +60,19 @@
 
     /** @returns {string} */
     get encoding() {
-      webidl.assertBranded(this, TextDecoder);
+      webidl.assertBranded(this, TextDecoderPrototype);
       return this.#encoding;
     }
 
     /** @returns {boolean} */
     get fatal() {
-      webidl.assertBranded(this, TextDecoder);
+      webidl.assertBranded(this, TextDecoderPrototype);
       return this.#fatal;
     }
 
     /** @returns {boolean} */
     get ignoreBOM() {
-      webidl.assertBranded(this, TextDecoder);
+      webidl.assertBranded(this, TextDecoderPrototype);
       return this.#ignoreBOM;
     }
 
@@ -80,7 +81,7 @@
      * @param {TextDecodeOptions} options
      */
     decode(input = new Uint8Array(), options = {}) {
-      webidl.assertBranded(this, TextDecoder);
+      webidl.assertBranded(this, TextDecoderPrototype);
       const prefix = "Failed to execute 'decode' on 'TextDecoder'";
       if (input !== undefined) {
         input = webidl.converters.BufferSource(input, {
@@ -119,7 +120,12 @@
           // If the buffer is detached, just create a new empty Uint8Array.
           input = new Uint8Array();
         }
-        if (input.buffer instanceof SharedArrayBuffer) {
+        if (
+          ObjectPrototypeIsPrototypeOf(
+            SharedArrayBuffer.prototype,
+            input.buffer,
+          )
+        ) {
           // We clone the data into a non-shared ArrayBuffer so we can pass it
           // to Rust.
           // `input` is now a Uint8Array, and calling the TypedArray constructor
@@ -140,6 +146,7 @@
   }
 
   webidl.configurePrototype(TextDecoder);
+  const TextDecoderPrototype = TextDecoder.prototype;
 
   class TextEncoder {
     constructor() {
@@ -148,7 +155,7 @@
 
     /** @returns {string} */
     get encoding() {
-      webidl.assertBranded(this, TextEncoder);
+      webidl.assertBranded(this, TextEncoderPrototype);
       return "utf-8";
     }
 
@@ -157,7 +164,7 @@
      * @returns {Uint8Array}
      */
     encode(input = "") {
-      webidl.assertBranded(this, TextEncoder);
+      webidl.assertBranded(this, TextEncoderPrototype);
       const prefix = "Failed to execute 'encode' on 'TextEncoder'";
       // The WebIDL type of `input` is `USVString`, but `core.encode` already
       // converts lone surrogates to the replacement character.
@@ -174,7 +181,7 @@
      * @returns {TextEncoderEncodeIntoResult}
      */
     encodeInto(source, destination) {
-      webidl.assertBranded(this, TextEncoder);
+      webidl.assertBranded(this, TextEncoderPrototype);
       const prefix = "Failed to execute 'encodeInto' on 'TextEncoder'";
       // The WebIDL type of `source` is `USVString`, but the ops bindings
       // already convert lone surrogates to the replacement character.
@@ -192,6 +199,7 @@
   }
 
   webidl.configurePrototype(TextEncoder);
+  const TextEncoderPrototype = TextEncoder.prototype;
 
   class TextDecoderStream {
     /** @type {TextDecoder} */
@@ -248,36 +256,37 @@
 
     /** @returns {string} */
     get encoding() {
-      webidl.assertBranded(this, TextDecoderStream);
+      webidl.assertBranded(this, TextDecoderStreamPrototype);
       return this.#decoder.encoding;
     }
 
     /** @returns {boolean} */
     get fatal() {
-      webidl.assertBranded(this, TextDecoderStream);
+      webidl.assertBranded(this, TextDecoderStreamPrototype);
       return this.#decoder.fatal;
     }
 
     /** @returns {boolean} */
     get ignoreBOM() {
-      webidl.assertBranded(this, TextDecoderStream);
+      webidl.assertBranded(this, TextDecoderStreamPrototype);
       return this.#decoder.ignoreBOM;
     }
 
     /** @returns {ReadableStream<string>} */
     get readable() {
-      webidl.assertBranded(this, TextDecoderStream);
+      webidl.assertBranded(this, TextDecoderStreamPrototype);
       return this.#transform.readable;
     }
 
     /** @returns {WritableStream<BufferSource>} */
     get writable() {
-      webidl.assertBranded(this, TextDecoderStream);
+      webidl.assertBranded(this, TextDecoderStreamPrototype);
       return this.#transform.writable;
     }
   }
 
   webidl.configurePrototype(TextDecoderStream);
+  const TextDecoderStreamPrototype = TextDecoderStream.prototype;
 
   class TextEncoderStream {
     /** @type {string | null} */
@@ -332,24 +341,25 @@
 
     /** @returns {string} */
     get encoding() {
-      webidl.assertBranded(this, TextEncoderStream);
+      webidl.assertBranded(this, TextEncoderStreamPrototype);
       return "utf-8";
     }
 
     /** @returns {ReadableStream<Uint8Array>} */
     get readable() {
-      webidl.assertBranded(this, TextEncoderStream);
+      webidl.assertBranded(this, TextEncoderStreamPrototype);
       return this.#transform.readable;
     }
 
     /** @returns {WritableStream<string>} */
     get writable() {
-      webidl.assertBranded(this, TextEncoderStream);
+      webidl.assertBranded(this, TextEncoderStreamPrototype);
       return this.#transform.writable;
     }
   }
 
   webidl.configurePrototype(TextEncoderStream);
+  const TextEncoderStreamPrototype = TextEncoderStream.prototype;
 
   webidl.converters.TextDecoderOptions = webidl.createDictionaryConverter(
     "TextDecoderOptions",
diff --git a/ext/web/09_file.js b/ext/web/09_file.js
index 289db22ecd..fbc00326ef 100644
--- a/ext/web/09_file.js
+++ b/ext/web/09_file.js
@@ -15,7 +15,7 @@
   const core = window.Deno.core;
   const webidl = window.__bootstrap.webidl;
   const {
-    ArrayBuffer,
+    ArrayBufferPrototype,
     ArrayBufferPrototypeSlice,
     ArrayBufferIsView,
     ArrayPrototypePush,
@@ -23,6 +23,7 @@
     DatePrototypeGetTime,
     MathMax,
     MathMin,
+    ObjectPrototypeIsPrototypeOf,
     RegExpPrototypeTest,
     StringPrototypeCharAt,
     StringPrototypeToLowerCase,
@@ -109,7 +110,7 @@
     const processedParts = [];
     let size = 0;
     for (const element of parts) {
-      if (element instanceof ArrayBuffer) {
+      if (ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, element)) {
         const chunk = new Uint8Array(ArrayBufferPrototypeSlice(element, 0));
         ArrayPrototypePush(processedParts, BlobReference.fromUint8Array(chunk));
         size += element.byteLength;
@@ -121,7 +122,7 @@
         );
         size += element.byteLength;
         ArrayPrototypePush(processedParts, BlobReference.fromUint8Array(chunk));
-      } else if (element instanceof Blob) {
+      } else if (ObjectPrototypeIsPrototypeOf(BlobPrototype, element)) {
         ArrayPrototypePush(processedParts, element);
         size += element.size;
       } else if (typeof element === "string") {
@@ -157,7 +158,7 @@
    */
   function getParts(blob, bag = []) {
     for (const part of blob[_parts]) {
-      if (part instanceof Blob) {
+      if (ObjectPrototypeIsPrototypeOf(BlobPrototype, part)) {
         getParts(part, bag);
       } else {
         ArrayPrototypePush(bag, part._id);
@@ -204,13 +205,13 @@
 
     /** @returns {number} */
     get size() {
-      webidl.assertBranded(this, Blob);
+      webidl.assertBranded(this, BlobPrototype);
       return this[_size];
     }
 
     /** @returns {string} */
     get type() {
-      webidl.assertBranded(this, Blob);
+      webidl.assertBranded(this, BlobPrototype);
       return this[_type];
     }
 
@@ -221,7 +222,7 @@
      * @returns {Blob}
      */
     slice(start = undefined, end = undefined, contentType = undefined) {
-      webidl.assertBranded(this, Blob);
+      webidl.assertBranded(this, BlobPrototype);
       const prefix = "Failed to execute 'slice' on 'Blob'";
       if (start !== undefined) {
         start = webidl.converters["long long"](start, {
@@ -316,7 +317,7 @@
      * @returns {ReadableStream<Uint8Array>}
      */
     stream() {
-      webidl.assertBranded(this, Blob);
+      webidl.assertBranded(this, BlobPrototype);
       const partIterator = toIterator(this[_parts]);
       const stream = new ReadableStream({
         type: "bytes",
@@ -338,7 +339,7 @@
      * @returns {Promise<string>}
      */
     async text() {
-      webidl.assertBranded(this, Blob);
+      webidl.assertBranded(this, BlobPrototype);
       const buffer = await this.arrayBuffer();
       return core.decode(new Uint8Array(buffer));
     }
@@ -347,7 +348,7 @@
      * @returns {Promise<ArrayBuffer>}
      */
     async arrayBuffer() {
-      webidl.assertBranded(this, Blob);
+      webidl.assertBranded(this, BlobPrototype);
       const stream = this.stream();
       const bytes = new Uint8Array(this.size);
       let offset = 0;
@@ -361,7 +362,7 @@
     [SymbolFor("Deno.customInspect")](inspect) {
       return inspect(consoleInternal.createFilteredInspectProxy({
         object: this,
-        evaluate: this instanceof Blob,
+        evaluate: ObjectPrototypeIsPrototypeOf(BlobPrototype, this),
         keys: [
           "size",
           "type",
@@ -371,15 +372,22 @@
   }
 
   webidl.configurePrototype(Blob);
+  const BlobPrototype = Blob.prototype;
 
-  webidl.converters["Blob"] = webidl.createInterfaceConverter("Blob", Blob);
+  webidl.converters["Blob"] = webidl.createInterfaceConverter(
+    "Blob",
+    Blob.prototype,
+  );
   webidl.converters["BlobPart"] = (V, opts) => {
     // Union for ((ArrayBuffer or ArrayBufferView) or Blob or USVString)
     if (typeof V == "object") {
-      if (V instanceof Blob) {
+      if (ObjectPrototypeIsPrototypeOf(BlobPrototype, V)) {
         return webidl.converters["Blob"](V, opts);
       }
-      if (V instanceof ArrayBuffer || V instanceof SharedArrayBuffer) {
+      if (
+        ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, V) ||
+        ObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype, V)
+      ) {
         return webidl.converters["ArrayBuffer"](V, opts);
       }
       if (ArrayBufferIsView(V)) {
@@ -458,18 +466,19 @@
 
     /** @returns {string} */
     get name() {
-      webidl.assertBranded(this, File);
+      webidl.assertBranded(this, FilePrototype);
       return this[_Name];
     }
 
     /** @returns {number} */
     get lastModified() {
-      webidl.assertBranded(this, File);
+      webidl.assertBranded(this, FilePrototype);
       return this[_LastModified];
     }
   }
 
   webidl.configurePrototype(File);
+  const FilePrototype = File.prototype;
 
   webidl.converters["FilePropertyBag"] = webidl.createDictionaryConverter(
     "FilePropertyBag",
@@ -593,6 +602,8 @@
     blobFromObjectUrl,
     getParts,
     Blob,
+    BlobPrototype,
     File,
+    FilePrototype,
   };
 })(this);
diff --git a/ext/web/10_filereader.js b/ext/web/10_filereader.js
index 294d96ebd8..039d3395d4 100644
--- a/ext/web/10_filereader.js
+++ b/ext/web/10_filereader.js
@@ -28,12 +28,14 @@
     MapPrototypeGet,
     MapPrototypeSet,
     ObjectDefineProperty,
+    ObjectPrototypeIsPrototypeOf,
     queueMicrotask,
     StringFromCodePoint,
     Symbol,
     TypedArrayPrototypeSet,
     TypeError,
     Uint8Array,
+    Uint8ArrayPrototype,
   } = window.__bootstrap.primordials;
 
   const state = Symbol("[[state]]");
@@ -116,7 +118,10 @@
 
             // 4. If chunkPromise is fulfilled with an object whose done property is false
             // and whose value property is a Uint8Array object, run these steps:
-            if (!chunk.done && chunk.value instanceof Uint8Array) {
+            if (
+              !chunk.done &&
+              ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, chunk.value)
+            ) {
               ArrayPrototypePush(chunks, chunk.value);
 
               // TODO(bartlomieju): (only) If roughly 50ms have passed since last progress
@@ -260,7 +265,7 @@
     }
 
     #getEventHandlerFor(name) {
-      webidl.assertBranded(this, FileReader);
+      webidl.assertBranded(this, FileReaderPrototype);
 
       const maybeMap = this[handlerSymbol];
       if (!maybeMap) return null;
@@ -269,7 +274,7 @@
     }
 
     #setEventHandlerFor(name, value) {
-      webidl.assertBranded(this, FileReader);
+      webidl.assertBranded(this, FileReaderPrototype);
 
       if (!this[handlerSymbol]) {
         this[handlerSymbol] = new Map();
@@ -292,7 +297,7 @@
 
     /** @returns {number} */
     get readyState() {
-      webidl.assertBranded(this, FileReader);
+      webidl.assertBranded(this, FileReaderPrototype);
       switch (this[state]) {
         case "empty":
           return FileReader.EMPTY;
@@ -306,17 +311,17 @@
     }
 
     get result() {
-      webidl.assertBranded(this, FileReader);
+      webidl.assertBranded(this, FileReaderPrototype);
       return this[result];
     }
 
     get error() {
-      webidl.assertBranded(this, FileReader);
+      webidl.assertBranded(this, FileReaderPrototype);
       return this[error];
     }
 
     abort() {
-      webidl.assertBranded(this, FileReader);
+      webidl.assertBranded(this, FileReaderPrototype);
       // If context object's state is "empty" or if context object's state is "done" set context object's result to null and terminate this algorithm.
       if (
         this[state] === "empty" ||
@@ -349,7 +354,7 @@
 
     /** @param {Blob} blob */
     readAsArrayBuffer(blob) {
-      webidl.assertBranded(this, FileReader);
+      webidl.assertBranded(this, FileReaderPrototype);
       const prefix = "Failed to execute 'readAsArrayBuffer' on 'FileReader'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       this.#readOperation(blob, { kind: "ArrayBuffer" });
@@ -357,7 +362,7 @@
 
     /** @param {Blob} blob */
     readAsBinaryString(blob) {
-      webidl.assertBranded(this, FileReader);
+      webidl.assertBranded(this, FileReaderPrototype);
       const prefix = "Failed to execute 'readAsBinaryString' on 'FileReader'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       // alias for readAsArrayBuffer
@@ -366,7 +371,7 @@
 
     /** @param {Blob} blob */
     readAsDataURL(blob) {
-      webidl.assertBranded(this, FileReader);
+      webidl.assertBranded(this, FileReaderPrototype);
       const prefix = "Failed to execute 'readAsDataURL' on 'FileReader'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       // alias for readAsArrayBuffer
@@ -378,7 +383,7 @@
      * @param {string} [encoding]
      */
     readAsText(blob, encoding = undefined) {
-      webidl.assertBranded(this, FileReader);
+      webidl.assertBranded(this, FileReaderPrototype);
       const prefix = "Failed to execute 'readAsText' on 'FileReader'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       if (encoding !== undefined) {
@@ -435,6 +440,7 @@
   }
 
   webidl.configurePrototype(FileReader);
+  const FileReaderPrototype = FileReader.prototype;
 
   ObjectDefineProperty(FileReader, "EMPTY", {
     writable: false,
diff --git a/ext/web/13_message_port.js b/ext/web/13_message_port.js
index ef332dd7af..8242f85f3e 100644
--- a/ext/web/13_message_port.js
+++ b/ext/web/13_message_port.js
@@ -10,19 +10,21 @@
 
 ((window) => {
   const core = window.Deno.core;
-  const { Interrupted } = core;
+  const { InterruptedPrototype } = core;
   const webidl = window.__bootstrap.webidl;
   const { setEventTargetData } = window.__bootstrap.eventTarget;
   const { defineEventHandler } = window.__bootstrap.event;
   const { DOMException } = window.__bootstrap.domException;
   const {
-    ArrayBuffer,
+    ArrayBufferPrototype,
     ArrayPrototypeFilter,
     ArrayPrototypeIncludes,
     ArrayPrototypePush,
+    ObjectPrototypeIsPrototypeOf,
     ObjectSetPrototypeOf,
     Symbol,
     SymbolFor,
+    SymbolIterator,
     TypeError,
     WeakSet,
     WeakSetPrototypeAdd,
@@ -45,12 +47,12 @@
     }
 
     get port1() {
-      webidl.assertBranded(this, MessageChannel);
+      webidl.assertBranded(this, MessageChannelPrototype);
       return this.#port1;
     }
 
     get port2() {
-      webidl.assertBranded(this, MessageChannel);
+      webidl.assertBranded(this, MessageChannelPrototype);
       return this.#port2;
     }
 
@@ -62,6 +64,7 @@
   }
 
   webidl.configurePrototype(MessageChannel);
+  const MessageChannelPrototype = MessageChannel.prototype;
 
   const _id = Symbol("id");
   const _enabled = Symbol("enabled");
@@ -72,7 +75,7 @@
    */
   function createMessagePort(id) {
     const port = core.createHostObject();
-    ObjectSetPrototypeOf(port, MessagePort.prototype);
+    ObjectSetPrototypeOf(port, MessagePortPrototype);
     port[webidl.brand] = webidl.brand;
     setEventTargetData(port);
     port[_id] = id;
@@ -95,7 +98,7 @@
      * @param {object[] | StructuredSerializeOptions} transferOrOptions
      */
     postMessage(message, transferOrOptions = {}) {
-      webidl.assertBranded(this, MessagePort);
+      webidl.assertBranded(this, MessagePortPrototype);
       const prefix = "Failed to execute 'postMessage' on 'MessagePort'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       message = webidl.converters.any(message);
@@ -103,7 +106,7 @@
       if (
         webidl.type(transferOrOptions) === "Object" &&
         transferOrOptions !== undefined &&
-        transferOrOptions[Symbol.iterator] !== undefined
+        transferOrOptions[SymbolIterator] !== undefined
       ) {
         const transfer = webidl.converters["sequence<object>"](
           transferOrOptions,
@@ -129,7 +132,7 @@
     }
 
     start() {
-      webidl.assertBranded(this, MessagePort);
+      webidl.assertBranded(this, MessagePortPrototype);
       if (this[_enabled]) return;
       (async () => {
         this[_enabled] = true;
@@ -142,7 +145,7 @@
               this[_id],
             );
           } catch (err) {
-            if (err instanceof Interrupted) break;
+            if (ObjectPrototypeIsPrototypeOf(InterruptedPrototype, err)) break;
             throw err;
           }
           if (data === null) break;
@@ -160,7 +163,7 @@
             data: message,
             ports: ArrayPrototypeFilter(
               transferables,
-              (t) => t instanceof MessagePort,
+              (t) => ObjectPrototypeIsPrototypeOf(MessagePortPrototype, t),
             ),
           });
           this.dispatchEvent(event);
@@ -170,7 +173,7 @@
     }
 
     close() {
-      webidl.assertBranded(this, MessagePort);
+      webidl.assertBranded(this, MessagePortPrototype);
       if (this[_id] !== null) {
         core.close(this[_id]);
         this[_id] = null;
@@ -184,6 +187,7 @@
   defineEventHandler(MessagePort.prototype, "messageerror");
 
   webidl.configurePrototype(MessagePort);
+  const MessagePortPrototype = MessagePort.prototype;
 
   /**
    * @returns {[number, number]}
@@ -245,7 +249,7 @@
   function serializeJsMessageData(data, transferables) {
     const transferedArrayBuffers = ArrayPrototypeFilter(
       transferables,
-      (a) => a instanceof ArrayBuffer,
+      (a) => ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, a),
     );
 
     for (const arrayBuffer of transferedArrayBuffers) {
@@ -266,7 +270,7 @@
       serializedData = core.serialize(data, {
         hostObjects: ArrayPrototypeFilter(
           transferables,
-          (a) => a instanceof MessagePort,
+          (a) => ObjectPrototypeIsPrototypeOf(MessagePortPrototype, a),
         ),
         transferedArrayBuffers,
       });
@@ -279,8 +283,8 @@
 
     let arrayBufferI = 0;
     for (const transferable of transferables) {
-      if (transferable instanceof MessagePort) {
-        webidl.assertBranded(transferable, MessagePort);
+      if (ObjectPrototypeIsPrototypeOf(MessagePortPrototype, transferable)) {
+        webidl.assertBranded(transferable, MessagePortPrototype);
         const id = transferable[_id];
         if (id === null) {
           throw new DOMException(
@@ -293,7 +297,9 @@
           kind: "messagePort",
           data: id,
         });
-      } else if (transferable instanceof ArrayBuffer) {
+      } else if (
+        ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, transferable)
+      ) {
         ArrayPrototypePush(serializedTransferables, {
           kind: "arrayBuffer",
           data: transferedArrayBuffers[arrayBufferI],
@@ -339,6 +345,7 @@
   window.__bootstrap.messagePort = {
     MessageChannel,
     MessagePort,
+    MessagePortPrototype,
     deserializeJsMessageData,
     serializeJsMessageData,
     structuredClone,
diff --git a/ext/web/14_compression.js b/ext/web/14_compression.js
index 1a0f77e665..0814958949 100644
--- a/ext/web/14_compression.js
+++ b/ext/web/14_compression.js
@@ -53,17 +53,18 @@
     }
 
     get readable() {
-      webidl.assertBranded(this, CompressionStream);
+      webidl.assertBranded(this, CompressionStreamPrototype);
       return this.#transform.readable;
     }
 
     get writable() {
-      webidl.assertBranded(this, CompressionStream);
+      webidl.assertBranded(this, CompressionStreamPrototype);
       return this.#transform.writable;
     }
   }
 
   webidl.configurePrototype(CompressionStream);
+  const CompressionStreamPrototype = CompressionStream.prototype;
 
   class DecompressionStream {
     #transform;
@@ -98,12 +99,12 @@
     }
 
     get readable() {
-      webidl.assertBranded(this, DecompressionStream);
+      webidl.assertBranded(this, DecompressionStreamPrototype);
       return this.#transform.readable;
     }
 
     get writable() {
-      webidl.assertBranded(this, DecompressionStream);
+      webidl.assertBranded(this, DecompressionStreamPrototype);
       return this.#transform.writable;
     }
   }
@@ -115,6 +116,7 @@
   }
 
   webidl.configurePrototype(DecompressionStream);
+  const DecompressionStreamPrototype = DecompressionStream.prototype;
 
   window.__bootstrap.compression = {
     CompressionStream,
diff --git a/ext/webgpu/01_webgpu.js b/ext/webgpu/01_webgpu.js
index 45d910c1a2..cd1a6e5ad7 100644
--- a/ext/webgpu/01_webgpu.js
+++ b/ext/webgpu/01_webgpu.js
@@ -25,6 +25,7 @@
     MathMax,
     ObjectDefineProperty,
     ObjectFreeze,
+    ObjectPrototypeIsPrototypeOf,
     Promise,
     PromiseAll,
     PromisePrototypeCatch,
@@ -42,6 +43,7 @@
     SymbolIterator,
     TypeError,
     Uint32Array,
+    Uint32ArrayPrototype,
     Uint8Array,
   } = window.__bootstrap.primordials;
 
@@ -157,6 +159,7 @@
       super("device out of memory");
     }
   }
+  const GPUOutOfMemoryErrorPrototype = GPUOutOfMemoryError.prototype;
 
   class GPUValidationError extends Error {
     name = "GPUValidationError";
@@ -183,7 +186,7 @@
      * @param {GPURequestAdapterOptions} options
      */
     async requestAdapter(options = {}) {
-      webidl.assertBranded(this, GPU);
+      webidl.assertBranded(this, GPUPrototype);
       options = webidl.converters.GPURequestAdapterOptions(options, {
         prefix: "Failed to execute 'requestAdapter' on 'GPU'",
         context: "Argument 1",
@@ -205,6 +208,7 @@
       return `${this.constructor.name} ${inspect({})}`;
     }
   }
+  const GPUPrototype = GPU.prototype;
 
   const _name = Symbol("[[name]]");
   const _adapter = Symbol("[[adapter]]");
@@ -243,17 +247,17 @@
 
     /** @returns {string} */
     get name() {
-      webidl.assertBranded(this, GPUAdapter);
+      webidl.assertBranded(this, GPUAdapterPrototype);
       return this[_name];
     }
     /** @returns {GPUSupportedFeatures} */
     get features() {
-      webidl.assertBranded(this, GPUAdapter);
+      webidl.assertBranded(this, GPUAdapterPrototype);
       return this[_adapter].features;
     }
     /** @returns {GPUSupportedLimits} */
     get limits() {
-      webidl.assertBranded(this, GPUAdapter);
+      webidl.assertBranded(this, GPUAdapterPrototype);
       return this[_adapter].limits;
     }
     /** @returns {boolean} */
@@ -270,7 +274,7 @@
      * @returns {Promise<GPUDevice>}
      */
     async requestDevice(descriptor = {}) {
-      webidl.assertBranded(this, GPUAdapter);
+      webidl.assertBranded(this, GPUAdapterPrototype);
       const prefix = "Failed to execute 'requestDevice' on 'GPUAdapter'";
       descriptor = webidl.converters.GPUDeviceDescriptor(descriptor, {
         prefix,
@@ -320,6 +324,7 @@
       }`;
     }
   }
+  const GPUAdapterPrototype = GPUAdapter.prototype;
 
   const _limits = Symbol("[[limits]]");
 
@@ -368,107 +373,107 @@
     }
 
     get maxTextureDimension1D() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxTextureDimension1D;
     }
     get maxTextureDimension2D() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxTextureDimension2D;
     }
     get maxTextureDimension3D() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxTextureDimension3D;
     }
     get maxTextureArrayLayers() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxTextureArrayLayers;
     }
     get maxBindGroups() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxBindGroups;
     }
     get maxDynamicUniformBuffersPerPipelineLayout() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxDynamicUniformBuffersPerPipelineLayout;
     }
     get maxDynamicStorageBuffersPerPipelineLayout() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxDynamicStorageBuffersPerPipelineLayout;
     }
     get maxSampledTexturesPerShaderStage() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxSampledTexturesPerShaderStage;
     }
     get maxSamplersPerShaderStage() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxSamplersPerShaderStage;
     }
     get maxStorageBuffersPerShaderStage() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxStorageBuffersPerShaderStage;
     }
     get maxStorageTexturesPerShaderStage() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxStorageTexturesPerShaderStage;
     }
     get maxUniformBuffersPerShaderStage() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxUniformBuffersPerShaderStage;
     }
     get maxUniformBufferBindingSize() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxUniformBufferBindingSize;
     }
     get maxStorageBufferBindingSize() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxStorageBufferBindingSize;
     }
     get minUniformBufferOffsetAlignment() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].minUniformBufferOffsetAlignment;
     }
     get minStorageBufferOffsetAlignment() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].minStorageBufferOffsetAlignment;
     }
     get maxVertexBuffers() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxVertexBuffers;
     }
     get maxVertexAttributes() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxVertexAttributes;
     }
     get maxVertexBufferArrayStride() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxVertexBufferArrayStride;
     }
     get maxInterStageShaderComponents() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxInterStageShaderComponents;
     }
     get maxComputeWorkgroupStorageSize() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxComputeWorkgroupStorageSize;
     }
     get maxComputeInvocationsPerWorkgroup() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxComputeInvocationsPerWorkgroup;
     }
     get maxComputeWorkgroupSizeX() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxComputeWorkgroupSizeX;
     }
     get maxComputeWorkgroupSizeY() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxComputeWorkgroupSizeY;
     }
     get maxComputeWorkgroupSizeZ() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxComputeWorkgroupSizeZ;
     }
     get maxComputeWorkgroupsPerDimension() {
-      webidl.assertBranded(this, GPUSupportedLimits);
+      webidl.assertBranded(this, GPUSupportedLimitsPrototype);
       return this[_limits].maxComputeWorkgroupsPerDimension;
     }
 
@@ -476,6 +481,7 @@
       return `${this.constructor.name} ${inspect(this[_limits])}`;
     }
   }
+  const GPUSupportedLimitsPrototype = GPUSupportedLimits.prototype;
 
   const _features = Symbol("[[features]]");
 
@@ -496,42 +502,42 @@
 
     /** @return {IterableIterator<[string, string]>} */
     entries() {
-      webidl.assertBranded(this, GPUSupportedFeatures);
+      webidl.assertBranded(this, GPUSupportedFeaturesPrototype);
       return SetPrototypeEntries(this[_features]);
     }
 
     /** @return {void} */
     forEach(callbackfn, thisArg) {
-      webidl.assertBranded(this, GPUSupportedFeatures);
+      webidl.assertBranded(this, GPUSupportedFeaturesPrototype);
       SetPrototypeForEach(this[_features], callbackfn, thisArg);
     }
 
     /** @return {boolean} */
     has(value) {
-      webidl.assertBranded(this, GPUSupportedFeatures);
+      webidl.assertBranded(this, GPUSupportedFeaturesPrototype);
       return SetPrototypeHas(this[_features], value);
     }
 
     /** @return {IterableIterator<string>} */
     keys() {
-      webidl.assertBranded(this, GPUSupportedFeatures);
+      webidl.assertBranded(this, GPUSupportedFeaturesPrototype);
       return SetPrototypeKeys(this[_features]);
     }
 
     /** @return {IterableIterator<string>} */
     values() {
-      webidl.assertBranded(this, GPUSupportedFeatures);
+      webidl.assertBranded(this, GPUSupportedFeaturesPrototype);
       return SetPrototypeValues(this[_features]);
     }
 
     /** @return {number} */
     get size() {
-      webidl.assertBranded(this, GPUSupportedFeatures);
+      webidl.assertBranded(this, GPUSupportedFeaturesPrototype);
       return this[_features].size;
     }
 
     [SymbolIterator]() {
-      webidl.assertBranded(this, GPUSupportedFeatures);
+      webidl.assertBranded(this, GPUSupportedFeaturesPrototype);
       return this[_features][SymbolIterator]();
     }
 
@@ -540,6 +546,8 @@
     }
   }
 
+  const GPUSupportedFeaturesPrototype = GPUSupportedFeatures.prototype;
+
   const _reason = Symbol("[[reason]]");
   const _message = Symbol("[[message]]");
 
@@ -567,11 +575,11 @@
     }
 
     get reason() {
-      webidl.assertBranded(this, GPUDeviceLostInfo);
+      webidl.assertBranded(this, GPUDeviceLostInfoPrototype);
       return this[_reason];
     }
     get message() {
-      webidl.assertBranded(this, GPUDeviceLostInfo);
+      webidl.assertBranded(this, GPUDeviceLostInfoPrototype);
       return this[_message];
     }
 
@@ -582,6 +590,8 @@
     }
   }
 
+  const GPUDeviceLostInfoPrototype = GPUDeviceLostInfo.prototype;
+
   const _label = Symbol("[[label]]");
 
   /**
@@ -595,14 +605,14 @@
        * @return {string | null}
        */
       get() {
-        webidl.assertBranded(this, type);
+        webidl.assertBranded(this, type.prototype);
         return this[_label];
       },
       /**
        * @param {string | null} label
        */
       set(label) {
-        webidl.assertBranded(this, type);
+        webidl.assertBranded(this, type.prototype);
         label = webidl.converters["UVString?"](label, {
           prefix: `Failed to set 'label' on '${name}'`,
           context: "Argument 1",
@@ -705,7 +715,9 @@
       const validationFilteredPromise = PromisePrototypeCatch(
         operation,
         (err) => {
-          if (err instanceof GPUValidationError) return PromiseReject(err);
+          if (ObjectPrototypeIsPrototypeOf.prototype(GPUValidationError, err)) {
+            return PromiseReject(err);
+          }
           return PromiseResolve();
         },
       );
@@ -728,7 +740,9 @@
       );
       const oomScope = oomStack[oomStack.length - 1];
       const oomFilteredPromise = PromisePrototypeCatch(operation, (err) => {
-        if (err instanceof GPUOutOfMemoryError) return PromiseReject(err);
+        if (ObjectPrototypeIsPrototypeOf(GPUOutOfMemoryErrorPrototype, err)) {
+          return PromiseReject(err);
+        }
         return PromiseResolve();
       });
       if (oomScope) {
@@ -784,15 +798,15 @@
     }
 
     get features() {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       return this[_device].features;
     }
     get limits() {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       return this[_device].limits;
     }
     get queue() {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       return this[_queue];
     }
 
@@ -802,7 +816,7 @@
     }
 
     destroy() {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       this[_cleanup]();
     }
 
@@ -811,7 +825,7 @@
      * @returns {GPUBuffer}
      */
     createBuffer(descriptor) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createBuffer' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       descriptor = webidl.converters.GPUBufferDescriptor(descriptor, {
@@ -858,7 +872,7 @@
      * @returns {GPUTexture}
      */
     createTexture(descriptor) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createTexture' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       descriptor = webidl.converters.GPUTextureDescriptor(descriptor, {
@@ -887,7 +901,7 @@
      * @returns {GPUSampler}
      */
     createSampler(descriptor = {}) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createSampler' on 'GPUDevice'";
       descriptor = webidl.converters.GPUSamplerDescriptor(descriptor, {
         prefix,
@@ -914,7 +928,7 @@
      * @returns {GPUBindGroupLayout}
      */
     createBindGroupLayout(descriptor) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createBindGroupLayout' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       descriptor = webidl.converters.GPUBindGroupLayoutDescriptor(descriptor, {
@@ -957,7 +971,7 @@
      * @returns {GPUPipelineLayout}
      */
     createPipelineLayout(descriptor) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createPipelineLayout' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       descriptor = webidl.converters.GPUPipelineLayoutDescriptor(descriptor, {
@@ -999,7 +1013,7 @@
      * @returns {GPUBindGroup}
      */
     createBindGroup(descriptor) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createBindGroup' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       descriptor = webidl.converters.GPUBindGroupDescriptor(descriptor, {
@@ -1019,7 +1033,7 @@
       const entries = ArrayPrototypeMap(descriptor.entries, (entry, i) => {
         const context = `entry ${i + 1}`;
         const resource = entry.resource;
-        if (resource instanceof GPUSampler) {
+        if (ObjectPrototypeIsPrototypeOf(GPUSamplerPrototype, resource)) {
           const rid = assertResource(resource, {
             prefix,
             context,
@@ -1034,7 +1048,9 @@
             kind: "GPUSampler",
             resource: rid,
           };
-        } else if (resource instanceof GPUTextureView) {
+        } else if (
+          ObjectPrototypeIsPrototypeOf(GPUTextureViewPrototype, resource)
+        ) {
           const rid = assertResource(resource, {
             prefix,
             context,
@@ -1091,7 +1107,7 @@
      * @param {GPUShaderModuleDescriptor} descriptor
      */
     createShaderModule(descriptor) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createShaderModule' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       descriptor = webidl.converters.GPUShaderModuleDescriptor(descriptor, {
@@ -1124,7 +1140,7 @@
      * @returns {GPUComputePipeline}
      */
     createComputePipeline(descriptor) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createComputePipeline' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       descriptor = webidl.converters.GPUComputePipelineDescriptor(descriptor, {
@@ -1181,7 +1197,7 @@
      * @returns {GPURenderPipeline}
      */
     createRenderPipeline(descriptor) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createRenderPipeline' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       descriptor = webidl.converters.GPURenderPipelineDescriptor(descriptor, {
@@ -1266,7 +1282,7 @@
      * @returns {GPUCommandEncoder}
      */
     createCommandEncoder(descriptor = {}) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createCommandEncoder' on 'GPUDevice'";
       descriptor = webidl.converters.GPUCommandEncoderDescriptor(descriptor, {
         prefix,
@@ -1293,7 +1309,7 @@
      * @returns {GPURenderBundleEncoder}
      */
     createRenderBundleEncoder(descriptor) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix =
         "Failed to execute 'createRenderBundleEncoder' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -1328,7 +1344,7 @@
      * @returns {GPUQuerySet}
      */
     createQuerySet(descriptor) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'createQuerySet' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       descriptor = webidl.converters.GPUQuerySetDescriptor(
@@ -1356,7 +1372,7 @@
     }
 
     get lost() {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const device = this[_device];
       if (!device) {
         return PromiseResolve(true);
@@ -1371,7 +1387,7 @@
      * @param {GPUErrorFilter} filter
      */
     pushErrorScope(filter) {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'pushErrorScope' on 'GPUDevice'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       filter = webidl.converters.GPUErrorFilter(filter, {
@@ -1387,7 +1403,7 @@
      */
     // deno-lint-ignore require-await
     async popErrorScope() {
-      webidl.assertBranded(this, GPUDevice);
+      webidl.assertBranded(this, GPUDevicePrototype);
       const prefix = "Failed to execute 'popErrorScope' on 'GPUDevice'";
       const device = assertDevice(this, { prefix, context: "this" });
       if (device.isLost) {
@@ -1420,6 +1436,7 @@
     }
   }
   GPUObjectBaseMixin("GPUDevice", GPUDevice);
+  const GPUDevicePrototype = GPUDevice.prototype;
 
   /**
    * @param {string | null} label
@@ -1446,7 +1463,7 @@
      * @param {GPUCommandBuffer[]} commandBuffers
      */
     submit(commandBuffers) {
-      webidl.assertBranded(this, GPUQueue);
+      webidl.assertBranded(this, GPUQueue.prototype);
       const prefix = "Failed to execute 'submit' on 'GPUQueue'";
       webidl.requiredArguments(arguments.length, 1, {
         prefix,
@@ -1477,7 +1494,7 @@
     }
 
     onSubmittedWorkDone() {
-      webidl.assertBranded(this, GPUQueue);
+      webidl.assertBranded(this, GPUQueue.prototype);
       return PromiseResolve();
     }
 
@@ -1489,7 +1506,7 @@
      * @param {number} [size]
      */
     writeBuffer(buffer, bufferOffset, data, dataOffset = 0, size) {
-      webidl.assertBranded(this, GPUQueue);
+      webidl.assertBranded(this, GPUQueue.prototype);
       const prefix = "Failed to execute 'writeBuffer' on 'GPUQueue'";
       webidl.requiredArguments(arguments.length, 3, { prefix });
       buffer = webidl.converters["GPUBuffer"](buffer, {
@@ -1545,7 +1562,7 @@
      * @param {GPUExtent3D} size
      */
     writeTexture(destination, data, dataLayout, size) {
-      webidl.assertBranded(this, GPUQueue);
+      webidl.assertBranded(this, GPUQueue.prototype);
       const prefix = "Failed to execute 'writeTexture' on 'GPUQueue'";
       webidl.requiredArguments(arguments.length, 4, { prefix });
       destination = webidl.converters.GPUImageCopyTexture(destination, {
@@ -1702,7 +1719,7 @@
      * @param {number} [size]
      */
     async mapAsync(mode, offset = 0, size) {
-      webidl.assertBranded(this, GPUBuffer);
+      webidl.assertBranded(this, GPUBuffer.prototype);
       const prefix = "Failed to execute 'mapAsync' on 'GPUBuffer'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       mode = webidl.converters.GPUMapModeFlags(mode, {
@@ -1804,7 +1821,7 @@
      * @param {number} size
      */
     getMappedRange(offset = 0, size) {
-      webidl.assertBranded(this, GPUBuffer);
+      webidl.assertBranded(this, GPUBuffer.prototype);
       const prefix = "Failed to execute 'getMappedRange' on 'GPUBuffer'";
       offset = webidl.converters.GPUSize64(offset, {
         prefix,
@@ -1861,7 +1878,7 @@
     }
 
     unmap() {
-      webidl.assertBranded(this, GPUBuffer);
+      webidl.assertBranded(this, GPUBuffer.prototype);
       const prefix = "Failed to execute 'unmap' on 'GPUBuffer'";
       const device = assertDevice(this, { prefix, context: "this" });
       const bufferRid = assertResource(this, { prefix, context: "this" });
@@ -1917,7 +1934,7 @@
     }
 
     destroy() {
-      webidl.assertBranded(this, GPUBuffer);
+      webidl.assertBranded(this, GPUBuffer.prototype);
       this[_cleanup]();
     }
 
@@ -2031,7 +2048,7 @@
      * @param {GPUTextureViewDescriptor} descriptor
      */
     createView(descriptor = {}) {
-      webidl.assertBranded(this, GPUTexture);
+      webidl.assertBranded(this, GPUTexture.prototype);
       const prefix = "Failed to execute 'createView' on 'GPUTexture'";
       webidl.requiredArguments(arguments.length, 0, { prefix });
       descriptor = webidl.converters.GPUTextureViewDescriptor(descriptor, {
@@ -2056,7 +2073,7 @@
     }
 
     destroy() {
-      webidl.assertBranded(this, GPUTexture);
+      webidl.assertBranded(this, GPUTexture.prototype);
       this[_cleanup]();
     }
 
@@ -2136,7 +2153,7 @@
     }
   }
   GPUObjectBaseMixin("GPUTextureView", GPUTextureView);
-
+  const GPUTextureViewPrototype = GPUTextureView.prototype;
   /**
    * @param {string | null} label
    * @param {InnerGPUDevice} device
@@ -2179,7 +2196,7 @@
     }
   }
   GPUObjectBaseMixin("GPUSampler", GPUSampler);
-
+  const GPUSamplerPrototype = GPUSampler.prototype;
   /**
    * @param {string | null} label
    * @param {InnerGPUDevice} device
@@ -2412,7 +2429,7 @@
      * @returns {GPUBindGroupLayout}
      */
     getBindGroupLayout(index) {
-      webidl.assertBranded(this, GPUComputePipeline);
+      webidl.assertBranded(this, GPUComputePipelinePrototype);
       const prefix =
         "Failed to execute 'getBindGroupLayout' on 'GPUComputePipeline'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -2449,6 +2466,7 @@
     }
   }
   GPUObjectBaseMixin("GPUComputePipeline", GPUComputePipeline);
+  const GPUComputePipelinePrototype = GPUComputePipeline.prototype;
 
   /**
    * @param {string | null} label
@@ -2487,7 +2505,7 @@
      * @param {number} index
      */
     getBindGroupLayout(index) {
-      webidl.assertBranded(this, GPURenderPipeline);
+      webidl.assertBranded(this, GPURenderPipelinePrototype);
       const prefix =
         "Failed to execute 'getBindGroupLayout' on 'GPURenderPipeline'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -2524,6 +2542,7 @@
     }
   }
   GPUObjectBaseMixin("GPURenderPipeline", GPURenderPipeline);
+  const GPURenderPipelinePrototype = GPURenderPipeline.prototype;
 
   class GPUColorWrite {
     constructor() {
@@ -2597,7 +2616,7 @@
      * @return {GPURenderPassEncoder}
      */
     beginRenderPass(descriptor) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix =
         "Failed to execute 'beginRenderPass' on 'GPUCommandEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -2747,7 +2766,7 @@
      * @param {GPUComputePassDescriptor} descriptor
      */
     beginComputePass(descriptor = {}) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix =
         "Failed to execute 'beginComputePass' on 'GPUCommandEncoder'";
       descriptor = webidl.converters.GPUComputePassDescriptor(descriptor, {
@@ -2792,7 +2811,7 @@
       destinationOffset,
       size,
     ) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix =
         "Failed to execute 'copyBufferToBuffer' on 'GPUCommandEncoder'";
       webidl.requiredArguments(arguments.length, 5, { prefix });
@@ -2860,7 +2879,7 @@
      * @param {GPUExtent3D} copySize
      */
     copyBufferToTexture(source, destination, copySize) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix =
         "Failed to execute 'copyBufferToTexture' on 'GPUCommandEncoder'";
       webidl.requiredArguments(arguments.length, 3, { prefix });
@@ -2928,7 +2947,7 @@
      * @param {GPUExtent3D} copySize
      */
     copyTextureToBuffer(source, destination, copySize) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix =
         "Failed to execute 'copyTextureToBuffer' on 'GPUCommandEncoder'";
       webidl.requiredArguments(arguments.length, 3, { prefix });
@@ -2995,7 +3014,7 @@
      * @param {GPUExtent3D} copySize
      */
     copyTextureToTexture(source, destination, copySize) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix =
         "Failed to execute 'copyTextureToTexture' on 'GPUCommandEncoder'";
       webidl.requiredArguments(arguments.length, 3, { prefix });
@@ -3066,7 +3085,7 @@
      * @param {GPUSize64} size
      */
     clearBuffer(destination, destinationOffset, size) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix = "Failed to execute 'clearBuffer' on 'GPUCommandEncoder'";
       webidl.requiredArguments(arguments.length, 3, { prefix });
       destination = webidl.converters.GPUBuffer(destination, {
@@ -3106,7 +3125,7 @@
      * @param {string} groupLabel
      */
     pushDebugGroup(groupLabel) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix =
         "Failed to execute 'pushDebugGroup' on 'GPUCommandEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -3130,7 +3149,7 @@
     }
 
     popDebugGroup() {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix = "Failed to execute 'popDebugGroup' on 'GPUCommandEncoder'";
       const device = assertDevice(this, { prefix, context: "this" });
       const commandEncoderRid = assertResource(this, {
@@ -3150,7 +3169,7 @@
      * @param {string} markerLabel
      */
     insertDebugMarker(markerLabel) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix =
         "Failed to execute 'insertDebugMarker' on 'GPUCommandEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -3178,7 +3197,7 @@
      * @param {number} queryIndex
      */
     writeTimestamp(querySet, queryIndex) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix =
         "Failed to execute 'writeTimestamp' on 'GPUCommandEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -3229,7 +3248,7 @@
       destination,
       destinationOffset,
     ) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix =
         "Failed to execute 'resolveQuerySet' on 'GPUCommandEncoder'";
       webidl.requiredArguments(arguments.length, 5, { prefix });
@@ -3295,7 +3314,7 @@
      * @returns {GPUCommandBuffer}
      */
     finish(descriptor = {}) {
-      webidl.assertBranded(this, GPUCommandEncoder);
+      webidl.assertBranded(this, GPUCommandEncoderPrototype);
       const prefix = "Failed to execute 'finish' on 'GPUCommandEncoder'";
       descriptor = webidl.converters.GPUCommandBufferDescriptor(descriptor, {
         prefix,
@@ -3332,6 +3351,7 @@
     }
   }
   GPUObjectBaseMixin("GPUCommandEncoder", GPUCommandEncoder);
+  const GPUCommandEncoderPrototype = GPUCommandEncoder.prototype;
 
   const _encoder = Symbol("[[encoder]]");
 
@@ -3378,7 +3398,7 @@
      * @param {number} maxDepth
      */
     setViewport(x, y, width, height, minDepth, maxDepth) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'setViewport' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 6, { prefix });
@@ -3424,7 +3444,7 @@
      * @param {number} height
      */
     setScissorRect(x, y, width, height) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'setScissorRect' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 4, { prefix });
@@ -3466,7 +3486,7 @@
      * @param {GPUColor} color
      */
     setBlendConstant(color) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'setBlendConstant' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -3493,7 +3513,7 @@
      * @param {number} reference
      */
     setStencilReference(reference) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'setStencilReference' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -3529,7 +3549,7 @@
      * @param {number} queryIndex
      */
     beginPipelineStatisticsQuery(querySet, queryIndex) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'beginPipelineStatisticsQuery' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -3567,7 +3587,7 @@
     }
 
     endPipelineStatisticsQuery() {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'endPipelineStatisticsQuery' on 'GPURenderPassEncoder'";
       assertDevice(this[_encoder], {
@@ -3589,7 +3609,7 @@
      * @param {number} queryIndex
      */
     writeTimestamp(querySet, queryIndex) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'writeTimestamp' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -3630,7 +3650,7 @@
      * @param {GPURenderBundle[]} bundles
      */
     executeBundles(bundles) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'executeBundles' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -3664,7 +3684,7 @@
     }
 
     endPass() {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix = "Failed to execute 'endPass' on 'GPURenderPassEncoder'";
       const device = assertDevice(this[_encoder], {
         prefix,
@@ -3691,7 +3711,7 @@
       dynamicOffsetsDataStart,
       dynamicOffsetsDataLength,
     ) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'setBindGroup' on 'GPURenderPassEncoder'";
       const device = assertDevice(this[_encoder], {
@@ -3712,7 +3732,12 @@
         resourceContext: "Argument 2",
         selfContext: "this",
       });
-      if (!(dynamicOffsetsData instanceof Uint32Array)) {
+      if (
+        !(ObjectPrototypeIsPrototypeOf(
+          Uint32ArrayPrototype,
+          dynamicOffsetsData,
+        ))
+      ) {
         dynamicOffsetsData = new Uint32Array(dynamicOffsetsData ?? []);
         dynamicOffsetsDataStart = 0;
         dynamicOffsetsDataLength = dynamicOffsetsData.length;
@@ -3731,7 +3756,7 @@
      * @param {string} groupLabel
      */
     pushDebugGroup(groupLabel) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'pushDebugGroup' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -3755,7 +3780,7 @@
     }
 
     popDebugGroup() {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'popDebugGroup' on 'GPURenderPassEncoder'";
       assertDevice(this[_encoder], {
@@ -3776,7 +3801,7 @@
      * @param {string} markerLabel
      */
     insertDebugMarker(markerLabel) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'insertDebugMarker' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -3803,7 +3828,7 @@
      * @param {GPURenderPipeline} pipeline
      */
     setPipeline(pipeline) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'setPipeline' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -3842,7 +3867,7 @@
      * @param {number} size
      */
     setIndexBuffer(buffer, indexFormat, offset = 0, size) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'setIndexBuffer' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -3898,7 +3923,7 @@
      * @param {number} size
      */
     setVertexBuffer(slot, buffer, offset = 0, size) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'setVertexBuffer' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -3954,7 +3979,7 @@
      * @param {number} firstInstance
      */
     draw(vertexCount, instanceCount = 1, firstVertex = 0, firstInstance = 0) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix = "Failed to execute 'draw' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       vertexCount = webidl.converters.GPUSize32(vertexCount, {
@@ -4005,7 +4030,7 @@
       baseVertex = 0,
       firstInstance = 0,
     ) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'drawIndexed' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4053,7 +4078,7 @@
      * @param {number} indirectOffset
      */
     drawIndirect(indirectBuffer, indirectOffset) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'drawIndirect' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -4095,7 +4120,7 @@
      * @param {number} indirectOffset
      */
     drawIndexedIndirect(indirectBuffer, indirectOffset) {
-      webidl.assertBranded(this, GPURenderPassEncoder);
+      webidl.assertBranded(this, GPURenderPassEncoderPrototype);
       const prefix =
         "Failed to execute 'drawIndirect' on 'GPURenderPassEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -4141,6 +4166,7 @@
     }
   }
   GPUObjectBaseMixin("GPURenderPassEncoder", GPURenderPassEncoder);
+  const GPURenderPassEncoderPrototype = GPURenderPassEncoder.prototype;
 
   /**
    * @param {string | null} label
@@ -4181,7 +4207,7 @@
      * @param {GPUComputePipeline} pipeline
      */
     setPipeline(pipeline) {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix =
         "Failed to execute 'setPipeline' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4219,7 +4245,7 @@
      * @param {number} z
      */
     dispatch(x, y = 1, z = 1) {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix = "Failed to execute 'dispatch' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       x = webidl.converters.GPUSize32(x, { prefix, context: "Argument 1" });
@@ -4247,7 +4273,7 @@
      * @param {number} indirectOffset
      */
     dispatchIndirect(indirectBuffer, indirectOffset) {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix =
         "Failed to execute 'dispatchIndirect' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -4289,7 +4315,7 @@
      * @param {number} queryIndex
      */
     beginPipelineStatisticsQuery(querySet, queryIndex) {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix =
         "Failed to execute 'beginPipelineStatisticsQuery' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -4330,7 +4356,7 @@
     }
 
     endPipelineStatisticsQuery() {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix =
         "Failed to execute 'endPipelineStatisticsQuery' on 'GPUComputePassEncoder'";
       assertDevice(this[_encoder], {
@@ -4352,7 +4378,7 @@
      * @param {number} queryIndex
      */
     writeTimestamp(querySet, queryIndex) {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix =
         "Failed to execute 'writeTimestamp' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -4390,7 +4416,7 @@
     }
 
     endPass() {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix = "Failed to execute 'endPass' on 'GPUComputePassEncoder'";
       const device = assertDevice(this[_encoder], {
         prefix,
@@ -4417,7 +4443,7 @@
       dynamicOffsetsDataStart,
       dynamicOffsetsDataLength,
     ) {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix =
         "Failed to execute 'setBindGroup' on 'GPUComputePassEncoder'";
       const device = assertDevice(this[_encoder], {
@@ -4438,7 +4464,12 @@
         resourceContext: "Argument 2",
         selfContext: "this",
       });
-      if (!(dynamicOffsetsData instanceof Uint32Array)) {
+      if (
+        !(ObjectPrototypeIsPrototypeOf(
+          Uint32ArrayPrototype,
+          dynamicOffsetsData,
+        ))
+      ) {
         dynamicOffsetsData = new Uint32Array(dynamicOffsetsData ?? []);
         dynamicOffsetsDataStart = 0;
         dynamicOffsetsDataLength = dynamicOffsetsData.length;
@@ -4457,7 +4488,7 @@
      * @param {string} groupLabel
      */
     pushDebugGroup(groupLabel) {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix =
         "Failed to execute 'pushDebugGroup' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4481,7 +4512,7 @@
     }
 
     popDebugGroup() {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix =
         "Failed to execute 'popDebugGroup' on 'GPUComputePassEncoder'";
       assertDevice(this[_encoder], {
@@ -4502,7 +4533,7 @@
      * @param {string} markerLabel
      */
     insertDebugMarker(markerLabel) {
-      webidl.assertBranded(this, GPUComputePassEncoder);
+      webidl.assertBranded(this, GPUComputePassEncoderPrototype);
       const prefix =
         "Failed to execute 'insertDebugMarker' on 'GPUComputePassEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4534,6 +4565,7 @@
     }
   }
   GPUObjectBaseMixin("GPUComputePassEncoder", GPUComputePassEncoder);
+  const GPUComputePassEncoderPrototype = GPUComputePassEncoder.prototype;
 
   /**
    * @param {string | null} label
@@ -4617,7 +4649,7 @@
      * @param {GPURenderBundleDescriptor} descriptor
      */
     finish(descriptor = {}) {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix = "Failed to execute 'finish' on 'GPURenderBundleEncoder'";
       descriptor = webidl.converters.GPURenderBundleDescriptor(descriptor, {
         prefix,
@@ -4655,7 +4687,7 @@
       dynamicOffsetsDataStart,
       dynamicOffsetsDataLength,
     ) {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix =
         "Failed to execute 'setBindGroup' on 'GPURenderBundleEncoder'";
       const device = assertDevice(this, { prefix, context: "this" });
@@ -4672,7 +4704,12 @@
         resourceContext: "Argument 2",
         selfContext: "this",
       });
-      if (!(dynamicOffsetsData instanceof Uint32Array)) {
+      if (
+        !(ObjectPrototypeIsPrototypeOf(
+          Uint32ArrayPrototype,
+          dynamicOffsetsData,
+        ))
+      ) {
         dynamicOffsetsData = new Uint32Array(dynamicOffsetsData ?? []);
         dynamicOffsetsDataStart = 0;
         dynamicOffsetsDataLength = dynamicOffsetsData.length;
@@ -4691,7 +4728,7 @@
      * @param {string} groupLabel
      */
     pushDebugGroup(groupLabel) {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix =
         "Failed to execute 'pushDebugGroup' on 'GPURenderBundleEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4711,7 +4748,7 @@
     }
 
     popDebugGroup() {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix =
         "Failed to execute 'popDebugGroup' on 'GPURenderBundleEncoder'";
       assertDevice(this, { prefix, context: "this" });
@@ -4728,7 +4765,7 @@
      * @param {string} markerLabel
      */
     insertDebugMarker(markerLabel) {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix =
         "Failed to execute 'insertDebugMarker' on 'GPURenderBundleEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4751,7 +4788,7 @@
      * @param {GPURenderPipeline} pipeline
      */
     setPipeline(pipeline) {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix =
         "Failed to execute 'setPipeline' on 'GPURenderBundleEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4786,7 +4823,7 @@
      * @param {number} size
      */
     setIndexBuffer(buffer, indexFormat, offset = 0, size = 0) {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix =
         "Failed to execute 'setIndexBuffer' on 'GPURenderBundleEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -4836,7 +4873,7 @@
      * @param {number} size
      */
     setVertexBuffer(slot, buffer, offset = 0, size = 0) {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix =
         "Failed to execute 'setVertexBuffer' on 'GPURenderBundleEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -4886,7 +4923,7 @@
      * @param {number} firstInstance
      */
     draw(vertexCount, instanceCount = 1, firstVertex = 0, firstInstance = 0) {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix = "Failed to execute 'draw' on 'GPURenderBundleEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       vertexCount = webidl.converters.GPUSize32(vertexCount, {
@@ -4933,7 +4970,7 @@
       baseVertex = 0,
       firstInstance = 0,
     ) {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix =
         "Failed to execute 'drawIndexed' on 'GPURenderBundleEncoder'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
@@ -4977,7 +5014,7 @@
      * @param {number} indirectOffset
      */
     drawIndirect(indirectBuffer, indirectOffset) {
-      webidl.assertBranded(this, GPURenderBundleEncoder);
+      webidl.assertBranded(this, GPURenderBundleEncoder.prototype);
       const prefix =
         "Failed to execute 'drawIndirect' on 'GPURenderBundleEncoder'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
@@ -5108,7 +5145,7 @@
     }
 
     destroy() {
-      webidl.assertBranded(this, GPUQuerySet);
+      webidl.assertBranded(this, GPUQuerySetPrototype);
       this[_cleanup]();
     }
 
@@ -5121,6 +5158,7 @@
     }
   }
   GPUObjectBaseMixin("GPUQuerySet", GPUQuerySet);
+  const GPUQuerySetPrototype = GPUQuerySet.prototype;
 
   window.__bootstrap.webgpu = {
     gpu: webidl.createBranded(GPU),
diff --git a/ext/webgpu/02_idl_types.js b/ext/webgpu/02_idl_types.js
index bc92bebab0..dd19f40271 100644
--- a/ext/webgpu/02_idl_types.js
+++ b/ext/webgpu/02_idl_types.js
@@ -56,13 +56,13 @@
   // INTERFACE: GPUSupportedLimits
   webidl.converters.GPUSupportedLimits = webidl.createInterfaceConverter(
     "GPUSupportedLimits",
-    GPUSupportedLimits,
+    GPUSupportedLimits.prototype,
   );
 
   // INTERFACE: GPUSupportedFeatures
   webidl.converters.GPUSupportedFeatures = webidl.createInterfaceConverter(
     "GPUSupportedFeatures",
-    GPUSupportedFeatures,
+    GPUSupportedFeatures.prototype,
   );
 
   // ENUM: GPUPredefinedColorSpace
@@ -72,7 +72,7 @@
   );
 
   // INTERFACE: GPU
-  webidl.converters.GPU = webidl.createInterfaceConverter("GPU", GPU);
+  webidl.converters.GPU = webidl.createInterfaceConverter("GPU", GPU.prototype);
 
   // ENUM: GPUPowerPreference
   webidl.converters["GPUPowerPreference"] = webidl.createEnumConverter(
@@ -104,7 +104,7 @@
   // INTERFACE: GPUAdapter
   webidl.converters.GPUAdapter = webidl.createInterfaceConverter(
     "GPUAdapter",
-    GPUAdapter,
+    GPUAdapter.prototype,
   );
 
   // ENUM: GPUFeatureName
@@ -178,13 +178,13 @@
   // INTERFACE: GPUDevice
   webidl.converters.GPUDevice = webidl.createInterfaceConverter(
     "GPUDevice",
-    GPUDevice,
+    GPUDevice.prototype,
   );
 
   // INTERFACE: GPUBuffer
   webidl.converters.GPUBuffer = webidl.createInterfaceConverter(
     "GPUBuffer",
-    GPUBuffer,
+    GPUBuffer.prototype,
   );
 
   // TYPEDEF: GPUSize64
@@ -218,7 +218,7 @@
   // INTERFACE: GPUBufferUsage
   webidl.converters.GPUBufferUsage = webidl.createInterfaceConverter(
     "GPUBufferUsage",
-    GPUBufferUsage,
+    GPUBufferUsage.prototype,
   );
 
   // TYPEDEF: GPUMapModeFlags
@@ -228,13 +228,13 @@
   // INTERFACE: GPUMapMode
   webidl.converters.GPUMapMode = webidl.createInterfaceConverter(
     "GPUMapMode",
-    GPUMapMode,
+    GPUMapMode.prototype,
   );
 
   // INTERFACE: GPUTexture
   webidl.converters.GPUTexture = webidl.createInterfaceConverter(
     "GPUTexture",
-    GPUTexture,
+    GPUTexture.prototype,
   );
 
   // TYPEDEF: GPUIntegerCoordinate
@@ -444,13 +444,13 @@
   // INTERFACE: GPUTextureUsage
   webidl.converters.GPUTextureUsage = webidl.createInterfaceConverter(
     "GPUTextureUsage",
-    GPUTextureUsage,
+    GPUTextureUsage.prototype,
   );
 
   // INTERFACE: GPUTextureView
   webidl.converters.GPUTextureView = webidl.createInterfaceConverter(
     "GPUTextureView",
-    GPUTextureView,
+    GPUTextureView.prototype,
   );
 
   // ENUM: GPUTextureViewDimension
@@ -517,7 +517,7 @@
   // INTERFACE: GPUSampler
   webidl.converters.GPUSampler = webidl.createInterfaceConverter(
     "GPUSampler",
-    GPUSampler,
+    GPUSampler.prototype,
   );
 
   // ENUM: GPUAddressMode
@@ -613,7 +613,7 @@
   // INTERFACE: GPUBindGroupLayout
   webidl.converters.GPUBindGroupLayout = webidl.createInterfaceConverter(
     "GPUBindGroupLayout",
-    GPUBindGroupLayout,
+    GPUBindGroupLayout.prototype,
   );
 
   // TYPEDEF: GPUIndex32
@@ -796,13 +796,13 @@
   // INTERFACE: GPUShaderStage
   webidl.converters.GPUShaderStage = webidl.createInterfaceConverter(
     "GPUShaderStage",
-    GPUShaderStage,
+    GPUShaderStage.prototype,
   );
 
   // INTERFACE: GPUBindGroup
   webidl.converters.GPUBindGroup = webidl.createInterfaceConverter(
     "GPUBindGroup",
-    GPUBindGroup,
+    GPUBindGroup.prototype,
   );
 
   // DICTIONARY: GPUBufferBinding
@@ -871,7 +871,7 @@
   // INTERFACE: GPUPipelineLayout
   webidl.converters.GPUPipelineLayout = webidl.createInterfaceConverter(
     "GPUPipelineLayout",
-    GPUPipelineLayout,
+    GPUPipelineLayout.prototype,
   );
 
   // DICTIONARY: GPUPipelineLayoutDescriptor
@@ -894,7 +894,7 @@
   // INTERFACE: GPUShaderModule
   webidl.converters.GPUShaderModule = webidl.createInterfaceConverter(
     "GPUShaderModule",
-    GPUShaderModule,
+    GPUShaderModule.prototype,
   );
 
   // DICTIONARY: GPUShaderModuleDescriptor
@@ -926,13 +926,13 @@
   // // INTERFACE: GPUCompilationMessage
   // webidl.converters.GPUCompilationMessage = webidl.createInterfaceConverter(
   //   "GPUCompilationMessage",
-  //   GPUCompilationMessage,
+  //   GPUCompilationMessage.prototype,
   // );
 
   // // INTERFACE: GPUCompilationInfo
   // webidl.converters.GPUCompilationInfo = webidl.createInterfaceConverter(
   //   "GPUCompilationInfo",
-  //   GPUCompilationInfo,
+  //   GPUCompilationInfo.prototype,
   // );
 
   // DICTIONARY: GPUPipelineDescriptorBase
@@ -981,7 +981,7 @@
   // INTERFACE: GPUComputePipeline
   webidl.converters.GPUComputePipeline = webidl.createInterfaceConverter(
     "GPUComputePipeline",
-    GPUComputePipeline,
+    GPUComputePipeline.prototype,
   );
 
   // DICTIONARY: GPUComputePipelineDescriptor
@@ -1003,7 +1003,7 @@
   // INTERFACE: GPURenderPipeline
   webidl.converters.GPURenderPipeline = webidl.createInterfaceConverter(
     "GPURenderPipeline",
-    GPURenderPipeline,
+    GPURenderPipeline.prototype,
   );
 
   // ENUM: GPUVertexStepMode
@@ -1476,13 +1476,13 @@
   // INTERFACE: GPUColorWrite
   webidl.converters.GPUColorWrite = webidl.createInterfaceConverter(
     "GPUColorWrite",
-    GPUColorWrite,
+    GPUColorWrite.prototype,
   );
 
   // INTERFACE: GPUCommandBuffer
   webidl.converters.GPUCommandBuffer = webidl.createInterfaceConverter(
     "GPUCommandBuffer",
-    GPUCommandBuffer,
+    GPUCommandBuffer.prototype,
   );
   webidl.converters["sequence<GPUCommandBuffer>"] = webidl
     .createSequenceConverter(webidl.converters["GPUCommandBuffer"]);
@@ -1499,7 +1499,7 @@
   // INTERFACE: GPUCommandEncoder
   webidl.converters.GPUCommandEncoder = webidl.createInterfaceConverter(
     "GPUCommandEncoder",
-    GPUCommandEncoder,
+    GPUCommandEncoder.prototype,
   );
 
   // DICTIONARY: GPUCommandEncoderDescriptor
@@ -1654,7 +1654,7 @@
   // INTERFACE: GPUComputePassEncoder
   webidl.converters.GPUComputePassEncoder = webidl.createInterfaceConverter(
     "GPUComputePassEncoder",
-    GPUComputePassEncoder,
+    GPUComputePassEncoder.prototype,
   );
 
   // DICTIONARY: GPUComputePassDescriptor
@@ -1669,7 +1669,7 @@
   // INTERFACE: GPURenderPassEncoder
   webidl.converters.GPURenderPassEncoder = webidl.createInterfaceConverter(
     "GPURenderPassEncoder",
-    GPURenderPassEncoder,
+    GPURenderPassEncoder.prototype,
   );
 
   // ENUM: GPULoadOp
@@ -1787,7 +1787,7 @@
   // INTERFACE: GPUQuerySet
   webidl.converters.GPUQuerySet = webidl.createInterfaceConverter(
     "GPUQuerySet",
-    GPUQuerySet,
+    GPUQuerySet.prototype,
   );
 
   // DICTIONARY: GPURenderPassDescriptor
@@ -1815,7 +1815,7 @@
   // INTERFACE: GPURenderBundle
   webidl.converters.GPURenderBundle = webidl.createInterfaceConverter(
     "GPURenderBundle",
-    GPURenderBundle,
+    GPURenderBundle.prototype,
   );
   webidl.converters["sequence<GPURenderBundle>"] = webidl
     .createSequenceConverter(webidl.converters["GPURenderBundle"]);
@@ -1832,7 +1832,7 @@
   // INTERFACE: GPURenderBundleEncoder
   webidl.converters.GPURenderBundleEncoder = webidl.createInterfaceConverter(
     "GPURenderBundleEncoder",
-    GPURenderBundleEncoder,
+    GPURenderBundleEncoder.prototype,
   );
 
   // DICTIONARY: GPURenderPassLayout
@@ -1885,7 +1885,7 @@
   // INTERFACE: GPUQueue
   webidl.converters.GPUQueue = webidl.createInterfaceConverter(
     "GPUQueue",
-    GPUQueue,
+    GPUQueue.prototype,
   );
 
   // ENUM: GPUQueryType
@@ -1945,7 +1945,7 @@
   // // INTERFACE: GPUDeviceLostInfo
   // webidl.converters.GPUDeviceLostInfo = webidl.createInterfaceConverter(
   //   "GPUDeviceLostInfo",
-  //   GPUDeviceLostInfo,
+  //   GPUDeviceLostInfo.prototype,
   // );
 
   // ENUM: GPUErrorFilter
@@ -1960,13 +1960,13 @@
   // INTERFACE: GPUOutOfMemoryError
   webidl.converters.GPUOutOfMemoryError = webidl.createInterfaceConverter(
     "GPUOutOfMemoryError",
-    GPUOutOfMemoryError,
+    GPUOutOfMemoryError.prototype,
   );
 
   // INTERFACE: GPUValidationError
   webidl.converters.GPUValidationError = webidl.createInterfaceConverter(
     "GPUValidationError",
-    GPUValidationError,
+    GPUValidationError.prototype,
   );
 
   // TYPEDEF: GPUError
@@ -1975,7 +1975,7 @@
   // // INTERFACE: GPUUncapturedErrorEvent
   // webidl.converters.GPUUncapturedErrorEvent = webidl.createInterfaceConverter(
   //   "GPUUncapturedErrorEvent",
-  //   GPUUncapturedErrorEvent,
+  //   GPUUncapturedErrorEvent.prototype,
   // );
 
   // DICTIONARY: GPUUncapturedErrorEventInit
diff --git a/ext/webidl/00_webidl.js b/ext/webidl/00_webidl.js
index 668c141cb0..de3221081b 100644
--- a/ext/webidl/00_webidl.js
+++ b/ext/webidl/00_webidl.js
@@ -11,7 +11,7 @@
 ((window) => {
   const core = window.Deno.core;
   const {
-    ArrayBuffer,
+    ArrayBufferPrototype,
     ArrayBufferIsView,
     ArrayPrototypeForEach,
     ArrayPrototypePush,
@@ -20,7 +20,6 @@
     BigInt,
     BigIntAsIntN,
     BigIntAsUintN,
-    DataView,
     Float32Array,
     Float64Array,
     FunctionPrototypeBind,
@@ -50,6 +49,7 @@
     ObjectGetOwnPropertyDescriptors,
     ObjectGetPrototypeOf,
     ObjectPrototypeHasOwnProperty,
+    ObjectPrototypeIsPrototypeOf,
     ObjectIs,
     PromisePrototypeThen,
     PromiseReject,
@@ -434,11 +434,11 @@
   }
 
   function isNonSharedArrayBuffer(V) {
-    return V instanceof ArrayBuffer;
+    return ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, V);
   }
 
   function isSharedArrayBuffer(V) {
-    return V instanceof SharedArrayBuffer;
+    return ObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype, V);
   }
 
   converters.ArrayBuffer = (V, opts = {}) => {
@@ -457,7 +457,7 @@
   };
 
   converters.DataView = (V, opts = {}) => {
-    if (!(V instanceof DataView)) {
+    if (!(ObjectPrototypeIsPrototypeOf(DataViewPrototype, V))) {
       throw makeException(TypeError, "is not a DataView", opts);
     }
 
@@ -862,7 +862,7 @@
 
   function createInterfaceConverter(name, prototype) {
     return (V, opts) => {
-      if (!(V instanceof prototype) || V[brand] !== brand) {
+      if (!ObjectPrototypeIsPrototypeOf(prototype, V) || V[brand] !== brand) {
         throw makeException(TypeError, `is not of type ${name}.`, opts);
       }
       return V;
@@ -877,7 +877,9 @@
   }
 
   function assertBranded(self, prototype) {
-    if (!(self instanceof prototype) || self[brand] !== brand) {
+    if (
+      !ObjectPrototypeIsPrototypeOf(prototype, self) || self[brand] !== brand
+    ) {
       throw new TypeError("Illegal invocation");
     }
   }
@@ -944,7 +946,7 @@
     }
 
     function entries() {
-      assertBranded(this, prototype);
+      assertBranded(this, prototype.prototype);
       return createDefaultIterator(this, "key+value");
     }
 
@@ -963,7 +965,7 @@
       },
       keys: {
         value: function keys() {
-          assertBranded(this, prototype);
+          assertBranded(this, prototype.prototype);
           return createDefaultIterator(this, "key");
         },
         writable: true,
@@ -972,7 +974,7 @@
       },
       values: {
         value: function values() {
-          assertBranded(this, prototype);
+          assertBranded(this, prototype.prototype);
           return createDefaultIterator(this, "value");
         },
         writable: true,
@@ -981,7 +983,7 @@
       },
       forEach: {
         value: function forEach(idlCallback, thisArg = undefined) {
-          assertBranded(this, prototype);
+          assertBranded(this, prototype.prototype);
           const prefix = `Failed to execute 'forEach' on '${name}'`;
           requiredArguments(arguments.length, 1, { prefix });
           idlCallback = converters["Function"](idlCallback, {
diff --git a/ext/websocket/01_websocket.js b/ext/websocket/01_websocket.js
index d04d7dab36..2c6337eef9 100644
--- a/ext/websocket/01_websocket.js
+++ b/ext/websocket/01_websocket.js
@@ -10,29 +10,31 @@
   const { HTTP_TOKEN_CODE_POINT_RE } = window.__bootstrap.infra;
   const { DOMException } = window.__bootstrap.domException;
   const { defineEventHandler } = window.__bootstrap.event;
-  const { Blob } = globalThis.__bootstrap.file;
+  const { Blob, BlobPrototype } = globalThis.__bootstrap.file;
   const {
-    ArrayBuffer,
+    ArrayBufferPrototype,
     ArrayBufferIsView,
     ArrayPrototypeJoin,
-    DataView,
-    ErrorPrototypeToString,
-    Set,
-    Symbol,
-    String,
-    StringPrototypeToLowerCase,
-    StringPrototypeEndsWith,
-    RegExpPrototypeTest,
-    ObjectDefineProperties,
     ArrayPrototypeMap,
     ArrayPrototypeSome,
+    DataView,
+    ErrorPrototypeToString,
+    ObjectDefineProperties,
+    ObjectPrototypeIsPrototypeOf,
     PromisePrototypeThen,
+    RegExpPrototypeTest,
+    Set,
+    String,
+    StringPrototypeEndsWith,
+    StringPrototypeToLowerCase,
+    Symbol,
+    SymbolIterator,
   } = window.__bootstrap.primordials;
 
   webidl.converters["sequence<DOMString> or DOMString"] = (V, opts) => {
     // Union for (sequence<DOMString> or DOMString)
     if (webidl.type(V) === "Object" && V !== null) {
-      if (V[Symbol.iterator] !== undefined) {
+      if (V[SymbolIterator] !== undefined) {
         return webidl.converters["sequence<DOMString>"](V, opts);
       }
     }
@@ -41,12 +43,15 @@
 
   webidl.converters["WebSocketSend"] = (V, opts) => {
     // Union for (Blob or ArrayBufferView or ArrayBuffer or USVString)
-    if (V instanceof Blob) {
+    if (ObjectPrototypeIsPrototypeOf(BlobPrototype, V)) {
       return webidl.converters["Blob"](V, opts);
     }
     if (typeof V === "object") {
       // TODO(littledivy): use primordial for SharedArrayBuffer
-      if (V instanceof ArrayBuffer || V instanceof SharedArrayBuffer) {
+      if (
+        ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, V) ||
+        ObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype, V)
+      ) {
         return webidl.converters["ArrayBuffer"](V, opts);
       }
       if (ArrayBufferIsView(V)) {
@@ -79,52 +84,52 @@
 
     [_readyState] = CONNECTING;
     get readyState() {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       return this[_readyState];
     }
 
     get CONNECTING() {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       return CONNECTING;
     }
     get OPEN() {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       return OPEN;
     }
     get CLOSING() {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       return CLOSING;
     }
     get CLOSED() {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       return CLOSED;
     }
 
     [_extensions] = "";
     get extensions() {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       return this[_extensions];
     }
 
     [_protocol] = "";
     get protocol() {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       return this[_protocol];
     }
 
     [_url] = "";
     get url() {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       return this[_url];
     }
 
     [_binaryType] = "blob";
     get binaryType() {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       return this[_binaryType];
     }
     set binaryType(value) {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       value = webidl.converters.DOMString(value, {
         prefix: "Failed to set 'binaryType' on 'WebSocket'",
       });
@@ -135,7 +140,7 @@
 
     [_bufferedAmount] = 0;
     get bufferedAmount() {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       return this[_bufferedAmount];
     }
 
@@ -267,7 +272,7 @@
     }
 
     send(data) {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       const prefix = "Failed to execute 'send' on 'WebSocket'";
 
       webidl.requiredArguments(arguments.length, 1, {
@@ -295,14 +300,14 @@
         );
       };
 
-      if (data instanceof Blob) {
+      if (ObjectPrototypeIsPrototypeOf(BlobPrototype, data)) {
         PromisePrototypeThen(
           data.slice().arrayBuffer(),
           (ab) => sendTypedArray(new DataView(ab)),
         );
       } else if (ArrayBufferIsView(data)) {
         sendTypedArray(data);
-      } else if (data instanceof ArrayBuffer) {
+      } else if (ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, data)) {
         sendTypedArray(new DataView(data));
       } else {
         const string = String(data);
@@ -321,7 +326,7 @@
     }
 
     close(code = undefined, reason = undefined) {
-      webidl.assertBranded(this, WebSocket);
+      webidl.assertBranded(this, WebSocketPrototype);
       const prefix = "Failed to execute 'close' on 'WebSocket'";
 
       if (code !== undefined) {
@@ -514,6 +519,7 @@
   defineEventHandler(WebSocket.prototype, "open");
 
   webidl.configurePrototype(WebSocket);
+  const WebSocketPrototype = WebSocket.prototype;
 
   window.__bootstrap.webSocket = {
     WebSocket,
diff --git a/ext/websocket/02_websocketstream.js b/ext/websocket/02_websocketstream.js
index 0a14657e9b..0f4cecaa5d 100644
--- a/ext/websocket/02_websocketstream.js
+++ b/ext/websocket/02_websocketstream.js
@@ -11,18 +11,19 @@
   const { add, remove } = window.__bootstrap.abortSignal;
 
   const {
+    ArrayPrototypeJoin,
+    ArrayPrototypeMap,
+    Error,
+    ObjectPrototypeIsPrototypeOf,
+    PromisePrototypeCatch,
+    PromisePrototypeThen,
+    Set,
     StringPrototypeEndsWith,
     StringPrototypeToLowerCase,
     Symbol,
     SymbolFor,
-    Set,
-    ArrayPrototypeMap,
-    ArrayPrototypeJoin,
-    PromisePrototypeThen,
-    PromisePrototypeCatch,
-    Uint8Array,
     TypeError,
-    Error,
+    Uint8ArrayPrototype,
   } = window.__bootstrap.primordials;
 
   webidl.converters.WebSocketStreamOptions = webidl.createDictionaryConverter(
@@ -70,7 +71,7 @@
 
     [_url];
     get url() {
-      webidl.assertBranded(this, WebSocketStream);
+      webidl.assertBranded(this, WebSocketStreamPrototype);
       return this[_url];
     }
 
@@ -195,7 +196,9 @@
                       kind: "text",
                       value: chunk,
                     });
-                  } else if (chunk instanceof Uint8Array) {
+                  } else if (
+                    ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, chunk)
+                  ) {
                     await core.opAsync("op_ws_send", this[_rid], {
                       kind: "binary",
                       value: chunk,
@@ -296,7 +299,7 @@
             }
           },
           (err) => {
-            if (err instanceof core.Interrupted) {
+            if (ObjectPrototypeIsPrototypeOf(core.InterruptedPrototype, err)) {
               // The signal was aborted.
               err = options.signal.reason;
             } else {
@@ -311,19 +314,19 @@
 
     [_connection] = new Deferred();
     get connection() {
-      webidl.assertBranded(this, WebSocketStream);
+      webidl.assertBranded(this, WebSocketStreamPrototype);
       return this[_connection].promise;
     }
 
     [_earlyClose] = false;
     [_closed] = new Deferred();
     get closed() {
-      webidl.assertBranded(this, WebSocketStream);
+      webidl.assertBranded(this, WebSocketStreamPrototype);
       return this[_closed].promise;
     }
 
     close(closeInfo) {
-      webidl.assertBranded(this, WebSocketStream);
+      webidl.assertBranded(this, WebSocketStreamPrototype);
       closeInfo = webidl.converters.WebSocketCloseInfo(closeInfo, {
         prefix: "Failed to execute 'close' on 'WebSocketStream'",
         context: "Argument 1",
@@ -381,5 +384,7 @@
     }
   }
 
+  const WebSocketStreamPrototype = WebSocketStream.prototype;
+
   window.__bootstrap.webSocket.WebSocketStream = WebSocketStream;
 })(this);
diff --git a/ext/webstorage/01_webstorage.js b/ext/webstorage/01_webstorage.js
index e71aafade9..7ed7b6618a 100644
--- a/ext/webstorage/01_webstorage.js
+++ b/ext/webstorage/01_webstorage.js
@@ -25,12 +25,12 @@
     }
 
     get length() {
-      webidl.assertBranded(this, Storage);
+      webidl.assertBranded(this, StoragePrototype);
       return core.opSync("op_webstorage_length", this[_persistent]);
     }
 
     key(index) {
-      webidl.assertBranded(this, Storage);
+      webidl.assertBranded(this, StoragePrototype);
       const prefix = "Failed to execute 'key' on 'Storage'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       index = webidl.converters["unsigned long"](index, {
@@ -42,7 +42,7 @@
     }
 
     setItem(key, value) {
-      webidl.assertBranded(this, Storage);
+      webidl.assertBranded(this, StoragePrototype);
       const prefix = "Failed to execute 'setItem' on 'Storage'";
       webidl.requiredArguments(arguments.length, 2, { prefix });
       key = webidl.converters.DOMString(key, {
@@ -61,7 +61,7 @@
     }
 
     getItem(key) {
-      webidl.assertBranded(this, Storage);
+      webidl.assertBranded(this, StoragePrototype);
       const prefix = "Failed to execute 'getItem' on 'Storage'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       key = webidl.converters.DOMString(key, {
@@ -73,7 +73,7 @@
     }
 
     removeItem(key) {
-      webidl.assertBranded(this, Storage);
+      webidl.assertBranded(this, StoragePrototype);
       const prefix = "Failed to execute 'removeItem' on 'Storage'";
       webidl.requiredArguments(arguments.length, 1, { prefix });
       key = webidl.converters.DOMString(key, {
@@ -85,11 +85,13 @@
     }
 
     clear() {
-      webidl.assertBranded(this, Storage);
+      webidl.assertBranded(this, StoragePrototype);
       core.opSync("op_webstorage_clear", this[_persistent]);
     }
   }
 
+  const StoragePrototype = Storage.prototype;
+
   function createStorage(persistent) {
     const storage = webidl.createBranded(Storage);
     storage[_persistent] = persistent;
diff --git a/runtime/js/06_util.js b/runtime/js/06_util.js
index 9b255615ee..e934c4f0e9 100644
--- a/runtime/js/06_util.js
+++ b/runtime/js/06_util.js
@@ -3,14 +3,15 @@
 
 ((window) => {
   const {
-    StringPrototypeReplace,
-    TypeError,
-    Promise,
     decodeURIComponent,
     Error,
+    ObjectPrototypeIsPrototypeOf,
+    Promise,
+    StringPrototypeReplace,
+    TypeError,
   } = window.__bootstrap.primordials;
   const { build } = window.__bootstrap.build;
-  const { URL } = window.__bootstrap.url;
+  const { URLPrototype } = window.__bootstrap.url;
   let logDebug = false;
   let logSource = "JS";
 
@@ -93,7 +94,7 @@
   }
 
   function pathFromURL(pathOrUrl) {
-    if (pathOrUrl instanceof URL) {
+    if (ObjectPrototypeIsPrototypeOf(URLPrototype, pathOrUrl)) {
       if (pathOrUrl.protocol != "file:") {
         throw new TypeError("Must be a file URL.");
       }
diff --git a/runtime/js/11_workers.js b/runtime/js/11_workers.js
index 4510004d69..80e85a3a15 100644
--- a/runtime/js/11_workers.js
+++ b/runtime/js/11_workers.js
@@ -5,6 +5,7 @@
   const core = window.Deno.core;
   const {
     Error,
+    ObjectPrototypeIsPrototypeOf,
     StringPrototypeStartsWith,
     String,
     SymbolIterator,
@@ -16,8 +17,11 @@
   const { serializePermissions } = window.__bootstrap.permissions;
   const { log } = window.__bootstrap.util;
   const { defineEventHandler } = window.__bootstrap.event;
-  const { deserializeJsMessageData, serializeJsMessageData } =
-    window.__bootstrap.messagePort;
+  const {
+    deserializeJsMessageData,
+    serializeJsMessageData,
+    MessagePortPrototype,
+  } = window.__bootstrap.messagePort;
 
   function createWorker(
     specifier,
@@ -199,7 +203,9 @@
         const event = new MessageEvent("message", {
           cancelable: false,
           data: message,
-          ports: transferables.filter((t) => t instanceof MessagePort),
+          ports: transferables.filter((t) =>
+            ObjectPrototypeIsPrototypeOf(MessagePortPrototype, t)
+          ),
         });
         this.dispatchEvent(event);
       }
diff --git a/runtime/js/30_fs.js b/runtime/js/30_fs.js
index bdd575f19f..51f2c411e2 100644
--- a/runtime/js/30_fs.js
+++ b/runtime/js/30_fs.js
@@ -5,7 +5,9 @@
   const core = window.Deno.core;
   const {
     Date,
+    DatePrototype,
     MathTrunc,
+    ObjectPrototypeIsPrototypeOf,
     SymbolAsyncIterator,
     SymbolIterator,
   } = window.__bootstrap.primordials;
@@ -277,7 +279,7 @@
   }
 
   function toUnixTimeFromEpoch(value) {
-    if (value instanceof Date) {
+    if (ObjectPrototypeIsPrototypeOf(DatePrototype, value)) {
       const time = value.valueOf();
       const seconds = MathTrunc(time / 1e3);
       const nanoseconds = MathTrunc(time - (seconds * 1e3)) * 1e6;
diff --git a/runtime/js/40_fs_events.js b/runtime/js/40_fs_events.js
index 27825eaacf..939d3ac7b5 100644
--- a/runtime/js/40_fs_events.js
+++ b/runtime/js/40_fs_events.js
@@ -3,9 +3,10 @@
 
 ((window) => {
   const core = window.Deno.core;
-  const { errors } = window.__bootstrap.errors;
+  const { BadResourcePrototype, InterruptedPrototype } = core;
   const {
     ArrayIsArray,
+    ObjectPrototypeIsPrototypeOf,
     PromiseResolve,
     SymbolAsyncIterator,
   } = window.__bootstrap.primordials;
@@ -28,9 +29,11 @@
           ? { value, done: false }
           : { value: undefined, done: true };
       } catch (error) {
-        if (error instanceof errors.BadResource) {
+        if (ObjectPrototypeIsPrototypeOf(BadResourcePrototype, error)) {
           return { value: undefined, done: true };
-        } else if (error instanceof errors.Interrupted) {
+        } else if (
+          ObjectPrototypeIsPrototypeOf(InterruptedPrototype, error)
+        ) {
           return { value: undefined, done: true };
         }
         throw error;
diff --git a/runtime/js/40_testing.js b/runtime/js/40_testing.js
index 5979a523ee..62eb1e9a98 100644
--- a/runtime/js/40_testing.js
+++ b/runtime/js/40_testing.js
@@ -9,14 +9,15 @@
   const { serializePermissions } = window.__bootstrap.permissions;
   const { assert } = window.__bootstrap.util;
   const {
-    AggregateError,
+    AggregateErrorPrototype,
     ArrayPrototypeFilter,
     ArrayPrototypePush,
     ArrayPrototypeShift,
     ArrayPrototypeSome,
     DateNow,
     Error,
-    Function,
+    FunctionPrototype,
+    ObjectPrototypeIsPrototypeOf,
     Number,
     ObjectKeys,
     Promise,
@@ -530,7 +531,7 @@ finishing test case.`;
   }
 
   function formatError(error) {
-    if (error instanceof AggregateError) {
+    if (ObjectPrototypeIsPrototypeOf(AggregateErrorPrototype, error)) {
       const message = error
         .errors
         .map((error) =>
@@ -984,7 +985,7 @@ finishing test case.`;
         /** @returns {TestStepDefinition} */
         function getDefinition() {
           if (typeof nameOrTestDefinition === "string") {
-            if (!(fn instanceof Function)) {
+            if (!(ObjectPrototypeIsPrototypeOf(FunctionPrototype, fn))) {
               throw new TypeError("Expected function for second argument.");
             }
             return {
diff --git a/runtime/js/99_main.js b/runtime/js/99_main.js
index ba2b367053..5a4d7e9894 100644
--- a/runtime/js/99_main.js
+++ b/runtime/js/99_main.js
@@ -16,6 +16,7 @@ delete Object.prototype.__proto__;
     ObjectDefineProperty,
     ObjectDefineProperties,
     ObjectFreeze,
+    ObjectPrototypeIsPrototypeOf,
     ObjectSetPrototypeOf,
     PromiseResolve,
     Symbol,
@@ -142,7 +143,9 @@ delete Object.prototype.__proto__;
       const msgEvent = new MessageEvent("message", {
         cancelable: false,
         data: message,
-        ports: transferables.filter((t) => t instanceof MessagePort),
+        ports: transferables.filter((t) =>
+          ObjectPrototypeIsPrototypeOf(messagePort.MessagePortPrototype, t)
+        ),
       });
 
       try {
@@ -311,7 +314,7 @@ delete Object.prototype.__proto__;
       configurable: true,
       enumerable: true,
       get() {
-        webidl.assertBranded(this, Navigator);
+        webidl.assertBranded(this, NavigatorPrototype);
         return webgpu.gpu;
       },
     },
@@ -319,11 +322,12 @@ delete Object.prototype.__proto__;
       configurable: true,
       enumerable: true,
       get() {
-        webidl.assertBranded(this, Navigator);
+        webidl.assertBranded(this, NavigatorPrototype);
         return numCpus;
       },
     },
   });
+  const NavigatorPrototype = Navigator.prototype;
 
   class WorkerNavigator {
     constructor() {
@@ -342,7 +346,7 @@ delete Object.prototype.__proto__;
       configurable: true,
       enumerable: true,
       get() {
-        webidl.assertBranded(this, WorkerNavigator);
+        webidl.assertBranded(this, WorkerNavigatorPrototype);
         return webgpu.gpu;
       },
     },
@@ -350,11 +354,12 @@ delete Object.prototype.__proto__;
       configurable: true,
       enumerable: true,
       get() {
-        webidl.assertBranded(this, WorkerNavigator);
+        webidl.assertBranded(this, WorkerNavigatorPrototype);
         return numCpus;
       },
     },
   });
+  const WorkerNavigatorPrototype = WorkerNavigator.prototype;
 
   // https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope
   const windowOrWorkerGlobalScope = {