@rsbuild/core 1.0.0-alpha.3 → 1.0.0-alpha.4

package/compiled/ws/index.js

@@ -1,18 +1,18 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 781:
+/***/ 749:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-const WebSocket = __nccwpck_require__(715);
+const WebSocket = __nccwpck_require__(227);
 
-WebSocket.createWebSocketStream = __nccwpck_require__(884);
-WebSocket.Server = __nccwpck_require__(120);
-WebSocket.Receiver = __nccwpck_require__(594);
-WebSocket.Sender = __nccwpck_require__(209);
+WebSocket.createWebSocketStream = __nccwpck_require__(192);
+WebSocket.Server = __nccwpck_require__(226);
+WebSocket.Receiver = __nccwpck_require__(245);
+WebSocket.Sender = __nccwpck_require__(415);
 
 WebSocket.WebSocket = WebSocket;
 WebSocket.WebSocketServer = WebSocket.Server;
@@ -22,13 +22,13 @@ module.exports = WebSocket;
 
 /***/ }),
 
-/***/ 870:
+/***/ 198:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-const { EMPTY_BUFFER } = __nccwpck_require__(556);
+const { EMPTY_BUFFER } = __nccwpck_require__(870);
 
 const FastBuffer = Buffer[Symbol.species];
 
@@ -161,16 +161,22 @@ if (!process.env.WS_NO_BUFFER_UTIL) {
 
 /***/ }),
 
-/***/ 556:
+/***/ 870:
 /***/ ((module) => {
 
 "use strict";
 
 
+const BINARY_TYPES = ['nodebuffer', 'arraybuffer', 'fragments'];
+const hasBlob = typeof Blob !== 'undefined';
+
+if (hasBlob) BINARY_TYPES.push('blob');
+
 module.exports = {
-  BINARY_TYPES: ['nodebuffer', 'arraybuffer', 'fragments'],
+  BINARY_TYPES,
   EMPTY_BUFFER: Buffer.alloc(0),
   GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+  hasBlob,
   kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
   kListener: Symbol('kListener'),
   kStatusCode: Symbol('status-code'),
@@ -181,13 +187,13 @@ module.exports = {
 
 /***/ }),
 
-/***/ 418:
+/***/ 456:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-const { kForOnEventAttribute, kListener } = __nccwpck_require__(556);
+const { kForOnEventAttribute, kListener } = __nccwpck_require__(870);
 
 const kCode = Symbol('kCode');
 const kData = Symbol('kData');
@@ -481,13 +487,13 @@ function callListener(listener, thisArg, event) {
 
 /***/ }),
 
-/***/ 787:
+/***/ 694:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-const { tokenChars } = __nccwpck_require__(502);
+const { tokenChars } = __nccwpck_require__(444);
 
 /**
  * Adds an offer to the map of extension offers or a parameter to the map of
@@ -692,7 +698,7 @@ module.exports = { format, parse };
 
 /***/ }),
 
-/***/ 202:
+/***/ 801:
 /***/ ((module) => {
 
 "use strict";
@@ -755,7 +761,7 @@ module.exports = Limiter;
 
 /***/ }),
 
-/***/ 262:
+/***/ 421:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -763,9 +769,9 @@ module.exports = Limiter;
 
 const zlib = __nccwpck_require__(796);
 
-const bufferUtil = __nccwpck_require__(870);
-const Limiter = __nccwpck_require__(202);
-const { kStatusCode } = __nccwpck_require__(556);
+const bufferUtil = __nccwpck_require__(198);
+const Limiter = __nccwpck_require__(801);
+const { kStatusCode } = __nccwpck_require__(870);
 
 const FastBuffer = Buffer[Symbol.species];
 const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
@@ -1277,23 +1283,23 @@ function inflateOnError(err) {
 
 /***/ }),
 
-/***/ 594:
+/***/ 245:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-const { Writable } = __nccwpck_require__(955);
+const { Writable } = __nccwpck_require__(781);
 
-const PerMessageDeflate = __nccwpck_require__(262);
+const PerMessageDeflate = __nccwpck_require__(421);
 const {
   BINARY_TYPES,
   EMPTY_BUFFER,
   kStatusCode,
   kWebSocket
-} = __nccwpck_require__(556);
-const { concat, toArrayBuffer, unmask } = __nccwpck_require__(870);
-const { isValidStatusCode, isValidUTF8 } = __nccwpck_require__(502);
+} = __nccwpck_require__(870);
+const { concat, toArrayBuffer, unmask } = __nccwpck_require__(198);
+const { isValidStatusCode, isValidUTF8 } = __nccwpck_require__(444);
 
 const FastBuffer = Buffer[Symbol.species];
 
@@ -1842,6 +1848,8 @@ class Receiver extends Writable {
         data = concat(fragments, messageLength);
       } else if (this._binaryType === 'arraybuffer') {
         data = toArrayBuffer(concat(fragments, messageLength));
+      } else if (this._binaryType === 'blob') {
+        data = new Blob(fragments);
       } else {
         data = fragments;
       }
@@ -1989,7 +1997,7 @@ module.exports = Receiver;
 
 /***/ }),
 
-/***/ 209:
+/***/ 415:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -1997,13 +2005,13 @@ module.exports = Receiver;
 
 
 
-const { Duplex } = __nccwpck_require__(955);
+const { Duplex } = __nccwpck_require__(781);
 const { randomFillSync } = __nccwpck_require__(113);
 
-const PerMessageDeflate = __nccwpck_require__(262);
-const { EMPTY_BUFFER } = __nccwpck_require__(556);
-const { isValidStatusCode } = __nccwpck_require__(502);
-const { mask: applyMask, toBuffer } = __nccwpck_require__(870);
+const PerMessageDeflate = __nccwpck_require__(421);
+const { EMPTY_BUFFER, kWebSocket, NOOP } = __nccwpck_require__(870);
+const { isBlob, isValidStatusCode } = __nccwpck_require__(444);
+const { mask: applyMask, toBuffer } = __nccwpck_require__(198);
 
 const kByteLength = Symbol('kByteLength');
 const maskBuffer = Buffer.alloc(4);
@@ -2011,6 +2019,10 @@ const RANDOM_POOL_SIZE = 8 * 1024;
 let randomPool;
 let randomPoolPointer = RANDOM_POOL_SIZE;
 
+const DEFAULT = 0;
+const DEFLATING = 1;
+const GET_BLOB_DATA = 2;
+
 /**
  * HyBi Sender implementation.
  */
@@ -2037,8 +2049,10 @@ class Sender {
     this._compress = false;
 
     this._bufferedBytes = 0;
-    this._deflating = false;
     this._queue = [];
+    this._state = DEFAULT;
+    this.onerror = NOOP;
+    this[kWebSocket] = undefined;
   }
 
   /**
@@ -2205,7 +2219,7 @@ class Sender {
       rsv1: false
     };
 
-    if (this._deflating) {
+    if (this._state !== DEFAULT) {
       this.enqueue([this.dispatch, buf, false, options, cb]);
     } else {
       this.sendFrame(Sender.frame(buf, options), cb);
@@ -2227,6 +2241,9 @@ class Sender {
     if (typeof data === 'string') {
       byteLength = Buffer.byteLength(data);
       readOnly = false;
+    } else if (isBlob(data)) {
+      byteLength = data.size;
+      readOnly = false;
     } else {
       data = toBuffer(data);
       byteLength = data.length;
@@ -2248,7 +2265,13 @@ class Sender {
       rsv1: false
     };
 
-    if (this._deflating) {
+    if (isBlob(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, false, options, cb]);
+      } else {
+        this.getBlobData(data, false, options, cb);
+      }
+    } else if (this._state !== DEFAULT) {
       this.enqueue([this.dispatch, data, false, options, cb]);
     } else {
       this.sendFrame(Sender.frame(data, options), cb);
@@ -2270,6 +2293,9 @@ class Sender {
     if (typeof data === 'string') {
       byteLength = Buffer.byteLength(data);
       readOnly = false;
+    } else if (isBlob(data)) {
+      byteLength = data.size;
+      readOnly = false;
     } else {
       data = toBuffer(data);
       byteLength = data.length;
@@ -2291,7 +2317,13 @@ class Sender {
       rsv1: false
     };
 
-    if (this._deflating) {
+    if (isBlob(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, false, options, cb]);
+      } else {
+        this.getBlobData(data, false, options, cb);
+      }
+    } else if (this._state !== DEFAULT) {
       this.enqueue([this.dispatch, data, false, options, cb]);
     } else {
       this.sendFrame(Sender.frame(data, options), cb);
@@ -2325,6 +2357,9 @@ class Sender {
     if (typeof data === 'string') {
       byteLength = Buffer.byteLength(data);
       readOnly = false;
+    } else if (isBlob(data)) {
+      byteLength = data.size;
+      readOnly = false;
     } else {
       data = toBuffer(data);
       byteLength = data.length;
@@ -2352,40 +2387,94 @@ class Sender {
 
     if (options.fin) this._firstFragment = true;
 
-    if (perMessageDeflate) {
-      const opts = {
-        [kByteLength]: byteLength,
-        fin: options.fin,
-        generateMask: this._generateMask,
-        mask: options.mask,
-        maskBuffer: this._maskBuffer,
-        opcode,
-        readOnly,
-        rsv1
-      };
+    const opts = {
+      [kByteLength]: byteLength,
+      fin: options.fin,
+      generateMask: this._generateMask,
+      mask: options.mask,
+      maskBuffer: this._maskBuffer,
+      opcode,
+      readOnly,
+      rsv1
+    };
 
-      if (this._deflating) {
-        this.enqueue([this.dispatch, data, this._compress, opts, cb]);
+    if (isBlob(data)) {
+      if (this._state !== DEFAULT) {
+        this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
       } else {
-        this.dispatch(data, this._compress, opts, cb);
+        this.getBlobData(data, this._compress, opts, cb);
       }
+    } else if (this._state !== DEFAULT) {
+      this.enqueue([this.dispatch, data, this._compress, opts, cb]);
     } else {
-      this.sendFrame(
-        Sender.frame(data, {
-          [kByteLength]: byteLength,
-          fin: options.fin,
-          generateMask: this._generateMask,
-          mask: options.mask,
-          maskBuffer: this._maskBuffer,
-          opcode,
-          readOnly,
-          rsv1: false
-        }),
-        cb
-      );
+      this.dispatch(data, this._compress, opts, cb);
     }
   }
 
+  /**
+   * Gets the contents of a blob as binary data.
+   *
+   * @param {Blob} blob The blob
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     the data
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  getBlobData(blob, compress, options, cb) {
+    this._bufferedBytes += options[kByteLength];
+    this._state = GET_BLOB_DATA;
+
+    blob
+      .arrayBuffer()
+      .then((arrayBuffer) => {
+        if (this._socket.destroyed) {
+          const err = new Error(
+            'The socket was closed while the blob was being read'
+          );
+
+          //
+          // `callCallbacks` is called in the next tick to ensure that errors
+          // that might be thrown in the callbacks behave like errors thrown
+          // outside the promise chain.
+          //
+          process.nextTick(callCallbacks, this, err, cb);
+          return;
+        }
+
+        this._bufferedBytes -= options[kByteLength];
+        const data = toBuffer(arrayBuffer);
+
+        if (!compress) {
+          this._state = DEFAULT;
+          this.sendFrame(Sender.frame(data, options), cb);
+          this.dequeue();
+        } else {
+          this.dispatch(data, compress, options, cb);
+        }
+      })
+      .catch((err) => {
+        //
+        // `onError` is called in the next tick for the same reason that
+        // `callCallbacks` above is.
+        //
+        process.nextTick(onError, this, err, cb);
+      });
+  }
+
   /**
    * Dispatches a message.
    *
@@ -2418,27 +2507,19 @@ class Sender {
     const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
 
     this._bufferedBytes += options[kByteLength];
-    this._deflating = true;
+    this._state = DEFLATING;
     perMessageDeflate.compress(data, options.fin, (_, buf) => {
       if (this._socket.destroyed) {
         const err = new Error(
           'The socket was closed while data was being compressed'
         );
 
-        if (typeof cb === 'function') cb(err);
-
-        for (let i = 0; i < this._queue.length; i++) {
-          const params = this._queue[i];
-          const callback = params[params.length - 1];
-
-          if (typeof callback === 'function') callback(err);
-        }
-
+        callCallbacks(this, err, cb);
         return;
       }
 
       this._bufferedBytes -= options[kByteLength];
-      this._deflating = false;
+      this._state = DEFAULT;
       options.readOnly = false;
       this.sendFrame(Sender.frame(buf, options), cb);
       this.dequeue();
@@ -2451,7 +2532,7 @@ class Sender {
    * @private
    */
   dequeue() {
-    while (!this._deflating && this._queue.length) {
+    while (this._state === DEFAULT && this._queue.length) {
       const params = this._queue.shift();
 
       this._bufferedBytes -= params[3][kByteLength];
@@ -2491,16 +2572,48 @@ class Sender {
 
 module.exports = Sender;
 
+/**
+ * Calls queued callbacks with an error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error to call the callbacks with
+ * @param {Function} [cb] The first callback
+ * @private
+ */
+function callCallbacks(sender, err, cb) {
+  if (typeof cb === 'function') cb(err);
+
+  for (let i = 0; i < sender._queue.length; i++) {
+    const params = sender._queue[i];
+    const callback = params[params.length - 1];
+
+    if (typeof callback === 'function') callback(err);
+  }
+}
+
+/**
+ * Handles a `Sender` error.
+ *
+ * @param {Sender} sender The `Sender` instance
+ * @param {Error} err The error
+ * @param {Function} [cb] The first pending callback
+ * @private
+ */
+function onError(sender, err, cb) {
+  callCallbacks(sender, err, cb);
+  sender.onerror(err);
+}
+
 
 /***/ }),
 
-/***/ 884:
+/***/ 192:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-const { Duplex } = __nccwpck_require__(955);
+const { Duplex } = __nccwpck_require__(781);
 
 /**
  * Emits the `'close'` event on a stream.
@@ -2661,13 +2774,13 @@ module.exports = createWebSocketStream;
 
 /***/ }),
 
-/***/ 690:
+/***/ 58:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
 
 
-const { tokenChars } = __nccwpck_require__(502);
+const { tokenChars } = __nccwpck_require__(444);
 
 /**
  * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names.
@@ -2731,7 +2844,7 @@ module.exports = { parse };
 
 /***/ }),
 
-/***/ 502:
+/***/ 444:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -2739,6 +2852,8 @@ module.exports = { parse };
 
 const { isUtf8 } = __nccwpck_require__(300);
 
+const { hasBlob } = __nccwpck_require__(870);
+
 //
 // Allowed token characters:
 //
@@ -2844,7 +2959,27 @@ function _isValidUTF8(buf) {
   return true;
 }
 
+/**
+ * Determines whether a value is a `Blob`.
+ *
+ * @param {*} value The value to be tested
+ * @return {Boolean} `true` if `value` is a `Blob`, else `false`
+ * @private
+ */
+function isBlob(value) {
+  return (
+    hasBlob &&
+    typeof value === 'object' &&
+    typeof value.arrayBuffer === 'function' &&
+    typeof value.type === 'string' &&
+    typeof value.stream === 'function' &&
+    (value[Symbol.toStringTag] === 'Blob' ||
+      value[Symbol.toStringTag] === 'File')
+  );
+}
+
 module.exports = {
+  isBlob,
   isValidStatusCode,
   isValidUTF8: _isValidUTF8,
   tokenChars
@@ -2869,7 +3004,7 @@ if (isUtf8) {
 
 /***/ }),
 
-/***/ 120:
+/***/ 226:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -2879,14 +3014,14 @@ if (isUtf8) {
 
 const EventEmitter = __nccwpck_require__(361);
 const http = __nccwpck_require__(685);
-const { Duplex } = __nccwpck_require__(955);
+const { Duplex } = __nccwpck_require__(781);
 const { createHash } = __nccwpck_require__(113);
 
-const extension = __nccwpck_require__(787);
-const PerMessageDeflate = __nccwpck_require__(262);
-const subprotocol = __nccwpck_require__(690);
-const WebSocket = __nccwpck_require__(715);
-const { GUID, kWebSocket } = __nccwpck_require__(556);
+const extension = __nccwpck_require__(694);
+const PerMessageDeflate = __nccwpck_require__(421);
+const subprotocol = __nccwpck_require__(58);
+const WebSocket = __nccwpck_require__(227);
+const { GUID, kWebSocket } = __nccwpck_require__(870);
 
 const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
 
@@ -3417,7 +3552,7 @@ function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
 
 /***/ }),
 
-/***/ 715:
+/***/ 227:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
 "use strict";
@@ -3431,12 +3566,14 @@ const http = __nccwpck_require__(685);
 const net = __nccwpck_require__(808);
 const tls = __nccwpck_require__(404);
 const { randomBytes, createHash } = __nccwpck_require__(113);
-const { Duplex, Readable } = __nccwpck_require__(955);
+const { Duplex, Readable } = __nccwpck_require__(781);
 const { URL } = __nccwpck_require__(310);
 
-const PerMessageDeflate = __nccwpck_require__(262);
-const Receiver = __nccwpck_require__(594);
-const Sender = __nccwpck_require__(209);
+const PerMessageDeflate = __nccwpck_require__(421);
+const Receiver = __nccwpck_require__(245);
+const Sender = __nccwpck_require__(415);
+const { isBlob } = __nccwpck_require__(444);
+
 const {
   BINARY_TYPES,
   EMPTY_BUFFER,
@@ -3446,12 +3583,12 @@ const {
   kStatusCode,
   kWebSocket,
   NOOP
-} = __nccwpck_require__(556);
+} = __nccwpck_require__(870);
 const {
   EventTarget: { addEventListener, removeEventListener }
-} = __nccwpck_require__(418);
-const { format, parse } = __nccwpck_require__(787);
-const { toBuffer } = __nccwpck_require__(870);
+} = __nccwpck_require__(456);
+const { format, parse } = __nccwpck_require__(694);
+const { toBuffer } = __nccwpck_require__(198);
 
 const closeTimeout = 30 * 1000;
 const kAborted = Symbol('kAborted');
@@ -3481,6 +3618,7 @@ class WebSocket extends EventEmitter {
     this._closeFrameSent = false;
     this._closeMessage = EMPTY_BUFFER;
     this._closeTimer = null;
+    this._errorEmitted = false;
     this._extensions = {};
     this._paused = false;
     this._protocol = '';
@@ -3513,9 +3651,8 @@ class WebSocket extends EventEmitter {
   }
 
   /**
-   * This deviates from the WHATWG interface since ws doesn't support the
-   * required default "blob" type (instead we define a custom "nodebuffer"
-   * type).
+   * For historical reasons, the custom "nodebuffer" type is used by the default
+   * instead of "blob".
    *
    * @type {String}
    */
@@ -3636,11 +3773,14 @@ class WebSocket extends EventEmitter {
       skipUTF8Validation: options.skipUTF8Validation
     });
 
-    this._sender = new Sender(socket, this._extensions, options.generateMask);
+    const sender = new Sender(socket, this._extensions, options.generateMask);
+
     this._receiver = receiver;
+    this._sender = sender;
     this._socket = socket;
 
     receiver[kWebSocket] = this;
+    sender[kWebSocket] = this;
     socket[kWebSocket] = this;
 
     receiver.on('conclude', receiverOnConclude);
@@ -3650,6 +3790,8 @@ class WebSocket extends EventEmitter {
     receiver.on('ping', receiverOnPing);
     receiver.on('pong', receiverOnPong);
 
+    sender.onerror = senderOnError;
+
     //
     // These methods may not be available if `socket` is just a `Duplex`.
     //
@@ -3745,13 +3887,7 @@ class WebSocket extends EventEmitter {
       }
     });
 
-    //
-    // Specify a timeout for the closing handshake to complete.
-    //
-    this._closeTimer = setTimeout(
-      this._socket.destroy.bind(this._socket),
-      closeTimeout
-    );
+    setCloseTimer(this);
   }
 
   /**
@@ -4455,6 +4591,11 @@ function initAsClient(websocket, address, protocols, options) {
  */
 function emitErrorAndClose(websocket, err) {
   websocket._readyState = WebSocket.CLOSING;
+  //
+  // The following assignment is practically useless and is done only for
+  // consistency.
+  //
+  websocket._errorEmitted = true;
   websocket.emit('error', err);
   websocket.emitClose();
 }
@@ -4535,7 +4676,7 @@ function abortHandshake(websocket, stream, message) {
  */
 function sendAfterClose(websocket, data, cb) {
   if (data) {
-    const length = toBuffer(data).length;
+    const length = isBlob(data) ? data.size : toBuffer(data).length;
 
     //
     // The `_bufferedAmount` property is used only when the peer is a client and
@@ -4611,7 +4752,10 @@ function receiverOnError(err) {
     websocket.close(err[kStatusCode]);
   }
 
-  websocket.emit('error', err);
+  if (!websocket._errorEmitted) {
+    websocket._errorEmitted = true;
+    websocket.emit('error', err);
+  }
 }
 
 /**
@@ -4667,6 +4811,47 @@ function resume(stream) {
   stream.resume();
 }
 
+/**
+ * The `Sender` error event handler.
+ *
+ * @param {Error} The error
+ * @private
+ */
+function senderOnError(err) {
+  const websocket = this[kWebSocket];
+
+  if (websocket.readyState === WebSocket.CLOSED) return;
+  if (websocket.readyState === WebSocket.OPEN) {
+    websocket._readyState = WebSocket.CLOSING;
+    setCloseTimer(websocket);
+  }
+
+  //
+  // `socket.end()` is used instead of `socket.destroy()` to allow the other
+  // peer to finish sending queued data. There is no need to set a timer here
+  // because `CLOSING` means that it is already set or not needed.
+  //
+  this._socket.end();
+
+  if (!websocket._errorEmitted) {
+    websocket._errorEmitted = true;
+    websocket.emit('error', err);
+  }
+}
+
+/**
+ * Set a timer to destroy the underlying raw socket of a WebSocket.
+ *
+ * @param {WebSocket} websocket The WebSocket instance
+ * @private
+ */
+function setCloseTimer(websocket) {
+  websocket._closeTimer = setTimeout(
+    websocket._socket.destroy.bind(websocket._socket),
+    closeTimeout
+  );
+}
+
 /**
  * The listener of the socket `'close'` event.
  *
@@ -4827,7 +5012,7 @@ module.exports = require("net");
 
 /***/ }),
 
-/***/ 955:
+/***/ 781:
 /***/ ((module) => {
 
 "use strict";
@@ -4901,7 +5086,7 @@ module.exports = require("zlib");
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
 /******/ 	// This entry module is referenced by other modules so it can't be inlined
-/******/ 	var __webpack_exports__ = __nccwpck_require__(781);
+/******/ 	var __webpack_exports__ = __nccwpck_require__(749);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()