dragonfly_chrome_headless 0.2.0

data/node_modules/ws/SECURITY.md

@@ -0,0 +1,33 @@
+# Security Guidelines
+
+Please contact us directly at **security@3rd-Eden.com** for any bug that might
+impact the security of this project. Please prefix the subject of your email
+with `[security]` in lowercase and square brackets. Our email filters will
+automatically prevent these messages from being moved to our spam box.
+
+You will receive an acknowledgement of your report within **24 hours**.
+
+All emails that do not include security vulnerabilities will be removed and
+blocked instantly.
+
+## Exceptions
+
+If you do not receive an acknowledgement within the said time frame please give
+us the benefit of the doubt as it's possible that we haven't seen it yet. In
+this case please send us a message **without details** using one of the
+following methods:
+
+- Contact the lead developers of this project on their personal e-mails. You
+  can find the e-mails in the git logs, for example using the following command:
+  `git --no-pager show -s --format='%an <%ae>' <gitsha>` where `<gitsha>` is the
+  SHA1 of their latest commit in the project.
+- Create a GitHub issue stating contact details and the severity of the issue.
+
+Once we have acknowledged receipt of your report and confirmed the bug
+ourselves we will work with you to fix the vulnerability and publicly acknowledge
+your responsible disclosure, if you wish. In addition to that we will report
+all vulnerabilities to the [Node Security Project](https://nodesecurity.io/).
+
+## History
+
+04 Jan 2016: [Buffer vulnerablity](https://github.com/websockets/ws/releases/tag/1.0.1)

data/node_modules/ws/index.js

@@ -0,0 +1,15 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+'use strict';
+
+const WebSocket = require('./lib/WebSocket');
+
+WebSocket.Server = require('./lib/WebSocketServer');
+WebSocket.Receiver = require('./lib/Receiver');
+WebSocket.Sender = require('./lib/Sender');
+
+module.exports = WebSocket;

data/node_modules/ws/lib/BufferUtil.fallback.js

@@ -0,0 +1,56 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+'use strict';
+
+/**
+ * Merges an array of buffers into a target buffer.
+ *
+ * @param {Buffer} target The target buffer
+ * @param {Buffer[]} buffers The array of buffers to merge
+ * @public
+ */
+const merge = (target, buffers) => {
+  var offset = 0;
+  for (var i = 0; i < buffers.length; i++) {
+    const buf = buffers[i];
+    buf.copy(target, offset);
+    offset += buf.length;
+  }
+};
+
+/**
+ * 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];
+  }
+};
+
+module.exports = { merge, mask, unmask };

data/node_modules/ws/lib/BufferUtil.js

@@ -0,0 +1,15 @@
+'use strict';
+
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+try {
+  const bufferUtil = require('bufferutil');
+
+  module.exports = bufferUtil.BufferUtil || bufferUtil;
+} catch (e) {
+  module.exports = require('./BufferUtil.fallback');
+}

data/node_modules/ws/lib/ErrorCodes.js

@@ -0,0 +1,28 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ * MIT Licensed
+ */
+
+'use strict';
+
+module.exports = {
+  isValidErrorCode: function (code) {
+    return (code >= 1000 && code <= 1013 && code !== 1004 && code !== 1005 && code !== 1006) ||
+      (code >= 3000 && code <= 4999);
+  },
+  1000: 'normal',
+  1001: 'going away',
+  1002: 'protocol error',
+  1003: 'unsupported data',
+  1004: 'reserved',
+  1005: 'reserved for extensions',
+  1006: 'reserved for extensions',
+  1007: 'inconsistent or invalid data',
+  1008: 'policy violation',
+  1009: 'message too big',
+  1010: 'extension handshake missing',
+  1011: 'an unexpected condition prevented the request from being fulfilled',
+  1012: 'service restart',
+  1013: 'try again later'
+};

data/node_modules/ws/lib/EventTarget.js

@@ -0,0 +1,158 @@
+'use strict';
+
+/**
+ * Class representing an event.
+ *
+ * @private
+ */
+class Event {
+  /**
+   * Create a new `Event`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} target A reference to the target to which the event was dispatched
+   */
+  constructor (type, target) {
+    this.target = target;
+    this.type = type;
+  }
+}
+
+/**
+ * Class representing a message event.
+ *
+ * @extends Event
+ * @private
+ */
+class MessageEvent extends Event {
+  /**
+   * Create a new `MessageEvent`.
+   *
+   * @param {(String|Buffer|ArrayBuffer)} data The received data
+   * @param {Boolean} isBinary Specifies if `data` is binary
+   * @param {WebSocket} target A reference to the target to which the event was dispatched
+   */
+  constructor (data, isBinary, target) {
+    super('message', target);
+
+    this.binary = isBinary; // non-standard.
+    this.data = data;
+  }
+}
+
+/**
+ * Class representing a close event.
+ *
+ * @extends Event
+ * @private
+ */
+class CloseEvent extends Event {
+  /**
+   * Create a new `CloseEvent`.
+   *
+   * @param {Number} code The status code explaining why the connection is being closed
+   * @param {String} reason A human-readable string explaining why the connection is closing
+   * @param {WebSocket} target A reference to the target to which the event was dispatched
+   */
+  constructor (code, reason, target) {
+    super('close', target);
+
+    this.wasClean = code === undefined || code === 1000;
+    this.reason = reason;
+    this.target = target;
+    this.type = 'close';
+    this.code = code;
+  }
+}
+
+/**
+ * Class representing an open event.
+ *
+ * @extends Event
+ * @private
+ */
+class OpenEvent extends Event {
+  /**
+   * Create a new `OpenEvent`.
+   *
+   * @param {WebSocket} target A reference to the target to which the event was dispatched
+   */
+  constructor (target) {
+    super('open', target);
+  }
+}
+
+/**
+ * This provides methods for emulating the `EventTarget` interface. It's not
+ * meant to be used directly.
+ *
+ * @mixin
+ */
+const EventTarget = {
+  /**
+   * Register an event listener.
+   *
+   * @param {String} method A string representing the event type to listen for
+   * @param {Function} listener The listener to add
+   * @public
+   */
+  addEventListener (method, listener) {
+    if (typeof listener !== 'function') return;
+
+    function onMessage (data, flags) {
+      if (flags.binary && this.binaryType === 'arraybuffer') {
+        data = new Uint8Array(data).buffer;
+      }
+      listener.call(this, new MessageEvent(data, !!flags.binary, this));
+    }
+
+    function onClose (code, message) {
+      listener.call(this, new CloseEvent(code, message, this));
+    }
+
+    function onError (event) {
+      event.type = 'error';
+      event.target = this;
+      listener.call(this, event);
+    }
+
+    function onOpen () {
+      listener.call(this, new OpenEvent(this));
+    }
+
+    if (method === 'message') {
+      onMessage._listener = listener;
+      this.on(method, onMessage);
+    } else if (method === 'close') {
+      onClose._listener = listener;
+      this.on(method, onClose);
+    } else if (method === 'error') {
+      onError._listener = listener;
+      this.on(method, onError);
+    } else if (method === 'open') {
+      onOpen._listener = listener;
+      this.on(method, onOpen);
+    } else {
+      this.on(method, listener);
+    }
+  },
+
+  /**
+   * Remove an event listener.
+   *
+   * @param {String} method A string representing the event type to remove
+   * @param {Function} listener The listener to remove
+   * @public
+   */
+  removeEventListener (method, listener) {
+    const listeners = this.listeners(method);
+
+    for (var i = 0; i < listeners.length; i++) {
+      if (listeners[i] === listener || listeners[i]._listener === listener) {
+        this.removeListener(method, listeners[i]);
+      }
+    }
+  }
+};
+
+module.exports = EventTarget;

data/node_modules/ws/lib/Extensions.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * Module exports.
+ */
+
+exports.parse = parse;
+exports.format = format;
+
+/**
+ * Parse extensions header value
+ */
+
+function parse (value) {
+  value = value || '';
+
+  var extensions = {};
+
+  value.split(',').forEach(function (v) {
+    var params = v.split(';');
+    var token = params.shift().trim();
+    var paramsList = extensions[token] = extensions[token] || [];
+    var parsedParams = {};
+
+    params.forEach(function (param) {
+      var parts = param.trim().split('=');
+      var key = parts[0];
+      var value = parts[1];
+      if (value === undefined) {
+        value = true;
+      } else {
+        // unquote value
+        if (value[0] === '"') {
+          value = value.slice(1);
+        }
+        if (value[value.length - 1] === '"') {
+          value = value.slice(0, value.length - 1);
+        }
+      }
+      (parsedParams[key] = parsedParams[key] || []).push(value);
+    });
+
+    paramsList.push(parsedParams);
+  });
+
+  return extensions;
+}
+
+/**
+ * Format extensions header value
+ */
+
+function format (value) {
+  return Object.keys(value).map(function (token) {
+    var paramsList = value[token];
+    if (!Array.isArray(paramsList)) {
+      paramsList = [paramsList];
+    }
+    return paramsList.map(function (params) {
+      return [token].concat(Object.keys(params).map(function (k) {
+        var p = params[k];
+        if (!Array.isArray(p)) p = [p];
+        return p.map(function (v) {
+          return v === true ? k : k + '=' + v;
+        }).join('; ');
+      })).join('; ');
+    }).join(', ');
+  }).join(', ');
+}

data/node_modules/ws/lib/PerMessageDeflate.js

@@ -0,0 +1,339 @@
+'use strict';
+
+const zlib = require('zlib');
+
+const AVAILABLE_WINDOW_BITS = [8, 9, 10, 11, 12, 13, 14, 15];
+const DEFAULT_WINDOW_BITS = 15;
+const DEFAULT_MEM_LEVEL = 8;
+const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
+const EMPTY_BLOCK = Buffer.from([0x00]);
+
+/**
+ * Per-message Compression Extensions implementation
+ */
+class PerMessageDeflate {
+  constructor (options, isServer, maxPayload) {
+    this._options = options || {};
+    this._isServer = !!isServer;
+    this._inflate = null;
+    this._deflate = null;
+    this.params = null;
+    this._maxPayload = maxPayload || 0;
+    this.threshold = this._options.threshold === undefined ? 1024 : this._options.threshold;
+  }
+
+  /**
+   * Create extension parameters offer
+   *
+   * @api public
+   */
+
+  offer () {
+    var params = {};
+    if (this._options.serverNoContextTakeover) {
+      params.server_no_context_takeover = true;
+    }
+    if (this._options.clientNoContextTakeover) {
+      params.client_no_context_takeover = true;
+    }
+    if (this._options.serverMaxWindowBits) {
+      params.server_max_window_bits = this._options.serverMaxWindowBits;
+    }
+    if (this._options.clientMaxWindowBits) {
+      params.client_max_window_bits = this._options.clientMaxWindowBits;
+    } else if (this._options.clientMaxWindowBits == null) {
+      params.client_max_window_bits = true;
+    }
+    return params;
+  }
+
+  /**
+   * Accept extension offer
+   *
+   * @api public
+   */
+  accept (paramsList) {
+    paramsList = this.normalizeParams(paramsList);
+
+    var params;
+    if (this._isServer) {
+      params = this.acceptAsServer(paramsList);
+    } else {
+      params = this.acceptAsClient(paramsList);
+    }
+
+    this.params = params;
+    return params;
+  }
+
+  /**
+   * Releases all resources used by the extension
+   *
+   * @api public
+   */
+  cleanup () {
+    if (this._inflate) {
+      if (this._inflate.writeInProgress) {
+        this._inflate.pendingClose = true;
+      } else {
+        this._inflate.close();
+        this._inflate = null;
+      }
+    }
+    if (this._deflate) {
+      if (this._deflate.writeInProgress) {
+        this._deflate.pendingClose = true;
+      } else {
+        this._deflate.close();
+        this._deflate = null;
+      }
+    }
+  }
+
+  /**
+   * Accept extension offer from client
+   *
+   * @api private
+   */
+
+  acceptAsServer (paramsList) {
+    var accepted = {};
+    var result = paramsList.some((params) => {
+      accepted = {};
+      if (this._options.serverNoContextTakeover === false && params.server_no_context_takeover) {
+        return;
+      }
+      if (this._options.serverMaxWindowBits === false && params.server_max_window_bits) {
+        return;
+      }
+      if (typeof this._options.serverMaxWindowBits === 'number' &&
+          typeof params.server_max_window_bits === 'number' &&
+          this._options.serverMaxWindowBits > params.server_max_window_bits) {
+        return;
+      }
+      if (typeof this._options.clientMaxWindowBits === 'number' && !params.client_max_window_bits) {
+        return;
+      }
+
+      if (this._options.serverNoContextTakeover || params.server_no_context_takeover) {
+        accepted.server_no_context_takeover = true;
+      }
+      if (this._options.clientNoContextTakeover) {
+        accepted.client_no_context_takeover = true;
+      }
+      if (this._options.clientNoContextTakeover !== false && params.client_no_context_takeover) {
+        accepted.client_no_context_takeover = true;
+      }
+      if (typeof this._options.serverMaxWindowBits === 'number') {
+        accepted.server_max_window_bits = this._options.serverMaxWindowBits;
+      } else if (typeof params.server_max_window_bits === 'number') {
+        accepted.server_max_window_bits = params.server_max_window_bits;
+      }
+      if (typeof this._options.clientMaxWindowBits === 'number') {
+        accepted.client_max_window_bits = this._options.clientMaxWindowBits;
+      } else if (this._options.clientMaxWindowBits !== false && typeof params.client_max_window_bits === 'number') {
+        accepted.client_max_window_bits = params.client_max_window_bits;
+      }
+      return true;
+    });
+
+    if (!result) {
+      throw new Error(`Doesn't support the offered configuration`);
+    }
+
+    return accepted;
+  }
+
+  /**
+   * Accept extension response from server
+   *
+   * @api privaye
+   */
+
+  acceptAsClient (paramsList) {
+    var params = paramsList[0];
+    if (this._options.clientNoContextTakeover != null) {
+      if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
+        throw new Error('Invalid value for "client_no_context_takeover"');
+      }
+    }
+    if (this._options.clientMaxWindowBits != null) {
+      if (this._options.clientMaxWindowBits === false && params.client_max_window_bits) {
+        throw new Error('Invalid value for "client_max_window_bits"');
+      }
+      if (typeof this._options.clientMaxWindowBits === 'number' &&
+          (!params.client_max_window_bits || params.client_max_window_bits > this._options.clientMaxWindowBits)) {
+        throw new Error('Invalid value for "client_max_window_bits"');
+      }
+    }
+    return params;
+  }
+
+  /**
+   * Normalize extensions parameters
+   *
+   * @api private
+   */
+
+  normalizeParams (paramsList) {
+    return paramsList.map((params) => {
+      Object.keys(params).forEach((key) => {
+        var value = params[key];
+        if (value.length > 1) {
+          throw new Error('Multiple extension parameters for ' + key);
+        }
+
+        value = value[0];
+
+        switch (key) {
+          case 'server_no_context_takeover':
+          case 'client_no_context_takeover':
+            if (value !== true) {
+              throw new Error(`invalid extension parameter value for ${key} (${value})`);
+            }
+            params[key] = true;
+            break;
+          case 'server_max_window_bits':
+          case 'client_max_window_bits':
+            if (typeof value === 'string') {
+              value = parseInt(value, 10);
+              if (!~AVAILABLE_WINDOW_BITS.indexOf(value)) {
+                throw new Error(`invalid extension parameter value for ${key} (${value})`);
+              }
+            }
+            if (!this._isServer && value === true) {
+              throw new Error(`Missing extension parameter value for ${key}`);
+            }
+            params[key] = value;
+            break;
+          default:
+            throw new Error(`Not defined extension parameter (${key})`);
+        }
+      });
+      return params;
+    });
+  }
+
+  /**
+   * Decompress data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  decompress (data, fin, callback) {
+    const endpoint = this._isServer ? 'client' : 'server';
+
+    if (!this._inflate) {
+      const maxWindowBits = this.params[`${endpoint}_max_window_bits`];
+      this._inflate = zlib.createInflateRaw({
+        windowBits: typeof maxWindowBits === 'number' ? maxWindowBits : DEFAULT_WINDOW_BITS
+      });
+    }
+    this._inflate.writeInProgress = true;
+
+    var totalLength = 0;
+    const buffers = [];
+    var err;
+
+    const onData = (data) => {
+      totalLength += data.length;
+      if (this._maxPayload < 1 || totalLength <= this._maxPayload) {
+        return buffers.push(data);
+      }
+
+      err = new Error('max payload size exceeded');
+      err.closeCode = 1009;
+      this._inflate.reset();
+    };
+
+    const onError = (err) => {
+      cleanup();
+      callback(err);
+    };
+
+    const cleanup = () => {
+      if (!this._inflate) return;
+
+      this._inflate.removeListener('error', onError);
+      this._inflate.removeListener('data', onData);
+      this._inflate.writeInProgress = false;
+
+      if (
+        fin && this.params[`${endpoint}_no_context_takeover`] ||
+        this._inflate.pendingClose
+      ) {
+        this._inflate.close();
+        this._inflate = null;
+      }
+    };
+
+    this._inflate.on('error', onError).on('data', onData);
+    this._inflate.write(data);
+    if (fin) this._inflate.write(TRAILER);
+
+    this._inflate.flush(() => {
+      cleanup();
+      if (err) callback(err);
+      else callback(null, Buffer.concat(buffers, totalLength));
+    });
+  }
+
+  /**
+   * Compress message
+   *
+   * @api public
+   */
+
+  compress (data, fin, callback) {
+    if (!data || data.length === 0) {
+      return callback(null, EMPTY_BLOCK);
+    }
+
+    var endpoint = this._isServer ? 'server' : 'client';
+
+    if (!this._deflate) {
+      var maxWindowBits = this.params[endpoint + '_max_window_bits'];
+      this._deflate = zlib.createDeflateRaw({
+        flush: zlib.Z_SYNC_FLUSH,
+        windowBits: typeof maxWindowBits === 'number' ? maxWindowBits : DEFAULT_WINDOW_BITS,
+        memLevel: this._options.memLevel || DEFAULT_MEM_LEVEL
+      });
+    }
+    this._deflate.writeInProgress = true;
+
+    const buffers = [];
+
+    const onData = (data) => buffers.push(data);
+    const onError = (err) => {
+      cleanup();
+      callback(err);
+    };
+    const cleanup = () => {
+      if (!this._deflate) return;
+      this._deflate.removeListener('error', onError);
+      this._deflate.removeListener('data', onData);
+      this._deflate.writeInProgress = false;
+      if ((fin && this.params[endpoint + '_no_context_takeover']) || this._deflate.pendingClose) {
+        this._deflate.close();
+        this._deflate = null;
+      }
+    };
+
+    this._deflate.on('error', onError).on('data', onData);
+    this._deflate.write(data);
+    this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+      cleanup();
+      var data = Buffer.concat(buffers);
+      if (fin) {
+        data = data.slice(0, data.length - 4);
+      }
+      callback(null, data);
+    });
+  }
+}
+
+PerMessageDeflate.extensionName = 'permessage-deflate';
+
+module.exports = PerMessageDeflate;