zmdms-utils 0.0.80 → 0.0.81

package/dist/es/node_modules/websocket-driver/lib/websocket/driver/client.js

@@ -0,0 +1,152 @@
+import '../../../../safe-buffer/index.js';
+import require$$0 from 'crypto';
+import require$$2 from 'url';
+import require$$1 from 'util';
+import http_parser from '../http_parser.js';
+import base from './base.js';
+import hybi from './hybi.js';
+import proxy from './proxy.js';
+import { exports as safeBufferExports } from '../../../../../_virtual/index9.js';
+
+var Buffer     = safeBufferExports.Buffer,
+    crypto     = require$$0,
+    url        = require$$2,
+    util       = require$$1,
+    HttpParser = http_parser,
+    Base       = base,
+    Hybi       = hybi,
+    Proxy      = proxy;
+
+var Client = function(_url, options) {
+  this.version = 'hybi-' + Hybi.VERSION;
+  Hybi.call(this, null, _url, options);
+
+  this.readyState = -1;
+  this._key       = Client.generateKey();
+  this._accept    = Hybi.generateAccept(this._key);
+  this._http      = new HttpParser('response');
+
+  var uri  = url.parse(this.url),
+      auth = uri.auth && Buffer.from(uri.auth, 'utf8').toString('base64');
+
+  if (this.VALID_PROTOCOLS.indexOf(uri.protocol) < 0)
+    throw new Error(this.url + ' is not a valid WebSocket URL');
+
+  this._pathname = (uri.pathname || '/') + (uri.search || '');
+
+  this._headers.set('Host', uri.host);
+  this._headers.set('Upgrade', 'websocket');
+  this._headers.set('Connection', 'Upgrade');
+  this._headers.set('Sec-WebSocket-Key', this._key);
+  this._headers.set('Sec-WebSocket-Version', Hybi.VERSION);
+
+  if (this._protocols.length > 0)
+    this._headers.set('Sec-WebSocket-Protocol', this._protocols.join(', '));
+
+  if (auth)
+    this._headers.set('Authorization', 'Basic ' + auth);
+};
+util.inherits(Client, Hybi);
+
+Client.generateKey = function() {
+  return crypto.randomBytes(16).toString('base64');
+};
+
+var instance = {
+  VALID_PROTOCOLS: ['ws:', 'wss:'],
+
+  proxy: function(origin, options) {
+    return new Proxy(this, origin, options);
+  },
+
+  start: function() {
+    if (this.readyState !== -1) return false;
+    this._write(this._handshakeRequest());
+    this.readyState = 0;
+    return true;
+  },
+
+  parse: function(chunk) {
+    if (this.readyState === 3) return;
+    if (this.readyState > 0) return Hybi.prototype.parse.call(this, chunk);
+
+    this._http.parse(chunk);
+    if (!this._http.isComplete()) return;
+
+    this._validateHandshake();
+    if (this.readyState === 3) return;
+
+    this._open();
+    this.parse(this._http.body);
+  },
+
+  _handshakeRequest: function() {
+    var extensions = this._extensions.generateOffer();
+    if (extensions)
+      this._headers.set('Sec-WebSocket-Extensions', extensions);
+
+    var start   = 'GET ' + this._pathname + ' HTTP/1.1',
+        headers = [start, this._headers.toString(), ''];
+
+    return Buffer.from(headers.join('\r\n'), 'utf8');
+  },
+
+  _failHandshake: function(message) {
+    message = 'Error during WebSocket handshake: ' + message;
+    this.readyState = 3;
+    this.emit('error', new Error(message));
+    this.emit('close', new Base.CloseEvent(this.ERRORS.protocol_error, message));
+  },
+
+  _validateHandshake: function() {
+    this.statusCode = this._http.statusCode;
+    this.headers    = this._http.headers;
+
+    if (this._http.error)
+      return this._failHandshake(this._http.error.message);
+
+    if (this._http.statusCode !== 101)
+      return this._failHandshake('Unexpected response code: ' + this._http.statusCode);
+
+    var headers    = this._http.headers,
+        upgrade    = headers['upgrade'] || '',
+        connection = headers['connection'] || '',
+        accept     = headers['sec-websocket-accept'] || '',
+        protocol   = headers['sec-websocket-protocol'] || '';
+
+    if (upgrade === '')
+      return this._failHandshake("'Upgrade' header is missing");
+    if (upgrade.toLowerCase() !== 'websocket')
+      return this._failHandshake("'Upgrade' header value is not 'WebSocket'");
+
+    if (connection === '')
+      return this._failHandshake("'Connection' header is missing");
+    if (connection.toLowerCase() !== 'upgrade')
+      return this._failHandshake("'Connection' header value is not 'Upgrade'");
+
+    if (accept !== this._accept)
+      return this._failHandshake('Sec-WebSocket-Accept mismatch');
+
+    this.protocol = null;
+
+    if (protocol !== '') {
+      if (this._protocols.indexOf(protocol) < 0)
+        return this._failHandshake('Sec-WebSocket-Protocol mismatch');
+      else
+        this.protocol = protocol;
+    }
+
+    try {
+      this._extensions.activate(this.headers['sec-websocket-extensions']);
+    } catch (e) {
+      return this._failHandshake(e.message);
+    }
+  }
+};
+
+for (var key in instance)
+  Client.prototype[key] = instance[key];
+
+var client = Client;
+
+export { client as default };

package/dist/es/node_modules/websocket-driver/lib/websocket/driver/draft75.js

@@ -0,0 +1,128 @@
+import '../../../../safe-buffer/index.js';
+import base from './base.js';
+import require$$1 from 'util';
+import { exports as safeBufferExports } from '../../../../../_virtual/index9.js';
+
+var Buffer = safeBufferExports.Buffer,
+    Base   = base,
+    util   = require$$1;
+
+var Draft75 = function(request, url, options) {
+  Base.apply(this, arguments);
+  this._stage  = 0;
+  this.version = 'hixie-75';
+
+  this._headers.set('Upgrade', 'WebSocket');
+  this._headers.set('Connection', 'Upgrade');
+  this._headers.set('WebSocket-Origin', this._request.headers.origin);
+  this._headers.set('WebSocket-Location', this.url);
+};
+util.inherits(Draft75, Base);
+
+var instance = {
+  close: function() {
+    if (this.readyState === 3) return false;
+    this.readyState = 3;
+    this.emit('close', new Base.CloseEvent(null, null));
+    return true;
+  },
+
+  parse: function(chunk) {
+    if (this.readyState > 1) return;
+
+    this._reader.put(chunk);
+
+    this._reader.eachByte(function(octet) {
+      var message;
+
+      switch (this._stage) {
+        case -1:
+          this._body.push(octet);
+          this._sendHandshakeBody();
+          break;
+
+        case 0:
+          this._parseLeadingByte(octet);
+          break;
+
+        case 1:
+          this._length = (octet & 0x7F) + 128 * this._length;
+
+          if (this._closing && this._length === 0) {
+            return this.close();
+          }
+          else if ((octet & 0x80) !== 0x80) {
+            if (this._length === 0) {
+              this._stage = 0;
+            }
+            else {
+              this._skipped = 0;
+              this._stage   = 2;
+            }
+          }
+          break;
+
+        case 2:
+          if (octet === 0xFF) {
+            this._stage = 0;
+            message = Buffer.from(this._buffer).toString('utf8', 0, this._buffer.length);
+            this.emit('message', new Base.MessageEvent(message));
+          }
+          else {
+            if (this._length) {
+              this._skipped += 1;
+              if (this._skipped === this._length)
+                this._stage = 0;
+            } else {
+              this._buffer.push(octet);
+              if (this._buffer.length > this._maxLength) return this.close();
+            }
+          }
+          break;
+      }
+    }, this);
+  },
+
+  frame: function(buffer) {
+    if (this.readyState === 0) return this._queue([buffer]);
+    if (this.readyState > 1) return false;
+
+    if (typeof buffer !== 'string') buffer = buffer.toString();
+
+    var length = Buffer.byteLength(buffer),
+        frame  = Buffer.allocUnsafe(length + 2);
+
+    frame[0] = 0x00;
+    frame.write(buffer, 1);
+    frame[frame.length - 1] = 0xFF;
+
+    this._write(frame);
+    return true;
+  },
+
+  _handshakeResponse: function() {
+    var start   = 'HTTP/1.1 101 Web Socket Protocol Handshake',
+        headers = [start, this._headers.toString(), ''];
+
+    return Buffer.from(headers.join('\r\n'), 'utf8');
+  },
+
+  _parseLeadingByte: function(octet) {
+    if ((octet & 0x80) === 0x80) {
+      this._length = 0;
+      this._stage  = 1;
+    } else {
+      delete this._length;
+      delete this._skipped;
+      this._buffer = [];
+      this._stage  = 2;
+    }
+  }
+};
+
+for (var key in instance)
+  Draft75.prototype[key] = instance[key];
+
+var draft75 = Draft75;
+
+export { draft75 as default };

package/dist/es/node_modules/websocket-driver/lib/websocket/driver/draft76.js

@@ -0,0 +1,124 @@
+import '../../../../safe-buffer/index.js';
+import base from './base.js';
+import draft75 from './draft75.js';
+import require$$0 from 'crypto';
+import require$$1 from 'util';
+import { exports as safeBufferExports } from '../../../../../_virtual/index9.js';
+
+var Buffer  = safeBufferExports.Buffer,
+    Base    = base,
+    Draft75 = draft75,
+    crypto  = require$$0,
+    util    = require$$1;
+
+
+var numberFromKey = function(key) {
+  return parseInt((key.match(/[0-9]/g) || []).join(''), 10);
+};
+
+var spacesInKey = function(key) {
+  return (key.match(/ /g) || []).length;
+};
+
+
+var Draft76 = function(request, url, options) {
+  Draft75.apply(this, arguments);
+  this._stage  = -1;
+  this._body   = [];
+  this.version = 'hixie-76';
+
+  this._headers.clear();
+
+  this._headers.set('Upgrade', 'WebSocket');
+  this._headers.set('Connection', 'Upgrade');
+  this._headers.set('Sec-WebSocket-Origin', this._request.headers.origin);
+  this._headers.set('Sec-WebSocket-Location', this.url);
+};
+util.inherits(Draft76, Draft75);
+
+var instance = {
+  BODY_SIZE: 8,
+
+  start: function() {
+    if (!Draft75.prototype.start.call(this)) return false;
+    this._started = true;
+    this._sendHandshakeBody();
+    return true;
+  },
+
+  close: function() {
+    if (this.readyState === 3) return false;
+    if (this.readyState === 1) this._write(Buffer.from([0xFF, 0x00]));
+    this.readyState = 3;
+    this.emit('close', new Base.CloseEvent(null, null));
+    return true;
+  },
+
+  _handshakeResponse: function() {
+    var headers = this._request.headers,
+        key1    = headers['sec-websocket-key1'],
+        key2    = headers['sec-websocket-key2'];
+
+    if (!key1) throw new Error('Missing required header: Sec-WebSocket-Key1');
+    if (!key2) throw new Error('Missing required header: Sec-WebSocket-Key2');
+
+    var number1 = numberFromKey(key1),
+        spaces1 = spacesInKey(key1),
+
+        number2 = numberFromKey(key2),
+        spaces2 = spacesInKey(key2);
+
+    if (number1 % spaces1 !== 0 || number2 % spaces2 !== 0)
+      throw new Error('Client sent invalid Sec-WebSocket-Key headers');
+
+    this._keyValues = [number1 / spaces1, number2 / spaces2];
+
+    var start   = 'HTTP/1.1 101 WebSocket Protocol Handshake',
+        headers = [start, this._headers.toString(), ''];
+
+    return Buffer.from(headers.join('\r\n'), 'binary');
+  },
+
+  _handshakeSignature: function() {
+    if (this._body.length < this.BODY_SIZE) return null;
+
+    var md5    = crypto.createHash('md5'),
+        buffer = Buffer.allocUnsafe(8 + this.BODY_SIZE);
+
+    buffer.writeUInt32BE(this._keyValues[0], 0);
+    buffer.writeUInt32BE(this._keyValues[1], 4);
+    Buffer.from(this._body).copy(buffer, 8, 0, this.BODY_SIZE);
+
+    md5.update(buffer);
+    return Buffer.from(md5.digest('binary'), 'binary');
+  },
+
+  _sendHandshakeBody: function() {
+    if (!this._started) return;
+    var signature = this._handshakeSignature();
+    if (!signature) return;
+
+    this._write(signature);
+    this._stage = 0;
+    this._open();
+
+    if (this._body.length > this.BODY_SIZE)
+      this.parse(this._body.slice(this.BODY_SIZE));
+  },
+
+  _parseLeadingByte: function(octet) {
+    if (octet !== 0xFF)
+      return Draft75.prototype._parseLeadingByte.call(this, octet);
+
+    this._closing = true;
+    this._length  = 0;
+    this._stage   = 1;
+  }
+};
+
+for (var key in instance)
+  Draft76.prototype[key] = instance[key];
+
+var draft76 = Draft76;
+
+export { draft76 as default };

package/dist/es/node_modules/websocket-driver/lib/websocket/driver/headers.js

@@ -0,0 +1,44 @@
+var headers;
+var hasRequiredHeaders;
+
+function requireHeaders () {
+	if (hasRequiredHeaders) return headers;
+	hasRequiredHeaders = 1;
+
+	var Headers = function() {
+	  this.clear();
+	};
+
+	Headers.prototype.ALLOWED_DUPLICATES = ['set-cookie', 'set-cookie2', 'warning', 'www-authenticate'];
+
+	Headers.prototype.clear = function() {
+	  this._sent  = {};
+	  this._lines = [];
+	};
+
+	Headers.prototype.set = function(name, value) {
+	  if (value === undefined) return;
+
+	  name = this._strip(name);
+	  value = this._strip(value);
+
+	  var key = name.toLowerCase();
+	  if (!this._sent.hasOwnProperty(key) || this.ALLOWED_DUPLICATES.indexOf(key) >= 0) {
+	    this._sent[key] = true;
+	    this._lines.push(name + ': ' + value + '\r\n');
+	  }
+	};
+
+	Headers.prototype.toString = function() {
+	  return this._lines.join('');
+	};
+
+	Headers.prototype._strip = function(string) {
+	  return string.toString().replace(/^ */, '').replace(/ *$/, '');
+	};
+
+	headers = Headers;
+	return headers;
+}
+
+export { requireHeaders as __require };

package/dist/es/node_modules/websocket-driver/lib/websocket/driver/hybi/frame.js

@@ -0,0 +1,21 @@
+var Frame = function() {};
+
+var instance = {
+  final:        false,
+  rsv1:         false,
+  rsv2:         false,
+  rsv3:         false,
+  opcode:       null,
+  masked:       false,
+  maskingKey:   null,
+  lengthBytes:  1,
+  length:       0,
+  payload:      null
+};
+
+for (var key in instance)
+  Frame.prototype[key] = instance[key];
+
+var frame = Frame;
+
+export { frame as default };

package/dist/es/node_modules/websocket-driver/lib/websocket/driver/hybi/message.js

@@ -0,0 +1,37 @@
+import '../../../../../safe-buffer/index.js';
+import { exports as safeBufferExports } from '../../../../../../_virtual/index9.js';
+
+var Buffer = safeBufferExports.Buffer;
+
+var Message = function() {
+  this.rsv1    = false;
+  this.rsv2    = false;
+  this.rsv3    = false;
+  this.opcode  = null;
+  this.length  = 0;
+  this._chunks = [];
+};
+
+var instance = {
+  read: function() {
+    return this.data = this.data || Buffer.concat(this._chunks, this.length);
+  },
+
+  pushFrame: function(frame) {
+    this.rsv1 = this.rsv1 || frame.rsv1;
+    this.rsv2 = this.rsv2 || frame.rsv2;
+    this.rsv3 = this.rsv3 || frame.rsv3;
+
+    if (this.opcode === null) this.opcode = frame.opcode;
+
+    this._chunks.push(frame.payload);
+    this.length += frame.length;
+  }
+};
+
+for (var key in instance)
+  Message.prototype[key] = instance[key];
+
+var message = Message;
+
+export { message as default };