iosignal 5.1.2 → 5.1.4

package/dist/iosignal.js

@@ -2,18 +2,19 @@ import require$$0$2, { Transform } from 'stream';
 import net from 'net';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
-import require$$2 from 'http';
+import require$$2$2 from 'http';
 import require$$4 from 'tls';
 import require$$1 from 'crypto';
 import require$$7 from 'url';
 import require$$0 from 'zlib';
-import require$$0$1 from 'buffer';
-import { networkInterfaces } from 'os';
 import fs, { readFileSync } from 'fs';
-import { memoryUsage } from 'process';
 import path from 'path';
+import require$$2, { networkInterfaces } from 'os';
+import require$$0$1 from 'buffer';
+import require$$2$1 from 'util';
+import { memoryUsage } from 'process';
 
-var version$1 = "5.1.2";
+var version$1 = "5.1.4";
 var pkg = {
 	version: version$1};
 
@@ -2180,6 +2181,7 @@ function requireConstants () {
 
 	constants = {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT: 30000,
 	  EMPTY_BUFFER: Buffer.alloc(0),
 	  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
 	  hasBlob,
@@ -2192,6 +2194,300 @@ function requireConstants () {
 	return constants;
 }
 
+var bufferutil = {exports: {}};
+
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+var nodeGypBuild$1 = {exports: {}};
+
+var nodeGypBuild;
+var hasRequiredNodeGypBuild$1;
+
+function requireNodeGypBuild$1 () {
+	if (hasRequiredNodeGypBuild$1) return nodeGypBuild;
+	hasRequiredNodeGypBuild$1 = 1;
+	var fs$1 = fs;
+	var path$1 = path;
+	var os = require$$2;
+
+	// Workaround to fix webpack's build warnings: 'the request of a dependency is an expression'
+	var runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : commonjsRequire; // eslint-disable-line
+
+	var vars = (process.config && process.config.variables) || {};
+	var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
+	var abi = process.versions.modules; // TODO: support old node where this is undef
+	var runtime = isElectron() ? 'electron' : (isNwjs() ? 'node-webkit' : 'node');
+
+	var arch = process.env.npm_config_arch || os.arch();
+	var platform = process.env.npm_config_platform || os.platform();
+	var libc = process.env.LIBC || (isAlpine(platform) ? 'musl' : 'glibc');
+	var armv = process.env.ARM_VERSION || (arch === 'arm64' ? '8' : vars.arm_version) || '';
+	var uv = (process.versions.uv || '').split('.')[0];
+
+	nodeGypBuild = load;
+
+	function load (dir) {
+	  return runtimeRequire(load.resolve(dir))
+	}
+
+	load.resolve = load.path = function (dir) {
+	  dir = path$1.resolve(dir || '.');
+
+	  try {
+	    var name = runtimeRequire(path$1.join(dir, 'package.json')).name.toUpperCase().replace(/-/g, '_');
+	    if (process.env[name + '_PREBUILD']) dir = process.env[name + '_PREBUILD'];
+	  } catch (err) {}
+
+	  if (!prebuildsOnly) {
+	    var release = getFirst(path$1.join(dir, 'build/Release'), matchBuild);
+	    if (release) return release
+
+	    var debug = getFirst(path$1.join(dir, 'build/Debug'), matchBuild);
+	    if (debug) return debug
+	  }
+
+	  var prebuild = resolve(dir);
+	  if (prebuild) return prebuild
+
+	  var nearby = resolve(path$1.dirname(process.execPath));
+	  if (nearby) return nearby
+
+	  var target = [
+	    'platform=' + platform,
+	    'arch=' + arch,
+	    'runtime=' + runtime,
+	    'abi=' + abi,
+	    'uv=' + uv,
+	    armv ? 'armv=' + armv : '',
+	    'libc=' + libc,
+	    'node=' + process.versions.node,
+	    process.versions.electron ? 'electron=' + process.versions.electron : '',
+	    typeof __webpack_require__ === 'function' ? 'webpack=true' : '' // eslint-disable-line
+	  ].filter(Boolean).join(' ');
+
+	  throw new Error('No native build was found for ' + target + '\n    loaded from: ' + dir + '\n')
+
+	  function resolve (dir) {
+	    // Find matching "prebuilds/<platform>-<arch>" directory
+	    var tuples = readdirSync(path$1.join(dir, 'prebuilds')).map(parseTuple);
+	    var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
+	    if (!tuple) return
+
+	    // Find most specific flavor first
+	    var prebuilds = path$1.join(dir, 'prebuilds', tuple.name);
+	    var parsed = readdirSync(prebuilds).map(parseTags);
+	    var candidates = parsed.filter(matchTags(runtime, abi));
+	    var winner = candidates.sort(compareTags(runtime))[0];
+	    if (winner) return path$1.join(prebuilds, winner.file)
+	  }
+	};
+
+	function readdirSync (dir) {
+	  try {
+	    return fs$1.readdirSync(dir)
+	  } catch (err) {
+	    return []
+	  }
+	}
+
+	function getFirst (dir, filter) {
+	  var files = readdirSync(dir).filter(filter);
+	  return files[0] && path$1.join(dir, files[0])
+	}
+
+	function matchBuild (name) {
+	  return /\.node$/.test(name)
+	}
+
+	function parseTuple (name) {
+	  // Example: darwin-x64+arm64
+	  var arr = name.split('-');
+	  if (arr.length !== 2) return
+
+	  var platform = arr[0];
+	  var architectures = arr[1].split('+');
+
+	  if (!platform) return
+	  if (!architectures.length) return
+	  if (!architectures.every(Boolean)) return
+
+	  return { name, platform, architectures }
+	}
+
+	function matchTuple (platform, arch) {
+	  return function (tuple) {
+	    if (tuple == null) return false
+	    if (tuple.platform !== platform) return false
+	    return tuple.architectures.includes(arch)
+	  }
+	}
+
+	function compareTuples (a, b) {
+	  // Prefer single-arch prebuilds over multi-arch
+	  return a.architectures.length - b.architectures.length
+	}
+
+	function parseTags (file) {
+	  var arr = file.split('.');
+	  var extension = arr.pop();
+	  var tags = { file: file, specificity: 0 };
+
+	  if (extension !== 'node') return
+
+	  for (var i = 0; i < arr.length; i++) {
+	    var tag = arr[i];
+
+	    if (tag === 'node' || tag === 'electron' || tag === 'node-webkit') {
+	      tags.runtime = tag;
+	    } else if (tag === 'napi') {
+	      tags.napi = true;
+	    } else if (tag.slice(0, 3) === 'abi') {
+	      tags.abi = tag.slice(3);
+	    } else if (tag.slice(0, 2) === 'uv') {
+	      tags.uv = tag.slice(2);
+	    } else if (tag.slice(0, 4) === 'armv') {
+	      tags.armv = tag.slice(4);
+	    } else if (tag === 'glibc' || tag === 'musl') {
+	      tags.libc = tag;
+	    } else {
+	      continue
+	    }
+
+	    tags.specificity++;
+	  }
+
+	  return tags
+	}
+
+	function matchTags (runtime, abi) {
+	  return function (tags) {
+	    if (tags == null) return false
+	    if (tags.runtime && tags.runtime !== runtime && !runtimeAgnostic(tags)) return false
+	    if (tags.abi && tags.abi !== abi && !tags.napi) return false
+	    if (tags.uv && tags.uv !== uv) return false
+	    if (tags.armv && tags.armv !== armv) return false
+	    if (tags.libc && tags.libc !== libc) return false
+
+	    return true
+	  }
+	}
+
+	function runtimeAgnostic (tags) {
+	  return tags.runtime === 'node' && tags.napi
+	}
+
+	function compareTags (runtime) {
+	  // Precedence: non-agnostic runtime, abi over napi, then by specificity.
+	  return function (a, b) {
+	    if (a.runtime !== b.runtime) {
+	      return a.runtime === runtime ? -1 : 1
+	    } else if (a.abi !== b.abi) {
+	      return a.abi ? -1 : 1
+	    } else if (a.specificity !== b.specificity) {
+	      return a.specificity > b.specificity ? -1 : 1
+	    } else {
+	      return 0
+	    }
+	  }
+	}
+
+	function isNwjs () {
+	  return !!(process.versions && process.versions.nw)
+	}
+
+	function isElectron () {
+	  if (process.versions && process.versions.electron) return true
+	  if (process.env.ELECTRON_RUN_AS_NODE) return true
+	  return typeof window !== 'undefined' && window.process && window.process.type === 'renderer'
+	}
+
+	function isAlpine (platform) {
+	  return platform === 'linux' && fs$1.existsSync('/etc/alpine-release')
+	}
+
+	// Exposed for unit tests
+	// TODO: move to lib
+	load.parseTags = parseTags;
+	load.matchTags = matchTags;
+	load.compareTags = compareTags;
+	load.parseTuple = parseTuple;
+	load.matchTuple = matchTuple;
+	load.compareTuples = compareTuples;
+	return nodeGypBuild;
+}
+
+var hasRequiredNodeGypBuild;
+
+function requireNodeGypBuild () {
+	if (hasRequiredNodeGypBuild) return nodeGypBuild$1.exports;
+	hasRequiredNodeGypBuild = 1;
+	const runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : commonjsRequire; // eslint-disable-line
+	if (typeof runtimeRequire.addon === 'function') { // if the platform supports native resolving prefer that
+	  nodeGypBuild$1.exports = runtimeRequire.addon.bind(runtimeRequire);
+	} else { // else use the runtime version here
+	  nodeGypBuild$1.exports = requireNodeGypBuild$1();
+	}
+	return nodeGypBuild$1.exports;
+}
+
+var fallback$1;
+var hasRequiredFallback$1;
+
+function requireFallback$1 () {
+	if (hasRequiredFallback$1) return fallback$1;
+	hasRequiredFallback$1 = 1;
+
+	/**
+	 * Masks a buffer using the given mask.
+	 *
+	 * @param {Buffer} source The buffer to mask
+	 * @param {Buffer} mask The mask to use
+	 * @param {Buffer} output The buffer where to store the result
+	 * @param {Number} offset The offset at which to start writing
+	 * @param {Number} length The number of bytes to mask.
+	 * @public
+	 */
+	const mask = (source, mask, output, offset, length) => {
+	  for (var i = 0; i < length; i++) {
+	    output[offset + i] = source[i] ^ mask[i & 3];
+	  }
+	};
+
+	/**
+	 * Unmasks a buffer using the given mask.
+	 *
+	 * @param {Buffer} buffer The buffer to unmask
+	 * @param {Buffer} mask The mask to use
+	 * @public
+	 */
+	const unmask = (buffer, mask) => {
+	  // Required until https://github.com/nodejs/node/issues/9006 is resolved.
+	  const length = buffer.length;
+	  for (var i = 0; i < length; i++) {
+	    buffer[i] ^= mask[i & 3];
+	  }
+	};
+
+	fallback$1 = { mask, unmask };
+	return fallback$1;
+}
+
+var hasRequiredBufferutil;
+
+function requireBufferutil () {
+	if (hasRequiredBufferutil) return bufferutil.exports;
+	hasRequiredBufferutil = 1;
+
+	try {
+	  bufferutil.exports = requireNodeGypBuild()(__dirname);
+	} catch (e) {
+	  bufferutil.exports = requireFallback$1();
+	}
+	return bufferutil.exports;
+}
+
 var hasRequiredBufferUtil;
 
 function requireBufferUtil () {
@@ -2312,7 +2608,7 @@ function requireBufferUtil () {
 	/* istanbul ignore else  */
 	if (!process.env.WS_NO_BUFFER_UTIL) {
 	  try {
-	    const bufferUtil$1 = require('bufferutil');
+	    const bufferUtil$1 = requireBufferutil();
 
 	    bufferUtil.exports.mask = function (source, mask, output, offset, length) {
 	      if (length < 48) _mask(source, mask, output, offset, length);
@@ -2437,6 +2733,9 @@ function requirePermessageDeflate () {
 	   *     acknowledge disabling of client context takeover
 	   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
 	   *     calls to zlib
+	   * @param {Boolean} [options.isServer=false] Create the instance in either
+	   *     server or client mode
+	   * @param {Number} [options.maxPayload=0] The maximum allowed message length
 	   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
 	   *     use of a custom server window size
 	   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
@@ -2447,16 +2746,13 @@ function requirePermessageDeflate () {
 	   *     deflate
 	   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
 	   *     inflate
-	   * @param {Boolean} [isServer=false] Create the instance in either server or
-	   *     client mode
-	   * @param {Number} [maxPayload=0] The maximum allowed message length
 	   */
-	  constructor(options, isServer, maxPayload) {
-	    this._maxPayload = maxPayload | 0;
+	  constructor(options) {
 	    this._options = options || {};
 	    this._threshold =
 	      this._options.threshold !== undefined ? this._options.threshold : 1024;
-	    this._isServer = !!isServer;
+	    this._maxPayload = this._options.maxPayload | 0;
+	    this._isServer = !!this._options.isServer;
 	    this._deflate = null;
 	    this._inflate = null;
 
@@ -2567,7 +2863,9 @@ function requirePermessageDeflate () {
 	            (typeof opts.serverMaxWindowBits === 'number' &&
 	              opts.serverMaxWindowBits > params.server_max_window_bits))) ||
 	        (typeof opts.clientMaxWindowBits === 'number' &&
-	          !params.client_max_window_bits)
+	          (typeof params.client_max_window_bits === 'number'
+	            ? opts.clientMaxWindowBits > params.client_max_window_bits
+	            : !params.client_max_window_bits))
 	      ) {
 	        return false;
 	      }
@@ -2931,6 +3229,92 @@ function requirePermessageDeflate () {
 
 var validation = {exports: {}};
 
+var utf8Validate = {exports: {}};
+
+var fallback;
+var hasRequiredFallback;
+
+function requireFallback () {
+	if (hasRequiredFallback) return fallback;
+	hasRequiredFallback = 1;
+
+	/**
+	 * Checks if a given buffer contains only correct UTF-8.
+	 * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
+	 * Markus Kuhn.
+	 *
+	 * @param {Buffer} buf The buffer to check
+	 * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
+	 * @public
+	 */
+	function isValidUTF8(buf) {
+	  const len = buf.length;
+	  let i = 0;
+
+	  while (i < len) {
+	    if ((buf[i] & 0x80) === 0x00) {  // 0xxxxxxx
+	      i++;
+	    } else if ((buf[i] & 0xe0) === 0xc0) {  // 110xxxxx 10xxxxxx
+	      if (
+	        i + 1 === len ||
+	        (buf[i + 1] & 0xc0) !== 0x80 ||
+	        (buf[i] & 0xfe) === 0xc0  // overlong
+	      ) {
+	        return false;
+	      }
+
+	      i += 2;
+	    } else if ((buf[i] & 0xf0) === 0xe0) {  // 1110xxxx 10xxxxxx 10xxxxxx
+	      if (
+	        i + 2 >= len ||
+	        (buf[i + 1] & 0xc0) !== 0x80 ||
+	        (buf[i + 2] & 0xc0) !== 0x80 ||
+	        buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80 ||  // overlong
+	        buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0  // surrogate (U+D800 - U+DFFF)
+	      ) {
+	        return false;
+	      }
+
+	      i += 3;
+	    } else if ((buf[i] & 0xf8) === 0xf0) {  // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+	      if (
+	        i + 3 >= len ||
+	        (buf[i + 1] & 0xc0) !== 0x80 ||
+	        (buf[i + 2] & 0xc0) !== 0x80 ||
+	        (buf[i + 3] & 0xc0) !== 0x80 ||
+	        buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80 ||  // overlong
+	        buf[i] === 0xf4 && buf[i + 1] > 0x8f || buf[i] > 0xf4  // > U+10FFFF
+	      ) {
+	        return false;
+	      }
+
+	      i += 4;
+	    } else {
+	      return false;
+	    }
+	  }
+
+	  return true;
+	}
+
+	fallback = isValidUTF8;
+	return fallback;
+}
+
+var hasRequiredUtf8Validate;
+
+function requireUtf8Validate () {
+	if (hasRequiredUtf8Validate) return utf8Validate.exports;
+	hasRequiredUtf8Validate = 1;
+
+	try {
+	  utf8Validate.exports = requireNodeGypBuild()(__dirname);
+	} catch (e) {
+	  utf8Validate.exports = requireFallback();
+	}
+	return utf8Validate.exports;
+}
+
 var hasRequiredValidation;
 
 function requireValidation () {
@@ -3078,7 +3462,7 @@ function requireValidation () {
 	  };
 	} /* istanbul ignore else  */ else if (!process.env.WS_NO_UTF_8_VALIDATE) {
 	  try {
-	    const isValidUTF8 = require('utf-8-validate');
+	    const isValidUTF8 = requireUtf8Validate();
 
 	    validation.exports.isValidUTF8 = function (buf) {
 	      return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
@@ -3137,6 +3521,10 @@ function requireReceiver () {
 	   *     extensions
 	   * @param {Boolean} [options.isServer=false] Specifies whether to operate in
 	   *     client or server mode
+	   * @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 length
 	   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
 	   *     not to skip UTF-8 validation for text and close messages
@@ -3151,6 +3539,8 @@ function requireReceiver () {
 	    this._binaryType = options.binaryType || BINARY_TYPES[0];
 	    this._extensions = options.extensions || {};
 	    this._isServer = !!options.isServer;
+	    this._maxBufferedChunks = options.maxBufferedChunks | 0;
+	    this._maxFragments = options.maxFragments | 0;
 	    this._maxPayload = options.maxPayload | 0;
 	    this._skipUTF8Validation = !!options.skipUTF8Validation;
 	    this[kWebSocket] = undefined;
@@ -3168,6 +3558,7 @@ function requireReceiver () {
 
 	    this._totalPayloadLength = 0;
 	    this._messageLength = 0;
+	    this._numFragments = 0;
 	    this._fragments = [];
 
 	    this._errored = false;
@@ -3186,6 +3577,22 @@ function requireReceiver () {
 	  _write(chunk, encoding, cb) {
 	    if (this._opcode === 0x08 && this._state == GET_INFO) return cb();
 
+	    if (
+	      this._maxBufferedChunks > 0 &&
+	      this._buffers.length >= this._maxBufferedChunks
+	    ) {
+	      cb(
+	        this.createError(
+	          RangeError,
+	          'Too many buffered chunks',
+	          false,
+	          1008,
+	          'WS_ERR_TOO_MANY_BUFFERED_PARTS'
+	        )
+	      );
+	      return;
+	    }
+
 	    this._bufferedBytes += chunk.length;
 	    this._buffers.push(chunk);
 	    this.startLoop(cb);
@@ -3575,6 +3982,19 @@ function requireReceiver () {
 	      return;
 	    }
 
+	    if (this._maxFragments > 0 && ++this._numFragments > this._maxFragments) {
+	      const error = this.createError(
+	        RangeError,
+	        'Too many message fragments',
+	        false,
+	        1008,
+	        'WS_ERR_TOO_MANY_BUFFERED_PARTS'
+	      );
+
+	      cb(error);
+	      return;
+	    }
+
 	    if (this._compressed) {
 	      this._state = INFLATING;
 	      this.decompress(data, cb);
@@ -3647,6 +4067,7 @@ function requireReceiver () {
 	    this._totalPayloadLength = 0;
 	    this._messageLength = 0;
 	    this._fragmented = 0;
+	    this._numFragments = 0;
 	    this._fragments = [];
 
 	    if (this._opcode === 2) {
@@ -3815,6 +4236,9 @@ function requireSender () {
 
 	const { Duplex } = require$$0$2;
 	const { randomFillSync } = require$$1;
+	const {
+	  types: { isUint8Array }
+	} = require$$2$1;
 
 	const PerMessageDeflate = requirePermessageDeflate();
 	const { EMPTY_BUFFER, kWebSocket, NOOP } = requireConstants();
@@ -4011,8 +4435,10 @@ function requireSender () {
 
 	      if (typeof data === 'string') {
 	        buf.write(data, 2);
-	      } else {
+	      } else if (isUint8Array(data)) {
 	        buf.set(data, 2);
+	      } else {
+	        throw new TypeError('Second argument must be a string or a Uint8Array');
 	      }
 	    }
 
@@ -4936,7 +5362,7 @@ function requireWebsocket () {
 
 	const EventEmitter = require$$0$3;
 	const https = require$$1$1;
-	const http = require$$2;
+	const http = require$$2$2;
 	const net$1 = net;
 	const tls = require$$4;
 	const { randomBytes, createHash } = require$$1;
@@ -4950,6 +5376,7 @@ function requireWebsocket () {
 
 	const {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT,
 	  EMPTY_BUFFER,
 	  GUID,
 	  kForOnEventAttribute,
@@ -4964,7 +5391,6 @@ function requireWebsocket () {
 	const { format, parse } = requireExtension();
 	const { toBuffer } = requireBufferUtil();
 
-	const closeTimeout = 30 * 1000;
 	const kAborted = Symbol('kAborted');
 	const protocolVersions = [8, 13];
 	const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
@@ -5020,6 +5446,7 @@ function requireWebsocket () {
 	      initAsClient(this, address, protocols, options);
 	    } else {
 	      this._autoPong = options.autoPong;
+	      this._closeTimeout = options.closeTimeout;
 	      this._isServer = true;
 	    }
 	  }
@@ -5132,6 +5559,10 @@ function requireWebsocket () {
 	   *     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
@@ -5143,6 +5574,8 @@ function requireWebsocket () {
 	      binaryType: this.binaryType,
 	      extensions: this._extensions,
 	      isServer: this._isServer,
+	      maxBufferedChunks: options.maxBufferedChunks,
+	      maxFragments: options.maxFragments,
 	      maxPayload: options.maxPayload,
 	      skipUTF8Validation: options.skipUTF8Validation
 	    });
@@ -5561,6 +5994,8 @@ function requireWebsocket () {
 	 *     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
@@ -5569,6 +6004,10 @@ function requireWebsocket () {
 	 *     masking key
 	 * @param {Number} [options.handshakeTimeout] Timeout in milliseconds for the
 	 *     handshake request
+	 * @param {Number} [options.maxBufferedChunks=262144] The maximum number of
+	 *     buffered data chunks
+	 * @param {Number} [options.maxFragments=16384] 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
@@ -5587,7 +6026,10 @@ function requireWebsocket () {
 	  const opts = {
 	    allowSynchronousEvents: true,
 	    autoPong: true,
+	    closeTimeout: CLOSE_TIMEOUT,
 	    protocolVersion: protocolVersions[1],
+	    maxBufferedChunks: 256 * 1024,
+	    maxFragments: 16 * 1024,
 	    maxPayload: 100 * 1024 * 1024,
 	    skipUTF8Validation: false,
 	    perMessageDeflate: true,
@@ -5605,6 +6047,7 @@ function requireWebsocket () {
 	  };
 
 	  websocket._autoPong = opts.autoPong;
+	  websocket._closeTimeout = opts.closeTimeout;
 
 	  if (!protocolVersions.includes(opts.protocolVersion)) {
 	    throw new RangeError(
@@ -5620,7 +6063,7 @@ function requireWebsocket () {
 	  } else {
 	    try {
 	      parsedUrl = new URL(address);
-	    } catch (e) {
+	    } catch {
 	      throw new SyntaxError(`Invalid URL: ${address}`);
 	    }
 	  }
@@ -5682,11 +6125,11 @@ function requireWebsocket () {
 	  opts.timeout = opts.handshakeTimeout;
 
 	  if (opts.perMessageDeflate) {
-	    perMessageDeflate = new PerMessageDeflate(
-	      opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
-	      false,
-	      opts.maxPayload
-	    );
+	    perMessageDeflate = new PerMessageDeflate({
+	      ...opts.perMessageDeflate,
+	      isServer: false,
+	      maxPayload: opts.maxPayload
+	    });
 	    opts.headers['Sec-WebSocket-Extensions'] = format({
 	      [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
 	    });
@@ -5944,6 +6387,8 @@ function requireWebsocket () {
 	    websocket.setSocket(socket, head, {
 	      allowSynchronousEvents: opts.allowSynchronousEvents,
 	      generateMask: opts.generateMask,
+	      maxBufferedChunks: opts.maxBufferedChunks,
+	      maxFragments: opts.maxFragments,
 	      maxPayload: opts.maxPayload,
 	      skipUTF8Validation: opts.skipUTF8Validation
 	    });
@@ -6222,7 +6667,7 @@ function requireWebsocket () {
 	function setCloseTimer(websocket) {
 	  websocket._closeTimer = setTimeout(
 	    websocket._socket.destroy.bind(websocket._socket),
-	    closeTimeout
+	    websocket._closeTimeout
 	  );
 	}
 
@@ -6240,23 +6685,23 @@ function requireWebsocket () {
 
 	  websocket._readyState = WebSocket.CLOSING;
 
-	  let chunk;
-
 	  //
 	  // 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 and `readable.read()`
-	  // will return `null`. If instead, the socket is paused, any possible buffered
-	  // data will be read as a single chunk.
+	  // 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 &&
-	    (chunk = websocket._socket.read()) !== null
+	    this._readableState.length !== 0
 	  ) {
+	    const chunk = this.read(this._readableState.length);
+
 	    websocket._receiver.write(chunk);
 	  }
 
@@ -6493,13 +6938,14 @@ function requireStream () {
 
 requireStream();
 
+requireExtension();
+
+requirePermessageDeflate();
+
 requireReceiver();
 
 requireSender();
 
-var websocketExports = requireWebsocket();
-var WebSocket = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
-
 var subprotocol;
 var hasRequiredSubprotocol;
 
@@ -6570,6 +7016,11 @@ function requireSubprotocol () {
 	return subprotocol;
 }
 
+requireSubprotocol();
+
+var websocketExports = requireWebsocket();
+var WebSocket = /*@__PURE__*/getDefaultExportFromCjs(websocketExports);
+
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex$", "caughtErrors": "none" }] */
 
 var websocketServer;
@@ -6580,7 +7031,7 @@ function requireWebsocketServer () {
 	hasRequiredWebsocketServer = 1;
 
 	const EventEmitter = require$$0$3;
-	const http = require$$2;
+	const http = require$$2$2;
 	const { Duplex } = require$$0$2;
 	const { createHash } = require$$1;
 
@@ -6588,7 +7039,7 @@ function requireWebsocketServer () {
 	const PerMessageDeflate = requirePermessageDeflate();
 	const subprotocol = requireSubprotocol();
 	const WebSocket = requireWebsocket();
-	const { GUID, kWebSocket } = requireConstants();
+	const { CLOSE_TIMEOUT, GUID, kWebSocket } = requireConstants();
 
 	const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
 
@@ -6615,8 +7066,15 @@ function requireWebsocketServer () {
 	   *     pending connections
 	   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
 	   *     track clients
+	   * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
+	   *     wait for the closing handshake to finish after `websocket.close()` is
+	   *     called
 	   * @param {Function} [options.handleProtocols] A hook to handle protocols
 	   * @param {String} [options.host] The hostname where to bind the server
+	   * @param {Number} [options.maxBufferedChunks=262144] The maximum number of
+	   *     buffered data chunks
+	   * @param {Number} [options.maxFragments=16384] The maximum number of message
+	   *     fragments
 	   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
 	   *     size
 	   * @param {Boolean} [options.noServer=false] Enable no server mode
@@ -6639,11 +7097,14 @@ function requireWebsocketServer () {
 	    options = {
 	      allowSynchronousEvents: true,
 	      autoPong: true,
+	      maxBufferedChunks: 256 * 1024,
+	      maxFragments: 16 * 1024,
 	      maxPayload: 100 * 1024 * 1024,
 	      skipUTF8Validation: false,
 	      perMessageDeflate: false,
 	      handleProtocols: null,
 	      clientTracking: true,
+	      closeTimeout: CLOSE_TIMEOUT,
 	      verifyClient: null,
 	      noServer: false,
 	      backlog: null, // use default (511 as implemented in net.js)
@@ -6866,11 +7327,11 @@ function requireWebsocketServer () {
 	      this.options.perMessageDeflate &&
 	      secWebSocketExtensions !== undefined
 	    ) {
-	      const perMessageDeflate = new PerMessageDeflate(
-	        this.options.perMessageDeflate,
-	        true,
-	        this.options.maxPayload
-	      );
+	      const perMessageDeflate = new PerMessageDeflate({
+	        ...this.options.perMessageDeflate,
+	        isServer: true,
+	        maxPayload: this.options.maxPayload
+	      });
 
 	      try {
 	        const offers = extension.parse(secWebSocketExtensions);
@@ -6997,6 +7458,8 @@ function requireWebsocketServer () {
 
 	    ws.setSocket(socket, head, {
 	      allowSynchronousEvents: this.options.allowSynchronousEvents,
+	      maxBufferedChunks: this.options.maxBufferedChunks,
+	      maxFragments: this.options.maxFragments,
 	      maxPayload: this.options.maxPayload,
 	      skipUTF8Validation: this.options.skipUTF8Validation
 	    });