@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/undici/lib/web/websocket/websocket.js

@@ -1,65 +1,32 @@
 'use strict'
 
-const { isArrayBuffer } = require('node:util/types')
-const { webidl } = require('../webidl')
+const { webidl } = require('../fetch/webidl')
 const { URLSerializer } = require('../fetch/data-url')
 const { environmentSettingsObject } = require('../fetch/util')
-const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints, opcodes } = require('./constants')
+const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = require('./constants')
+const {
+  kWebSocketURL,
+  kReadyState,
+  kController,
+  kBinaryType,
+  kResponse,
+  kSentClose,
+  kByteParser
+} = require('./symbols')
 const {
   isConnecting,
   isEstablished,
   isClosing,
-  isClosed,
   isValidSubprotocol,
-  fireEvent,
-  utf8Decode,
-  toArrayBuffer,
-  getURLRecord
+  fireEvent
 } = require('./util')
-const { establishWebSocketConnection, closeWebSocketConnection, failWebsocketConnection } = require('./connection')
+const { establishWebSocketConnection, closeWebSocketConnection } = require('./connection')
 const { ByteParser } = require('./receiver')
-const { kEnumerableProperty } = require('../../core/util')
+const { kEnumerableProperty, isBlobLike } = require('../../core/util')
 const { getGlobalDispatcher } = require('../../global')
-const { ErrorEvent, CloseEvent, createFastMessageEvent } = require('./events')
+const { types } = require('node:util')
+const { ErrorEvent, CloseEvent } = require('./events')
 const { SendQueue } = require('./sender')
-const { WebsocketFrameSend } = require('./frame')
-const { channels } = require('../../core/diagnostics')
-
-const kRef = Symbol.for('nodejs.ref')
-const kUnref = Symbol.for('nodejs.unref')
-
-let ping
-
-function getSocketAddress (socket) {
-  if (typeof socket?.address === 'function') {
-    return socket.address()
-  }
-
-  if (typeof socket?.session?.socket?.address === 'function') {
-    return socket.session.socket.address()
-  }
-
-  return null
-}
-
-/**
- * @typedef {object} Handler
- * @property {(response: any, extensions?: string[]) => void} onConnectionEstablished
- * @property {(opcode: number, data: Buffer) => void} onMessage
- * @property {(error: Error) => void} onParserError
- * @property {() => void} onParserDrain
- * @property {(chunk: Buffer) => void} onSocketData
- * @property {(err: Error) => void} onSocketError
- * @property {() => void} onSocketClose
- * @property {(body: Buffer) => void} onPing
- * @property {(body: Buffer) => void} onPong
- *
- * @property {number} readyState
- * @property {import('stream').Duplex} socket
- * @property {Set<number>} closeState
- * @property {import('../fetch/index').Fetch} controller
- * @property {boolean} [wasEverConnected=false]
- */
 
 // https://websockets.spec.whatwg.org/#interface-definition
 class WebSocket extends EventTarget {
@@ -73,61 +40,10 @@ class WebSocket extends EventTarget {
   #bufferedAmount = 0
   #protocol = ''
   #extensions = ''
-  #refed = true
 
   /** @type {SendQueue} */
   #sendQueue
 
-  /** @type {Handler} */
-  #handler = {
-    onConnectionEstablished: (response, extensions) => this.#onConnectionEstablished(response, extensions),
-    onMessage: (opcode, data) => this.#onMessage(opcode, data),
-    onParserError: (err) => failWebsocketConnection(this.#handler, null, err.message),
-    onParserDrain: () => this.#onParserDrain(),
-    onSocketData: (chunk) => {
-      if (!this.#parser.write(chunk)) {
-        this.#handler.socket.pause()
-      }
-    },
-    onSocketError: (err) => {
-      this.#handler.readyState = states.CLOSING
-
-      if (channels.socketError.hasSubscribers) {
-        channels.socketError.publish(err)
-      }
-
-      this.#handler.socket.destroy()
-    },
-    onSocketClose: () => this.#onSocketClose(),
-    onPing: (body) => {
-      if (channels.ping.hasSubscribers) {
-        channels.ping.publish({
-          payload: body,
-          websocket: this
-        })
-      }
-    },
-    onPong: (body) => {
-      if (channels.pong.hasSubscribers) {
-        channels.pong.publish({
-          payload: body,
-          websocket: this
-        })
-      }
-    },
-
-    readyState: states.CONNECTING,
-    socket: null,
-    closeState: new Set(),
-    controller: null,
-    wasEverConnected: false
-  }
-
-  #url
-  #binaryType
-  /** @type {import('./receiver').ByteParser} */
-  #parser
-
   /**
    * @param {string} url
    * @param {string|string[]} protocols
@@ -142,22 +58,51 @@ class WebSocket extends EventTarget {
 
     const options = webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'](protocols, prefix, 'options')
 
-    url = webidl.converters.USVString(url)
+    url = webidl.converters.USVString(url, prefix, 'url')
     protocols = options.protocols
 
     // 1. Let baseURL be this's relevant settings object's API base URL.
     const baseURL = environmentSettingsObject.settingsObject.baseUrl
 
-    // 2. Let urlRecord be the result of getting a URL record given url and baseURL.
-    const urlRecord = getURLRecord(url, baseURL)
+    // 1. Let urlRecord be the result of applying the URL parser to url with baseURL.
+    let urlRecord
+
+    try {
+      urlRecord = new URL(url, baseURL)
+    } catch (e) {
+      // 3. If urlRecord is failure, then throw a "SyntaxError" DOMException.
+      throw new DOMException(e, 'SyntaxError')
+    }
+
+    // 4. If urlRecord’s scheme is "http", then set urlRecord’s scheme to "ws".
+    if (urlRecord.protocol === 'http:') {
+      urlRecord.protocol = 'ws:'
+    } else if (urlRecord.protocol === 'https:') {
+      // 5. Otherwise, if urlRecord’s scheme is "https", set urlRecord’s scheme to "wss".
+      urlRecord.protocol = 'wss:'
+    }
+
+    // 6. If urlRecord’s scheme is not "ws" or "wss", then throw a "SyntaxError" DOMException.
+    if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') {
+      throw new DOMException(
+        `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
+        'SyntaxError'
+      )
+    }
 
-    // 3. If protocols is a string, set protocols to a sequence consisting
+    // 7. If urlRecord’s fragment is non-null, then throw a "SyntaxError"
+    //    DOMException.
+    if (urlRecord.hash || urlRecord.href.endsWith('#')) {
+      throw new DOMException('Got fragment', 'SyntaxError')
+    }
+
+    // 8. If protocols is a string, set protocols to a sequence consisting
     //    of just that string.
     if (typeof protocols === 'string') {
       protocols = [protocols]
     }
 
-    // 4. If any of the values in protocols occur more than once or otherwise
+    // 9. If any of the values in protocols occur more than once or otherwise
     //    fail to match the requirements for elements that comprise the value
     //    of `Sec-WebSocket-Protocol` fields as defined by The WebSocket
     //    protocol, then throw a "SyntaxError" DOMException.
@@ -169,27 +114,31 @@ class WebSocket extends EventTarget {
       throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError')
     }
 
-    // 5. Set this's url to urlRecord.
-    this.#url = new URL(urlRecord.href)
+    // 10. Set this's url to urlRecord.
+    this[kWebSocketURL] = new URL(urlRecord.href)
 
-    // 6. Let client be this's relevant settings object.
+    // 11. Let client be this's relevant settings object.
     const client = environmentSettingsObject.settingsObject
 
-    // 7. Run this step in parallel:
-    // 7.1. Establish a WebSocket connection given urlRecord, protocols,
-    //      and client.
-    this.#handler.controller = establishWebSocketConnection(
+    // 12. Run this step in parallel:
+
+    //    1. Establish a WebSocket connection given urlRecord, protocols,
+    //       and client.
+    this[kController] = establishWebSocketConnection(
       urlRecord,
       protocols,
       client,
-      this.#handler,
+      this,
+      (response, extensions) => this.#onConnectionEstablished(response, extensions),
       options
     )
 
     // Each WebSocket object has an associated ready state, which is a
     // number representing the state of the connection. Initially it must
     // be CONNECTING (0).
-    this.#handler.readyState = WebSocket.CONNECTING
+    this[kReadyState] = WebSocket.CONNECTING
+
+    this[kSentClose] = sentCloseFrameState.NOT_SENT
 
     // The extensions attribute must initially return the empty string.
 
@@ -197,19 +146,7 @@ class WebSocket extends EventTarget {
 
     // Each WebSocket object has an associated binary type, which is a
     // BinaryType. Initially it must be "blob".
-    this.#binaryType = 'blob'
-  }
-
-  // TODO: remove this
-  [kRef] () {
-    this.#refed = true
-    this.#handler.socket?.ref?.()
-  }
-
-  // TODO: remove this
-  [kUnref] () {
-    this.#refed = false
-    this.#handler.socket?.unref?.()
+    this[kBinaryType] = 'blob'
   }
 
   /**
@@ -218,26 +155,46 @@ class WebSocket extends EventTarget {
    * @param {string|undefined} reason
    */
   close (code = undefined, reason = undefined) {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     const prefix = 'WebSocket.close'
 
     if (code !== undefined) {
-      code = webidl.converters['unsigned short'](code, prefix, 'code', webidl.attributes.Clamp)
+      code = webidl.converters['unsigned short'](code, prefix, 'code', { clamp: true })
     }
 
     if (reason !== undefined) {
-      reason = webidl.converters.USVString(reason)
+      reason = webidl.converters.USVString(reason, prefix, 'reason')
     }
 
-    // 1. If code is the special value "missing", then set code to null.
-    code ??= null
+    // 1. If code is present, but is neither an integer equal to 1000 nor an
+    //    integer in the range 3000 to 4999, inclusive, throw an
+    //    "InvalidAccessError" DOMException.
+    if (code !== undefined) {
+      if (code !== 1000 && (code < 3000 || code > 4999)) {
+        throw new DOMException('invalid code', 'InvalidAccessError')
+      }
+    }
+
+    let reasonByteLength = 0
 
-    // 2. If reason is the special value "missing", then set reason to the empty string.
-    reason ??= ''
+    // 2. If reason is present, then run these substeps:
+    if (reason !== undefined) {
+      // 1. Let reasonBytes be the result of encoding reason.
+      // 2. If reasonBytes is longer than 123 bytes, then throw a
+      //    "SyntaxError" DOMException.
+      reasonByteLength = Buffer.byteLength(reason)
+
+      if (reasonByteLength > 123) {
+        throw new DOMException(
+          `Reason must be less than 123 bytes; received ${reasonByteLength}`,
+          'SyntaxError'
+        )
+      }
+    }
 
-    // 3. Close the WebSocket with this, code, and reason.
-    closeWebSocketConnection(this.#handler, code, reason, true)
+    // 3. Run the first matching steps from the following list:
+    closeWebSocketConnection(this, code, reason, reasonByteLength)
   }
 
   /**
@@ -245,7 +202,7 @@ class WebSocket extends EventTarget {
    * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
    */
   send (data) {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     const prefix = 'WebSocket.send'
     webidl.argumentLengthCheck(arguments, 1, prefix)
@@ -254,7 +211,7 @@ class WebSocket extends EventTarget {
 
     // 1. If this's ready state is CONNECTING, then throw an
     //    "InvalidStateError" DOMException.
-    if (isConnecting(this.#handler.readyState)) {
+    if (isConnecting(this)) {
       throw new DOMException('Sent before connected.', 'InvalidStateError')
     }
 
@@ -262,7 +219,7 @@ class WebSocket extends EventTarget {
     // https://datatracker.ietf.org/doc/html/rfc6455#section-6.1
     // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
 
-    if (!isEstablished(this.#handler.readyState) || isClosing(this.#handler.readyState)) {
+    if (!isEstablished(this) || isClosing(this)) {
       return
     }
 
@@ -279,13 +236,13 @@ class WebSocket extends EventTarget {
       // the bufferedAmount attribute by the number of bytes needed to
       // express the argument as UTF-8.
 
-      const buffer = Buffer.from(data)
+      const length = Buffer.byteLength(data)
 
-      this.#bufferedAmount += buffer.byteLength
-      this.#sendQueue.add(buffer, () => {
-        this.#bufferedAmount -= buffer.byteLength
-      }, sendHints.text)
-    } else if (isArrayBuffer(data)) {
+      this.#bufferedAmount += length
+      this.#sendQueue.add(data, () => {
+        this.#bufferedAmount -= length
+      }, sendHints.string)
+    } else if (types.isArrayBuffer(data)) {
       // If the WebSocket connection is established, and the WebSocket
       // closing handshake has not yet started, then the user agent must
       // send a WebSocket Message comprised of data using a binary frame
@@ -319,7 +276,7 @@ class WebSocket extends EventTarget {
       this.#sendQueue.add(data, () => {
         this.#bufferedAmount -= data.byteLength
       }, sendHints.typedArray)
-    } else if (webidl.is.Blob(data)) {
+    } else if (isBlobLike(data)) {
       // If the WebSocket connection is established, and the WebSocket
       // closing handshake has not yet started, then the user agent must
       // send a WebSocket Message comprised of data using a binary frame
@@ -339,142 +296,134 @@ class WebSocket extends EventTarget {
   }
 
   get readyState () {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     // The readyState getter steps are to return this's ready state.
-    return this.#handler.readyState
+    return this[kReadyState]
   }
 
   get bufferedAmount () {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     return this.#bufferedAmount
   }
 
   get url () {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     // The url getter steps are to return this's url, serialized.
-    return URLSerializer(this.#url)
+    return URLSerializer(this[kWebSocketURL])
   }
 
   get extensions () {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     return this.#extensions
   }
 
   get protocol () {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     return this.#protocol
   }
 
   get onopen () {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     return this.#events.open
   }
 
   set onopen (fn) {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     if (this.#events.open) {
       this.removeEventListener('open', this.#events.open)
     }
 
-    const listener = webidl.converters.EventHandlerNonNull(fn)
-
-    if (listener !== null) {
-      this.addEventListener('open', listener)
+    if (typeof fn === 'function') {
       this.#events.open = fn
+      this.addEventListener('open', fn)
     } else {
       this.#events.open = null
     }
   }
 
   get onerror () {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     return this.#events.error
   }
 
   set onerror (fn) {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     if (this.#events.error) {
       this.removeEventListener('error', this.#events.error)
     }
 
-    const listener = webidl.converters.EventHandlerNonNull(fn)
-
-    if (listener !== null) {
-      this.addEventListener('error', listener)
+    if (typeof fn === 'function') {
       this.#events.error = fn
+      this.addEventListener('error', fn)
     } else {
       this.#events.error = null
     }
   }
 
   get onclose () {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     return this.#events.close
   }
 
   set onclose (fn) {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     if (this.#events.close) {
       this.removeEventListener('close', this.#events.close)
     }
 
-    const listener = webidl.converters.EventHandlerNonNull(fn)
-
-    if (listener !== null) {
-      this.addEventListener('close', listener)
+    if (typeof fn === 'function') {
       this.#events.close = fn
+      this.addEventListener('close', fn)
     } else {
       this.#events.close = null
     }
   }
 
   get onmessage () {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     return this.#events.message
   }
 
   set onmessage (fn) {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     if (this.#events.message) {
       this.removeEventListener('message', this.#events.message)
     }
 
-    const listener = webidl.converters.EventHandlerNonNull(fn)
-
-    if (listener !== null) {
-      this.addEventListener('message', listener)
+    if (typeof fn === 'function') {
       this.#events.message = fn
+      this.addEventListener('message', fn)
     } else {
       this.#events.message = null
     }
   }
 
   get binaryType () {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
-    return this.#binaryType
+    return this[kBinaryType]
   }
 
   set binaryType (type) {
-    webidl.brandCheck(this, webidl.is.WebSocket)
+    webidl.brandCheck(this, WebSocket)
 
     if (type !== 'blob' && type !== 'arraybuffer') {
-      this.#binaryType = 'blob'
+      this[kBinaryType] = 'blob'
     } else {
-      this.#binaryType = type
+      this[kBinaryType] = type
     }
   }
 
@@ -484,28 +433,26 @@ class WebSocket extends EventTarget {
   #onConnectionEstablished (response, parsedExtensions) {
     // processResponse is called when the "response's header list has been received and initialized."
     // once this happens, the connection is open
-    this.#handler.socket = response.socket
+    this[kResponse] = response
 
-    if (!this.#refed) {
-      this.#handler.socket.unref?.()
-    }
-
-    // Get options from dispatcher options
-    const maxFragments = this.#handler.controller.dispatcher?.webSocketOptions?.maxFragments
-    const maxPayloadSize = this.#handler.controller.dispatcher?.webSocketOptions?.maxPayloadSize
+    const webSocketOptions = this[kController]?.dispatcher?.webSocketOptions
+    const maxFragments = webSocketOptions?.maxFragments
+    const maxPayloadSize = webSocketOptions?.maxPayloadSize
 
-    const parser = new ByteParser(this.#handler, parsedExtensions, {
+    const parser = new ByteParser(this, parsedExtensions, {
       maxFragments,
       maxPayloadSize
     })
-    parser.on('drain', () => this.#handler.onParserDrain())
-    parser.on('error', (err) => this.#handler.onParserError(err))
+    parser.on('drain', onParserDrain)
+    parser.on('error', onParserError.bind(this))
+
+    response.socket.ws = this
+    this[kByteParser] = parser
 
-    this.#parser = parser
     this.#sendQueue = new SendQueue(response.socket)
 
     // 1. Change the ready state to OPEN (1).
-    this.#handler.readyState = states.OPEN
+    this[kReadyState] = states.OPEN
 
     // 2. Change the extensions attribute’s value to the extensions in use, if
     //    it is not the null value.
@@ -527,160 +474,6 @@ class WebSocket extends EventTarget {
 
     // 4. Fire an event named open at the WebSocket object.
     fireEvent('open', this)
-
-    if (channels.open.hasSubscribers) {
-      // Convert headers to a plain object for the event
-      const headers = response.headersList.entries
-      channels.open.publish({
-        address: getSocketAddress(response.socket),
-        protocol: this.#protocol,
-        extensions: this.#extensions,
-        websocket: this,
-        handshakeResponse: {
-          status: response.status,
-          statusText: response.statusText,
-          headers
-        }
-      })
-    }
-  }
-
-  #onMessage (type, data) {
-    // 1. If ready state is not OPEN (1), then return.
-    if (this.#handler.readyState !== states.OPEN) {
-      return
-    }
-
-    // 2. Let dataForEvent be determined by switching on type and binary type:
-    let dataForEvent
-
-    if (type === opcodes.TEXT) {
-      // -> type indicates that the data is Text
-      //      a new DOMString containing data
-      try {
-        dataForEvent = utf8Decode(data)
-      } catch {
-        failWebsocketConnection(this.#handler, 1007, 'Received invalid UTF-8 in text frame.')
-        return
-      }
-    } else if (type === opcodes.BINARY) {
-      if (this.#binaryType === 'blob') {
-        // -> type indicates that the data is Binary and binary type is "blob"
-        //      a new Blob object, created in the relevant Realm of the WebSocket
-        //      object, that represents data as its raw data
-        dataForEvent = new Blob([data])
-      } else {
-        // -> type indicates that the data is Binary and binary type is "arraybuffer"
-        //      a new ArrayBuffer object, created in the relevant Realm of the
-        //      WebSocket object, whose contents are data
-        dataForEvent = toArrayBuffer(data)
-      }
-    }
-
-    // 3. Fire an event named message at the WebSocket object, using MessageEvent,
-    //    with the origin attribute initialized to the serialization of the WebSocket
-    //    object’s url's origin, and the data attribute initialized to dataForEvent.
-    fireEvent('message', this, createFastMessageEvent, {
-      origin: this.#url.origin,
-      data: dataForEvent
-    })
-  }
-
-  #onParserDrain () {
-    this.#handler.socket.resume()
-  }
-
-  /**
-   * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
-   * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.4
-   */
-  #onSocketClose () {
-    // If the TCP connection was closed after the
-    // WebSocket closing handshake was completed, the WebSocket connection
-    // is said to have been closed _cleanly_.
-    const wasClean =
-      this.#handler.closeState.has(sentCloseFrameState.SENT) &&
-      this.#handler.closeState.has(sentCloseFrameState.RECEIVED)
-
-    let code = 1005
-    let reason = ''
-
-    const result = this.#parser?.closingInfo
-
-    if (result && !result.error) {
-      code = result.code ?? 1005
-      reason = result.reason
-    }
-
-    // 1. Change the ready state to CLOSED (3).
-    this.#handler.readyState = states.CLOSED
-
-    // 2. If the user agent was required to fail the WebSocket
-    //    connection, or if the WebSocket connection was closed
-    //    after being flagged as full, fire an event named error
-    //    at the WebSocket object.
-    if (!this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
-      // If _The WebSocket
-      // Connection is Closed_ and no Close control frame was received by the
-      // endpoint (such as could occur if the underlying transport connection
-      // is lost), _The WebSocket Connection Close Code_ is considered to be
-      // 1006.
-      code = 1006
-
-      fireEvent('error', this, (type, init) => new ErrorEvent(type, init), {
-        error: new TypeError(reason)
-      })
-    }
-
-    // 3. Fire an event named close at the WebSocket object,
-    //    using CloseEvent, with the wasClean attribute
-    //    initialized to true if the connection closed cleanly
-    //    and false otherwise, the code attribute initialized to
-    //    the WebSocket connection close code, and the reason
-    //    attribute initialized to the result of applying UTF-8
-    //    decode without BOM to the WebSocket connection close
-    //    reason.
-    // TODO: process.nextTick
-    fireEvent('close', this, (type, init) => new CloseEvent(type, init), {
-      wasClean, code, reason
-    })
-
-    if (channels.close.hasSubscribers) {
-      channels.close.publish({
-        websocket: this,
-        code,
-        reason
-      })
-    }
-  }
-
-  static {
-    /**
-     * @param {WebSocket} ws
-     * @param {Buffer|undefined} buffer
-     */
-    ping = (ws, buffer) => {
-      if (Buffer.isBuffer(buffer)) {
-        if (buffer.length > 125) {
-          throw new TypeError('A PING frame cannot have a body larger than 125 bytes.')
-        }
-      } else if (buffer !== undefined) {
-        throw new TypeError('Expected buffer payload')
-      }
-
-      // An endpoint MAY send a Ping frame any time after the connection is
-      // established and before the connection is closed.
-      const readyState = ws.#handler.readyState
-
-      if (isEstablished(readyState) && !isClosing(readyState) && !isClosed(readyState)) {
-        const frame = new WebsocketFrameSend(buffer)
-        ws.#handler.socket.write(frame.createFrame(opcodes.PING))
-      }
-    }
-
-    webidl.is.WebSocket = (arg) => {
-      return arg != null && typeof arg === 'object' && #handler in arg
-    }
   }
 }
 
@@ -730,7 +523,7 @@ webidl.converters['sequence<DOMString>'] = webidl.sequenceConverter(
 )
 
 webidl.converters['DOMString or sequence<DOMString>'] = function (V, prefix, argument) {
-  if (webidl.util.Type(V) === webidl.util.Types.OBJECT && Symbol.iterator in V) {
+  if (webidl.util.Type(V) === 'Object' && Symbol.iterator in V) {
     return webidl.converters['sequence<DOMString>'](V)
   }
 
@@ -742,7 +535,7 @@ webidl.converters.WebSocketInit = webidl.dictionaryConverter([
   {
     key: 'protocols',
     converter: webidl.converters['DOMString or sequence<DOMString>'],
-    defaultValue: () => []
+    defaultValue: () => new Array(0)
   },
   {
     key: 'dispatcher',
@@ -756,7 +549,7 @@ webidl.converters.WebSocketInit = webidl.dictionaryConverter([
 ])
 
 webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'] = function (V) {
-  if (webidl.util.Type(V) === webidl.util.Types.OBJECT && !(Symbol.iterator in V)) {
+  if (webidl.util.Type(V) === 'Object' && !(Symbol.iterator in V)) {
     return webidl.converters.WebSocketInit(V)
   }
 
@@ -764,20 +557,39 @@ webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'] = functio
 }
 
 webidl.converters.WebSocketSendData = function (V) {
-  if (webidl.util.Type(V) === webidl.util.Types.OBJECT) {
-    if (webidl.is.Blob(V)) {
-      return V
+  if (webidl.util.Type(V) === 'Object') {
+    if (isBlobLike(V)) {
+      return webidl.converters.Blob(V, { strict: false })
     }
 
-    if (webidl.is.BufferSource(V)) {
-      return V
+    if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
+      return webidl.converters.BufferSource(V)
     }
   }
 
   return webidl.converters.USVString(V)
 }
 
+function onParserDrain () {
+  this.ws[kResponse].socket.resume()
+}
+
+function onParserError (err) {
+  let message
+  let code
+
+  if (err instanceof CloseEvent) {
+    message = err.reason
+    code = err.code
+  } else {
+    message = err.message
+  }
+
+  fireEvent('error', this, () => new ErrorEvent('error', { error: err, message }))
+
+  closeWebSocketConnection(this, code)
+}
+
 module.exports = {
-  WebSocket,
-  ping
+  WebSocket
 }