@wabot-dev/framework 0.0.14 → 0.0.16

package/dist/src/node_modules/engine.io/node_modules/ws/lib/sender.js

@@ -1,513 +0,0 @@
-import require$$0 from 'stream';
-import require$$1 from 'crypto';
-import { __require as requirePermessageDeflate } from './permessage-deflate.js';
-import { __require as requireConstants } from './constants.js';
-import { __require as requireValidation } from './validation.js';
-import { __require as requireBufferUtil } from './buffer-util.js';
-
-/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
-
-var sender;
-var hasRequiredSender;
-
-function requireSender () {
-	if (hasRequiredSender) return sender;
-	hasRequiredSender = 1;
-
-	const { Duplex } = require$$0;
-	const { randomFillSync } = require$$1;
-
-	const PerMessageDeflate = requirePermessageDeflate();
-	const { EMPTY_BUFFER } = requireConstants();
-	const { isValidStatusCode } = requireValidation();
-	const { mask: applyMask, toBuffer } = requireBufferUtil();
-
-	const kByteLength = Symbol('kByteLength');
-	const maskBuffer = Buffer.alloc(4);
-	const RANDOM_POOL_SIZE = 8 * 1024;
-	let randomPool;
-	let randomPoolPointer = RANDOM_POOL_SIZE;
-
-	/**
-	 * HyBi Sender implementation.
-	 */
-	class Sender {
-	  /**
-	   * Creates a Sender instance.
-	   *
-	   * @param {Duplex} socket The connection socket
-	   * @param {Object} [extensions] An object containing the negotiated extensions
-	   * @param {Function} [generateMask] The function used to generate the masking
-	   *     key
-	   */
-	  constructor(socket, extensions, generateMask) {
-	    this._extensions = extensions || {};
-
-	    if (generateMask) {
-	      this._generateMask = generateMask;
-	      this._maskBuffer = Buffer.alloc(4);
-	    }
-
-	    this._socket = socket;
-
-	    this._firstFragment = true;
-	    this._compress = false;
-
-	    this._bufferedBytes = 0;
-	    this._deflating = false;
-	    this._queue = [];
-	  }
-
-	  /**
-	   * Frames a piece of data according to the HyBi WebSocket protocol.
-	   *
-	   * @param {(Buffer|String)} data The data to frame
-	   * @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
-	   * @return {(Buffer|String)[]} The framed data
-	   * @public
-	   */
-	  static frame(data, options) {
-	    let mask;
-	    let merge = false;
-	    let offset = 2;
-	    let skipMasking = false;
-
-	    if (options.mask) {
-	      mask = options.maskBuffer || maskBuffer;
-
-	      if (options.generateMask) {
-	        options.generateMask(mask);
-	      } else {
-	        if (randomPoolPointer === RANDOM_POOL_SIZE) {
-	          /* istanbul ignore else  */
-	          if (randomPool === undefined) {
-	            //
-	            // This is lazily initialized because server-sent frames must not
-	            // be masked so it may never be used.
-	            //
-	            randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
-	          }
-
-	          randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
-	          randomPoolPointer = 0;
-	        }
-
-	        mask[0] = randomPool[randomPoolPointer++];
-	        mask[1] = randomPool[randomPoolPointer++];
-	        mask[2] = randomPool[randomPoolPointer++];
-	        mask[3] = randomPool[randomPoolPointer++];
-	      }
-
-	      skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
-	      offset = 6;
-	    }
-
-	    let dataLength;
-
-	    if (typeof data === 'string') {
-	      if (
-	        (!options.mask || skipMasking) &&
-	        options[kByteLength] !== undefined
-	      ) {
-	        dataLength = options[kByteLength];
-	      } else {
-	        data = Buffer.from(data);
-	        dataLength = data.length;
-	      }
-	    } else {
-	      dataLength = data.length;
-	      merge = options.mask && options.readOnly && !skipMasking;
-	    }
-
-	    let payloadLength = dataLength;
-
-	    if (dataLength >= 65536) {
-	      offset += 8;
-	      payloadLength = 127;
-	    } else if (dataLength > 125) {
-	      offset += 2;
-	      payloadLength = 126;
-	    }
-
-	    const target = Buffer.allocUnsafe(merge ? dataLength + offset : offset);
-
-	    target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
-	    if (options.rsv1) target[0] |= 0x40;
-
-	    target[1] = payloadLength;
-
-	    if (payloadLength === 126) {
-	      target.writeUInt16BE(dataLength, 2);
-	    } else if (payloadLength === 127) {
-	      target[2] = target[3] = 0;
-	      target.writeUIntBE(dataLength, 4, 6);
-	    }
-
-	    if (!options.mask) return [target, data];
-
-	    target[1] |= 0x80;
-	    target[offset - 4] = mask[0];
-	    target[offset - 3] = mask[1];
-	    target[offset - 2] = mask[2];
-	    target[offset - 1] = mask[3];
-
-	    if (skipMasking) return [target, data];
-
-	    if (merge) {
-	      applyMask(data, mask, target, offset, dataLength);
-	      return [target];
-	    }
-
-	    applyMask(data, mask, data, 0, dataLength);
-	    return [target, data];
-	  }
-
-	  /**
-	   * Sends a close message to the other peer.
-	   *
-	   * @param {Number} [code] The status code component of the body
-	   * @param {(String|Buffer)} [data] The message component of the body
-	   * @param {Boolean} [mask=false] Specifies whether or not to mask the message
-	   * @param {Function} [cb] Callback
-	   * @public
-	   */
-	  close(code, data, mask, cb) {
-	    let buf;
-
-	    if (code === undefined) {
-	      buf = EMPTY_BUFFER;
-	    } else if (typeof code !== 'number' || !isValidStatusCode(code)) {
-	      throw new TypeError('First argument must be a valid error code number');
-	    } else if (data === undefined || !data.length) {
-	      buf = Buffer.allocUnsafe(2);
-	      buf.writeUInt16BE(code, 0);
-	    } else {
-	      const length = Buffer.byteLength(data);
-
-	      if (length > 123) {
-	        throw new RangeError('The message must not be greater than 123 bytes');
-	      }
-
-	      buf = Buffer.allocUnsafe(2 + length);
-	      buf.writeUInt16BE(code, 0);
-
-	      if (typeof data === 'string') {
-	        buf.write(data, 2);
-	      } else {
-	        buf.set(data, 2);
-	      }
-	    }
-
-	    const options = {
-	      [kByteLength]: buf.length,
-	      fin: true,
-	      generateMask: this._generateMask,
-	      mask,
-	      maskBuffer: this._maskBuffer,
-	      opcode: 0x08,
-	      readOnly: false,
-	      rsv1: false
-	    };
-
-	    if (this._deflating) {
-	      this.enqueue([this.dispatch, buf, false, options, cb]);
-	    } else {
-	      this.sendFrame(Sender.frame(buf, options), cb);
-	    }
-	  }
-
-	  /**
-	   * Sends a ping message to the other peer.
-	   *
-	   * @param {*} data The message to send
-	   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-	   * @param {Function} [cb] Callback
-	   * @public
-	   */
-	  ping(data, mask, cb) {
-	    let byteLength;
-	    let readOnly;
-
-	    if (typeof data === 'string') {
-	      byteLength = Buffer.byteLength(data);
-	      readOnly = false;
-	    } else {
-	      data = toBuffer(data);
-	      byteLength = data.length;
-	      readOnly = toBuffer.readOnly;
-	    }
-
-	    if (byteLength > 125) {
-	      throw new RangeError('The data size must not be greater than 125 bytes');
-	    }
-
-	    const options = {
-	      [kByteLength]: byteLength,
-	      fin: true,
-	      generateMask: this._generateMask,
-	      mask,
-	      maskBuffer: this._maskBuffer,
-	      opcode: 0x09,
-	      readOnly,
-	      rsv1: false
-	    };
-
-	    if (this._deflating) {
-	      this.enqueue([this.dispatch, data, false, options, cb]);
-	    } else {
-	      this.sendFrame(Sender.frame(data, options), cb);
-	    }
-	  }
-
-	  /**
-	   * Sends a pong message to the other peer.
-	   *
-	   * @param {*} data The message to send
-	   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-	   * @param {Function} [cb] Callback
-	   * @public
-	   */
-	  pong(data, mask, cb) {
-	    let byteLength;
-	    let readOnly;
-
-	    if (typeof data === 'string') {
-	      byteLength = Buffer.byteLength(data);
-	      readOnly = false;
-	    } else {
-	      data = toBuffer(data);
-	      byteLength = data.length;
-	      readOnly = toBuffer.readOnly;
-	    }
-
-	    if (byteLength > 125) {
-	      throw new RangeError('The data size must not be greater than 125 bytes');
-	    }
-
-	    const options = {
-	      [kByteLength]: byteLength,
-	      fin: true,
-	      generateMask: this._generateMask,
-	      mask,
-	      maskBuffer: this._maskBuffer,
-	      opcode: 0x0a,
-	      readOnly,
-	      rsv1: false
-	    };
-
-	    if (this._deflating) {
-	      this.enqueue([this.dispatch, data, false, options, cb]);
-	    } else {
-	      this.sendFrame(Sender.frame(data, options), cb);
-	    }
-	  }
-
-	  /**
-	   * Sends a data message to the other peer.
-	   *
-	   * @param {*} data The message to send
-	   * @param {Object} options Options object
-	   * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
-	   *     or text
-	   * @param {Boolean} [options.compress=false] Specifies whether or not to
-	   *     compress `data`
-	   * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
-	   *     last one
-	   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
-	   *     `data`
-	   * @param {Function} [cb] Callback
-	   * @public
-	   */
-	  send(data, options, cb) {
-	    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
-	    let opcode = options.binary ? 2 : 1;
-	    let rsv1 = options.compress;
-
-	    let byteLength;
-	    let readOnly;
-
-	    if (typeof data === 'string') {
-	      byteLength = Buffer.byteLength(data);
-	      readOnly = false;
-	    } else {
-	      data = toBuffer(data);
-	      byteLength = data.length;
-	      readOnly = toBuffer.readOnly;
-	    }
-
-	    if (this._firstFragment) {
-	      this._firstFragment = false;
-	      if (
-	        rsv1 &&
-	        perMessageDeflate &&
-	        perMessageDeflate.params[
-	          perMessageDeflate._isServer
-	            ? 'server_no_context_takeover'
-	            : 'client_no_context_takeover'
-	        ]
-	      ) {
-	        rsv1 = byteLength >= perMessageDeflate._threshold;
-	      }
-	      this._compress = rsv1;
-	    } else {
-	      rsv1 = false;
-	      opcode = 0;
-	    }
-
-	    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
-	      };
-
-	      if (this._deflating) {
-	        this.enqueue([this.dispatch, data, this._compress, opts, cb]);
-	      } else {
-	        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
-	      );
-	    }
-	  }
-
-	  /**
-	   * Dispatches a message.
-	   *
-	   * @param {(Buffer|String)} data The message to send
-	   * @param {Boolean} [compress=false] Specifies whether or not to compress
-	   *     `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
-	   */
-	  dispatch(data, compress, options, cb) {
-	    if (!compress) {
-	      this.sendFrame(Sender.frame(data, options), cb);
-	      return;
-	    }
-
-	    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
-
-	    this._bufferedBytes += options[kByteLength];
-	    this._deflating = true;
-	    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);
-	        }
-
-	        return;
-	      }
-
-	      this._bufferedBytes -= options[kByteLength];
-	      this._deflating = false;
-	      options.readOnly = false;
-	      this.sendFrame(Sender.frame(buf, options), cb);
-	      this.dequeue();
-	    });
-	  }
-
-	  /**
-	   * Executes queued send operations.
-	   *
-	   * @private
-	   */
-	  dequeue() {
-	    while (!this._deflating && this._queue.length) {
-	      const params = this._queue.shift();
-
-	      this._bufferedBytes -= params[3][kByteLength];
-	      Reflect.apply(params[0], this, params.slice(1));
-	    }
-	  }
-
-	  /**
-	   * Enqueues a send operation.
-	   *
-	   * @param {Array} params Send operation parameters.
-	   * @private
-	   */
-	  enqueue(params) {
-	    this._bufferedBytes += params[3][kByteLength];
-	    this._queue.push(params);
-	  }
-
-	  /**
-	   * Sends a frame.
-	   *
-	   * @param {Buffer[]} list The frame to send
-	   * @param {Function} [cb] Callback
-	   * @private
-	   */
-	  sendFrame(list, cb) {
-	    if (list.length === 2) {
-	      this._socket.cork();
-	      this._socket.write(list[0]);
-	      this._socket.write(list[1], cb);
-	      this._socket.uncork();
-	    } else {
-	      this._socket.write(list[0], cb);
-	    }
-	  }
-	}
-
-	sender = Sender;
-	return sender;
-}
-
-export { requireSender as __require };

package/dist/src/node_modules/engine.io/node_modules/ws/lib/stream.js

@@ -1,170 +0,0 @@
-import require$$0 from 'stream';
-
-var stream;
-var hasRequiredStream;
-
-function requireStream () {
-	if (hasRequiredStream) return stream;
-	hasRequiredStream = 1;
-
-	const { Duplex } = require$$0;
-
-	/**
-	 * Emits the `'close'` event on a stream.
-	 *
-	 * @param {Duplex} stream The stream.
-	 * @private
-	 */
-	function emitClose(stream) {
-	  stream.emit('close');
-	}
-
-	/**
-	 * The listener of the `'end'` event.
-	 *
-	 * @private
-	 */
-	function duplexOnEnd() {
-	  if (!this.destroyed && this._writableState.finished) {
-	    this.destroy();
-	  }
-	}
-
-	/**
-	 * The listener of the `'error'` event.
-	 *
-	 * @param {Error} err The error
-	 * @private
-	 */
-	function duplexOnError(err) {
-	  this.removeListener('error', duplexOnError);
-	  this.destroy();
-	  if (this.listenerCount('error') === 0) {
-	    // Do not suppress the throwing behavior.
-	    this.emit('error', err);
-	  }
-	}
-
-	/**
-	 * Wraps a `WebSocket` in a duplex stream.
-	 *
-	 * @param {WebSocket} ws The `WebSocket` to wrap
-	 * @param {Object} [options] The options for the `Duplex` constructor
-	 * @return {Duplex} The duplex stream
-	 * @public
-	 */
-	function createWebSocketStream(ws, options) {
-	  let terminateOnDestroy = true;
-
-	  const duplex = new Duplex({
-	    ...options,
-	    autoDestroy: false,
-	    emitClose: false,
-	    objectMode: false,
-	    writableObjectMode: false
-	  });
-
-	  ws.on('message', function message(msg, isBinary) {
-	    const data =
-	      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
-
-	    if (!duplex.push(data)) ws.pause();
-	  });
-
-	  ws.once('error', function error(err) {
-	    if (duplex.destroyed) return;
-
-	    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
-	    //
-	    // - If the `'error'` event is emitted before the `'open'` event, then
-	    //   `ws.terminate()` is a noop as no socket is assigned.
-	    // - Otherwise, the error is re-emitted by the listener of the `'error'`
-	    //   event of the `Receiver` object. The listener already closes the
-	    //   connection by calling `ws.close()`. This allows a close frame to be
-	    //   sent to the other peer. If `ws.terminate()` is called right after this,
-	    //   then the close frame might not be sent.
-	    terminateOnDestroy = false;
-	    duplex.destroy(err);
-	  });
-
-	  ws.once('close', function close() {
-	    if (duplex.destroyed) return;
-
-	    duplex.push(null);
-	  });
-
-	  duplex._destroy = function (err, callback) {
-	    if (ws.readyState === ws.CLOSED) {
-	      callback(err);
-	      process.nextTick(emitClose, duplex);
-	      return;
-	    }
-
-	    let called = false;
-
-	    ws.once('error', function error(err) {
-	      called = true;
-	      callback(err);
-	    });
-
-	    ws.once('close', function close() {
-	      if (!called) callback(err);
-	      process.nextTick(emitClose, duplex);
-	    });
-
-	    if (terminateOnDestroy) ws.terminate();
-	  };
-
-	  duplex._final = function (callback) {
-	    if (ws.readyState === ws.CONNECTING) {
-	      ws.once('open', function open() {
-	        duplex._final(callback);
-	      });
-	      return;
-	    }
-
-	    // If the value of the `_socket` property is `null` it means that `ws` is a
-	    // client websocket and the handshake failed. In fact, when this happens, a
-	    // socket is never assigned to the websocket. Wait for the `'error'` event
-	    // that will be emitted by the websocket.
-	    if (ws._socket === null) return;
-
-	    if (ws._socket._writableState.finished) {
-	      callback();
-	      if (duplex._readableState.endEmitted) duplex.destroy();
-	    } else {
-	      ws._socket.once('finish', function finish() {
-	        // `duplex` is not destroyed here because the `'end'` event will be
-	        // emitted on `duplex` after this `'finish'` event. The EOF signaling
-	        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
-	        callback();
-	      });
-	      ws.close();
-	    }
-	  };
-
-	  duplex._read = function () {
-	    if (ws.isPaused) ws.resume();
-	  };
-
-	  duplex._write = function (chunk, encoding, callback) {
-	    if (ws.readyState === ws.CONNECTING) {
-	      ws.once('open', function open() {
-	        duplex._write(chunk, encoding, callback);
-	      });
-	      return;
-	    }
-
-	    ws.send(chunk, callback);
-	  };
-
-	  duplex.on('end', duplexOnEnd);
-	  duplex.on('error', duplexOnError);
-	  return duplex;
-	}
-
-	stream = createWebSocketStream;
-	return stream;
-}
-
-export { requireStream as __require };