undici 7.15.0 → 7.17.0

package/lib/web/webidl/index.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { types, inspect } = require('node:util')
-const { markAsUncloneable } = require('node:worker_threads')
+const { runtimeFeatures } = require('../../util/runtime-features')
 
 const UNDEFINED = 1
 const BOOLEAN = 2
@@ -157,10 +157,12 @@ webidl.util.TypeValueToString = function (o) {
   }
 }
 
-webidl.util.markAsUncloneable = markAsUncloneable || (() => {})
+webidl.util.markAsUncloneable = runtimeFeatures.has('markAsUncloneable')
+  ? require('node:worker_threads').markAsUncloneable
+  : () => {}
 
 // https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
-webidl.util.ConvertToInt = function (V, bitLength, signedness, opts) {
+webidl.util.ConvertToInt = function (V, bitLength, signedness, flags) {
   let upperBound
   let lowerBound
 
@@ -204,7 +206,7 @@ webidl.util.ConvertToInt = function (V, bitLength, signedness, opts) {
 
   // 6. If the conversion is to an IDL type associated
   //    with the [EnforceRange] extended attribute, then:
-  if (opts?.enforceRange === true) {
+  if (webidl.util.HasFlag(flags, webidl.attributes.EnforceRange)) {
     // 1. If x is NaN, +∞, or −∞, then throw a TypeError.
     if (
       Number.isNaN(x) ||
@@ -236,7 +238,7 @@ webidl.util.ConvertToInt = function (V, bitLength, signedness, opts) {
   // 7. If x is not NaN and the conversion is to an IDL
   //    type associated with the [Clamp] extended
   //    attribute, then:
-  if (!Number.isNaN(x) && opts?.clamp === true) {
+  if (!Number.isNaN(x) && webidl.util.HasFlag(flags, webidl.attributes.Clamp)) {
     // 1. Set x to min(max(x, lowerBound), upperBound).
     x = Math.min(Math.max(x, lowerBound), upperBound)
 
@@ -310,6 +312,25 @@ webidl.util.Stringify = function (V) {
   }
 }
 
+webidl.util.IsResizableArrayBuffer = function (V) {
+  if (types.isArrayBuffer(V)) {
+    return V.resizable
+  }
+
+  if (types.isSharedArrayBuffer(V)) {
+    return V.growable
+  }
+
+  throw webidl.errors.exception({
+    header: 'IsResizableArrayBuffer',
+    message: `"${webidl.util.Stringify(V)}" is not an array buffer.`
+  })
+}
+
+webidl.util.HasFlag = function (flags, attributes) {
+  return typeof flags === 'number' && (flags & attributes) === attributes
+}
+
 // https://webidl.spec.whatwg.org/#es-sequence
 webidl.sequenceConverter = function (converter) {
   return (V, prefix, argument, Iterable) => {
@@ -514,13 +535,20 @@ webidl.is.URL = webidl.util.MakeTypeAssertion(URL)
 webidl.is.AbortSignal = webidl.util.MakeTypeAssertion(AbortSignal)
 webidl.is.MessagePort = webidl.util.MakeTypeAssertion(MessagePort)
 
+webidl.is.BufferSource = function (V) {
+  return types.isArrayBuffer(V) || (
+    ArrayBuffer.isView(V) &&
+    types.isArrayBuffer(V.buffer)
+  )
+}
+
 // https://webidl.spec.whatwg.org/#es-DOMString
-webidl.converters.DOMString = function (V, prefix, argument, opts) {
+webidl.converters.DOMString = function (V, prefix, argument, flags) {
   // 1. If V is null and the conversion is to an IDL type
   //    associated with the [LegacyNullToEmptyString]
   //    extended attribute, then return the DOMString value
   //    that represents the empty string.
-  if (V === null && opts?.legacyNullToEmptyString) {
+  if (V === null && webidl.util.HasFlag(flags, webidl.attributes.LegacyNullToEmptyString)) {
     return ''
   }
 
@@ -599,7 +627,7 @@ webidl.converters.any = function (V) {
 // https://webidl.spec.whatwg.org/#es-long-long
 webidl.converters['long long'] = function (V, prefix, argument) {
   // 1. Let x be ? ConvertToInt(V, 64, "signed").
-  const x = webidl.util.ConvertToInt(V, 64, 'signed', undefined, prefix, argument)
+  const x = webidl.util.ConvertToInt(V, 64, 'signed', 0, prefix, argument)
 
   // 2. Return the IDL long long value that represents
   //    the same numeric value as x.
@@ -609,7 +637,7 @@ webidl.converters['long long'] = function (V, prefix, argument) {
 // https://webidl.spec.whatwg.org/#es-unsigned-long-long
 webidl.converters['unsigned long long'] = function (V, prefix, argument) {
   // 1. Let x be ? ConvertToInt(V, 64, "unsigned").
-  const x = webidl.util.ConvertToInt(V, 64, 'unsigned', undefined, prefix, argument)
+  const x = webidl.util.ConvertToInt(V, 64, 'unsigned', 0, prefix, argument)
 
   // 2. Return the IDL unsigned long long value that
   //    represents the same numeric value as x.
@@ -619,7 +647,7 @@ webidl.converters['unsigned long long'] = function (V, prefix, argument) {
 // https://webidl.spec.whatwg.org/#es-unsigned-long
 webidl.converters['unsigned long'] = function (V, prefix, argument) {
   // 1. Let x be ? ConvertToInt(V, 32, "unsigned").
-  const x = webidl.util.ConvertToInt(V, 32, 'unsigned', undefined, prefix, argument)
+  const x = webidl.util.ConvertToInt(V, 32, 'unsigned', 0, prefix, argument)
 
   // 2. Return the IDL unsigned long value that
   //    represents the same numeric value as x.
@@ -627,9 +655,9 @@ webidl.converters['unsigned long'] = function (V, prefix, argument) {
 }
 
 // https://webidl.spec.whatwg.org/#es-unsigned-short
-webidl.converters['unsigned short'] = function (V, prefix, argument, opts) {
+webidl.converters['unsigned short'] = function (V, prefix, argument, flags) {
   // 1. Let x be ? ConvertToInt(V, 16, "unsigned").
-  const x = webidl.util.ConvertToInt(V, 16, 'unsigned', opts, prefix, argument)
+  const x = webidl.util.ConvertToInt(V, 16, 'unsigned', flags, prefix, argument)
 
   // 2. Return the IDL unsigned short value that represents
   //    the same numeric value as x.
@@ -637,15 +665,16 @@ webidl.converters['unsigned short'] = function (V, prefix, argument, opts) {
 }
 
 // https://webidl.spec.whatwg.org/#idl-ArrayBuffer
-webidl.converters.ArrayBuffer = function (V, prefix, argument, opts) {
-  // 1. If Type(V) is not Object, or V does not have an
+webidl.converters.ArrayBuffer = function (V, prefix, argument, flags) {
+  // 1. If V is not an Object, or V does not have an
   //    [[ArrayBufferData]] internal slot, then throw a
   //    TypeError.
+  // 2. If IsSharedArrayBuffer(V) is true, then throw a
+  //    TypeError.
   // see: https://tc39.es/ecma262/#sec-properties-of-the-arraybuffer-instances
-  // see: https://tc39.es/ecma262/#sec-properties-of-the-sharedarraybuffer-instances
   if (
     webidl.util.Type(V) !== OBJECT ||
-    !types.isAnyArrayBuffer(V)
+    !types.isArrayBuffer(V)
   ) {
     throw webidl.errors.conversionFailed({
       prefix,
@@ -654,14 +683,38 @@ webidl.converters.ArrayBuffer = function (V, prefix, argument, opts) {
     })
   }
 
-  // 2. If the conversion is not to an IDL type associated
-  //    with the [AllowShared] extended attribute, and
-  //    IsSharedArrayBuffer(V) is true, then throw a
+  // 3. If the conversion is not to an IDL type associated
+  //    with the [AllowResizable] extended attribute, and
+  //    IsResizableArrayBuffer(V) is true, then throw a
   //    TypeError.
-  if (opts?.allowShared === false && types.isSharedArrayBuffer(V)) {
+  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V)) {
     throw webidl.errors.exception({
-      header: 'ArrayBuffer',
-      message: 'SharedArrayBuffer is not allowed.'
+      header: prefix,
+      message: `${argument} cannot be a resizable ArrayBuffer.`
+    })
+  }
+
+  // 4. Return the IDL ArrayBuffer value that is a
+  //    reference to the same object as V.
+  return V
+}
+
+// https://webidl.spec.whatwg.org/#idl-SharedArrayBuffer
+webidl.converters.SharedArrayBuffer = function (V, prefix, argument, flags) {
+  // 1. If V is not an Object, or V does not have an
+  //    [[ArrayBufferData]] internal slot, then throw a
+  //    TypeError.
+  // 2. If IsSharedArrayBuffer(V) is false, then throw a
+  //    TypeError.
+  // see: https://tc39.es/ecma262/#sec-properties-of-the-sharedarraybuffer-instances
+  if (
+    webidl.util.Type(V) !== OBJECT ||
+    !types.isSharedArrayBuffer(V)
+  ) {
+    throw webidl.errors.conversionFailed({
+      prefix,
+      argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+      types: ['SharedArrayBuffer']
     })
   }
 
@@ -669,19 +722,20 @@ webidl.converters.ArrayBuffer = function (V, prefix, argument, opts) {
   //    with the [AllowResizable] extended attribute, and
   //    IsResizableArrayBuffer(V) is true, then throw a
   //    TypeError.
-  if (V.resizable || V.growable) {
+  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V)) {
     throw webidl.errors.exception({
-      header: 'ArrayBuffer',
-      message: 'Received a resizable ArrayBuffer.'
+      header: prefix,
+      message: `${argument} cannot be a resizable SharedArrayBuffer.`
     })
   }
 
-  // 4. Return the IDL ArrayBuffer value that is a
+  // 4. Return the IDL SharedArrayBuffer value that is a
   //    reference to the same object as V.
   return V
 }
 
-webidl.converters.TypedArray = function (V, T, prefix, name, opts) {
+// https://webidl.spec.whatwg.org/#dfn-typed-array-type
+webidl.converters.TypedArray = function (V, T, prefix, argument, flags) {
   // 1. Let T be the IDL type V is being converted to.
 
   // 2. If Type(V) is not Object, or V does not have a
@@ -694,7 +748,7 @@ webidl.converters.TypedArray = function (V, T, prefix, name, opts) {
   ) {
     throw webidl.errors.conversionFailed({
       prefix,
-      argument: `${name} ("${webidl.util.Stringify(V)}")`,
+      argument: `${argument} ("${webidl.util.Stringify(V)}")`,
       types: [T.name]
     })
   }
@@ -703,10 +757,10 @@ webidl.converters.TypedArray = function (V, T, prefix, name, opts) {
   //    with the [AllowShared] extended attribute, and
   //    IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is
   //    true, then throw a TypeError.
-  if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
+  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {
     throw webidl.errors.exception({
-      header: 'ArrayBuffer',
-      message: 'SharedArrayBuffer is not allowed.'
+      header: prefix,
+      message: `${argument} cannot be a view on a shared array buffer.`
     })
   }
 
@@ -714,10 +768,10 @@ webidl.converters.TypedArray = function (V, T, prefix, name, opts) {
   //    with the [AllowResizable] extended attribute, and
   //    IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is
   //    true, then throw a TypeError.
-  if (V.buffer.resizable || V.buffer.growable) {
+  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {
     throw webidl.errors.exception({
-      header: 'ArrayBuffer',
-      message: 'Received a resizable ArrayBuffer.'
+      header: prefix,
+      message: `${argument} cannot be a view on a resizable array buffer.`
     })
   }
 
@@ -726,13 +780,15 @@ webidl.converters.TypedArray = function (V, T, prefix, name, opts) {
   return V
 }
 
-webidl.converters.DataView = function (V, prefix, name, opts) {
+// https://webidl.spec.whatwg.org/#idl-DataView
+webidl.converters.DataView = function (V, prefix, argument, flags) {
   // 1. If Type(V) is not Object, or V does not have a
   //    [[DataView]] internal slot, then throw a TypeError.
   if (webidl.util.Type(V) !== OBJECT || !types.isDataView(V)) {
-    throw webidl.errors.exception({
-      header: prefix,
-      message: `${name} is not a DataView.`
+    throw webidl.errors.conversionFailed({
+      prefix,
+      argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+      types: ['DataView']
     })
   }
 
@@ -740,10 +796,10 @@ webidl.converters.DataView = function (V, prefix, name, opts) {
   //    with the [AllowShared] extended attribute, and
   //    IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is true,
   //    then throw a TypeError.
-  if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
+  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {
     throw webidl.errors.exception({
-      header: 'ArrayBuffer',
-      message: 'SharedArrayBuffer is not allowed.'
+      header: prefix,
+      message: `${argument} cannot be a view on a shared array buffer.`
     })
   }
 
@@ -751,10 +807,10 @@ webidl.converters.DataView = function (V, prefix, name, opts) {
   //    with the [AllowResizable] extended attribute, and
   //    IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is
   //    true, then throw a TypeError.
-  if (V.buffer.resizable || V.buffer.growable) {
+  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {
     throw webidl.errors.exception({
-      header: 'ArrayBuffer',
-      message: 'Received a resizable ArrayBuffer.'
+      header: prefix,
+      message: `${argument} cannot be a view on a resizable array buffer.`
     })
   }
 
@@ -763,6 +819,85 @@ webidl.converters.DataView = function (V, prefix, name, opts) {
   return V
 }
 
+// https://webidl.spec.whatwg.org/#ArrayBufferView
+webidl.converters.ArrayBufferView = function (V, prefix, argument, flags) {
+  if (
+    webidl.util.Type(V) !== OBJECT ||
+    !types.isArrayBufferView(V)
+  ) {
+    throw webidl.errors.conversionFailed({
+      prefix,
+      argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+      types: ['ArrayBufferView']
+    })
+  }
+
+  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowShared) && types.isSharedArrayBuffer(V.buffer)) {
+    throw webidl.errors.exception({
+      header: prefix,
+      message: `${argument} cannot be a view on a shared array buffer.`
+    })
+  }
+
+  if (!webidl.util.HasFlag(flags, webidl.attributes.AllowResizable) && webidl.util.IsResizableArrayBuffer(V.buffer)) {
+    throw webidl.errors.exception({
+      header: prefix,
+      message: `${argument} cannot be a view on a resizable array buffer.`
+    })
+  }
+
+  return V
+}
+
+// https://webidl.spec.whatwg.org/#BufferSource
+webidl.converters.BufferSource = function (V, prefix, argument, flags) {
+  if (types.isArrayBuffer(V)) {
+    return webidl.converters.ArrayBuffer(V, prefix, argument, flags)
+  }
+
+  if (types.isArrayBufferView(V)) {
+    flags &= ~webidl.attributes.AllowShared
+
+    return webidl.converters.ArrayBufferView(V, prefix, argument, flags)
+  }
+
+  // Make this explicit for easier debugging
+  if (types.isSharedArrayBuffer(V)) {
+    throw webidl.errors.exception({
+      header: prefix,
+      message: `${argument} cannot be a SharedArrayBuffer.`
+    })
+  }
+
+  throw webidl.errors.conversionFailed({
+    prefix,
+    argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+    types: ['ArrayBuffer', 'ArrayBufferView']
+  })
+}
+
+// https://webidl.spec.whatwg.org/#AllowSharedBufferSource
+webidl.converters.AllowSharedBufferSource = function (V, prefix, argument, flags) {
+  if (types.isArrayBuffer(V)) {
+    return webidl.converters.ArrayBuffer(V, prefix, argument, flags)
+  }
+
+  if (types.isSharedArrayBuffer(V)) {
+    return webidl.converters.SharedArrayBuffer(V, prefix, argument, flags)
+  }
+
+  if (types.isArrayBufferView(V)) {
+    flags |= webidl.attributes.AllowShared
+    return webidl.converters.ArrayBufferView(V, prefix, argument, flags)
+  }
+
+  throw webidl.errors.conversionFailed({
+    prefix,
+    argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+    types: ['ArrayBuffer', 'SharedArrayBuffer', 'ArrayBufferView']
+  })
+}
+
 webidl.converters['sequence<ByteString>'] = webidl.sequenceConverter(
   webidl.converters.ByteString
 )
@@ -783,6 +918,34 @@ webidl.converters.AbortSignal = webidl.interfaceConverter(
   'AbortSignal'
 )
 
+/**
+ * [LegacyTreatNonObjectAsNull]
+ * callback EventHandlerNonNull = any (Event event);
+ * typedef EventHandlerNonNull? EventHandler;
+ * @param {*} V
+ */
+webidl.converters.EventHandlerNonNull = function (V) {
+  if (webidl.util.Type(V) !== OBJECT) {
+    return null
+  }
+
+  // [I]f the value is not an object, it will be converted to null, and if the value is not callable,
+  // it will be converted to a callback function value that does nothing when called.
+  if (typeof V === 'function') {
+    return V
+  }
+
+  return () => {}
+}
+
+webidl.attributes = {
+  Clamp: 1 << 0,
+  EnforceRange: 1 << 1,
+  AllowShared: 1 << 2,
+  AllowResizable: 1 << 3,
+  LegacyNullToEmptyString: 1 << 4
+}
+
 module.exports = {
   webidl
 }

package/lib/web/websocket/connection.js

@@ -1,22 +1,20 @@
 'use strict'
 
 const { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = require('./constants')
-const { parseExtensions, isClosed, isClosing, isEstablished, validateCloseCodeAndReason } = require('./util')
+const { parseExtensions, isClosed, isClosing, isEstablished, isConnecting, validateCloseCodeAndReason } = require('./util')
 const { makeRequest } = require('../fetch/request')
 const { fetching } = require('../fetch/index')
 const { Headers, getHeadersList } = require('../fetch/headers')
 const { getDecodeSplit } = require('../fetch/util')
 const { WebsocketFrameSend } = require('./frame')
 const assert = require('node:assert')
+const { runtimeFeatures } = require('../../util/runtime-features')
 
-/** @type {import('crypto')} */
-let crypto
-try {
-  crypto = require('node:crypto')
-/* c8 ignore next 3 */
-} catch {
+const crypto = runtimeFeatures.has('crypto')
+  ? require('node:crypto')
+  : null
 
-}
+let warningEmitted = false
 
 /**
  * @see https://websockets.spec.whatwg.org/#concept-websocket-establish
@@ -95,17 +93,27 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
     useParallelQueue: true,
     dispatcher: options.dispatcher,
     processResponse (response) {
-      if (response.type === 'error') {
-        // If the WebSocket connection could not be established, it is also said
-        // that _The WebSocket Connection is Closed_, but not _cleanly_.
-        handler.readyState = states.CLOSED
-      }
-
       // 1. If response is a network error or its status is not 101,
       //    fail the WebSocket connection.
+      // if (response.type === 'error' || ((response.socket?.session != null && response.status !== 200) && response.status !== 101)) {
       if (response.type === 'error' || response.status !== 101) {
-        failWebsocketConnection(handler, 1002, 'Received network error or non-101 status code.', response.error)
-        return
+        // The presence of a session property on the socket indicates HTTP2
+        // HTTP1
+        if (response.socket?.session == null) {
+          failWebsocketConnection(handler, 1002, 'Received network error or non-101 status code.', response.error)
+          return
+        }
+
+        // HTTP2
+        if (response.status !== 200) {
+          failWebsocketConnection(handler, 1002, 'Received network error or non-200 status code.', response.error)
+          return
+        }
+      }
+
+      if (warningEmitted === false && response.socket?.session != null) {
+        process.emitWarning('WebSocket over HTTP2 is experimental, and subject to change.', 'ExperimentalWarning')
+        warningEmitted = true
       }
 
       // 2. If protocols is not the empty list and extracting header
@@ -127,7 +135,8 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
       //    header field contains a value that is not an ASCII case-
       //    insensitive match for the value "websocket", the client MUST
       //    _Fail the WebSocket Connection_.
-      if (response.headersList.get('Upgrade')?.toLowerCase() !== 'websocket') {
+      //    For H2, no upgrade header is expected.
+      if (response.socket.session == null && response.headersList.get('Upgrade')?.toLowerCase() !== 'websocket') {
         failWebsocketConnection(handler, 1002, 'Server did not set Upgrade header to "websocket".')
         return
       }
@@ -136,7 +145,8 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
       //    |Connection| header field doesn't contain a token that is an
       //    ASCII case-insensitive match for the value "Upgrade", the client
       //    MUST _Fail the WebSocket Connection_.
-      if (response.headersList.get('Connection')?.toLowerCase() !== 'upgrade') {
+      //    For H2, no connection header is expected.
+      if (response.socket.session == null && response.headersList.get('Connection')?.toLowerCase() !== 'upgrade') {
         failWebsocketConnection(handler, 1002, 'Server did not set Connection header to "upgrade".')
         return
       }
@@ -149,7 +159,7 @@ function establishWebSocketConnection (url, protocols, client, handler, options)
       //    trailing whitespace, the client MUST _Fail the WebSocket
       //    Connection_.
       const secWSAccept = response.headersList.get('Sec-WebSocket-Accept')
-      const digest = crypto.createHash('sha1').update(keyValue + uid).digest('base64')
+      const digest = crypto.hash('sha1', keyValue + uid, 'base64')
       if (secWSAccept !== digest) {
         failWebsocketConnection(handler, 1002, 'Incorrect hash received in Sec-WebSocket-Accept header.')
         return
@@ -303,11 +313,12 @@ function failWebsocketConnection (handler, code, reason, cause) {
 
   handler.controller.abort()
 
-  if (handler.socket?.destroyed === false) {
+  if (isConnecting(handler.readyState)) {
+    // If the connection was not established, we must still emit an 'error' and 'close' events
+    handler.onSocketClose()
+  } else if (handler.socket?.destroyed === false) {
     handler.socket.destroy()
   }
-
-  handler.onFail(code, reason, cause)
 }
 
 module.exports = {

package/lib/web/websocket/events.js

@@ -272,7 +272,7 @@ webidl.converters.MessageEventInit = webidl.dictionaryConverter([
   {
     key: 'ports',
     converter: webidl.converters['sequence<MessagePort>'],
-    defaultValue: () => new Array(0)
+    defaultValue: () => []
   }
 ])
 

package/lib/web/websocket/frame.js

@@ -1,33 +1,27 @@
 'use strict'
 
+const { runtimeFeatures } = require('../../util/runtime-features')
 const { maxUnsigned16Bit, opcodes } = require('./constants')
 
 const BUFFER_SIZE = 8 * 1024
 
-/** @type {import('crypto')} */
-let crypto
 let buffer = null
 let bufIdx = BUFFER_SIZE
 
-try {
-  crypto = require('node:crypto')
-/* c8 ignore next 3 */
-} catch {
-  crypto = {
-    // not full compatibility, but minimum.
-    randomFillSync: function randomFillSync (buffer, _offset, _size) {
-      for (let i = 0; i < buffer.length; ++i) {
-        buffer[i] = Math.random() * 255 | 0
-      }
-      return buffer
+const randomFillSync = runtimeFeatures.has('crypto')
+  ? require('node:crypto').randomFillSync
+  // not full compatibility, but minimum.
+  : function randomFillSync (buffer, _offset, _size) {
+    for (let i = 0; i < buffer.length; ++i) {
+      buffer[i] = Math.random() * 255 | 0
     }
+    return buffer
   }
-}
 
 function generateMask () {
   if (bufIdx === BUFFER_SIZE) {
     bufIdx = 0
-    crypto.randomFillSync((buffer ??= Buffer.allocUnsafeSlow(BUFFER_SIZE)), 0, BUFFER_SIZE)
+    randomFillSync((buffer ??= Buffer.allocUnsafeSlow(BUFFER_SIZE)), 0, BUFFER_SIZE)
   }
   return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]]
 }

package/lib/web/websocket/stream/websocketerror.js

@@ -5,7 +5,28 @@ const { validateCloseCodeAndReason } = require('../util')
 const { kConstruct } = require('../../../core/symbols')
 const { kEnumerableProperty } = require('../../../core/util')
 
-class WebSocketError extends DOMException {
+function createInheritableDOMException () {
+  // https://github.com/nodejs/node/issues/59677
+  class Test extends DOMException {
+    get reason () {
+      return ''
+    }
+  }
+
+  if (new Test().reason !== undefined) {
+    return DOMException
+  }
+
+  return new Proxy(DOMException, {
+    construct (target, args, newTarget) {
+      const instance = Reflect.construct(target, args, target)
+      Object.setPrototypeOf(instance, newTarget.prototype)
+      return instance
+    }
+  })
+}
+
+class WebSocketError extends createInheritableDOMException() {
   #closeCode
   #reason