/*!
* Pusher JavaScript Library v8.4.0-rc2
* https://pusher.com/
*
* Copyright 2020, Pusher
* Released under the MIT licence.
*/
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 21);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {
module.exports = require("util");
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
/* eslint-disable node/no-deprecated-api */
var buffer = __webpack_require__(22)
var Buffer = buffer.Buffer
// alternative to using Object.keys for old browsers
function copyProps (src, dst) {
for (var key in src) {
dst[key] = src[key]
}
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
module.exports = buffer
} else {
// Copy properties from require('buffer')
copyProps(buffer, exports)
exports.Buffer = SafeBuffer
}
function SafeBuffer (arg, encodingOrOffset, length) {
return Buffer(arg, encodingOrOffset, length)
}
// Copy static methods from Buffer
copyProps(Buffer, SafeBuffer)
SafeBuffer.from = function (arg, encodingOrOffset, length) {
if (typeof arg === 'number') {
throw new TypeError('Argument must not be a number')
}
return Buffer(arg, encodingOrOffset, length)
}
SafeBuffer.alloc = function (size, fill, encoding) {
if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
var buf = Buffer(size)
if (fill !== undefined) {
if (typeof encoding === 'string') {
buf.fill(fill, encoding)
} else {
buf.fill(fill)
}
} else {
buf.fill(0)
}
return buf
}
SafeBuffer.allocUnsafe = function (size) {
if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
return Buffer(size)
}
SafeBuffer.allocUnsafeSlow = function (size) {
if (typeof size !== 'number') {
throw new TypeError('Argument must be a number')
}
return buffer.SlowBuffer(size)
}
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Buffer = __webpack_require__(1).Buffer,
Emitter = __webpack_require__(23).EventEmitter,
util = __webpack_require__(0),
streams = __webpack_require__(24),
Headers = __webpack_require__(9),
Reader = __webpack_require__(25);
var Base = function(request, url, options) {
Emitter.call(this);
Base.validateOptions(options || {}, ['maxLength', 'masking', 'requireMasking', 'protocols']);
this._request = request;
this._reader = new Reader();
this._options = options || {};
this._maxLength = this._options.maxLength || this.MAX_LENGTH;
this._headers = new Headers();
this.__queue = [];
this.readyState = 0;
this.url = url;
this.io = new streams.IO(this);
this.messages = new streams.Messages(this);
this._bindEventListeners();
};
util.inherits(Base, Emitter);
Base.isWebSocket = function(request) {
var connection = request.headers.connection || '',
upgrade = request.headers.upgrade || '';
return request.method === 'GET' &&
connection.toLowerCase().split(/ *, */).indexOf('upgrade') >= 0 &&
upgrade.toLowerCase() === 'websocket';
};
Base.validateOptions = function(options, validKeys) {
for (var key in options) {
if (validKeys.indexOf(key) < 0)
throw new Error('Unrecognized option: ' + key);
}
};
var instance = {
// This is 64MB, small enough for an average VPS to handle without
// crashing from process out of memory
MAX_LENGTH: 0x3ffffff,
STATES: ['connecting', 'open', 'closing', 'closed'],
_bindEventListeners: function() {
var self = this;
// Protocol errors are informational and do not have to be handled
this.messages.on('error', function() {});
this.on('message', function(event) {
var messages = self.messages;
if (messages.readable) messages.emit('data', event.data);
});
this.on('error', function(error) {
var messages = self.messages;
if (messages.readable) messages.emit('error', error);
});
this.on('close', function() {
var messages = self.messages;
if (!messages.readable) return;
messages.readable = messages.writable = false;
messages.emit('end');
});
},
getState: function() {
return this.STATES[this.readyState] || null;
},
addExtension: function(extension) {
return false;
},
setHeader: function(name, value) {
if (this.readyState > 0) return false;
this._headers.set(name, value);
return true;
},
start: function() {
if (this.readyState !== 0) return false;
if (!Base.isWebSocket(this._request))
return this._failHandshake(new Error('Not a WebSocket request'));
var response;
try {
response = this._handshakeResponse();
} catch (error) {
return this._failHandshake(error);
}
this._write(response);
if (this._stage !== -1) this._open();
return true;
},
_failHandshake: function(error) {
var headers = new Headers();
headers.set('Content-Type', 'text/plain');
headers.set('Content-Length', Buffer.byteLength(error.message, 'utf8'));
headers = ['HTTP/1.1 400 Bad Request', headers.toString(), error.message];
this._write(Buffer.from(headers.join('\r\n'), 'utf8'));
this._fail('protocol_error', error.message);
return false;
},
text: function(message) {
return this.frame(message);
},
binary: function(message) {
return false;
},
ping: function() {
return false;
},
pong: function() {
return false;
},
close: function(reason, code) {
if (this.readyState !== 1) return false;
this.readyState = 3;
this.emit('close', new Base.CloseEvent(null, null));
return true;
},
_open: function() {
this.readyState = 1;
this.__queue.forEach(function(args) { this.frame.apply(this, args) }, this);
this.__queue = [];
this.emit('open', new Base.OpenEvent());
},
_queue: function(message) {
this.__queue.push(message);
return true;
},
_write: function(chunk) {
var io = this.io;
if (io.readable) io.emit('data', chunk);
},
_fail: function(type, message) {
this.readyState = 2;
this.emit('error', new Error(message));
this.close();
}
};
for (var key in instance)
Base.prototype[key] = instance[key];
Base.ConnectEvent = function() {};
Base.OpenEvent = function() {};
Base.CloseEvent = function(code, reason) {
this.code = code;
this.reason = reason;
};
Base.MessageEvent = function(data) {
this.data = data;
};
Base.PingEvent = function(data) {
this.data = data;
};
Base.PongEvent = function(data) {
this.data = data;
};
module.exports = Base;
/***/ }),
/* 3 */
/***/ (function(module, exports) {
module.exports = require("crypto");
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// Protocol references:
//
// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
// * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
var Base = __webpack_require__(2),
Client = __webpack_require__(26),
Server = __webpack_require__(37);
var Driver = {
client: function(url, options) {
options = options || {};
if (options.masking === undefined) options.masking = true;
return new Client(url, options);
},
server: function(options) {
options = options || {};
if (options.requireMasking === undefined) options.requireMasking = true;
return new Server(options);
},
http: function() {
return Server.http.apply(Server, arguments);
},
isSecureRequest: function(request) {
return Server.isSecureRequest(request);
},
isWebSocket: function(request) {
return Base.isWebSocket(request);
},
validateOptions: function(options, validKeys) {
Base.validateOptions(options, validKeys);
}
};
module.exports = Driver;
/***/ }),
/* 5 */
/***/ (function(module, exports) {
module.exports = require("stream");
/***/ }),
/* 6 */
/***/ (function(module, exports) {
module.exports = require("url");
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Event = function(eventType, options) {
this.type = eventType;
for (var key in options)
this[key] = options[key];
};
Event.prototype.initEvent = function(eventType, canBubble, cancelable) {
this.type = eventType;
this.bubbles = canBubble;
this.cancelable = cancelable;
};
Event.prototype.stopPropagation = function() {};
Event.prototype.preventDefault = function() {};
Event.CAPTURING_PHASE = 1;
Event.AT_TARGET = 2;
Event.BUBBLING_PHASE = 3;
module.exports = Event;
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// Copyright (C) 2016 Dmitry Chestnykh
// MIT License. See LICENSE file for details.
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
/**
* Package base64 implements Base64 encoding and decoding.
*/
// Invalid character used in decoding to indicate
// that the character to decode is out of range of
// alphabet and cannot be decoded.
var INVALID_BYTE = 256;
/**
* Implements standard Base64 encoding.
*
* Operates in constant time.
*/
var Coder = /** @class */ (function () {
// TODO(dchest): methods to encode chunk-by-chunk.
function Coder(_paddingCharacter) {
if (_paddingCharacter === void 0) { _paddingCharacter = "="; }
this._paddingCharacter = _paddingCharacter;
}
Coder.prototype.encodedLength = function (length) {
if (!this._paddingCharacter) {
return (length * 8 + 5) / 6 | 0;
}
return (length + 2) / 3 * 4 | 0;
};
Coder.prototype.encode = function (data) {
var out = "";
var i = 0;
for (; i < data.length - 2; i += 3) {
var c = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]);
out += this._encodeByte((c >>> 3 * 6) & 63);
out += this._encodeByte((c >>> 2 * 6) & 63);
out += this._encodeByte((c >>> 1 * 6) & 63);
out += this._encodeByte((c >>> 0 * 6) & 63);
}
var left = data.length - i;
if (left > 0) {
var c = (data[i] << 16) | (left === 2 ? data[i + 1] << 8 : 0);
out += this._encodeByte((c >>> 3 * 6) & 63);
out += this._encodeByte((c >>> 2 * 6) & 63);
if (left === 2) {
out += this._encodeByte((c >>> 1 * 6) & 63);
}
else {
out += this._paddingCharacter || "";
}
out += this._paddingCharacter || "";
}
return out;
};
Coder.prototype.maxDecodedLength = function (length) {
if (!this._paddingCharacter) {
return (length * 6 + 7) / 8 | 0;
}
return length / 4 * 3 | 0;
};
Coder.prototype.decodedLength = function (s) {
return this.maxDecodedLength(s.length - this._getPaddingLength(s));
};
Coder.prototype.decode = function (s) {
if (s.length === 0) {
return new Uint8Array(0);
}
var paddingLength = this._getPaddingLength(s);
var length = s.length - paddingLength;
var out = new Uint8Array(this.maxDecodedLength(length));
var op = 0;
var i = 0;
var haveBad = 0;
var v0 = 0, v1 = 0, v2 = 0, v3 = 0;
for (; i < length - 4; i += 4) {
v0 = this._decodeChar(s.charCodeAt(i + 0));
v1 = this._decodeChar(s.charCodeAt(i + 1));
v2 = this._decodeChar(s.charCodeAt(i + 2));
v3 = this._decodeChar(s.charCodeAt(i + 3));
out[op++] = (v0 << 2) | (v1 >>> 4);
out[op++] = (v1 << 4) | (v2 >>> 2);
out[op++] = (v2 << 6) | v3;
haveBad |= v0 & INVALID_BYTE;
haveBad |= v1 & INVALID_BYTE;
haveBad |= v2 & INVALID_BYTE;
haveBad |= v3 & INVALID_BYTE;
}
if (i < length - 1) {
v0 = this._decodeChar(s.charCodeAt(i));
v1 = this._decodeChar(s.charCodeAt(i + 1));
out[op++] = (v0 << 2) | (v1 >>> 4);
haveBad |= v0 & INVALID_BYTE;
haveBad |= v1 & INVALID_BYTE;
}
if (i < length - 2) {
v2 = this._decodeChar(s.charCodeAt(i + 2));
out[op++] = (v1 << 4) | (v2 >>> 2);
haveBad |= v2 & INVALID_BYTE;
}
if (i < length - 3) {
v3 = this._decodeChar(s.charCodeAt(i + 3));
out[op++] = (v2 << 6) | v3;
haveBad |= v3 & INVALID_BYTE;
}
if (haveBad !== 0) {
throw new Error("Base64Coder: incorrect characters for decoding");
}
return out;
};
// Standard encoding have the following encoded/decoded ranges,
// which we need to convert between.
//
// ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789 + /
// Index: 0 - 25 26 - 51 52 - 61 62 63
// ASCII: 65 - 90 97 - 122 48 - 57 43 47
//
// Encode 6 bits in b into a new character.
Coder.prototype._encodeByte = function (b) {
// Encoding uses constant time operations as follows:
//
// 1. Define comparison of A with B using (A - B) >>> 8:
// if A > B, then result is positive integer
// if A <= B, then result is 0
//
// 2. Define selection of C or 0 using bitwise AND: X & C:
// if X == 0, then result is 0
// if X != 0, then result is C
//
// 3. Start with the smallest comparison (b >= 0), which is always
// true, so set the result to the starting ASCII value (65).
//
// 4. Continue comparing b to higher ASCII values, and selecting
// zero if comparison isn't true, otherwise selecting a value
// to add to result, which:
//
// a) undoes the previous addition
// b) provides new value to add
//
var result = b;
// b >= 0
result += 65;
// b > 25
result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
// b > 51
result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
// b > 61
result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 43);
// b > 62
result += ((62 - b) >>> 8) & ((62 - 43) - 63 + 47);
return String.fromCharCode(result);
};
// Decode a character code into a byte.
// Must return 256 if character is out of alphabet range.
Coder.prototype._decodeChar = function (c) {
// Decoding works similar to encoding: using the same comparison
// function, but now it works on ranges: result is always incremented
// by value, but this value becomes zero if the range is not
// satisfied.
//
// Decoding starts with invalid value, 256, which is then
// subtracted when the range is satisfied. If none of the ranges
// apply, the function returns 256, which is then checked by
// the caller to throw error.
var result = INVALID_BYTE; // start with invalid character
// c == 43 (c > 42 and c < 44)
result += (((42 - c) & (c - 44)) >>> 8) & (-INVALID_BYTE + c - 43 + 62);
// c == 47 (c > 46 and c < 48)
result += (((46 - c) & (c - 48)) >>> 8) & (-INVALID_BYTE + c - 47 + 63);
// c > 47 and c < 58
result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
// c > 64 and c < 91
result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
// c > 96 and c < 123
result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
return result;
};
Coder.prototype._getPaddingLength = function (s) {
var paddingLength = 0;
if (this._paddingCharacter) {
for (var i = s.length - 1; i >= 0; i--) {
if (s[i] !== this._paddingCharacter) {
break;
}
paddingLength++;
}
if (s.length < 4 || paddingLength > 2) {
throw new Error("Base64Coder: incorrect padding");
}
}
return paddingLength;
};
return Coder;
}());
exports.Coder = Coder;
var stdCoder = new Coder();
function encode(data) {
return stdCoder.encode(data);
}
exports.encode = encode;
function decode(s) {
return stdCoder.decode(s);
}
exports.decode = decode;
/**
* Implements URL-safe Base64 encoding.
* (Same as Base64, but '+' is replaced with '-', and '/' with '_').
*
* Operates in constant time.
*/
var URLSafeCoder = /** @class */ (function (_super) {
__extends(URLSafeCoder, _super);
function URLSafeCoder() {
return _super !== null && _super.apply(this, arguments) || this;
}
// URL-safe encoding have the following encoded/decoded ranges:
//
// ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789 - _
// Index: 0 - 25 26 - 51 52 - 61 62 63
// ASCII: 65 - 90 97 - 122 48 - 57 45 95
//
URLSafeCoder.prototype._encodeByte = function (b) {
var result = b;
// b >= 0
result += 65;
// b > 25
result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
// b > 51
result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
// b > 61
result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 45);
// b > 62
result += ((62 - b) >>> 8) & ((62 - 45) - 63 + 95);
return String.fromCharCode(result);
};
URLSafeCoder.prototype._decodeChar = function (c) {
var result = INVALID_BYTE;
// c == 45 (c > 44 and c < 46)
result += (((44 - c) & (c - 46)) >>> 8) & (-INVALID_BYTE + c - 45 + 62);
// c == 95 (c > 94 and c < 96)
result += (((94 - c) & (c - 96)) >>> 8) & (-INVALID_BYTE + c - 95 + 63);
// c > 47 and c < 58
result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
// c > 64 and c < 91
result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
// c > 96 and c < 123
result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
return result;
};
return URLSafeCoder;
}(Coder));
exports.URLSafeCoder = URLSafeCoder;
var urlSafeCoder = new URLSafeCoder();
function encodeURLSafe(data) {
return urlSafeCoder.encode(data);
}
exports.encodeURLSafe = encodeURLSafe;
function decodeURLSafe(s) {
return urlSafeCoder.decode(s);
}
exports.decodeURLSafe = decodeURLSafe;
exports.encodedLength = function (length) {
return stdCoder.encodedLength(length);
};
exports.maxDecodedLength = function (length) {
return stdCoder.maxDecodedLength(length);
};
exports.decodedLength = function (s) {
return stdCoder.decodedLength(s);
};
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
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(/ *$/, '');
};
module.exports = Headers;
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var NodeHTTPParser = __webpack_require__(27).HTTPParser,
Buffer = __webpack_require__(1).Buffer;
var TYPES = {
request: NodeHTTPParser.REQUEST || 'request',
response: NodeHTTPParser.RESPONSE || 'response'
};
var HttpParser = function(type) {
this._type = type;
this._parser = new NodeHTTPParser(TYPES[type]);
this._complete = false;
this.headers = {};
var current = null,
self = this;
this._parser.onHeaderField = function(b, start, length) {
current = b.toString('utf8', start, start + length).toLowerCase();
};
this._parser.onHeaderValue = function(b, start, length) {
var value = b.toString('utf8', start, start + length);
if (self.headers.hasOwnProperty(current))
self.headers[current] += ', ' + value;
else
self.headers[current] = value;
};
this._parser.onHeadersComplete = this._parser[NodeHTTPParser.kOnHeadersComplete] =
function(majorVersion, minorVersion, headers, method, pathname, statusCode) {
var info = arguments[0];
if (typeof info === 'object') {
method = info.method;
pathname = info.url;
statusCode = info.statusCode;
headers = info.headers;
}
self.method = (typeof method === 'number') ? HttpParser.METHODS[method] : method;
self.statusCode = statusCode;
self.url = pathname;
if (!headers) return;
for (var i = 0, n = headers.length, key, value; i < n; i += 2) {
key = headers[i].toLowerCase();
value = headers[i+1];
if (self.headers.hasOwnProperty(key))
self.headers[key] += ', ' + value;
else
self.headers[key] = value;
}
self._complete = true;
};
};
HttpParser.METHODS = {
0: 'DELETE',
1: 'GET',
2: 'HEAD',
3: 'POST',
4: 'PUT',
5: 'CONNECT',
6: 'OPTIONS',
7: 'TRACE',
8: 'COPY',
9: 'LOCK',
10: 'MKCOL',
11: 'MOVE',
12: 'PROPFIND',
13: 'PROPPATCH',
14: 'SEARCH',
15: 'UNLOCK',
16: 'BIND',
17: 'REBIND',
18: 'UNBIND',
19: 'ACL',
20: 'REPORT',
21: 'MKACTIVITY',
22: 'CHECKOUT',
23: 'MERGE',
24: 'M-SEARCH',
25: 'NOTIFY',
26: 'SUBSCRIBE',
27: 'UNSUBSCRIBE',
28: 'PATCH',
29: 'PURGE',
30: 'MKCALENDAR',
31: 'LINK',
32: 'UNLINK'
};
var VERSION = process.version
? process.version.match(/[0-9]+/g).map(function(n) { return parseInt(n, 10) })
: [];
if (VERSION[0] === 0 && VERSION[1] === 12) {
HttpParser.METHODS[16] = 'REPORT';
HttpParser.METHODS[17] = 'MKACTIVITY';
HttpParser.METHODS[18] = 'CHECKOUT';
HttpParser.METHODS[19] = 'MERGE';
HttpParser.METHODS[20] = 'M-SEARCH';
HttpParser.METHODS[21] = 'NOTIFY';
HttpParser.METHODS[22] = 'SUBSCRIBE';
HttpParser.METHODS[23] = 'UNSUBSCRIBE';
HttpParser.METHODS[24] = 'PATCH';
HttpParser.METHODS[25] = 'PURGE';
}
HttpParser.prototype.isComplete = function() {
return this._complete;
};
HttpParser.prototype.parse = function(chunk) {
var consumed = this._parser.execute(chunk, 0, chunk.length);
if (typeof consumed !== 'number') {
this.error = consumed;
this._complete = true;
return;
}
if (this._complete)
this.body = (consumed < chunk.length)
? chunk.slice(consumed)
: Buffer.alloc(0);
};
module.exports = HttpParser;
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Stream = __webpack_require__(5).Stream,
util = __webpack_require__(0),
driver = __webpack_require__(4),
EventTarget = __webpack_require__(16),
Event = __webpack_require__(7);
var API = function(options) {
options = options || {};
driver.validateOptions(options, ['headers', 'extensions', 'maxLength', 'ping', 'proxy', 'tls', 'ca']);
this.readable = this.writable = true;
var headers = options.headers;
if (headers) {
for (var name in headers) this._driver.setHeader(name, headers[name]);
}
var extensions = options.extensions;
if (extensions) {
[].concat(extensions).forEach(this._driver.addExtension, this._driver);
}
this._ping = options.ping;
this._pingId = 0;
this.readyState = API.CONNECTING;
this.bufferedAmount = 0;
this.protocol = '';
this.url = this._driver.url;
this.version = this._driver.version;
var self = this;
this._driver.on('open', function(e) { self._open() });
this._driver.on('message', function(e) { self._receiveMessage(e.data) });
this._driver.on('close', function(e) { self._beginClose(e.reason, e.code) });
this._driver.on('error', function(error) {
self._emitError(error.message);
});
this.on('error', function() {});
this._driver.messages.on('drain', function() {
self.emit('drain');
});
if (this._ping)
this._pingTimer = setInterval(function() {
self._pingId += 1;
self.ping(self._pingId.toString());
}, this._ping * 1000);
this._configureStream();
if (!this._proxy) {
this._stream.pipe(this._driver.io);
this._driver.io.pipe(this._stream);
}
};
util.inherits(API, Stream);
API.CONNECTING = 0;
API.OPEN = 1;
API.CLOSING = 2;
API.CLOSED = 3;
API.CLOSE_TIMEOUT = 30000;
var instance = {
write: function(data) {
return this.send(data);
},
end: function(data) {
if (data !== undefined) this.send(data);
this.close();
},
pause: function() {
return this._driver.messages.pause();
},
resume: function() {
return this._driver.messages.resume();
},
send: function(data) {
if (this.readyState > API.OPEN) return false;
if (!(data instanceof Buffer)) data = String(data);
return this._driver.messages.write(data);
},
ping: function(message, callback) {
if (this.readyState > API.OPEN) return false;
return this._driver.ping(message, callback);
},
close: function(code, reason) {
if (code === undefined) code = 1000;
if (reason === undefined) reason = '';
if (code !== 1000 && (code < 3000 || code > 4999))
throw new Error("Failed to execute 'close' on WebSocket: " +
"The code must be either 1000, or between 3000 and 4999. " +
code + " is neither.");
if (this.readyState !== API.CLOSED) this.readyState = API.CLOSING;
var self = this;
this._closeTimer = setTimeout(function() {
self._beginClose('', 1006);
}, API.CLOSE_TIMEOUT);
this._driver.close(reason, code);
},
_configureStream: function() {
var self = this;
this._stream.setTimeout(0);
this._stream.setNoDelay(true);
['close', 'end'].forEach(function(event) {
this._stream.on(event, function() { self._finalizeClose() });
}, this);
this._stream.on('error', function(error) {
self._emitError('Network error: ' + self.url + ': ' + error.message);
self._finalizeClose();
});
},
_open: function() {
if (this.readyState !== API.CONNECTING) return;
this.readyState = API.OPEN;
this.protocol = this._driver.protocol || '';
var event = new Event('open');
event.initEvent('open', false, false);
this.dispatchEvent(event);
},
_receiveMessage: function(data) {
if (this.readyState > API.OPEN) return false;
if (this.readable) this.emit('data', data);
var event = new Event('message', {data: data});
event.initEvent('message', false, false);
this.dispatchEvent(event);
},
_emitError: function(message) {
if (this.readyState >= API.CLOSING) return;
var event = new Event('error', {message: message});
event.initEvent('error', false, false);
this.dispatchEvent(event);
},
_beginClose: function(reason, code) {
if (this.readyState === API.CLOSED) return;
this.readyState = API.CLOSING;
this._closeParams = [reason, code];
if (this._stream) {
this._stream.destroy();
if (!this._stream.readable) this._finalizeClose();
}
},
_finalizeClose: function() {
if (this.readyState === API.CLOSED) return;
this.readyState = API.CLOSED;
if (this._closeTimer) clearTimeout(this._closeTimer);
if (this._pingTimer) clearInterval(this._pingTimer);
if (this._stream) this._stream.end();
if (this.readable) this.emit('end');
this.readable = this.writable = false;
var reason = this._closeParams ? this._closeParams[0] : '',
code = this._closeParams ? this._closeParams[1] : 1006;
var event = new Event('close', {code: code, reason: reason});
event.initEvent('close', false, false);
this.dispatchEvent(event);
}
};
for (var method in instance) API.prototype[method] = instance[method];
for (var key in EventTarget) API.prototype[key] = EventTarget[key];
module.exports = API;
/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Buffer = __webpack_require__(1).Buffer,
crypto = __webpack_require__(3),
util = __webpack_require__(0),
Extensions = __webpack_require__(29),
Base = __webpack_require__(2),
Frame = __webpack_require__(34),
Message = __webpack_require__(35);
var Hybi = function(request, url, options) {
Base.apply(this, arguments);
this._extensions = new Extensions();
this._stage = 0;
this._masking = this._options.masking;
this._protocols = this._options.protocols || [];
this._requireMasking = this._options.requireMasking;
this._pingCallbacks = {};
if (typeof this._protocols === 'string')
this._protocols = this._protocols.split(/ *, */);
if (!this._request) return;
var protos = this._request.headers['sec-websocket-protocol'],
supported = this._protocols;
if (protos !== undefined) {
if (typeof protos === 'string') protos = protos.split(/ *, */);
this.protocol = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
}
this.version = 'hybi-' + Hybi.VERSION;
};
util.inherits(Hybi, Base);
Hybi.VERSION = '13';
Hybi.mask = function(payload, mask, offset) {
if (!mask || mask.length === 0) return payload;
offset = offset || 0;
for (var i = 0, n = payload.length - offset; i < n; i++) {
payload[offset + i] = payload[offset + i] ^ mask[i % 4];
}
return payload;
};
Hybi.generateAccept = function(key) {
var sha1 = crypto.createHash('sha1');
sha1.update(key + Hybi.GUID);
return sha1.digest('base64');
};
Hybi.GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
var instance = {
FIN: 0x80,
MASK: 0x80,
RSV1: 0x40,
RSV2: 0x20,
RSV3: 0x10,
OPCODE: 0x0F,
LENGTH: 0x7F,
OPCODES: {
continuation: 0,
text: 1,
binary: 2,
close: 8,
ping: 9,
pong: 10
},
OPCODE_CODES: [0, 1, 2, 8, 9, 10],
MESSAGE_OPCODES: [0, 1, 2],
OPENING_OPCODES: [1, 2],
ERRORS: {
normal_closure: 1000,
going_away: 1001,
protocol_error: 1002,
unacceptable: 1003,
encoding_error: 1007,
policy_violation: 1008,
too_large: 1009,
extension_error: 1010,
unexpected_condition: 1011
},
ERROR_CODES: [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011],
DEFAULT_ERROR_CODE: 1000,
MIN_RESERVED_ERROR: 3000,
MAX_RESERVED_ERROR: 4999,
// http://www.w3.org/International/questions/qa-forms-utf-8.en.php
UTF8_MATCH: /^([\x00-\x7F]|[\xC2-\xDF][\x80-\xBF]|\xE0[\xA0-\xBF][\x80-\xBF]|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}|\xED[\x80-\x9F][\x80-\xBF]|\xF0[\x90-\xBF][\x80-\xBF]{2}|[\xF1-\xF3][\x80-\xBF]{3}|\xF4[\x80-\x8F][\x80-\xBF]{2})*$/,
addExtension: function(extension) {
this._extensions.add(extension);
return true;
},
parse: function(chunk) {
this._reader.put(chunk);
var buffer = true;
while (buffer) {
switch (this._stage) {
case 0:
buffer = this._reader.read(1);
if (buffer) this._parseOpcode(buffer[0]);
break;
case 1:
buffer = this._reader.read(1);
if (buffer) this._parseLength(buffer[0]);
break;
case 2:
buffer = this._reader.read(this._frame.lengthBytes);
if (buffer) this._parseExtendedLength(buffer);
break;
case 3:
buffer = this._reader.read(4);
if (buffer) {
this._stage = 4;
this._frame.maskingKey = buffer;
}
break;
case 4:
buffer = this._reader.read(this._frame.length);
if (buffer) {
this._stage = 0;
this._emitFrame(buffer);
}
break;
default:
buffer = null;
}
}
},
text: function(message) {
if (this.readyState > 1) return false;
return this.frame(message, 'text');
},
binary: function(message) {
if (this.readyState > 1) return false;
return this.frame(message, 'binary');
},
ping: function(message, callback) {
if (this.readyState > 1) return false;
message = message || '';
if (callback) this._pingCallbacks[message] = callback;
return this.frame(message, 'ping');
},
pong: function(message) {
if (this.readyState > 1) return false;
message = message ||'';
return this.frame(message, 'pong');
},
close: function(reason, code) {
reason = reason || '';
code = code || this.ERRORS.normal_closure;
if (this.readyState <= 0) {
this.readyState = 3;
this.emit('close', new Base.CloseEvent(code, reason));
return true;
} else if (this.readyState === 1) {
this.readyState = 2;
this._extensions.close(function() { this.frame(reason, 'close', code) }, this);
return true;
} else {
return false;
}
},
frame: function(buffer, type, code) {
if (this.readyState <= 0) return this._queue([buffer, type, code]);
if (this.readyState > 2) return false;
if (buffer instanceof Array) buffer = Buffer.from(buffer);
if (typeof buffer === 'number') buffer = buffer.toString();
var message = new Message(),
isText = (typeof buffer === 'string'),
payload, copy;
message.rsv1 = message.rsv2 = message.rsv3 = false;
message.opcode = this.OPCODES[type || (isText ? 'text' : 'binary')];
payload = isText ? Buffer.from(buffer, 'utf8') : buffer;
if (code) {
copy = payload;
payload = Buffer.allocUnsafe(2 + copy.length);
payload.writeUInt16BE(code, 0);
copy.copy(payload, 2);
}
message.data = payload;
var onMessageReady = function(message) {
var frame = new Frame();
frame.final = true;
frame.rsv1 = message.rsv1;
frame.rsv2 = message.rsv2;
frame.rsv3 = message.rsv3;
frame.opcode = message.opcode;
frame.masked = !!this._masking;
frame.length = message.data.length;
frame.payload = message.data;
if (frame.masked) frame.maskingKey = crypto.randomBytes(4);
this._sendFrame(frame);
};
if (this.MESSAGE_OPCODES.indexOf(message.opcode) >= 0)
this._extensions.processOutgoingMessage(message, function(error, message) {
if (error) return this._fail('extension_error', error.message);
onMessageReady.call(this, message);
}, this);
else
onMessageReady.call(this, message);
return true;
},
_sendFrame: function(frame) {
var length = frame.length,
header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
offset = header + (frame.masked ? 4 : 0),
buffer = Buffer.allocUnsafe(offset + length),
masked = frame.masked ? this.MASK : 0;
buffer[0] = (frame.final ? this.FIN : 0) |
(frame.rsv1 ? this.RSV1 : 0) |
(frame.rsv2 ? this.RSV2 : 0) |
(frame.rsv3 ? this.RSV3 : 0) |
frame.opcode;
if (length <= 125) {
buffer[1] = masked | length;
} else if (length <= 65535) {
buffer[1] = masked | 126;
buffer.writeUInt16BE(length, 2);
} else {
buffer[1] = masked | 127;
buffer.writeUInt32BE(Math.floor(length / 0x100000000), 2);
buffer.writeUInt32BE(length % 0x100000000, 6);
}
frame.payload.copy(buffer, offset);
if (frame.masked) {
frame.maskingKey.copy(buffer, header);
Hybi.mask(buffer, frame.maskingKey, offset);
}
this._write(buffer);
},
_handshakeResponse: function() {
var secKey = this._request.headers['sec-websocket-key'],
version = this._request.headers['sec-websocket-version'];
if (version !== Hybi.VERSION)
throw new Error('Unsupported WebSocket version: ' + version);
if (typeof secKey !== 'string')
throw new Error('Missing handshake request header: Sec-WebSocket-Key');
this._headers.set('Upgrade', 'websocket');
this._headers.set('Connection', 'Upgrade');
this._headers.set('Sec-WebSocket-Accept', Hybi.generateAccept(secKey));
if (this.protocol) this._headers.set('Sec-WebSocket-Protocol', this.protocol);
var extensions = this._extensions.generateResponse(this._request.headers['sec-websocket-extensions']);
if (extensions) this._headers.set('Sec-WebSocket-Extensions', extensions);
var start = 'HTTP/1.1 101 Switching Protocols',
headers = [start, this._headers.toString(), ''];
return Buffer.from(headers.join('\r\n'), 'utf8');
},
_shutdown: function(code, reason, error) {
delete this._frame;
delete this._message;
this._stage = 5;
var sendCloseFrame = (this.readyState === 1);
this.readyState = 2;
this._extensions.close(function() {
if (sendCloseFrame) this.frame(reason, 'close', code);
this.readyState = 3;
if (error) this.emit('error', new Error(reason));
this.emit('close', new Base.CloseEvent(code, reason));
}, this);
},
_fail: function(type, message) {
if (this.readyState > 1) return;
this._shutdown(this.ERRORS[type], message, true);
},
_parseOpcode: function(octet) {
var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) {
return (octet & rsv) === rsv;
});
var frame = this._frame = new Frame();
frame.final = (octet & this.FIN) === this.FIN;
frame.rsv1 = rsvs[0];
frame.rsv2 = rsvs[1];
frame.rsv3 = rsvs[2];
frame.opcode = (octet & this.OPCODE);
this._stage = 1;
if (!this._extensions.validFrameRsv(frame))
return this._fail('protocol_error',
'One or more reserved bits are on: reserved1 = ' + (frame.rsv1 ? 1 : 0) +
', reserved2 = ' + (frame.rsv2 ? 1 : 0) +
', reserved3 = ' + (frame.rsv3 ? 1 : 0));
if (this.OPCODE_CODES.indexOf(frame.opcode) < 0)
return this._fail('protocol_error', 'Unrecognized frame opcode: ' + frame.opcode);
if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && !frame.final)
return this._fail('protocol_error', 'Received fragmented control frame: opcode = ' + frame.opcode);
if (this._message && this.OPENING_OPCODES.indexOf(frame.opcode) >= 0)
return this._fail('protocol_error', 'Received new data frame but previous continuous frame is unfinished');
},
_parseLength: function(octet) {
var frame = this._frame;
frame.masked = (octet & this.MASK) === this.MASK;
frame.length = (octet & this.LENGTH);
if (frame.length >= 0 && frame.length <= 125) {
this._stage = frame.masked ? 3 : 4;
if (!this._checkFrameLength()) return;
} else {
this._stage = 2;
frame.lengthBytes = (frame.length === 126 ? 2 : 8);
}
if (this._requireMasking && !frame.masked)
return this._fail('unacceptable', 'Received unmasked frame but masking is required');
},
_parseExtendedLength: function(buffer) {
var frame = this._frame;
frame.length = this._readUInt(buffer);
this._stage = frame.masked ? 3 : 4;
if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && frame.length > 125)
return this._fail('protocol_error', 'Received control frame having too long payload: ' + frame.length);
if (!this._checkFrameLength()) return;
},
_checkFrameLength: function() {
var length = this._message ? this._message.length : 0;
if (length + this._frame.length > this._maxLength) {
this._fail('too_large', 'WebSocket frame length too large');
return false;
} else {
return true;
}
},
_emitFrame: function(buffer) {
var frame = this._frame,
payload = frame.payload = Hybi.mask(buffer, frame.maskingKey),
opcode = frame.opcode,
message,
code, reason,
callbacks, callback;
delete this._frame;
if (opcode === this.OPCODES.continuation) {
if (!this._message) return this._fail('protocol_error', 'Received unexpected continuation frame');
this._message.pushFrame(frame);
}
if (opcode === this.OPCODES.text || opcode === this.OPCODES.binary) {
this._message = new Message();
this._message.pushFrame(frame);
}
if (frame.final && this.MESSAGE_OPCODES.indexOf(opcode) >= 0)
return this._emitMessage(this._message);
if (opcode === this.OPCODES.close) {
code = (payload.length >= 2) ? payload.readUInt16BE(0) : null;
reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
if (!(payload.length === 0) &&
!(code !== null && code >= this.MIN_RESERVED_ERROR && code <= this.MAX_RESERVED_ERROR) &&
this.ERROR_CODES.indexOf(code) < 0)
code = this.ERRORS.protocol_error;
if (payload.length > 125 || (payload.length > 2 && !reason))
code = this.ERRORS.protocol_error;
this._shutdown(code || this.DEFAULT_ERROR_CODE, reason || '');
}
if (opcode === this.OPCODES.ping) {
this.frame(payload, 'pong');
this.emit('ping', new Base.PingEvent(payload.toString()))
}
if (opcode === this.OPCODES.pong) {
callbacks = this._pingCallbacks;
message = this._encode(payload);
callback = callbacks[message];
delete callbacks[message];
if (callback) callback()
this.emit('pong', new Base.PongEvent(payload.toString()))
}
},
_emitMessage: function(message) {
var message = this._message;
message.read();
delete this._message;
this._extensions.processIncomingMessage(message, function(error, message) {
if (error) return this._fail('extension_error', error.message);
var payload = message.data;
if (message.opcode === this.OPCODES.text) payload = this._encode(payload);
if (payload === null)
return this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
else
this.emit('message', new Base.MessageEvent(payload));
}, this);
},
_encode: function(buffer) {
try {
var string = buffer.toString('binary', 0, buffer.length);
if (!this.UTF8_MATCH.test(string)) return null;
} catch (e) {}
return buffer.toString('utf8', 0, buffer.length);
},
_readUInt: function(buffer) {
if (buffer.length === 2) return buffer.readUInt16BE(0);
return buffer.readUInt32BE(0) * 0x100000000 +
buffer.readUInt32BE(4);
}
};
for (var key in instance)
Hybi.prototype[key] = instance[key];
module.exports = Hybi;
/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var RingBuffer = function(bufferSize) {
this._bufferSize = bufferSize;
this.clear();
};
RingBuffer.prototype.clear = function() {
this._buffer = new Array(this._bufferSize);
this._ringOffset = 0;
this._ringSize = this._bufferSize;
this._head = 0;
this._tail = 0;
this.length = 0;
};
RingBuffer.prototype.push = function(value) {
var expandBuffer = false,
expandRing = false;
if (this._ringSize < this._bufferSize) {
expandBuffer = (this._tail === 0);
} else if (this._ringOffset === this._ringSize) {
expandBuffer = true;
expandRing = (this._tail === 0);
}
if (expandBuffer) {
this._tail = this._bufferSize;
this._buffer = this._buffer.concat(new Array(this._bufferSize));
this._bufferSize = this._buffer.length;
if (expandRing)
this._ringSize = this._bufferSize;
}
this._buffer[this._tail] = value;
this.length += 1;
if (this._tail < this._ringSize) this._ringOffset += 1;
this._tail = (this._tail + 1) % this._bufferSize;
};
RingBuffer.prototype.peek = function() {
if (this.length === 0) return void 0;
return this._buffer[this._head];
};
RingBuffer.prototype.shift = function() {
if (this.length === 0) return void 0;
var value = this._buffer[this._head];
this._buffer[this._head] = void 0;
this.length -= 1;
this._ringOffset -= 1;
if (this._ringOffset === 0 && this.length > 0) {
this._head = this._ringSize;
this._ringOffset = this.length;
this._ringSize = this._bufferSize;
} else {
this._head = (this._head + 1) % this._ringSize;
}
return value;
};
module.exports = RingBuffer;
/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var RingBuffer = __webpack_require__(13);
var Pledge = function() {
this._complete = false;
this._callbacks = new RingBuffer(Pledge.QUEUE_SIZE);
};
Pledge.QUEUE_SIZE = 4;
Pledge.all = function(list) {
var pledge = new Pledge(),
pending = list.length,
n = pending;
if (pending === 0) pledge.done();
while (n--) list[n].then(function() {
pending -= 1;
if (pending === 0) pledge.done();
});
return pledge;
};
Pledge.prototype.then = function(callback) {
if (this._complete) callback();
else this._callbacks.push(callback);
};
Pledge.prototype.done = function() {
this._complete = true;
var callbacks = this._callbacks, callback;
while (callback = callbacks.shift()) callback();
};
module.exports = Pledge;
/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Buffer = __webpack_require__(1).Buffer,
Base = __webpack_require__(2),
util = __webpack_require__(0);
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];
module.exports = Draft75;
/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Event = __webpack_require__(7);
var EventTarget = {
onopen: null,
onmessage: null,
onerror: null,
onclose: null,
addEventListener: function(eventType, listener, useCapture) {
this.on(eventType, listener);
},
removeEventListener: function(eventType, listener, useCapture) {
this.removeListener(eventType, listener);
},
dispatchEvent: function(event) {
event.target = event.currentTarget = this;
event.eventPhase = Event.AT_TARGET;
if (this['on' + event.type])
this['on' + event.type](event);
this.emit(event.type, event);
}
};
module.exports = EventTarget;
/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// Copyright (C) 2016 Dmitry Chestnykh
// MIT License. See LICENSE file for details.
Object.defineProperty(exports, "__esModule", { value: true });
/**
* Package utf8 implements UTF-8 encoding and decoding.
*/
var INVALID_UTF16 = "utf8: invalid string";
var INVALID_UTF8 = "utf8: invalid source encoding";
/**
* Encodes the given string into UTF-8 byte array.
* Throws if the source string has invalid UTF-16 encoding.
*/
function encode(s) {
// Calculate result length and allocate output array.
// encodedLength() also validates string and throws errors,
// so we don't need repeat validation here.
var arr = new Uint8Array(encodedLength(s));
var pos = 0;
for (var i = 0; i < s.length; i++) {
var c = s.charCodeAt(i);
if (c < 0x80) {
arr[pos++] = c;
}
else if (c < 0x800) {
arr[pos++] = 0xc0 | c >> 6;
arr[pos++] = 0x80 | c & 0x3f;
}
else if (c < 0xd800) {
arr[pos++] = 0xe0 | c >> 12;
arr[pos++] = 0x80 | (c >> 6) & 0x3f;
arr[pos++] = 0x80 | c & 0x3f;
}
else {
i++; // get one more character
c = (c & 0x3ff) << 10;
c |= s.charCodeAt(i) & 0x3ff;
c += 0x10000;
arr[pos++] = 0xf0 | c >> 18;
arr[pos++] = 0x80 | (c >> 12) & 0x3f;
arr[pos++] = 0x80 | (c >> 6) & 0x3f;
arr[pos++] = 0x80 | c & 0x3f;
}
}
return arr;
}
exports.encode = encode;
/**
* Returns the number of bytes required to encode the given string into UTF-8.
* Throws if the source string has invalid UTF-16 encoding.
*/
function encodedLength(s) {
var result = 0;
for (var i = 0; i < s.length; i++) {
var c = s.charCodeAt(i);
if (c < 0x80) {
result += 1;
}
else if (c < 0x800) {
result += 2;
}
else if (c < 0xd800) {
result += 3;
}
else if (c <= 0xdfff) {
if (i >= s.length - 1) {
throw new Error(INVALID_UTF16);
}
i++; // "eat" next character
result += 4;
}
else {
throw new Error(INVALID_UTF16);
}
}
return result;
}
exports.encodedLength = encodedLength;
/**
* Decodes the given byte array from UTF-8 into a string.
* Throws if encoding is invalid.
*/
function decode(arr) {
var chars = [];
for (var i = 0; i < arr.length; i++) {
var b = arr[i];
if (b & 0x80) {
var min = void 0;
if (b < 0xe0) {
// Need 1 more byte.
if (i >= arr.length) {
throw new Error(INVALID_UTF8);
}
var n1 = arr[++i];
if ((n1 & 0xc0) !== 0x80) {
throw new Error(INVALID_UTF8);
}
b = (b & 0x1f) << 6 | (n1 & 0x3f);
min = 0x80;
}
else if (b < 0xf0) {
// Need 2 more bytes.
if (i >= arr.length - 1) {
throw new Error(INVALID_UTF8);
}
var n1 = arr[++i];
var n2 = arr[++i];
if ((n1 & 0xc0) !== 0x80 || (n2 & 0xc0) !== 0x80) {
throw new Error(INVALID_UTF8);
}
b = (b & 0x0f) << 12 | (n1 & 0x3f) << 6 | (n2 & 0x3f);
min = 0x800;
}
else if (b < 0xf8) {
// Need 3 more bytes.
if (i >= arr.length - 2) {
throw new Error(INVALID_UTF8);
}
var n1 = arr[++i];
var n2 = arr[++i];
var n3 = arr[++i];
if ((n1 & 0xc0) !== 0x80 || (n2 & 0xc0) !== 0x80 || (n3 & 0xc0) !== 0x80) {
throw new Error(INVALID_UTF8);
}
b = (b & 0x0f) << 18 | (n1 & 0x3f) << 12 | (n2 & 0x3f) << 6 | (n3 & 0x3f);
min = 0x10000;
}
else {
throw new Error(INVALID_UTF8);
}
if (b < min || (b >= 0xd800 && b <= 0xdfff)) {
throw new Error(INVALID_UTF8);
}
if (b >= 0x10000) {
// Surrogate pair.
if (b > 0x10ffff) {
throw new Error(INVALID_UTF8);
}
b -= 0x10000;
chars.push(String.fromCharCode(0xd800 | (b >> 10)));
b = 0xdc00 | (b & 0x3ff);
}
}
chars.push(String.fromCharCode(b));
}
return chars.join("");
}
exports.decode = decode;
/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// API references:
//
// * https://html.spec.whatwg.org/multipage/comms.html#network
// * https://dom.spec.whatwg.org/#interface-eventtarget
// * https://dom.spec.whatwg.org/#interface-event
var util = __webpack_require__(0),
driver = __webpack_require__(4),
API = __webpack_require__(11);
var WebSocket = function(request, socket, body, protocols, options) {
options = options || {};
this._stream = socket;
this._driver = driver.http(request, {maxLength: options.maxLength, protocols: protocols});
var self = this;
if (!this._stream || !this._stream.writable) return;
if (!this._stream.readable) return this._stream.end();
var catchup = function() { self._stream.removeListener('data', catchup) };
this._stream.on('data', catchup);
API.call(this, options);
process.nextTick(function() {
self._driver.start();
self._driver.io.write(body);
});
};
util.inherits(WebSocket, API);
WebSocket.isWebSocket = function(request) {
return driver.isWebSocket(request);
};
WebSocket.validateOptions = function(options, validKeys) {
driver.validateOptions(options, validKeys);
};
WebSocket.WebSocket = WebSocket;
WebSocket.Client = __webpack_require__(39);
WebSocket.EventSource = __webpack_require__(42);
module.exports = WebSocket;
/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {
/**
* Wrapper for built-in http.js to emulate the browser XMLHttpRequest object.
*
* This can be used with JS designed for browsers to improve reuse of code and
* allow the use of existing libraries.
*
* Usage: include("XMLHttpRequest.js") and use XMLHttpRequest per W3C specs.
*
* @author Dan DeFelippi <dan@driverdan.com>
* @contributor David Ellis <d.f.ellis@ieee.org>
* @license MIT
*/
var Url = __webpack_require__(6);
var spawn = __webpack_require__(43).spawn;
var fs = __webpack_require__(44);
exports.XMLHttpRequest = function() {
"use strict";
/**
* Private variables
*/
var self = this;
var http = __webpack_require__(45);
var https = __webpack_require__(46);
// Holds http.js objects
var request;
var response;
// Request settings
var settings = {};
// Disable header blacklist.
// Not part of XHR specs.
var disableHeaderCheck = false;
// Set some default headers
var defaultHeaders = {
"User-Agent": "node-XMLHttpRequest",
"Accept": "*/*",
};
var headers = {};
var headersCase = {};
// These headers are not user setable.
// The following are allowed but banned in the spec:
// * user-agent
var forbiddenRequestHeaders = [
"accept-charset",
"accept-encoding",
"access-control-request-headers",
"access-control-request-method",
"connection",
"content-length",
"content-transfer-encoding",
"cookie",
"cookie2",
"date",
"expect",
"host",
"keep-alive",
"origin",
"referer",
"te",
"trailer",
"transfer-encoding",
"upgrade",
"via"
];
// These request methods are not allowed
var forbiddenRequestMethods = [
"TRACE",
"TRACK",
"CONNECT"
];
// Send flag
var sendFlag = false;
// Error flag, used when errors occur or abort is called
var errorFlag = false;
// Event listeners
var listeners = {};
/**
* Constants
*/
this.UNSENT = 0;
this.OPENED = 1;
this.HEADERS_RECEIVED = 2;
this.LOADING = 3;
this.DONE = 4;
/**
* Public vars
*/
// Current state
this.readyState = this.UNSENT;
// default ready state change handler in case one is not set or is set late
this.onreadystatechange = null;
// Result & response
this.responseText = "";
this.responseXML = "";
this.status = null;
this.statusText = null;
// Whether cross-site Access-Control requests should be made using
// credentials such as cookies or authorization headers
this.withCredentials = false;
/**
* Private methods
*/
/**
* Check if the specified header is allowed.
*
* @param string header Header to validate
* @return boolean False if not allowed, otherwise true
*/
var isAllowedHttpHeader = function(header) {
return disableHeaderCheck || (header && forbiddenRequestHeaders.indexOf(header.toLowerCase()) === -1);
};
/**
* Check if the specified method is allowed.
*
* @param string method Request method to validate
* @return boolean False if not allowed, otherwise true
*/
var isAllowedHttpMethod = function(method) {
return (method && forbiddenRequestMethods.indexOf(method) === -1);
};
/**
* Public methods
*/
/**
* Open the connection. Currently supports local server requests.
*
* @param string method Connection method (eg GET, POST)
* @param string url URL for the connection.
* @param boolean async Asynchronous connection. Default is true.
* @param string user Username for basic authentication (optional)
* @param string password Password for basic authentication (optional)
*/
this.open = function(method, url, async, user, password) {
this.abort();
errorFlag = false;
// Check for valid request method
if (!isAllowedHttpMethod(method)) {
throw new Error("SecurityError: Request method not allowed");
}
settings = {
"method": method,
"url": url.toString(),
"async": (typeof async !== "boolean" ? true : async),
"user": user || null,
"password": password || null
};
setState(this.OPENED);
};
/**
* Disables or enables isAllowedHttpHeader() check the request. Enabled by default.
* This does not conform to the W3C spec.
*
* @param boolean state Enable or disable header checking.
*/
this.setDisableHeaderCheck = function(state) {
disableHeaderCheck = state;
};
/**
* Sets a header for the request or appends the value if one is already set.
*
* @param string header Header name
* @param string value Header value
*/
this.setRequestHeader = function(header, value) {
if (this.readyState !== this.OPENED) {
throw new Error("INVALID_STATE_ERR: setRequestHeader can only be called when state is OPEN");
}
if (!isAllowedHttpHeader(header)) {
console.warn("Refused to set unsafe header \"" + header + "\"");
return;
}
if (sendFlag) {
throw new Error("INVALID_STATE_ERR: send flag is true");
}
header = headersCase[header.toLowerCase()] || header;
headersCase[header.toLowerCase()] = header;
headers[header] = headers[header] ? headers[header] + ', ' + value : value;
};
/**
* Gets a header from the server response.
*
* @param string header Name of header to get.
* @return string Text of the header or null if it doesn't exist.
*/
this.getResponseHeader = function(header) {
if (typeof header === "string"
&& this.readyState > this.OPENED
&& response
&& response.headers
&& response.headers[header.toLowerCase()]
&& !errorFlag
) {
return response.headers[header.toLowerCase()];
}
return null;
};
/**
* Gets all the response headers.
*
* @return string A string with all response headers separated by CR+LF
*/
this.getAllResponseHeaders = function() {
if (this.readyState < this.HEADERS_RECEIVED || errorFlag) {
return "";
}
var result = "";
for (var i in response.headers) {
// Cookie headers are excluded
if (i !== "set-cookie" && i !== "set-cookie2") {
result += i + ": " + response.headers[i] + "\r\n";
}
}
return result.substr(0, result.length - 2);
};
/**
* Gets a request header
*
* @param string name Name of header to get
* @return string Returns the request header or empty string if not set
*/
this.getRequestHeader = function(name) {
if (typeof name === "string" && headersCase[name.toLowerCase()]) {
return headers[headersCase[name.toLowerCase()]];
}
return "";
};
/**
* Sends the request to the server.
*
* @param string data Optional data to send as request body.
*/
this.send = function(data) {
if (this.readyState !== this.OPENED) {
throw new Error("INVALID_STATE_ERR: connection must be opened before send() is called");
}
if (sendFlag) {
throw new Error("INVALID_STATE_ERR: send has already been called");
}
var ssl = false, local = false;
var url = Url.parse(settings.url);
var host;
// Determine the server
switch (url.protocol) {
case "https:":
ssl = true;
// SSL & non-SSL both need host, no break here.
case "http:":
host = url.hostname;
break;
case "file:":
local = true;
break;
case undefined:
case null:
case "":
host = "localhost";
break;
default:
throw new Error("Protocol not supported.");
}
// Load files off the local filesystem (file://)
if (local) {
if (settings.method !== "GET") {
throw new Error("XMLHttpRequest: Only GET method is supported");
}
if (settings.async) {
fs.readFile(url.pathname, "utf8", function(error, data) {
if (error) {
self.handleError(error);
} else {
self.status = 200;
self.responseText = data;
setState(self.DONE);
}
});
} else {
try {
this.responseText = fs.readFileSync(url.pathname, "utf8");
this.status = 200;
setState(self.DONE);
} catch(e) {
this.handleError(e);
}
}
return;
}
// Default to port 80. If accessing localhost on another port be sure
// to use http://localhost:port/path
var port = url.port || (ssl ? 443 : 80);
// Add query string if one is used
var uri = url.pathname + (url.search ? url.search : "");
// Set the defaults if they haven't been set
for (var name in defaultHeaders) {
if (!headersCase[name.toLowerCase()]) {
headers[name] = defaultHeaders[name];
}
}
// Set the Host header or the server may reject the request
headers.Host = host;
if (!((ssl && port === 443) || port === 80)) {
headers.Host += ":" + url.port;
}
// Set Basic Auth if necessary
if (settings.user) {
if (typeof settings.password === "undefined") {
settings.password = "";
}
var authBuf = new Buffer(settings.user + ":" + settings.password);
headers.Authorization = "Basic " + authBuf.toString("base64");
}
// Set content length header
if (settings.method === "GET" || settings.method === "HEAD") {
data = null;
} else if (data) {
headers["Content-Length"] = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data);
if (!headers["Content-Type"]) {
headers["Content-Type"] = "text/plain;charset=UTF-8";
}
} else if (settings.method === "POST") {
// For a post with no data set Content-Length: 0.
// This is required by buggy servers that don't meet the specs.
headers["Content-Length"] = 0;
}
var options = {
host: host,
port: port,
path: uri,
method: settings.method,
headers: headers,
agent: false,
withCredentials: self.withCredentials
};
// Reset error flag
errorFlag = false;
// Handle async requests
if (settings.async) {
// Use the proper protocol
var doRequest = ssl ? https.request : http.request;
// Request is being sent, set send flag
sendFlag = true;
// As per spec, this is called here for historical reasons.
self.dispatchEvent("readystatechange");
// Handler for the response
var responseHandler = function responseHandler(resp) {
// Set response var to the response we got back
// This is so it remains accessable outside this scope
response = resp;
// Check for redirect
// @TODO Prevent looped redirects
if (response.statusCode === 301 || response.statusCode === 302 || response.statusCode === 303 || response.statusCode === 307) {
// Change URL to the redirect location
settings.url = response.headers.location;
var url = Url.parse(settings.url);
// Set host var in case it's used later
host = url.hostname;
// Options for the new request
var newOptions = {
hostname: url.hostname,
port: url.port,
path: url.path,
method: response.statusCode === 303 ? "GET" : settings.method,
headers: headers,
withCredentials: self.withCredentials
};
// Issue the new request
request = doRequest(newOptions, responseHandler).on("error", errorHandler);
request.end();
// @TODO Check if an XHR event needs to be fired here
return;
}
response.setEncoding("utf8");
setState(self.HEADERS_RECEIVED);
self.status = response.statusCode;
response.on("data", function(chunk) {
// Make sure there's some data
if (chunk) {
self.responseText += chunk;
}
// Don't emit state changes if the connection has been aborted.
if (sendFlag) {
setState(self.LOADING);
}
});
response.on("end", function() {
if (sendFlag) {
// Discard the end event if the connection has been aborted
setState(self.DONE);
sendFlag = false;
}
});
response.on("error", function(error) {
self.handleError(error);
});
};
// Error handler for the request
var errorHandler = function errorHandler(error) {
self.handleError(error);
};
// Create the request
request = doRequest(options, responseHandler).on("error", errorHandler);
// Node 0.4 and later won't accept empty data. Make sure it's needed.
if (data) {
request.write(data);
}
request.end();
self.dispatchEvent("loadstart");
} else { // Synchronous
// Create a temporary file for communication with the other Node process
var contentFile = ".node-xmlhttprequest-content-" + process.pid;
var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
fs.writeFileSync(syncFile, "", "utf8");
// The async request the other Node process executes
var execString = "var http = require('http'), https = require('https'), fs = require('fs');"
+ "var doRequest = http" + (ssl ? "s" : "") + ".request;"
+ "var options = " + JSON.stringify(options) + ";"
+ "var responseText = '';"
+ "var req = doRequest(options, function(response) {"
+ "response.setEncoding('utf8');"
+ "response.on('data', function(chunk) {"
+ " responseText += chunk;"
+ "});"
+ "response.on('end', function() {"
+ "fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText}}), 'utf8');"
+ "fs.unlinkSync('" + syncFile + "');"
+ "});"
+ "response.on('error', function(error) {"
+ "fs.writeFileSync('" + contentFile + "', JSON.stringify({err: error}), 'utf8');"
+ "fs.unlinkSync('" + syncFile + "');"
+ "});"
+ "}).on('error', function(error) {"
+ "fs.writeFileSync('" + contentFile + "', JSON.stringify({err: error}), 'utf8');"
+ "fs.unlinkSync('" + syncFile + "');"
+ "});"
+ (data ? "req.write('" + JSON.stringify(data).slice(1,-1).replace(/'/g, "\\'") + "');":"")
+ "req.end();";
// Start the other Node Process, executing this string
var syncProc = spawn(process.argv[0], ["-e", execString]);
while(fs.existsSync(syncFile)) {
// Wait while the sync file is empty
}
var resp = JSON.parse(fs.readFileSync(contentFile, 'utf8'));
// Kill the child process once the file has data
syncProc.stdin.end();
// Remove the temporary file
fs.unlinkSync(contentFile);
if (resp.err) {
self.handleError(resp.err);
} else {
response = resp.data;
self.status = resp.data.statusCode;
self.responseText = resp.data.text;
setState(self.DONE);
}
}
};
/**
* Called when an error is encountered to deal with it.
*/
this.handleError = function(error) {
this.status = 0;
this.statusText = error;
this.responseText = error.stack;
errorFlag = true;
setState(this.DONE);
this.dispatchEvent('error');
};
/**
* Aborts a request.
*/
this.abort = function() {
if (request) {
request.abort();
request = null;
}
headers = defaultHeaders;
this.status = 0;
this.responseText = "";
this.responseXML = "";
errorFlag = true;
if (this.readyState !== this.UNSENT
&& (this.readyState !== this.OPENED || sendFlag)
&& this.readyState !== this.DONE) {
sendFlag = false;
setState(this.DONE);
}
this.readyState = this.UNSENT;
this.dispatchEvent('abort');
};
/**
* Adds an event listener. Preferred method of binding to events.
*/
this.addEventListener = function(event, callback) {
if (!(event in listeners)) {
listeners[event] = [];
}
// Currently allows duplicate callbacks. Should it?
listeners[event].push(callback);
};
/**
* Remove an event callback that has already been bound.
* Only works on the matching funciton, cannot be a copy.
*/
this.removeEventListener = function(event, callback) {
if (event in listeners) {
// Filter will return a new array with the callback removed
listeners[event] = listeners[event].filter(function(ev) {
return ev !== callback;
});
}
};
/**
* Dispatch any events, including both "on" methods and events attached using addEventListener.
*/
this.dispatchEvent = function(event) {
if (typeof self["on" + event] === "function") {
self["on" + event]();
}
if (event in listeners) {
for (var i = 0, len = listeners[event].length; i < len; i++) {
listeners[event][i].call(self);
}
}
};
/**
* Changes readyState and calls onreadystatechange.
*
* @param int state New state
*/
var setState = function(state) {
if (state == self.LOADING || self.readyState !== state) {
self.readyState = state;
if (settings.async || self.readyState < self.OPENED || self.readyState === self.DONE) {
self.dispatchEvent("readystatechange");
}
if (self.readyState === self.DONE && !errorFlag) {
self.dispatchEvent("load");
// @TODO figure out InspectorInstrumentation::didLoadXHR(cookie)
self.dispatchEvent("loadend");
}
}
};
};
/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {
(function(nacl) {
'use strict';
// Ported in 2014 by Dmitry Chestnykh and Devi Mandiri.
// Public domain.
//
// Implementation derived from TweetNaCl version 20140427.
// See for details: http://tweetnacl.cr.yp.to/
var gf = function(init) {
var i, r = new Float64Array(16);
if (init) for (i = 0; i < init.length; i++) r[i] = init[i];
return r;
};
// Pluggable, initialized in high-level API below.
var randombytes = function(/* x, n */) { throw new Error('no PRNG'); };
var _0 = new Uint8Array(16);
var _9 = new Uint8Array(32); _9[0] = 9;
var gf0 = gf(),
gf1 = gf([1]),
_121665 = gf([0xdb41, 1]),
D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203]),
D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406]),
X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169]),
Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666]),
I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]);
function ts64(x, i, h, l) {
x[i] = (h >> 24) & 0xff;
x[i+1] = (h >> 16) & 0xff;
x[i+2] = (h >> 8) & 0xff;
x[i+3] = h & 0xff;
x[i+4] = (l >> 24) & 0xff;
x[i+5] = (l >> 16) & 0xff;
x[i+6] = (l >> 8) & 0xff;
x[i+7] = l & 0xff;
}
function vn(x, xi, y, yi, n) {
var i,d = 0;
for (i = 0; i < n; i++) d |= x[xi+i]^y[yi+i];
return (1 & ((d - 1) >>> 8)) - 1;
}
function crypto_verify_16(x, xi, y, yi) {
return vn(x,xi,y,yi,16);
}
function crypto_verify_32(x, xi, y, yi) {
return vn(x,xi,y,yi,32);
}
function core_salsa20(o, p, k, c) {
var j0 = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24,
j1 = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24,
j2 = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24,
j3 = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24,
j4 = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24,
j5 = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24,
j6 = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24,
j7 = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24,
j8 = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24,
j9 = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24,
j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24,
j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24,
j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24,
j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24,
j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24,
j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24;
var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,
x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,
x15 = j15, u;
for (var i = 0; i < 20; i += 2) {
u = x0 + x12 | 0;
x4 ^= u<<7 | u>>>(32-7);
u = x4 + x0 | 0;
x8 ^= u<<9 | u>>>(32-9);
u = x8 + x4 | 0;
x12 ^= u<<13 | u>>>(32-13);
u = x12 + x8 | 0;
x0 ^= u<<18 | u>>>(32-18);
u = x5 + x1 | 0;
x9 ^= u<<7 | u>>>(32-7);
u = x9 + x5 | 0;
x13 ^= u<<9 | u>>>(32-9);
u = x13 + x9 | 0;
x1 ^= u<<13 | u>>>(32-13);
u = x1 + x13 | 0;
x5 ^= u<<18 | u>>>(32-18);
u = x10 + x6 | 0;
x14 ^= u<<7 | u>>>(32-7);
u = x14 + x10 | 0;
x2 ^= u<<9 | u>>>(32-9);
u = x2 + x14 | 0;
x6 ^= u<<13 | u>>>(32-13);
u = x6 + x2 | 0;
x10 ^= u<<18 | u>>>(32-18);
u = x15 + x11 | 0;
x3 ^= u<<7 | u>>>(32-7);
u = x3 + x15 | 0;
x7 ^= u<<9 | u>>>(32-9);
u = x7 + x3 | 0;
x11 ^= u<<13 | u>>>(32-13);
u = x11 + x7 | 0;
x15 ^= u<<18 | u>>>(32-18);
u = x0 + x3 | 0;
x1 ^= u<<7 | u>>>(32-7);
u = x1 + x0 | 0;
x2 ^= u<<9 | u>>>(32-9);
u = x2 + x1 | 0;
x3 ^= u<<13 | u>>>(32-13);
u = x3 + x2 | 0;
x0 ^= u<<18 | u>>>(32-18);
u = x5 + x4 | 0;
x6 ^= u<<7 | u>>>(32-7);
u = x6 + x5 | 0;
x7 ^= u<<9 | u>>>(32-9);
u = x7 + x6 | 0;
x4 ^= u<<13 | u>>>(32-13);
u = x4 + x7 | 0;
x5 ^= u<<18 | u>>>(32-18);
u = x10 + x9 | 0;
x11 ^= u<<7 | u>>>(32-7);
u = x11 + x10 | 0;
x8 ^= u<<9 | u>>>(32-9);
u = x8 + x11 | 0;
x9 ^= u<<13 | u>>>(32-13);
u = x9 + x8 | 0;
x10 ^= u<<18 | u>>>(32-18);
u = x15 + x14 | 0;
x12 ^= u<<7 | u>>>(32-7);
u = x12 + x15 | 0;
x13 ^= u<<9 | u>>>(32-9);
u = x13 + x12 | 0;
x14 ^= u<<13 | u>>>(32-13);
u = x14 + x13 | 0;
x15 ^= u<<18 | u>>>(32-18);
}
x0 = x0 + j0 | 0;
x1 = x1 + j1 | 0;
x2 = x2 + j2 | 0;
x3 = x3 + j3 | 0;
x4 = x4 + j4 | 0;
x5 = x5 + j5 | 0;
x6 = x6 + j6 | 0;
x7 = x7 + j7 | 0;
x8 = x8 + j8 | 0;
x9 = x9 + j9 | 0;
x10 = x10 + j10 | 0;
x11 = x11 + j11 | 0;
x12 = x12 + j12 | 0;
x13 = x13 + j13 | 0;
x14 = x14 + j14 | 0;
x15 = x15 + j15 | 0;
o[ 0] = x0 >>> 0 & 0xff;
o[ 1] = x0 >>> 8 & 0xff;
o[ 2] = x0 >>> 16 & 0xff;
o[ 3] = x0 >>> 24 & 0xff;
o[ 4] = x1 >>> 0 & 0xff;
o[ 5] = x1 >>> 8 & 0xff;
o[ 6] = x1 >>> 16 & 0xff;
o[ 7] = x1 >>> 24 & 0xff;
o[ 8] = x2 >>> 0 & 0xff;
o[ 9] = x2 >>> 8 & 0xff;
o[10] = x2 >>> 16 & 0xff;
o[11] = x2 >>> 24 & 0xff;
o[12] = x3 >>> 0 & 0xff;
o[13] = x3 >>> 8 & 0xff;
o[14] = x3 >>> 16 & 0xff;
o[15] = x3 >>> 24 & 0xff;
o[16] = x4 >>> 0 & 0xff;
o[17] = x4 >>> 8 & 0xff;
o[18] = x4 >>> 16 & 0xff;
o[19] = x4 >>> 24 & 0xff;
o[20] = x5 >>> 0 & 0xff;
o[21] = x5 >>> 8 & 0xff;
o[22] = x5 >>> 16 & 0xff;
o[23] = x5 >>> 24 & 0xff;
o[24] = x6 >>> 0 & 0xff;
o[25] = x6 >>> 8 & 0xff;
o[26] = x6 >>> 16 & 0xff;
o[27] = x6 >>> 24 & 0xff;
o[28] = x7 >>> 0 & 0xff;
o[29] = x7 >>> 8 & 0xff;
o[30] = x7 >>> 16 & 0xff;
o[31] = x7 >>> 24 & 0xff;
o[32] = x8 >>> 0 & 0xff;
o[33] = x8 >>> 8 & 0xff;
o[34] = x8 >>> 16 & 0xff;
o[35] = x8 >>> 24 & 0xff;
o[36] = x9 >>> 0 & 0xff;
o[37] = x9 >>> 8 & 0xff;
o[38] = x9 >>> 16 & 0xff;
o[39] = x9 >>> 24 & 0xff;
o[40] = x10 >>> 0 & 0xff;
o[41] = x10 >>> 8 & 0xff;
o[42] = x10 >>> 16 & 0xff;
o[43] = x10 >>> 24 & 0xff;
o[44] = x11 >>> 0 & 0xff;
o[45] = x11 >>> 8 & 0xff;
o[46] = x11 >>> 16 & 0xff;
o[47] = x11 >>> 24 & 0xff;
o[48] = x12 >>> 0 & 0xff;
o[49] = x12 >>> 8 & 0xff;
o[50] = x12 >>> 16 & 0xff;
o[51] = x12 >>> 24 & 0xff;
o[52] = x13 >>> 0 & 0xff;
o[53] = x13 >>> 8 & 0xff;
o[54] = x13 >>> 16 & 0xff;
o[55] = x13 >>> 24 & 0xff;
o[56] = x14 >>> 0 & 0xff;
o[57] = x14 >>> 8 & 0xff;
o[58] = x14 >>> 16 & 0xff;
o[59] = x14 >>> 24 & 0xff;
o[60] = x15 >>> 0 & 0xff;
o[61] = x15 >>> 8 & 0xff;
o[62] = x15 >>> 16 & 0xff;
o[63] = x15 >>> 24 & 0xff;
}
function core_hsalsa20(o,p,k,c) {
var j0 = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24,
j1 = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24,
j2 = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24,
j3 = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24,
j4 = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24,
j5 = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24,
j6 = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24,
j7 = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24,
j8 = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24,
j9 = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24,
j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24,
j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24,
j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24,
j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24,
j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24,
j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24;
var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,
x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,
x15 = j15, u;
for (var i = 0; i < 20; i += 2) {
u = x0 + x12 | 0;
x4 ^= u<<7 | u>>>(32-7);
u = x4 + x0 | 0;
x8 ^= u<<9 | u>>>(32-9);
u = x8 + x4 | 0;
x12 ^= u<<13 | u>>>(32-13);
u = x12 + x8 | 0;
x0 ^= u<<18 | u>>>(32-18);
u = x5 + x1 | 0;
x9 ^= u<<7 | u>>>(32-7);
u = x9 + x5 | 0;
x13 ^= u<<9 | u>>>(32-9);
u = x13 + x9 | 0;
x1 ^= u<<13 | u>>>(32-13);
u = x1 + x13 | 0;
x5 ^= u<<18 | u>>>(32-18);
u = x10 + x6 | 0;
x14 ^= u<<7 | u>>>(32-7);
u = x14 + x10 | 0;
x2 ^= u<<9 | u>>>(32-9);
u = x2 + x14 | 0;
x6 ^= u<<13 | u>>>(32-13);
u = x6 + x2 | 0;
x10 ^= u<<18 | u>>>(32-18);
u = x15 + x11 | 0;
x3 ^= u<<7 | u>>>(32-7);
u = x3 + x15 | 0;
x7 ^= u<<9 | u>>>(32-9);
u = x7 + x3 | 0;
x11 ^= u<<13 | u>>>(32-13);
u = x11 + x7 | 0;
x15 ^= u<<18 | u>>>(32-18);
u = x0 + x3 | 0;
x1 ^= u<<7 | u>>>(32-7);
u = x1 + x0 | 0;
x2 ^= u<<9 | u>>>(32-9);
u = x2 + x1 | 0;
x3 ^= u<<13 | u>>>(32-13);
u = x3 + x2 | 0;
x0 ^= u<<18 | u>>>(32-18);
u = x5 + x4 | 0;
x6 ^= u<<7 | u>>>(32-7);
u = x6 + x5 | 0;
x7 ^= u<<9 | u>>>(32-9);
u = x7 + x6 | 0;
x4 ^= u<<13 | u>>>(32-13);
u = x4 + x7 | 0;
x5 ^= u<<18 | u>>>(32-18);
u = x10 + x9 | 0;
x11 ^= u<<7 | u>>>(32-7);
u = x11 + x10 | 0;
x8 ^= u<<9 | u>>>(32-9);
u = x8 + x11 | 0;
x9 ^= u<<13 | u>>>(32-13);
u = x9 + x8 | 0;
x10 ^= u<<18 | u>>>(32-18);
u = x15 + x14 | 0;
x12 ^= u<<7 | u>>>(32-7);
u = x12 + x15 | 0;
x13 ^= u<<9 | u>>>(32-9);
u = x13 + x12 | 0;
x14 ^= u<<13 | u>>>(32-13);
u = x14 + x13 | 0;
x15 ^= u<<18 | u>>>(32-18);
}
o[ 0] = x0 >>> 0 & 0xff;
o[ 1] = x0 >>> 8 & 0xff;
o[ 2] = x0 >>> 16 & 0xff;
o[ 3] = x0 >>> 24 & 0xff;
o[ 4] = x5 >>> 0 & 0xff;
o[ 5] = x5 >>> 8 & 0xff;
o[ 6] = x5 >>> 16 & 0xff;
o[ 7] = x5 >>> 24 & 0xff;
o[ 8] = x10 >>> 0 & 0xff;
o[ 9] = x10 >>> 8 & 0xff;
o[10] = x10 >>> 16 & 0xff;
o[11] = x10 >>> 24 & 0xff;
o[12] = x15 >>> 0 & 0xff;
o[13] = x15 >>> 8 & 0xff;
o[14] = x15 >>> 16 & 0xff;
o[15] = x15 >>> 24 & 0xff;
o[16] = x6 >>> 0 & 0xff;
o[17] = x6 >>> 8 & 0xff;
o[18] = x6 >>> 16 & 0xff;
o[19] = x6 >>> 24 & 0xff;
o[20] = x7 >>> 0 & 0xff;
o[21] = x7 >>> 8 & 0xff;
o[22] = x7 >>> 16 & 0xff;
o[23] = x7 >>> 24 & 0xff;
o[24] = x8 >>> 0 & 0xff;
o[25] = x8 >>> 8 & 0xff;
o[26] = x8 >>> 16 & 0xff;
o[27] = x8 >>> 24 & 0xff;
o[28] = x9 >>> 0 & 0xff;
o[29] = x9 >>> 8 & 0xff;
o[30] = x9 >>> 16 & 0xff;
o[31] = x9 >>> 24 & 0xff;
}
function crypto_core_salsa20(out,inp,k,c) {
core_salsa20(out,inp,k,c);
}
function crypto_core_hsalsa20(out,inp,k,c) {
core_hsalsa20(out,inp,k,c);
}
var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
// "expand 32-byte k"
function crypto_stream_salsa20_xor(c,cpos,m,mpos,b,n,k) {
var z = new Uint8Array(16), x = new Uint8Array(64);
var u, i;
for (i = 0; i < 16; i++) z[i] = 0;
for (i = 0; i < 8; i++) z[i] = n[i];
while (b >= 64) {
crypto_core_salsa20(x,z,k,sigma);
for (i = 0; i < 64; i++) c[cpos+i] = m[mpos+i] ^ x[i];
u = 1;
for (i = 8; i < 16; i++) {
u = u + (z[i] & 0xff) | 0;
z[i] = u & 0xff;
u >>>= 8;
}
b -= 64;
cpos += 64;
mpos += 64;
}
if (b > 0) {
crypto_core_salsa20(x,z,k,sigma);
for (i = 0; i < b; i++) c[cpos+i] = m[mpos+i] ^ x[i];
}
return 0;
}
function crypto_stream_salsa20(c,cpos,b,n,k) {
var z = new Uint8Array(16), x = new Uint8Array(64);
var u, i;
for (i = 0; i < 16; i++) z[i] = 0;
for (i = 0; i < 8; i++) z[i] = n[i];
while (b >= 64) {
crypto_core_salsa20(x,z,k,sigma);
for (i = 0; i < 64; i++) c[cpos+i] = x[i];
u = 1;
for (i = 8; i < 16; i++) {
u = u + (z[i] & 0xff) | 0;
z[i] = u & 0xff;
u >>>= 8;
}
b -= 64;
cpos += 64;
}
if (b > 0) {
crypto_core_salsa20(x,z,k,sigma);
for (i = 0; i < b; i++) c[cpos+i] = x[i];
}
return 0;
}
function crypto_stream(c,cpos,d,n,k) {
var s = new Uint8Array(32);
crypto_core_hsalsa20(s,n,k,sigma);
var sn = new Uint8Array(8);
for (var i = 0; i < 8; i++) sn[i] = n[i+16];
return crypto_stream_salsa20(c,cpos,d,sn,s);
}
function crypto_stream_xor(c,cpos,m,mpos,d,n,k) {
var s = new Uint8Array(32);
crypto_core_hsalsa20(s,n,k,sigma);
var sn = new Uint8Array(8);
for (var i = 0; i < 8; i++) sn[i] = n[i+16];
return crypto_stream_salsa20_xor(c,cpos,m,mpos,d,sn,s);
}
/*
* Port of Andrew Moon's Poly1305-donna-16. Public domain.
* https://github.com/floodyberry/poly1305-donna
*/
var poly1305 = function(key) {
this.buffer = new Uint8Array(16);
this.r = new Uint16Array(10);
this.h = new Uint16Array(10);
this.pad = new Uint16Array(8);
this.leftover = 0;
this.fin = 0;
var t0, t1, t2, t3, t4, t5, t6, t7;
t0 = key[ 0] & 0xff | (key[ 1] & 0xff) << 8; this.r[0] = ( t0 ) & 0x1fff;
t1 = key[ 2] & 0xff | (key[ 3] & 0xff) << 8; this.r[1] = ((t0 >>> 13) | (t1 << 3)) & 0x1fff;
t2 = key[ 4] & 0xff | (key[ 5] & 0xff) << 8; this.r[2] = ((t1 >>> 10) | (t2 << 6)) & 0x1f03;
t3 = key[ 6] & 0xff | (key[ 7] & 0xff) << 8; this.r[3] = ((t2 >>> 7) | (t3 << 9)) & 0x1fff;
t4 = key[ 8] & 0xff | (key[ 9] & 0xff) << 8; this.r[4] = ((t3 >>> 4) | (t4 << 12)) & 0x00ff;
this.r[5] = ((t4 >>> 1)) & 0x1ffe;
t5 = key[10] & 0xff | (key[11] & 0xff) << 8; this.r[6] = ((t4 >>> 14) | (t5 << 2)) & 0x1fff;
t6 = key[12] & 0xff | (key[13] & 0xff) << 8; this.r[7] = ((t5 >>> 11) | (t6 << 5)) & 0x1f81;
t7 = key[14] & 0xff | (key[15] & 0xff) << 8; this.r[8] = ((t6 >>> 8) | (t7 << 8)) & 0x1fff;
this.r[9] = ((t7 >>> 5)) & 0x007f;
this.pad[0] = key[16] & 0xff | (key[17] & 0xff) << 8;
this.pad[1] = key[18] & 0xff | (key[19] & 0xff) << 8;
this.pad[2] = key[20] & 0xff | (key[21] & 0xff) << 8;
this.pad[3] = key[22] & 0xff | (key[23] & 0xff) << 8;
this.pad[4] = key[24] & 0xff | (key[25] & 0xff) << 8;
this.pad[5] = key[26] & 0xff | (key[27] & 0xff) << 8;
this.pad[6] = key[28] & 0xff | (key[29] & 0xff) << 8;
this.pad[7] = key[30] & 0xff | (key[31] & 0xff) << 8;
};
poly1305.prototype.blocks = function(m, mpos, bytes) {
var hibit = this.fin ? 0 : (1 << 11);
var t0, t1, t2, t3, t4, t5, t6, t7, c;
var d0, d1, d2, d3, d4, d5, d6, d7, d8, d9;
var h0 = this.h[0],
h1 = this.h[1],
h2 = this.h[2],
h3 = this.h[3],
h4 = this.h[4],
h5 = this.h[5],
h6 = this.h[6],
h7 = this.h[7],
h8 = this.h[8],
h9 = this.h[9];
var r0 = this.r[0],
r1 = this.r[1],
r2 = this.r[2],
r3 = this.r[3],
r4 = this.r[4],
r5 = this.r[5],
r6 = this.r[6],
r7 = this.r[7],
r8 = this.r[8],
r9 = this.r[9];
while (bytes >= 16) {
t0 = m[mpos+ 0] & 0xff | (m[mpos+ 1] & 0xff) << 8; h0 += ( t0 ) & 0x1fff;
t1 = m[mpos+ 2] & 0xff | (m[mpos+ 3] & 0xff) << 8; h1 += ((t0 >>> 13) | (t1 << 3)) & 0x1fff;
t2 = m[mpos+ 4] & 0xff | (m[mpos+ 5] & 0xff) << 8; h2 += ((t1 >>> 10) | (t2 << 6)) & 0x1fff;
t3 = m[mpos+ 6] & 0xff | (m[mpos+ 7] & 0xff) << 8; h3 += ((t2 >>> 7) | (t3 << 9)) & 0x1fff;
t4 = m[mpos+ 8] & 0xff | (m[mpos+ 9] & 0xff) << 8; h4 += ((t3 >>> 4) | (t4 << 12)) & 0x1fff;
h5 += ((t4 >>> 1)) & 0x1fff;
t5 = m[mpos+10] & 0xff | (m[mpos+11] & 0xff) << 8; h6 += ((t4 >>> 14) | (t5 << 2)) & 0x1fff;
t6 = m[mpos+12] & 0xff | (m[mpos+13] & 0xff) << 8; h7 += ((t5 >>> 11) | (t6 << 5)) & 0x1fff;
t7 = m[mpos+14] & 0xff | (m[mpos+15] & 0xff) << 8; h8 += ((t6 >>> 8) | (t7 << 8)) & 0x1fff;
h9 += ((t7 >>> 5)) | hibit;
c = 0;
d0 = c;
d0 += h0 * r0;
d0 += h1 * (5 * r9);
d0 += h2 * (5 * r8);
d0 += h3 * (5 * r7);
d0 += h4 * (5 * r6);
c = (d0 >>> 13); d0 &= 0x1fff;
d0 += h5 * (5 * r5);
d0 += h6 * (5 * r4);
d0 += h7 * (5 * r3);
d0 += h8 * (5 * r2);
d0 += h9 * (5 * r1);
c += (d0 >>> 13); d0 &= 0x1fff;
d1 = c;
d1 += h0 * r1;
d1 += h1 * r0;
d1 += h2 * (5 * r9);
d1 += h3 * (5 * r8);
d1 += h4 * (5 * r7);
c = (d1 >>> 13); d1 &= 0x1fff;
d1 += h5 * (5 * r6);
d1 += h6 * (5 * r5);
d1 += h7 * (5 * r4);
d1 += h8 * (5 * r3);
d1 += h9 * (5 * r2);
c += (d1 >>> 13); d1 &= 0x1fff;
d2 = c;
d2 += h0 * r2;
d2 += h1 * r1;
d2 += h2 * r0;
d2 += h3 * (5 * r9);
d2 += h4 * (5 * r8);
c = (d2 >>> 13); d2 &= 0x1fff;
d2 += h5 * (5 * r7);
d2 += h6 * (5 * r6);
d2 += h7 * (5 * r5);
d2 += h8 * (5 * r4);
d2 += h9 * (5 * r3);
c += (d2 >>> 13); d2 &= 0x1fff;
d3 = c;
d3 += h0 * r3;
d3 += h1 * r2;
d3 += h2 * r1;
d3 += h3 * r0;
d3 += h4 * (5 * r9);
c = (d3 >>> 13); d3 &= 0x1fff;
d3 += h5 * (5 * r8);
d3 += h6 * (5 * r7);
d3 += h7 * (5 * r6);
d3 += h8 * (5 * r5);
d3 += h9 * (5 * r4);
c += (d3 >>> 13); d3 &= 0x1fff;
d4 = c;
d4 += h0 * r4;
d4 += h1 * r3;
d4 += h2 * r2;
d4 += h3 * r1;
d4 += h4 * r0;
c = (d4 >>> 13); d4 &= 0x1fff;
d4 += h5 * (5 * r9);
d4 += h6 * (5 * r8);
d4 += h7 * (5 * r7);
d4 += h8 * (5 * r6);
d4 += h9 * (5 * r5);
c += (d4 >>> 13); d4 &= 0x1fff;
d5 = c;
d5 += h0 * r5;
d5 += h1 * r4;
d5 += h2 * r3;
d5 += h3 * r2;
d5 += h4 * r1;
c = (d5 >>> 13); d5 &= 0x1fff;
d5 += h5 * r0;
d5 += h6 * (5 * r9);
d5 += h7 * (5 * r8);
d5 += h8 * (5 * r7);
d5 += h9 * (5 * r6);
c += (d5 >>> 13); d5 &= 0x1fff;
d6 = c;
d6 += h0 * r6;
d6 += h1 * r5;
d6 += h2 * r4;
d6 += h3 * r3;
d6 += h4 * r2;
c = (d6 >>> 13); d6 &= 0x1fff;
d6 += h5 * r1;
d6 += h6 * r0;
d6 += h7 * (5 * r9);
d6 += h8 * (5 * r8);
d6 += h9 * (5 * r7);
c += (d6 >>> 13); d6 &= 0x1fff;
d7 = c;
d7 += h0 * r7;
d7 += h1 * r6;
d7 += h2 * r5;
d7 += h3 * r4;
d7 += h4 * r3;
c = (d7 >>> 13); d7 &= 0x1fff;
d7 += h5 * r2;
d7 += h6 * r1;
d7 += h7 * r0;
d7 += h8 * (5 * r9);
d7 += h9 * (5 * r8);
c += (d7 >>> 13); d7 &= 0x1fff;
d8 = c;
d8 += h0 * r8;
d8 += h1 * r7;
d8 += h2 * r6;
d8 += h3 * r5;
d8 += h4 * r4;
c = (d8 >>> 13); d8 &= 0x1fff;
d8 += h5 * r3;
d8 += h6 * r2;
d8 += h7 * r1;
d8 += h8 * r0;
d8 += h9 * (5 * r9);
c += (d8 >>> 13); d8 &= 0x1fff;
d9 = c;
d9 += h0 * r9;
d9 += h1 * r8;
d9 += h2 * r7;
d9 += h3 * r6;
d9 += h4 * r5;
c = (d9 >>> 13); d9 &= 0x1fff;
d9 += h5 * r4;
d9 += h6 * r3;
d9 += h7 * r2;
d9 += h8 * r1;
d9 += h9 * r0;
c += (d9 >>> 13); d9 &= 0x1fff;
c = (((c << 2) + c)) | 0;
c = (c + d0) | 0;
d0 = c & 0x1fff;
c = (c >>> 13);
d1 += c;
h0 = d0;
h1 = d1;
h2 = d2;
h3 = d3;
h4 = d4;
h5 = d5;
h6 = d6;
h7 = d7;
h8 = d8;
h9 = d9;
mpos += 16;
bytes -= 16;
}
this.h[0] = h0;
this.h[1] = h1;
this.h[2] = h2;
this.h[3] = h3;
this.h[4] = h4;
this.h[5] = h5;
this.h[6] = h6;
this.h[7] = h7;
this.h[8] = h8;
this.h[9] = h9;
};
poly1305.prototype.finish = function(mac, macpos) {
var g = new Uint16Array(10);
var c, mask, f, i;
if (this.leftover) {
i = this.leftover;
this.buffer[i++] = 1;
for (; i < 16; i++) this.buffer[i] = 0;
this.fin = 1;
this.blocks(this.buffer, 0, 16);
}
c = this.h[1] >>> 13;
this.h[1] &= 0x1fff;
for (i = 2; i < 10; i++) {
this.h[i] += c;
c = this.h[i] >>> 13;
this.h[i] &= 0x1fff;
}
this.h[0] += (c * 5);
c = this.h[0] >>> 13;
this.h[0] &= 0x1fff;
this.h[1] += c;
c = this.h[1] >>> 13;
this.h[1] &= 0x1fff;
this.h[2] += c;
g[0] = this.h[0] + 5;
c = g[0] >>> 13;
g[0] &= 0x1fff;
for (i = 1; i < 10; i++) {
g[i] = this.h[i] + c;
c = g[i] >>> 13;
g[i] &= 0x1fff;
}
g[9] -= (1 << 13);
mask = (c ^ 1) - 1;
for (i = 0; i < 10; i++) g[i] &= mask;
mask = ~mask;
for (i = 0; i < 10; i++) this.h[i] = (this.h[i] & mask) | g[i];
this.h[0] = ((this.h[0] ) | (this.h[1] << 13) ) & 0xffff;
this.h[1] = ((this.h[1] >>> 3) | (this.h[2] << 10) ) & 0xffff;
this.h[2] = ((this.h[2] >>> 6) | (this.h[3] << 7) ) & 0xffff;
this.h[3] = ((this.h[3] >>> 9) | (this.h[4] << 4) ) & 0xffff;
this.h[4] = ((this.h[4] >>> 12) | (this.h[5] << 1) | (this.h[6] << 14)) & 0xffff;
this.h[5] = ((this.h[6] >>> 2) | (this.h[7] << 11) ) & 0xffff;
this.h[6] = ((this.h[7] >>> 5) | (this.h[8] << 8) ) & 0xffff;
this.h[7] = ((this.h[8] >>> 8) | (this.h[9] << 5) ) & 0xffff;
f = this.h[0] + this.pad[0];
this.h[0] = f & 0xffff;
for (i = 1; i < 8; i++) {
f = (((this.h[i] + this.pad[i]) | 0) + (f >>> 16)) | 0;
this.h[i] = f & 0xffff;
}
mac[macpos+ 0] = (this.h[0] >>> 0) & 0xff;
mac[macpos+ 1] = (this.h[0] >>> 8) & 0xff;
mac[macpos+ 2] = (this.h[1] >>> 0) & 0xff;
mac[macpos+ 3] = (this.h[1] >>> 8) & 0xff;
mac[macpos+ 4] = (this.h[2] >>> 0) & 0xff;
mac[macpos+ 5] = (this.h[2] >>> 8) & 0xff;
mac[macpos+ 6] = (this.h[3] >>> 0) & 0xff;
mac[macpos+ 7] = (this.h[3] >>> 8) & 0xff;
mac[macpos+ 8] = (this.h[4] >>> 0) & 0xff;
mac[macpos+ 9] = (this.h[4] >>> 8) & 0xff;
mac[macpos+10] = (this.h[5] >>> 0) & 0xff;
mac[macpos+11] = (this.h[5] >>> 8) & 0xff;
mac[macpos+12] = (this.h[6] >>> 0) & 0xff;
mac[macpos+13] = (this.h[6] >>> 8) & 0xff;
mac[macpos+14] = (this.h[7] >>> 0) & 0xff;
mac[macpos+15] = (this.h[7] >>> 8) & 0xff;
};
poly1305.prototype.update = function(m, mpos, bytes) {
var i, want;
if (this.leftover) {
want = (16 - this.leftover);
if (want > bytes)
want = bytes;
for (i = 0; i < want; i++)
this.buffer[this.leftover + i] = m[mpos+i];
bytes -= want;
mpos += want;
this.leftover += want;
if (this.leftover < 16)
return;
this.blocks(this.buffer, 0, 16);
this.leftover = 0;
}
if (bytes >= 16) {
want = bytes - (bytes % 16);
this.blocks(m, mpos, want);
mpos += want;
bytes -= want;
}
if (bytes) {
for (i = 0; i < bytes; i++)
this.buffer[this.leftover + i] = m[mpos+i];
this.leftover += bytes;
}
};
function crypto_onetimeauth(out, outpos, m, mpos, n, k) {
var s = new poly1305(k);
s.update(m, mpos, n);
s.finish(out, outpos);
return 0;
}
function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) {
var x = new Uint8Array(16);
crypto_onetimeauth(x,0,m,mpos,n,k);
return crypto_verify_16(h,hpos,x,0);
}
function crypto_secretbox(c,m,d,n,k) {
var i;
if (d < 32) return -1;
crypto_stream_xor(c,0,m,0,d,n,k);
crypto_onetimeauth(c, 16, c, 32, d - 32, c);
for (i = 0; i < 16; i++) c[i] = 0;
return 0;
}
function crypto_secretbox_open(m,c,d,n,k) {
var i;
var x = new Uint8Array(32);
if (d < 32) return -1;
crypto_stream(x,0,32,n,k);
if (crypto_onetimeauth_verify(c, 16,c, 32,d - 32,x) !== 0) return -1;
crypto_stream_xor(m,0,c,0,d,n,k);
for (i = 0; i < 32; i++) m[i] = 0;
return 0;
}
function set25519(r, a) {
var i;
for (i = 0; i < 16; i++) r[i] = a[i]|0;
}
function car25519(o) {
var i, v, c = 1;
for (i = 0; i < 16; i++) {
v = o[i] + c + 65535;
c = Math.floor(v / 65536);
o[i] = v - c * 65536;
}
o[0] += c-1 + 37 * (c-1);
}
function sel25519(p, q, b) {
var t, c = ~(b-1);
for (var i = 0; i < 16; i++) {
t = c & (p[i] ^ q[i]);
p[i] ^= t;
q[i] ^= t;
}
}
function pack25519(o, n) {
var i, j, b;
var m = gf(), t = gf();
for (i = 0; i < 16; i++) t[i] = n[i];
car25519(t);
car25519(t);
car25519(t);
for (j = 0; j < 2; j++) {
m[0] = t[0] - 0xffed;
for (i = 1; i < 15; i++) {
m[i] = t[i] - 0xffff - ((m[i-1]>>16) & 1);
m[i-1] &= 0xffff;
}
m[15] = t[15] - 0x7fff - ((m[14]>>16) & 1);
b = (m[15]>>16) & 1;
m[14] &= 0xffff;
sel25519(t, m, 1-b);
}
for (i = 0; i < 16; i++) {
o[2*i] = t[i] & 0xff;
o[2*i+1] = t[i]>>8;
}
}
function neq25519(a, b) {
var c = new Uint8Array(32), d = new Uint8Array(32);
pack25519(c, a);
pack25519(d, b);
return crypto_verify_32(c, 0, d, 0);
}
function par25519(a) {
var d = new Uint8Array(32);
pack25519(d, a);
return d[0] & 1;
}
function unpack25519(o, n) {
var i;
for (i = 0; i < 16; i++) o[i] = n[2*i] + (n[2*i+1] << 8);
o[15] &= 0x7fff;
}
function A(o, a, b) {
for (var i = 0; i < 16; i++) o[i] = a[i] + b[i];
}
function Z(o, a, b) {
for (var i = 0; i < 16; i++) o[i] = a[i] - b[i];
}
function M(o, a, b) {
var v, c,
t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0,
t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0,
t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0,
t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0,
b0 = b[0],
b1 = b[1],
b2 = b[2],
b3 = b[3],
b4 = b[4],
b5 = b[5],
b6 = b[6],
b7 = b[7],
b8 = b[8],
b9 = b[9],
b10 = b[10],
b11 = b[11],
b12 = b[12],
b13 = b[13],
b14 = b[14],
b15 = b[15];
v = a[0];
t0 += v * b0;
t1 += v * b1;
t2 += v * b2;
t3 += v * b3;
t4 += v * b4;
t5 += v * b5;
t6 += v * b6;
t7 += v * b7;
t8 += v * b8;
t9 += v * b9;
t10 += v * b10;
t11 += v * b11;
t12 += v * b12;
t13 += v * b13;
t14 += v * b14;
t15 += v * b15;
v = a[1];
t1 += v * b0;
t2 += v * b1;
t3 += v * b2;
t4 += v * b3;
t5 += v * b4;
t6 += v * b5;
t7 += v * b6;
t8 += v * b7;
t9 += v * b8;
t10 += v * b9;
t11 += v * b10;
t12 += v * b11;
t13 += v * b12;
t14 += v * b13;
t15 += v * b14;
t16 += v * b15;
v = a[2];
t2 += v * b0;
t3 += v * b1;
t4 += v * b2;
t5 += v * b3;
t6 += v * b4;
t7 += v * b5;
t8 += v * b6;
t9 += v * b7;
t10 += v * b8;
t11 += v * b9;
t12 += v * b10;
t13 += v * b11;
t14 += v * b12;
t15 += v * b13;
t16 += v * b14;
t17 += v * b15;
v = a[3];
t3 += v * b0;
t4 += v * b1;
t5 += v * b2;
t6 += v * b3;
t7 += v * b4;
t8 += v * b5;
t9 += v * b6;
t10 += v * b7;
t11 += v * b8;
t12 += v * b9;
t13 += v * b10;
t14 += v * b11;
t15 += v * b12;
t16 += v * b13;
t17 += v * b14;
t18 += v * b15;
v = a[4];
t4 += v * b0;
t5 += v * b1;
t6 += v * b2;
t7 += v * b3;
t8 += v * b4;
t9 += v * b5;
t10 += v * b6;
t11 += v * b7;
t12 += v * b8;
t13 += v * b9;
t14 += v * b10;
t15 += v * b11;
t16 += v * b12;
t17 += v * b13;
t18 += v * b14;
t19 += v * b15;
v = a[5];
t5 += v * b0;
t6 += v * b1;
t7 += v * b2;
t8 += v * b3;
t9 += v * b4;
t10 += v * b5;
t11 += v * b6;
t12 += v * b7;
t13 += v * b8;
t14 += v * b9;
t15 += v * b10;
t16 += v * b11;
t17 += v * b12;
t18 += v * b13;
t19 += v * b14;
t20 += v * b15;
v = a[6];
t6 += v * b0;
t7 += v * b1;
t8 += v * b2;
t9 += v * b3;
t10 += v * b4;
t11 += v * b5;
t12 += v * b6;
t13 += v * b7;
t14 += v * b8;
t15 += v * b9;
t16 += v * b10;
t17 += v * b11;
t18 += v * b12;
t19 += v * b13;
t20 += v * b14;
t21 += v * b15;
v = a[7];
t7 += v * b0;
t8 += v * b1;
t9 += v * b2;
t10 += v * b3;
t11 += v * b4;
t12 += v * b5;
t13 += v * b6;
t14 += v * b7;
t15 += v * b8;
t16 += v * b9;
t17 += v * b10;
t18 += v * b11;
t19 += v * b12;
t20 += v * b13;
t21 += v * b14;
t22 += v * b15;
v = a[8];
t8 += v * b0;
t9 += v * b1;
t10 += v * b2;
t11 += v * b3;
t12 += v * b4;
t13 += v * b5;
t14 += v * b6;
t15 += v * b7;
t16 += v * b8;
t17 += v * b9;
t18 += v * b10;
t19 += v * b11;
t20 += v * b12;
t21 += v * b13;
t22 += v * b14;
t23 += v * b15;
v = a[9];
t9 += v * b0;
t10 += v * b1;
t11 += v * b2;
t12 += v * b3;
t13 += v * b4;
t14 += v * b5;
t15 += v * b6;
t16 += v * b7;
t17 += v * b8;
t18 += v * b9;
t19 += v * b10;
t20 += v * b11;
t21 += v * b12;
t22 += v * b13;
t23 += v * b14;
t24 += v * b15;
v = a[10];
t10 += v * b0;
t11 += v * b1;
t12 += v * b2;
t13 += v * b3;
t14 += v * b4;
t15 += v * b5;
t16 += v * b6;
t17 += v * b7;
t18 += v * b8;
t19 += v * b9;
t20 += v * b10;
t21 += v * b11;
t22 += v * b12;
t23 += v * b13;
t24 += v * b14;
t25 += v * b15;
v = a[11];
t11 += v * b0;
t12 += v * b1;
t13 += v * b2;
t14 += v * b3;
t15 += v * b4;
t16 += v * b5;
t17 += v * b6;
t18 += v * b7;
t19 += v * b8;
t20 += v * b9;
t21 += v * b10;
t22 += v * b11;
t23 += v * b12;
t24 += v * b13;
t25 += v * b14;
t26 += v * b15;
v = a[12];
t12 += v * b0;
t13 += v * b1;
t14 += v * b2;
t15 += v * b3;
t16 += v * b4;
t17 += v * b5;
t18 += v * b6;
t19 += v * b7;
t20 += v * b8;
t21 += v * b9;
t22 += v * b10;
t23 += v * b11;
t24 += v * b12;
t25 += v * b13;
t26 += v * b14;
t27 += v * b15;
v = a[13];
t13 += v * b0;
t14 += v * b1;
t15 += v * b2;
t16 += v * b3;
t17 += v * b4;
t18 += v * b5;
t19 += v * b6;
t20 += v * b7;
t21 += v * b8;
t22 += v * b9;
t23 += v * b10;
t24 += v * b11;
t25 += v * b12;
t26 += v * b13;
t27 += v * b14;
t28 += v * b15;
v = a[14];
t14 += v * b0;
t15 += v * b1;
t16 += v * b2;
t17 += v * b3;
t18 += v * b4;
t19 += v * b5;
t20 += v * b6;
t21 += v * b7;
t22 += v * b8;
t23 += v * b9;
t24 += v * b10;
t25 += v * b11;
t26 += v * b12;
t27 += v * b13;
t28 += v * b14;
t29 += v * b15;
v = a[15];
t15 += v * b0;
t16 += v * b1;
t17 += v * b2;
t18 += v * b3;
t19 += v * b4;
t20 += v * b5;
t21 += v * b6;
t22 += v * b7;
t23 += v * b8;
t24 += v * b9;
t25 += v * b10;
t26 += v * b11;
t27 += v * b12;
t28 += v * b13;
t29 += v * b14;
t30 += v * b15;
t0 += 38 * t16;
t1 += 38 * t17;
t2 += 38 * t18;
t3 += 38 * t19;
t4 += 38 * t20;
t5 += 38 * t21;
t6 += 38 * t22;
t7 += 38 * t23;
t8 += 38 * t24;
t9 += 38 * t25;
t10 += 38 * t26;
t11 += 38 * t27;
t12 += 38 * t28;
t13 += 38 * t29;
t14 += 38 * t30;
// t15 left as is
// first car
c = 1;
v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536;
v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536;
v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536;
v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536;
v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536;
v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536;
v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536;
v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536;
v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536;
v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536;
v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536;
v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536;
v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536;
v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536;
v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536;
v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536;
t0 += c-1 + 37 * (c-1);
// second car
c = 1;
v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536;
v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536;
v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536;
v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536;
v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536;
v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536;
v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536;
v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536;
v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536;
v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536;
v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536;
v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536;
v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536;
v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536;
v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536;
v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536;
t0 += c-1 + 37 * (c-1);
o[ 0] = t0;
o[ 1] = t1;
o[ 2] = t2;
o[ 3] = t3;
o[ 4] = t4;
o[ 5] = t5;
o[ 6] = t6;
o[ 7] = t7;
o[ 8] = t8;
o[ 9] = t9;
o[10] = t10;
o[11] = t11;
o[12] = t12;
o[13] = t13;
o[14] = t14;
o[15] = t15;
}
function S(o, a) {
M(o, a, a);
}
function inv25519(o, i) {
var c = gf();
var a;
for (a = 0; a < 16; a++) c[a] = i[a];
for (a = 253; a >= 0; a--) {
S(c, c);
if(a !== 2 && a !== 4) M(c, c, i);
}
for (a = 0; a < 16; a++) o[a] = c[a];
}
function pow2523(o, i) {
var c = gf();
var a;
for (a = 0; a < 16; a++) c[a] = i[a];
for (a = 250; a >= 0; a--) {
S(c, c);
if(a !== 1) M(c, c, i);
}
for (a = 0; a < 16; a++) o[a] = c[a];
}
function crypto_scalarmult(q, n, p) {
var z = new Uint8Array(32);
var x = new Float64Array(80), r, i;
var a = gf(), b = gf(), c = gf(),
d = gf(), e = gf(), f = gf();
for (i = 0; i < 31; i++) z[i] = n[i];
z[31]=(n[31]&127)|64;
z[0]&=248;
unpack25519(x,p);
for (i = 0; i < 16; i++) {
b[i]=x[i];
d[i]=a[i]=c[i]=0;
}
a[0]=d[0]=1;
for (i=254; i>=0; --i) {
r=(z[i>>>3]>>>(i&7))&1;
sel25519(a,b,r);
sel25519(c,d,r);
A(e,a,c);
Z(a,a,c);
A(c,b,d);
Z(b,b,d);
S(d,e);
S(f,a);
M(a,c,a);
M(c,b,e);
A(e,a,c);
Z(a,a,c);
S(b,a);
Z(c,d,f);
M(a,c,_121665);
A(a,a,d);
M(c,c,a);
M(a,d,f);
M(d,b,x);
S(b,e);
sel25519(a,b,r);
sel25519(c,d,r);
}
for (i = 0; i < 16; i++) {
x[i+16]=a[i];
x[i+32]=c[i];
x[i+48]=b[i];
x[i+64]=d[i];
}
var x32 = x.subarray(32);
var x16 = x.subarray(16);
inv25519(x32,x32);
M(x16,x16,x32);
pack25519(q,x16);
return 0;
}
function crypto_scalarmult_base(q, n) {
return crypto_scalarmult(q, n, _9);
}
function crypto_box_keypair(y, x) {
randombytes(x, 32);
return crypto_scalarmult_base(y, x);
}
function crypto_box_beforenm(k, y, x) {
var s = new Uint8Array(32);
crypto_scalarmult(s, x, y);
return crypto_core_hsalsa20(k, _0, s, sigma);
}
var crypto_box_afternm = crypto_secretbox;
var crypto_box_open_afternm = crypto_secretbox_open;
function crypto_box(c, m, d, n, y, x) {
var k = new Uint8Array(32);
crypto_box_beforenm(k, y, x);
return crypto_box_afternm(c, m, d, n, k);
}
function crypto_box_open(m, c, d, n, y, x) {
var k = new Uint8Array(32);
crypto_box_beforenm(k, y, x);
return crypto_box_open_afternm(m, c, d, n, k);
}
var K = [
0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
];
function crypto_hashblocks_hl(hh, hl, m, n) {
var wh = new Int32Array(16), wl = new Int32Array(16),
bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7,
bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7,
th, tl, i, j, h, l, a, b, c, d;
var ah0 = hh[0],
ah1 = hh[1],
ah2 = hh[2],
ah3 = hh[3],
ah4 = hh[4],
ah5 = hh[5],
ah6 = hh[6],
ah7 = hh[7],
al0 = hl[0],
al1 = hl[1],
al2 = hl[2],
al3 = hl[3],
al4 = hl[4],
al5 = hl[5],
al6 = hl[6],
al7 = hl[7];
var pos = 0;
while (n >= 128) {
for (i = 0; i < 16; i++) {
j = 8 * i + pos;
wh[i] = (m[j+0] << 24) | (m[j+1] << 16) | (m[j+2] << 8) | m[j+3];
wl[i] = (m[j+4] << 24) | (m[j+5] << 16) | (m[j+6] << 8) | m[j+7];
}
for (i = 0; i < 80; i++) {
bh0 = ah0;
bh1 = ah1;
bh2 = ah2;
bh3 = ah3;
bh4 = ah4;
bh5 = ah5;
bh6 = ah6;
bh7 = ah7;
bl0 = al0;
bl1 = al1;
bl2 = al2;
bl3 = al3;
bl4 = al4;
bl5 = al5;
bl6 = al6;
bl7 = al7;
// add
h = ah7;
l = al7;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
// Sigma1
h = ((ah4 >>> 14) | (al4 << (32-14))) ^ ((ah4 >>> 18) | (al4 << (32-18))) ^ ((al4 >>> (41-32)) | (ah4 << (32-(41-32))));
l = ((al4 >>> 14) | (ah4 << (32-14))) ^ ((al4 >>> 18) | (ah4 << (32-18))) ^ ((ah4 >>> (41-32)) | (al4 << (32-(41-32))));
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
// Ch
h = (ah4 & ah5) ^ (~ah4 & ah6);
l = (al4 & al5) ^ (~al4 & al6);
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
// K
h = K[i*2];
l = K[i*2+1];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
// w
h = wh[i%16];
l = wl[i%16];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
th = c & 0xffff | d << 16;
tl = a & 0xffff | b << 16;
// add
h = th;
l = tl;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
// Sigma0
h = ((ah0 >>> 28) | (al0 << (32-28))) ^ ((al0 >>> (34-32)) | (ah0 << (32-(34-32)))) ^ ((al0 >>> (39-32)) | (ah0 << (32-(39-32))));
l = ((al0 >>> 28) | (ah0 << (32-28))) ^ ((ah0 >>> (34-32)) | (al0 << (32-(34-32)))) ^ ((ah0 >>> (39-32)) | (al0 << (32-(39-32))));
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
// Maj
h = (ah0 & ah1) ^ (ah0 & ah2) ^ (ah1 & ah2);
l = (al0 & al1) ^ (al0 & al2) ^ (al1 & al2);
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
bh7 = (c & 0xffff) | (d << 16);
bl7 = (a & 0xffff) | (b << 16);
// add
h = bh3;
l = bl3;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
h = th;
l = tl;
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
bh3 = (c & 0xffff) | (d << 16);
bl3 = (a & 0xffff) | (b << 16);
ah1 = bh0;
ah2 = bh1;
ah3 = bh2;
ah4 = bh3;
ah5 = bh4;
ah6 = bh5;
ah7 = bh6;
ah0 = bh7;
al1 = bl0;
al2 = bl1;
al3 = bl2;
al4 = bl3;
al5 = bl4;
al6 = bl5;
al7 = bl6;
al0 = bl7;
if (i%16 === 15) {
for (j = 0; j < 16; j++) {
// add
h = wh[j];
l = wl[j];
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
h = wh[(j+9)%16];
l = wl[(j+9)%16];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
// sigma0
th = wh[(j+1)%16];
tl = wl[(j+1)%16];
h = ((th >>> 1) | (tl << (32-1))) ^ ((th >>> 8) | (tl << (32-8))) ^ (th >>> 7);
l = ((tl >>> 1) | (th << (32-1))) ^ ((tl >>> 8) | (th << (32-8))) ^ ((tl >>> 7) | (th << (32-7)));
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
// sigma1
th = wh[(j+14)%16];
tl = wl[(j+14)%16];
h = ((th >>> 19) | (tl << (32-19))) ^ ((tl >>> (61-32)) | (th << (32-(61-32)))) ^ (th >>> 6);
l = ((tl >>> 19) | (th << (32-19))) ^ ((th >>> (61-32)) | (tl << (32-(61-32)))) ^ ((tl >>> 6) | (th << (32-6)));
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
wh[j] = (c & 0xffff) | (d << 16);
wl[j] = (a & 0xffff) | (b << 16);
}
}
}
// add
h = ah0;
l = al0;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
h = hh[0];
l = hl[0];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[0] = ah0 = (c & 0xffff) | (d << 16);
hl[0] = al0 = (a & 0xffff) | (b << 16);
h = ah1;
l = al1;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
h = hh[1];
l = hl[1];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[1] = ah1 = (c & 0xffff) | (d << 16);
hl[1] = al1 = (a & 0xffff) | (b << 16);
h = ah2;
l = al2;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
h = hh[2];
l = hl[2];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[2] = ah2 = (c & 0xffff) | (d << 16);
hl[2] = al2 = (a & 0xffff) | (b << 16);
h = ah3;
l = al3;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
h = hh[3];
l = hl[3];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[3] = ah3 = (c & 0xffff) | (d << 16);
hl[3] = al3 = (a & 0xffff) | (b << 16);
h = ah4;
l = al4;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
h = hh[4];
l = hl[4];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[4] = ah4 = (c & 0xffff) | (d << 16);
hl[4] = al4 = (a & 0xffff) | (b << 16);
h = ah5;
l = al5;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
h = hh[5];
l = hl[5];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[5] = ah5 = (c & 0xffff) | (d << 16);
hl[5] = al5 = (a & 0xffff) | (b << 16);
h = ah6;
l = al6;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
h = hh[6];
l = hl[6];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[6] = ah6 = (c & 0xffff) | (d << 16);
hl[6] = al6 = (a & 0xffff) | (b << 16);
h = ah7;
l = al7;
a = l & 0xffff; b = l >>> 16;
c = h & 0xffff; d = h >>> 16;
h = hh[7];
l = hl[7];
a += l & 0xffff; b += l >>> 16;
c += h & 0xffff; d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[7] = ah7 = (c & 0xffff) | (d << 16);
hl[7] = al7 = (a & 0xffff) | (b << 16);
pos += 128;
n -= 128;
}
return n;
}
function crypto_hash(out, m, n) {
var hh = new Int32Array(8),
hl = new Int32Array(8),
x = new Uint8Array(256),
i, b = n;
hh[0] = 0x6a09e667;
hh[1] = 0xbb67ae85;
hh[2] = 0x3c6ef372;
hh[3] = 0xa54ff53a;
hh[4] = 0x510e527f;
hh[5] = 0x9b05688c;
hh[6] = 0x1f83d9ab;
hh[7] = 0x5be0cd19;
hl[0] = 0xf3bcc908;
hl[1] = 0x84caa73b;
hl[2] = 0xfe94f82b;
hl[3] = 0x5f1d36f1;
hl[4] = 0xade682d1;
hl[5] = 0x2b3e6c1f;
hl[6] = 0xfb41bd6b;
hl[7] = 0x137e2179;
crypto_hashblocks_hl(hh, hl, m, n);
n %= 128;
for (i = 0; i < n; i++) x[i] = m[b-n+i];
x[n] = 128;
n = 256-128*(n<112?1:0);
x[n-9] = 0;
ts64(x, n-8, (b / 0x20000000) | 0, b << 3);
crypto_hashblocks_hl(hh, hl, x, n);
for (i = 0; i < 8; i++) ts64(out, 8*i, hh[i], hl[i]);
return 0;
}
function add(p, q) {
var a = gf(), b = gf(), c = gf(),
d = gf(), e = gf(), f = gf(),
g = gf(), h = gf(), t = gf();
Z(a, p[1], p[0]);
Z(t, q[1], q[0]);
M(a, a, t);
A(b, p[0], p[1]);
A(t, q[0], q[1]);
M(b, b, t);
M(c, p[3], q[3]);
M(c, c, D2);
M(d, p[2], q[2]);
A(d, d, d);
Z(e, b, a);
Z(f, d, c);
A(g, d, c);
A(h, b, a);
M(p[0], e, f);
M(p[1], h, g);
M(p[2], g, f);
M(p[3], e, h);
}
function cswap(p, q, b) {
var i;
for (i = 0; i < 4; i++) {
sel25519(p[i], q[i], b);
}
}
function pack(r, p) {
var tx = gf(), ty = gf(), zi = gf();
inv25519(zi, p[2]);
M(tx, p[0], zi);
M(ty, p[1], zi);
pack25519(r, ty);
r[31] ^= par25519(tx) << 7;
}
function scalarmult(p, q, s) {
var b, i;
set25519(p[0], gf0);
set25519(p[1], gf1);
set25519(p[2], gf1);
set25519(p[3], gf0);
for (i = 255; i >= 0; --i) {
b = (s[(i/8)|0] >> (i&7)) & 1;
cswap(p, q, b);
add(q, p);
add(p, p);
cswap(p, q, b);
}
}
function scalarbase(p, s) {
var q = [gf(), gf(), gf(), gf()];
set25519(q[0], X);
set25519(q[1], Y);
set25519(q[2], gf1);
M(q[3], X, Y);
scalarmult(p, q, s);
}
function crypto_sign_keypair(pk, sk, seeded) {
var d = new Uint8Array(64);
var p = [gf(), gf(), gf(), gf()];
var i;
if (!seeded) randombytes(sk, 32);
crypto_hash(d, sk, 32);
d[0] &= 248;
d[31] &= 127;
d[31] |= 64;
scalarbase(p, d);
pack(pk, p);
for (i = 0; i < 32; i++) sk[i+32] = pk[i];
return 0;
}
var L = new Float64Array([0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10]);
function modL(r, x) {
var carry, i, j, k;
for (i = 63; i >= 32; --i) {
carry = 0;
for (j = i - 32, k = i - 12; j < k; ++j) {
x[j] += carry - 16 * x[i] * L[j - (i - 32)];
carry = Math.floor((x[j] + 128) / 256);
x[j] -= carry * 256;
}
x[j] += carry;
x[i] = 0;
}
carry = 0;
for (j = 0; j < 32; j++) {
x[j] += carry - (x[31] >> 4) * L[j];
carry = x[j] >> 8;
x[j] &= 255;
}
for (j = 0; j < 32; j++) x[j] -= carry * L[j];
for (i = 0; i < 32; i++) {
x[i+1] += x[i] >> 8;
r[i] = x[i] & 255;
}
}
function reduce(r) {
var x = new Float64Array(64), i;
for (i = 0; i < 64; i++) x[i] = r[i];
for (i = 0; i < 64; i++) r[i] = 0;
modL(r, x);
}
// Note: difference from C - smlen returned, not passed as argument.
function crypto_sign(sm, m, n, sk) {
var d = new Uint8Array(64), h = new Uint8Array(64), r = new Uint8Array(64);
var i, j, x = new Float64Array(64);
var p = [gf(), gf(), gf(), gf()];
crypto_hash(d, sk, 32);
d[0] &= 248;
d[31] &= 127;
d[31] |= 64;
var smlen = n + 64;
for (i = 0; i < n; i++) sm[64 + i] = m[i];
for (i = 0; i < 32; i++) sm[32 + i] = d[32 + i];
crypto_hash(r, sm.subarray(32), n+32);
reduce(r);
scalarbase(p, r);
pack(sm, p);
for (i = 32; i < 64; i++) sm[i] = sk[i];
crypto_hash(h, sm, n + 64);
reduce(h);
for (i = 0; i < 64; i++) x[i] = 0;
for (i = 0; i < 32; i++) x[i] = r[i];
for (i = 0; i < 32; i++) {
for (j = 0; j < 32; j++) {
x[i+j] += h[i] * d[j];
}
}
modL(sm.subarray(32), x);
return smlen;
}
function unpackneg(r, p) {
var t = gf(), chk = gf(), num = gf(),
den = gf(), den2 = gf(), den4 = gf(),
den6 = gf();
set25519(r[2], gf1);
unpack25519(r[1], p);
S(num, r[1]);
M(den, num, D);
Z(num, num, r[2]);
A(den, r[2], den);
S(den2, den);
S(den4, den2);
M(den6, den4, den2);
M(t, den6, num);
M(t, t, den);
pow2523(t, t);
M(t, t, num);
M(t, t, den);
M(t, t, den);
M(r[0], t, den);
S(chk, r[0]);
M(chk, chk, den);
if (neq25519(chk, num)) M(r[0], r[0], I);
S(chk, r[0]);
M(chk, chk, den);
if (neq25519(chk, num)) return -1;
if (par25519(r[0]) === (p[31]>>7)) Z(r[0], gf0, r[0]);
M(r[3], r[0], r[1]);
return 0;
}
function crypto_sign_open(m, sm, n, pk) {
var i;
var t = new Uint8Array(32), h = new Uint8Array(64);
var p = [gf(), gf(), gf(), gf()],
q = [gf(), gf(), gf(), gf()];
if (n < 64) return -1;
if (unpackneg(q, pk)) return -1;
for (i = 0; i < n; i++) m[i] = sm[i];
for (i = 0; i < 32; i++) m[i+32] = pk[i];
crypto_hash(h, m, n);
reduce(h);
scalarmult(p, q, h);
scalarbase(q, sm.subarray(32));
add(p, q);
pack(t, p);
n -= 64;
if (crypto_verify_32(sm, 0, t, 0)) {
for (i = 0; i < n; i++) m[i] = 0;
return -1;
}
for (i = 0; i < n; i++) m[i] = sm[i + 64];
return n;
}
var crypto_secretbox_KEYBYTES = 32,
crypto_secretbox_NONCEBYTES = 24,
crypto_secretbox_ZEROBYTES = 32,
crypto_secretbox_BOXZEROBYTES = 16,
crypto_scalarmult_BYTES = 32,
crypto_scalarmult_SCALARBYTES = 32,
crypto_box_PUBLICKEYBYTES = 32,
crypto_box_SECRETKEYBYTES = 32,
crypto_box_BEFORENMBYTES = 32,
crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES,
crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES,
crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES,
crypto_sign_BYTES = 64,
crypto_sign_PUBLICKEYBYTES = 32,
crypto_sign_SECRETKEYBYTES = 64,
crypto_sign_SEEDBYTES = 32,
crypto_hash_BYTES = 64;
nacl.lowlevel = {
crypto_core_hsalsa20: crypto_core_hsalsa20,
crypto_stream_xor: crypto_stream_xor,
crypto_stream: crypto_stream,
crypto_stream_salsa20_xor: crypto_stream_salsa20_xor,
crypto_stream_salsa20: crypto_stream_salsa20,
crypto_onetimeauth: crypto_onetimeauth,
crypto_onetimeauth_verify: crypto_onetimeauth_verify,
crypto_verify_16: crypto_verify_16,
crypto_verify_32: crypto_verify_32,
crypto_secretbox: crypto_secretbox,
crypto_secretbox_open: crypto_secretbox_open,
crypto_scalarmult: crypto_scalarmult,
crypto_scalarmult_base: crypto_scalarmult_base,
crypto_box_beforenm: crypto_box_beforenm,
crypto_box_afternm: crypto_box_afternm,
crypto_box: crypto_box,
crypto_box_open: crypto_box_open,
crypto_box_keypair: crypto_box_keypair,
crypto_hash: crypto_hash,
crypto_sign: crypto_sign,
crypto_sign_keypair: crypto_sign_keypair,
crypto_sign_open: crypto_sign_open,
crypto_secretbox_KEYBYTES: crypto_secretbox_KEYBYTES,
crypto_secretbox_NONCEBYTES: crypto_secretbox_NONCEBYTES,
crypto_secretbox_ZEROBYTES: crypto_secretbox_ZEROBYTES,
crypto_secretbox_BOXZEROBYTES: crypto_secretbox_BOXZEROBYTES,
crypto_scalarmult_BYTES: crypto_scalarmult_BYTES,
crypto_scalarmult_SCALARBYTES: crypto_scalarmult_SCALARBYTES,
crypto_box_PUBLICKEYBYTES: crypto_box_PUBLICKEYBYTES,
crypto_box_SECRETKEYBYTES: crypto_box_SECRETKEYBYTES,
crypto_box_BEFORENMBYTES: crypto_box_BEFORENMBYTES,
crypto_box_NONCEBYTES: crypto_box_NONCEBYTES,
crypto_box_ZEROBYTES: crypto_box_ZEROBYTES,
crypto_box_BOXZEROBYTES: crypto_box_BOXZEROBYTES,
crypto_sign_BYTES: crypto_sign_BYTES,
crypto_sign_PUBLICKEYBYTES: crypto_sign_PUBLICKEYBYTES,
crypto_sign_SECRETKEYBYTES: crypto_sign_SECRETKEYBYTES,
crypto_sign_SEEDBYTES: crypto_sign_SEEDBYTES,
crypto_hash_BYTES: crypto_hash_BYTES,
gf: gf,
D: D,
L: L,
pack25519: pack25519,
unpack25519: unpack25519,
M: M,
A: A,
S: S,
Z: Z,
pow2523: pow2523,
add: add,
set25519: set25519,
modL: modL,
scalarmult: scalarmult,
scalarbase: scalarbase,
};
/* High-level API */
function checkLengths(k, n) {
if (k.length !== crypto_secretbox_KEYBYTES) throw new Error('bad key size');
if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error('bad nonce size');
}
function checkBoxLengths(pk, sk) {
if (pk.length !== crypto_box_PUBLICKEYBYTES) throw new Error('bad public key size');
if (sk.length !== crypto_box_SECRETKEYBYTES) throw new Error('bad secret key size');
}
function checkArrayTypes() {
for (var i = 0; i < arguments.length; i++) {
if (!(arguments[i] instanceof Uint8Array))
throw new TypeError('unexpected type, use Uint8Array');
}
}
function cleanup(arr) {
for (var i = 0; i < arr.length; i++) arr[i] = 0;
}
nacl.randomBytes = function(n) {
var b = new Uint8Array(n);
randombytes(b, n);
return b;
};
nacl.secretbox = function(msg, nonce, key) {
checkArrayTypes(msg, nonce, key);
checkLengths(key, nonce);
var m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
var c = new Uint8Array(m.length);
for (var i = 0; i < msg.length; i++) m[i+crypto_secretbox_ZEROBYTES] = msg[i];
crypto_secretbox(c, m, m.length, nonce, key);
return c.subarray(crypto_secretbox_BOXZEROBYTES);
};
nacl.secretbox.open = function(box, nonce, key) {
checkArrayTypes(box, nonce, key);
checkLengths(key, nonce);
var c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
var m = new Uint8Array(c.length);
for (var i = 0; i < box.length; i++) c[i+crypto_secretbox_BOXZEROBYTES] = box[i];
if (c.length < 32) return null;
if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0) return null;
return m.subarray(crypto_secretbox_ZEROBYTES);
};
nacl.secretbox.keyLength = crypto_secretbox_KEYBYTES;
nacl.secretbox.nonceLength = crypto_secretbox_NONCEBYTES;
nacl.secretbox.overheadLength = crypto_secretbox_BOXZEROBYTES;
nacl.scalarMult = function(n, p) {
checkArrayTypes(n, p);
if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');
if (p.length !== crypto_scalarmult_BYTES) throw new Error('bad p size');
var q = new Uint8Array(crypto_scalarmult_BYTES);
crypto_scalarmult(q, n, p);
return q;
};
nacl.scalarMult.base = function(n) {
checkArrayTypes(n);
if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');
var q = new Uint8Array(crypto_scalarmult_BYTES);
crypto_scalarmult_base(q, n);
return q;
};
nacl.scalarMult.scalarLength = crypto_scalarmult_SCALARBYTES;
nacl.scalarMult.groupElementLength = crypto_scalarmult_BYTES;
nacl.box = function(msg, nonce, publicKey, secretKey) {
var k = nacl.box.before(publicKey, secretKey);
return nacl.secretbox(msg, nonce, k);
};
nacl.box.before = function(publicKey, secretKey) {
checkArrayTypes(publicKey, secretKey);
checkBoxLengths(publicKey, secretKey);
var k = new Uint8Array(crypto_box_BEFORENMBYTES);
crypto_box_beforenm(k, publicKey, secretKey);
return k;
};
nacl.box.after = nacl.secretbox;
nacl.box.open = function(msg, nonce, publicKey, secretKey) {
var k = nacl.box.before(publicKey, secretKey);
return nacl.secretbox.open(msg, nonce, k);
};
nacl.box.open.after = nacl.secretbox.open;
nacl.box.keyPair = function() {
var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
var sk = new Uint8Array(crypto_box_SECRETKEYBYTES);
crypto_box_keypair(pk, sk);
return {publicKey: pk, secretKey: sk};
};
nacl.box.keyPair.fromSecretKey = function(secretKey) {
checkArrayTypes(secretKey);
if (secretKey.length !== crypto_box_SECRETKEYBYTES)
throw new Error('bad secret key size');
var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
crypto_scalarmult_base(pk, secretKey);
return {publicKey: pk, secretKey: new Uint8Array(secretKey)};
};
nacl.box.publicKeyLength = crypto_box_PUBLICKEYBYTES;
nacl.box.secretKeyLength = crypto_box_SECRETKEYBYTES;
nacl.box.sharedKeyLength = crypto_box_BEFORENMBYTES;
nacl.box.nonceLength = crypto_box_NONCEBYTES;
nacl.box.overheadLength = nacl.secretbox.overheadLength;
nacl.sign = function(msg, secretKey) {
checkArrayTypes(msg, secretKey);
if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
throw new Error('bad secret key size');
var signedMsg = new Uint8Array(crypto_sign_BYTES+msg.length);
crypto_sign(signedMsg, msg, msg.length, secretKey);
return signedMsg;
};
nacl.sign.open = function(signedMsg, publicKey) {
checkArrayTypes(signedMsg, publicKey);
if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
throw new Error('bad public key size');
var tmp = new Uint8Array(signedMsg.length);
var mlen = crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey);
if (mlen < 0) return null;
var m = new Uint8Array(mlen);
for (var i = 0; i < m.length; i++) m[i] = tmp[i];
return m;
};
nacl.sign.detached = function(msg, secretKey) {
var signedMsg = nacl.sign(msg, secretKey);
var sig = new Uint8Array(crypto_sign_BYTES);
for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i];
return sig;
};
nacl.sign.detached.verify = function(msg, sig, publicKey) {
checkArrayTypes(msg, sig, publicKey);
if (sig.length !== crypto_sign_BYTES)
throw new Error('bad signature size');
if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
throw new Error('bad public key size');
var sm = new Uint8Array(crypto_sign_BYTES + msg.length);
var m = new Uint8Array(crypto_sign_BYTES + msg.length);
var i;
for (i = 0; i < crypto_sign_BYTES; i++) sm[i] = sig[i];
for (i = 0; i < msg.length; i++) sm[i+crypto_sign_BYTES] = msg[i];
return (crypto_sign_open(m, sm, sm.length, publicKey) >= 0);
};
nacl.sign.keyPair = function() {
var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
crypto_sign_keypair(pk, sk);
return {publicKey: pk, secretKey: sk};
};
nacl.sign.keyPair.fromSecretKey = function(secretKey) {
checkArrayTypes(secretKey);
if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
throw new Error('bad secret key size');
var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
for (var i = 0; i < pk.length; i++) pk[i] = secretKey[32+i];
return {publicKey: pk, secretKey: new Uint8Array(secretKey)};
};
nacl.sign.keyPair.fromSeed = function(seed) {
checkArrayTypes(seed);
if (seed.length !== crypto_sign_SEEDBYTES)
throw new Error('bad seed size');
var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
for (var i = 0; i < 32; i++) sk[i] = seed[i];
crypto_sign_keypair(pk, sk, true);
return {publicKey: pk, secretKey: sk};
};
nacl.sign.publicKeyLength = crypto_sign_PUBLICKEYBYTES;
nacl.sign.secretKeyLength = crypto_sign_SECRETKEYBYTES;
nacl.sign.seedLength = crypto_sign_SEEDBYTES;
nacl.sign.signatureLength = crypto_sign_BYTES;
nacl.hash = function(msg) {
checkArrayTypes(msg);
var h = new Uint8Array(crypto_hash_BYTES);
crypto_hash(h, msg, msg.length);
return h;
};
nacl.hash.hashLength = crypto_hash_BYTES;
nacl.verify = function(x, y) {
checkArrayTypes(x, y);
// Zero length arguments are considered not equal.
if (x.length === 0 || y.length === 0) return false;
if (x.length !== y.length) return false;
return (vn(x, 0, y, 0, x.length) === 0) ? true : false;
};
nacl.setPRNG = function(fn) {
randombytes = fn;
};
(function() {
// Initialize PRNG if environment provides CSPRNG.
// If not, methods calling randombytes will throw.
var crypto = typeof self !== 'undefined' ? (self.crypto || self.msCrypto) : null;
if (crypto && crypto.getRandomValues) {
// Browsers.
var QUOTA = 65536;
nacl.setPRNG(function(x, n) {
var i, v = new Uint8Array(n);
for (i = 0; i < n; i += QUOTA) {
crypto.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA)));
}
for (i = 0; i < n; i++) x[i] = v[i];
cleanup(v);
});
} else if (true) {
// Node.js.
crypto = __webpack_require__(3);
if (crypto && crypto.randomBytes) {
nacl.setPRNG(function(x, n) {
var i, v = crypto.randomBytes(n);
for (i = 0; i < n; i++) x[i] = v[i];
cleanup(v);
});
}
}
})();
})( true && module.exports ? module.exports : (self.nacl = self.nacl || {}));
/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(47).default;
/***/ }),
/* 22 */
/***/ (function(module, exports) {
module.exports = require("buffer");
/***/ }),
/* 23 */
/***/ (function(module, exports) {
module.exports = require("events");
/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
Streams in a WebSocket connection
---------------------------------
We model a WebSocket as two duplex streams: one stream is for the wire protocol
over an I/O socket, and the other is for incoming/outgoing messages.
+----------+ +---------+ +----------+
[1] write(chunk) -->| ~~~~~~~~ +----->| parse() +----->| ~~~~~~~~ +--> emit('data') [2]
| | +----+----+ | |
| | | | |
| IO | | [5] | Messages |
| | V | |
| | +---------+ | |
[4] emit('data') <--+ ~~~~~~~~ |<-----+ frame() |<-----+ ~~~~~~~~ |<-- write(chunk) [3]
+----------+ +---------+ +----------+
Message transfer in each direction is simple: IO receives a byte stream [1] and
sends this stream for parsing. The parser will periodically emit a complete
message text on the Messages stream [2]. Similarly, when messages are written
to the Messages stream [3], they are framed using the WebSocket wire format and
emitted via IO [4].
There is a feedback loop via [5] since some input from [1] will be things like
ping, pong and close frames. In these cases the protocol responds by emitting
responses directly back to [4] rather than emitting messages via [2].
For the purposes of flow control, we consider the sources of each Readable
stream to be as follows:
* [2] receives input from [1]
* [4] receives input from [1] and [3]
The classes below express the relationships described above without prescribing
anything about how parse() and frame() work, other than assuming they emit
'data' events to the IO and Messages streams. They will work with any protocol
driver having these two methods.
**/
var Stream = __webpack_require__(5).Stream,
util = __webpack_require__(0);
var IO = function(driver) {
this.readable = this.writable = true;
this._paused = false;
this._driver = driver;
};
util.inherits(IO, Stream);
// The IO pause() and resume() methods will be called when the socket we are
// piping to gets backed up and drains. Since IO output [4] comes from IO input
// [1] and Messages input [3], we need to tell both of those to return false
// from write() when this stream is paused.
IO.prototype.pause = function() {
this._paused = true;
this._driver.messages._paused = true;
};
IO.prototype.resume = function() {
this._paused = false;
this.emit('drain');
var messages = this._driver.messages;
messages._paused = false;
messages.emit('drain');
};
// When we receive input from a socket, send it to the parser and tell the
// source whether to back off.
IO.prototype.write = function(chunk) {
if (!this.writable) return false;
this._driver.parse(chunk);
return !this._paused;
};
// The IO end() method will be called when the socket piping into it emits
// 'close' or 'end', i.e. the socket is closed. In this situation the Messages
// stream will not emit any more data so we emit 'end'.
IO.prototype.end = function(chunk) {
if (!this.writable) return;
if (chunk !== undefined) this.write(chunk);
this.writable = false;
var messages = this._driver.messages;
if (messages.readable) {
messages.readable = messages.writable = false;
messages.emit('end');
}
};
IO.prototype.destroy = function() {
this.end();
};
var Messages = function(driver) {
this.readable = this.writable = true;
this._paused = false;
this._driver = driver;
};
util.inherits(Messages, Stream);
// The Messages pause() and resume() methods will be called when the app that's
// processing the messages gets backed up and drains. If we're emitting
// messages too fast we should tell the source to slow down. Message output [2]
// comes from IO input [1].
Messages.prototype.pause = function() {
this._driver.io._paused = true;
};
Messages.prototype.resume = function() {
this._driver.io._paused = false;
this._driver.io.emit('drain');
};
// When we receive messages from the user, send them to the formatter and tell
// the source whether to back off.
Messages.prototype.write = function(message) {
if (!this.writable) return false;
if (typeof message === 'string') this._driver.text(message);
else this._driver.binary(message);
return !this._paused;
};
// The Messages end() method will be called when a stream piping into it emits
// 'end'. Many streams may be piped into the WebSocket and one of them ending
// does not mean the whole socket is done, so just process the input and move
// on leaving the socket open.
Messages.prototype.end = function(message) {
if (message !== undefined) this.write(message);
};
Messages.prototype.destroy = function() {};
exports.IO = IO;
exports.Messages = Messages;
/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Buffer = __webpack_require__(1).Buffer;
var StreamReader = function() {
this._queue = [];
this._queueSize = 0;
this._offset = 0;
};
StreamReader.prototype.put = function(buffer) {
if (!buffer || buffer.length === 0) return;
if (!Buffer.isBuffer(buffer)) buffer = Buffer.from(buffer);
this._queue.push(buffer);
this._queueSize += buffer.length;
};
StreamReader.prototype.read = function(length) {
if (length > this._queueSize) return null;
if (length === 0) return Buffer.alloc(0);
this._queueSize -= length;
var queue = this._queue,
remain = length,
first = queue[0],
buffers, buffer;
if (first.length >= length) {
if (first.length === length) {
return queue.shift();
} else {
buffer = first.slice(0, length);
queue[0] = first.slice(length);
return buffer;
}
}
for (var i = 0, n = queue.length; i < n; i++) {
if (remain < queue[i].length) break;
remain -= queue[i].length;
}
buffers = queue.splice(0, i);
if (remain > 0 && queue.length > 0) {
buffers.push(queue[0].slice(0, remain));
queue[0] = queue[0].slice(remain);
}
return Buffer.concat(buffers, length);
};
StreamReader.prototype.eachByte = function(callback, context) {
var buffer, n, index;
while (this._queue.length > 0) {
buffer = this._queue[0];
n = buffer.length;
while (this._offset < n) {
index = this._offset;
this._offset += 1;
callback.call(context, buffer[index]);
}
this._offset = 0;
this._queue.shift();
}
};
module.exports = StreamReader;
/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Buffer = __webpack_require__(1).Buffer,
crypto = __webpack_require__(3),
url = __webpack_require__(6),
util = __webpack_require__(0),
HttpParser = __webpack_require__(10),
Base = __webpack_require__(2),
Hybi = __webpack_require__(12),
Proxy = __webpack_require__(36);
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];
module.exports = Client;
/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {
/*jshint node:true */
var assert = __webpack_require__(28);
exports.HTTPParser = HTTPParser;
function HTTPParser(type) {
assert.ok(type === HTTPParser.REQUEST || type === HTTPParser.RESPONSE || type === undefined);
if (type === undefined) {
// Node v12+
} else {
this.initialize(type);
}
this.maxHeaderSize=HTTPParser.maxHeaderSize
}
HTTPParser.prototype.initialize = function (type, async_resource) {
assert.ok(type === HTTPParser.REQUEST || type === HTTPParser.RESPONSE);
this.type = type;
this.state = type + '_LINE';
this.info = {
headers: [],
upgrade: false
};
this.trailers = [];
this.line = '';
this.isChunked = false;
this.connection = '';
this.headerSize = 0; // for preventing too big headers
this.body_bytes = null;
this.isUserCall = false;
this.hadError = false;
};
HTTPParser.encoding = 'ascii';
HTTPParser.maxHeaderSize = 80 * 1024; // maxHeaderSize (in bytes) is configurable, but 80kb by default;
HTTPParser.REQUEST = 'REQUEST';
HTTPParser.RESPONSE = 'RESPONSE';
// Note: *not* starting with kOnHeaders=0 line the Node parser, because any
// newly added constants (kOnTimeout in Node v12.19.0) will overwrite 0!
var kOnHeaders = HTTPParser.kOnHeaders = 1;
var kOnHeadersComplete = HTTPParser.kOnHeadersComplete = 2;
var kOnBody = HTTPParser.kOnBody = 3;
var kOnMessageComplete = HTTPParser.kOnMessageComplete = 4;
// Some handler stubs, needed for compatibility
HTTPParser.prototype[kOnHeaders] =
HTTPParser.prototype[kOnHeadersComplete] =
HTTPParser.prototype[kOnBody] =
HTTPParser.prototype[kOnMessageComplete] = function () {};
var compatMode0_12 = true;
Object.defineProperty(HTTPParser, 'kOnExecute', {
get: function () {
// hack for backward compatibility
compatMode0_12 = false;
return 99;
}
});
var methods = exports.methods = HTTPParser.methods = [
'DELETE',
'GET',
'HEAD',
'POST',
'PUT',
'CONNECT',
'OPTIONS',
'TRACE',
'COPY',
'LOCK',
'MKCOL',
'MOVE',
'PROPFIND',
'PROPPATCH',
'SEARCH',
'UNLOCK',
'BIND',
'REBIND',
'UNBIND',
'ACL',
'REPORT',
'MKACTIVITY',
'CHECKOUT',
'MERGE',
'M-SEARCH',
'NOTIFY',
'SUBSCRIBE',
'UNSUBSCRIBE',
'PATCH',
'PURGE',
'MKCALENDAR',
'LINK',
'UNLINK',
'SOURCE',
];
var method_connect = methods.indexOf('CONNECT');
HTTPParser.prototype.reinitialize = HTTPParser;
HTTPParser.prototype.close =
HTTPParser.prototype.pause =
HTTPParser.prototype.resume =
HTTPParser.prototype.free = function () {};
HTTPParser.prototype._compatMode0_11 = false;
HTTPParser.prototype.getAsyncId = function() { return 0; };
var headerState = {
REQUEST_LINE: true,
RESPONSE_LINE: true,
HEADER: true
};
HTTPParser.prototype.execute = function (chunk, start, length) {
if (!(this instanceof HTTPParser)) {
throw new TypeError('not a HTTPParser');
}
// backward compat to node < 0.11.4
// Note: the start and length params were removed in newer version
start = start || 0;
length = typeof length === 'number' ? length : chunk.length;
this.chunk = chunk;
this.offset = start;
var end = this.end = start + length;
try {
while (this.offset < end) {
if (this[this.state]()) {
break;
}
}
} catch (err) {
if (this.isUserCall) {
throw err;
}
this.hadError = true;
return err;
}
this.chunk = null;
length = this.offset - start;
if (headerState[this.state]) {
this.headerSize += length;
if (this.headerSize > (this.maxHeaderSize||HTTPParser.maxHeaderSize)) {
return new Error('max header size exceeded');
}
}
return length;
};
var stateFinishAllowed = {
REQUEST_LINE: true,
RESPONSE_LINE: true,
BODY_RAW: true
};
HTTPParser.prototype.finish = function () {
if (this.hadError) {
return;
}
if (!stateFinishAllowed[this.state]) {
return new Error('invalid state for EOF');
}
if (this.state === 'BODY_RAW') {
this.userCall()(this[kOnMessageComplete]());
}
};
// These three methods are used for an internal speed optimization, and it also
// works if theses are noops. Basically consume() asks us to read the bytes
// ourselves, but if we don't do it we get them through execute().
HTTPParser.prototype.consume =
HTTPParser.prototype.unconsume =
HTTPParser.prototype.getCurrentBuffer = function () {};
//For correct error handling - see HTTPParser#execute
//Usage: this.userCall()(userFunction('arg'));
HTTPParser.prototype.userCall = function () {
this.isUserCall = true;
var self = this;
return function (ret) {
self.isUserCall = false;
return ret;
};
};
HTTPParser.prototype.nextRequest = function () {
this.userCall()(this[kOnMessageComplete]());
this.reinitialize(this.type);
};
HTTPParser.prototype.consumeLine = function () {
var end = this.end,
chunk = this.chunk;
for (var i = this.offset; i < end; i++) {
if (chunk[i] === 0x0a) { // \n
var line = this.line + chunk.toString(HTTPParser.encoding, this.offset, i);
if (line.charAt(line.length - 1) === '\r') {
line = line.substr(0, line.length - 1);
}
this.line = '';
this.offset = i + 1;
return line;
}
}
//line split over multiple chunks
this.line += chunk.toString(HTTPParser.encoding, this.offset, this.end);
this.offset = this.end;
};
var headerExp = /^([^: \t]+):[ \t]*((?:.*[^ \t])|)/;
var headerContinueExp = /^[ \t]+(.*[^ \t])/;
HTTPParser.prototype.parseHeader = function (line, headers) {
if (line.indexOf('\r') !== -1) {
throw parseErrorCode('HPE_LF_EXPECTED');
}
var match = headerExp.exec(line);
var k = match && match[1];
if (k) { // skip empty string (malformed header)
headers.push(k);
headers.push(match[2]);
} else {
var matchContinue = headerContinueExp.exec(line);
if (matchContinue && headers.length) {
if (headers[headers.length - 1]) {
headers[headers.length - 1] += ' ';
}
headers[headers.length - 1] += matchContinue[1];
}
}
};
var requestExp = /^([A-Z-]+) ([^ ]+) HTTP\/(\d)\.(\d)$/;
HTTPParser.prototype.REQUEST_LINE = function () {
var line = this.consumeLine();
if (!line) {
return;
}
var match = requestExp.exec(line);
if (match === null) {
throw parseErrorCode('HPE_INVALID_CONSTANT');
}
this.info.method = this._compatMode0_11 ? match[1] : methods.indexOf(match[1]);
if (this.info.method === -1) {
throw new Error('invalid request method');
}
this.info.url = match[2];
this.info.versionMajor = +match[3];
this.info.versionMinor = +match[4];
this.body_bytes = 0;
this.state = 'HEADER';
};
var responseExp = /^HTTP\/(\d)\.(\d) (\d{3}) ?(.*)$/;
HTTPParser.prototype.RESPONSE_LINE = function () {
var line = this.consumeLine();
if (!line) {
return;
}
var match = responseExp.exec(line);
if (match === null) {
throw parseErrorCode('HPE_INVALID_CONSTANT');
}
this.info.versionMajor = +match[1];
this.info.versionMinor = +match[2];
var statusCode = this.info.statusCode = +match[3];
this.info.statusMessage = match[4];
// Implied zero length.
if ((statusCode / 100 | 0) === 1 || statusCode === 204 || statusCode === 304) {
this.body_bytes = 0;
}
this.state = 'HEADER';
};
HTTPParser.prototype.shouldKeepAlive = function () {
if (this.info.versionMajor > 0 && this.info.versionMinor > 0) {
if (this.connection.indexOf('close') !== -1) {
return false;
}
} else if (this.connection.indexOf('keep-alive') === -1) {
return false;
}
if (this.body_bytes !== null || this.isChunked) { // || skipBody
return true;
}
return false;
};
HTTPParser.prototype.HEADER = function () {
var line = this.consumeLine();
if (line === undefined) {
return;
}
var info = this.info;
if (line) {
this.parseHeader(line, info.headers);
} else {
var headers = info.headers;
var hasContentLength = false;
var currentContentLengthValue;
var hasUpgradeHeader = false;
for (var i = 0; i < headers.length; i += 2) {
switch (headers[i].toLowerCase()) {
case 'transfer-encoding':
this.isChunked = headers[i + 1].toLowerCase() === 'chunked';
break;
case 'content-length':
currentContentLengthValue = +headers[i + 1];
if (hasContentLength) {
// Fix duplicate Content-Length header with same values.
// Throw error only if values are different.
// Known issues:
// https://github.com/request/request/issues/2091#issuecomment-328715113
// https://github.com/nodejs/node/issues/6517#issuecomment-216263771
if (currentContentLengthValue !== this.body_bytes) {
throw parseErrorCode('HPE_UNEXPECTED_CONTENT_LENGTH');
}
} else {
hasContentLength = true;
this.body_bytes = currentContentLengthValue;
}
break;
case 'connection':
this.connection += headers[i + 1].toLowerCase();
break;
case 'upgrade':
hasUpgradeHeader = true;
break;
}
}
// if both isChunked and hasContentLength, isChunked wins
// This is required so the body is parsed using the chunked method, and matches
// Chrome's behavior. We could, maybe, ignore them both (would get chunked
// encoding into the body), and/or disable shouldKeepAlive to be more
// resilient.
if (this.isChunked && hasContentLength) {
hasContentLength = false;
this.body_bytes = null;
}
// Logic from https://github.com/nodejs/http-parser/blob/921d5585515a153fa00e411cf144280c59b41f90/http_parser.c#L1727-L1737
// "For responses, "Upgrade: foo" and "Connection: upgrade" are
// mandatory only when it is a 101 Switching Protocols response,
// otherwise it is purely informational, to announce support.
if (hasUpgradeHeader && this.connection.indexOf('upgrade') != -1) {
info.upgrade = this.type === HTTPParser.REQUEST || info.statusCode === 101;
} else {
info.upgrade = info.method === method_connect;
}
if (this.isChunked && info.upgrade) {
this.isChunked = false;
}
info.shouldKeepAlive = this.shouldKeepAlive();
//problem which also exists in original node: we should know skipBody before calling onHeadersComplete
var skipBody;
if (compatMode0_12) {
skipBody = this.userCall()(this[kOnHeadersComplete](info));
} else {
skipBody = this.userCall()(this[kOnHeadersComplete](info.versionMajor,
info.versionMinor, info.headers, info.method, info.url, info.statusCode,
info.statusMessage, info.upgrade, info.shouldKeepAlive));
}
if (skipBody === 2) {
this.nextRequest();
return true;
} else if (this.isChunked && !skipBody) {
this.state = 'BODY_CHUNKHEAD';
} else if (skipBody || this.body_bytes === 0) {
this.nextRequest();
// For older versions of node (v6.x and older?), that return skipBody=1 or skipBody=true,
// need this "return true;" if it's an upgrade request.
return info.upgrade;
} else if (this.body_bytes === null) {
this.state = 'BODY_RAW';
} else {
this.state = 'BODY_SIZED';
}
}
};
HTTPParser.prototype.BODY_CHUNKHEAD = function () {
var line = this.consumeLine();
if (line === undefined) {
return;
}
this.body_bytes = parseInt(line, 16);
if (!this.body_bytes) {
this.state = 'BODY_CHUNKTRAILERS';
} else {
this.state = 'BODY_CHUNK';
}
};
HTTPParser.prototype.BODY_CHUNK = function () {
var length = Math.min(this.end - this.offset, this.body_bytes);
this.userCall()(this[kOnBody](this.chunk, this.offset, length));
this.offset += length;
this.body_bytes -= length;
if (!this.body_bytes) {
this.state = 'BODY_CHUNKEMPTYLINE';
}
};
HTTPParser.prototype.BODY_CHUNKEMPTYLINE = function () {
var line = this.consumeLine();
if (line === undefined) {
return;
}
assert.equal(line, '');
this.state = 'BODY_CHUNKHEAD';
};
HTTPParser.prototype.BODY_CHUNKTRAILERS = function () {
var line = this.consumeLine();
if (line === undefined) {
return;
}
if (line) {
this.parseHeader(line, this.trailers);
} else {
if (this.trailers.length) {
this.userCall()(this[kOnHeaders](this.trailers, ''));
}
this.nextRequest();
}
};
HTTPParser.prototype.BODY_RAW = function () {
var length = this.end - this.offset;
this.userCall()(this[kOnBody](this.chunk, this.offset, length));
this.offset = this.end;
};
HTTPParser.prototype.BODY_SIZED = function () {
var length = Math.min(this.end - this.offset, this.body_bytes);
this.userCall()(this[kOnBody](this.chunk, this.offset, length));
this.offset += length;
this.body_bytes -= length;
if (!this.body_bytes) {
this.nextRequest();
}
};
// backward compat to node < 0.11.6
['Headers', 'HeadersComplete', 'Body', 'MessageComplete'].forEach(function (name) {
var k = HTTPParser['kOn' + name];
Object.defineProperty(HTTPParser.prototype, 'on' + name, {
get: function () {
return this[k];
},
set: function (to) {
// hack for backward compatibility
this._compatMode0_11 = true;
method_connect = 'CONNECT';
return (this[k] = to);
}
});
});
function parseErrorCode(code) {
var err = new Error('Parse Error');
err.code = code;
return err;
}
/***/ }),
/* 28 */
/***/ (function(module, exports) {
module.exports = require("assert");
/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Parser = __webpack_require__(30),
Pipeline = __webpack_require__(31);
var Extensions = function() {
this._rsv1 = this._rsv2 = this._rsv3 = null;
this._byName = {};
this._inOrder = [];
this._sessions = [];
this._index = {};
};
Extensions.MESSAGE_OPCODES = [1, 2];
var instance = {
add: function(ext) {
if (typeof ext.name !== 'string') throw new TypeError('extension.name must be a string');
if (ext.type !== 'permessage') throw new TypeError('extension.type must be "permessage"');
if (typeof ext.rsv1 !== 'boolean') throw new TypeError('extension.rsv1 must be true or false');
if (typeof ext.rsv2 !== 'boolean') throw new TypeError('extension.rsv2 must be true or false');
if (typeof ext.rsv3 !== 'boolean') throw new TypeError('extension.rsv3 must be true or false');
if (this._byName.hasOwnProperty(ext.name))
throw new TypeError('An extension with name "' + ext.name + '" is already registered');
this._byName[ext.name] = ext;
this._inOrder.push(ext);
},
generateOffer: function() {
var sessions = [],
offer = [],
index = {};
this._inOrder.forEach(function(ext) {
var session = ext.createClientSession();
if (!session) return;
var record = [ext, session];
sessions.push(record);
index[ext.name] = record;
var offers = session.generateOffer();
offers = offers ? [].concat(offers) : [];
offers.forEach(function(off) {
offer.push(Parser.serializeParams(ext.name, off));
}, this);
}, this);
this._sessions = sessions;
this._index = index;
return offer.length > 0 ? offer.join(', ') : null;
},
activate: function(header) {
var responses = Parser.parseHeader(header),
sessions = [];
responses.eachOffer(function(name, params) {
var record = this._index[name];
if (!record)
throw new Error('Server sent an extension response for unknown extension "' + name + '"');
var ext = record[0],
session = record[1],
reserved = this._reserved(ext);
if (reserved)
throw new Error('Server sent two extension responses that use the RSV' +
reserved[0] + ' bit: "' +
reserved[1] + '" and "' + ext.name + '"');
if (session.activate(params) !== true)
throw new Error('Server sent unacceptable extension parameters: ' +
Parser.serializeParams(name, params));
this._reserve(ext);
sessions.push(record);
}, this);
this._sessions = sessions;
this._pipeline = new Pipeline(sessions);
},
generateResponse: function(header) {
var sessions = [],
response = [],
offers = Parser.parseHeader(header);
this._inOrder.forEach(function(ext) {
var offer = offers.byName(ext.name);
if (offer.length === 0 || this._reserved(ext)) return;
var session = ext.createServerSession(offer);
if (!session) return;
this._reserve(ext);
sessions.push([ext, session]);
response.push(Parser.serializeParams(ext.name, session.generateResponse()));
}, this);
this._sessions = sessions;
this._pipeline = new Pipeline(sessions);
return response.length > 0 ? response.join(', ') : null;
},
validFrameRsv: function(frame) {
var allowed = { rsv1: false, rsv2: false, rsv3: false },
ext;
if (Extensions.MESSAGE_OPCODES.indexOf(frame.opcode) >= 0) {
for (var i = 0, n = this._sessions.length; i < n; i++) {
ext = this._sessions[i][0];
allowed.rsv1 = allowed.rsv1 || ext.rsv1;
allowed.rsv2 = allowed.rsv2 || ext.rsv2;
allowed.rsv3 = allowed.rsv3 || ext.rsv3;
}
}
return (allowed.rsv1 || !frame.rsv1) &&
(allowed.rsv2 || !frame.rsv2) &&
(allowed.rsv3 || !frame.rsv3);
},
processIncomingMessage: function(message, callback, context) {
this._pipeline.processIncomingMessage(message, callback, context);
},
processOutgoingMessage: function(message, callback, context) {
this._pipeline.processOutgoingMessage(message, callback, context);
},
close: function(callback, context) {
if (!this._pipeline) return callback.call(context);
this._pipeline.close(callback, context);
},
_reserve: function(ext) {
this._rsv1 = this._rsv1 || (ext.rsv1 && ext.name);
this._rsv2 = this._rsv2 || (ext.rsv2 && ext.name);
this._rsv3 = this._rsv3 || (ext.rsv3 && ext.name);
},
_reserved: function(ext) {
if (this._rsv1 && ext.rsv1) return [1, this._rsv1];
if (this._rsv2 && ext.rsv2) return [2, this._rsv2];
if (this._rsv3 && ext.rsv3) return [3, this._rsv3];
return false;
}
};
for (var key in instance)
Extensions.prototype[key] = instance[key];
module.exports = Extensions;
/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var TOKEN = /([!#\$%&'\*\+\-\.\^_`\|~0-9A-Za-z]+)/,
NOTOKEN = /([^!#\$%&'\*\+\-\.\^_`\|~0-9A-Za-z])/g,
QUOTED = /"((?:\\[\x00-\x7f]|[^\x00-\x08\x0a-\x1f\x7f"\\])*)"/,
PARAM = new RegExp(TOKEN.source + '(?:=(?:' + TOKEN.source + '|' + QUOTED.source + '))?'),
EXT = new RegExp(TOKEN.source + '(?: *; *' + PARAM.source + ')*', 'g'),
EXT_LIST = new RegExp('^' + EXT.source + '(?: *, *' + EXT.source + ')*$'),
NUMBER = /^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var Parser = {
parseHeader: function(header) {
var offers = new Offers();
if (header === '' || header === undefined) return offers;
if (!EXT_LIST.test(header))
throw new SyntaxError('Invalid Sec-WebSocket-Extensions header: ' + header);
var values = header.match(EXT);
values.forEach(function(value) {
var params = value.match(new RegExp(PARAM.source, 'g')),
name = params.shift(),
offer = {};
params.forEach(function(param) {
var args = param.match(PARAM), key = args[1], data;
if (args[2] !== undefined) {
data = args[2];
} else if (args[3] !== undefined) {
data = args[3].replace(/\\/g, '');
} else {
data = true;
}
if (NUMBER.test(data)) data = parseFloat(data);
if (hasOwnProperty.call(offer, key)) {
offer[key] = [].concat(offer[key]);
offer[key].push(data);
} else {
offer[key] = data;
}
}, this);
offers.push(name, offer);
}, this);
return offers;
},
serializeParams: function(name, params) {
var values = [];
var print = function(key, value) {
if (value instanceof Array) {
value.forEach(function(v) { print(key, v) });
} else if (value === true) {
values.push(key);
} else if (typeof value === 'number') {
values.push(key + '=' + value);
} else if (NOTOKEN.test(value)) {
values.push(key + '="' + value.replace(/"/g, '\\"') + '"');
} else {
values.push(key + '=' + value);
}
};
for (var key in params) print(key, params[key]);
return [name].concat(values).join('; ');
}
};
var Offers = function() {
this._byName = {};
this._inOrder = [];
};
Offers.prototype.push = function(name, params) {
if (!hasOwnProperty.call(this._byName, name))
this._byName[name] = [];
this._byName[name].push(params);
this._inOrder.push({ name: name, params: params });
};
Offers.prototype.eachOffer = function(callback, context) {
var list = this._inOrder;
for (var i = 0, n = list.length; i < n; i++)
callback.call(context, list[i].name, list[i].params);
};
Offers.prototype.byName = function(name) {
return this._byName[name] || [];
};
Offers.prototype.toArray = function() {
return this._inOrder.slice();
};
module.exports = Parser;
/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Cell = __webpack_require__(32),
Pledge = __webpack_require__(14);
var Pipeline = function(sessions) {
this._cells = sessions.map(function(session) { return new Cell(session) });
this._stopped = { incoming: false, outgoing: false };
};
Pipeline.prototype.processIncomingMessage = function(message, callback, context) {
if (this._stopped.incoming) return;
this._loop('incoming', this._cells.length - 1, -1, -1, message, callback, context);
};
Pipeline.prototype.processOutgoingMessage = function(message, callback, context) {
if (this._stopped.outgoing) return;
this._loop('outgoing', 0, this._cells.length, 1, message, callback, context);
};
Pipeline.prototype.close = function(callback, context) {
this._stopped = { incoming: true, outgoing: true };
var closed = this._cells.map(function(a) { return a.close() });
if (callback)
Pledge.all(closed).then(function() { callback.call(context) });
};
Pipeline.prototype._loop = function(direction, start, end, step, message, callback, context) {
var cells = this._cells,
n = cells.length,
self = this;
while (n--) cells[n].pending(direction);
var pipe = function(index, error, msg) {
if (index === end) return callback.call(context, error, msg);
cells[index][direction](error, msg, function(err, m) {
if (err) self._stopped[direction] = true;
pipe(index + step, err, m);
});
};
pipe(start, null, message);
};
module.exports = Pipeline;
/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Functor = __webpack_require__(33),
Pledge = __webpack_require__(14);
var Cell = function(tuple) {
this._ext = tuple[0];
this._session = tuple[1];
this._functors = {
incoming: new Functor(this._session, 'processIncomingMessage'),
outgoing: new Functor(this._session, 'processOutgoingMessage')
};
};
Cell.prototype.pending = function(direction) {
var functor = this._functors[direction];
if (!functor._stopped) functor.pending += 1;
};
Cell.prototype.incoming = function(error, message, callback, context) {
this._exec('incoming', error, message, callback, context);
};
Cell.prototype.outgoing = function(error, message, callback, context) {
this._exec('outgoing', error, message, callback, context);
};
Cell.prototype.close = function() {
this._closed = this._closed || new Pledge();
this._doClose();
return this._closed;
};
Cell.prototype._exec = function(direction, error, message, callback, context) {
this._functors[direction].call(error, message, function(err, msg) {
if (err) err.message = this._ext.name + ': ' + err.message;
callback.call(context, err, msg);
this._doClose();
}, this);
};
Cell.prototype._doClose = function() {
var fin = this._functors.incoming,
fout = this._functors.outgoing;
if (!this._closed || fin.pending + fout.pending !== 0) return;
if (this._session) this._session.close();
this._session = null;
this._closed.done();
};
module.exports = Cell;
/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var RingBuffer = __webpack_require__(13);
var Functor = function(session, method) {
this._session = session;
this._method = method;
this._queue = new RingBuffer(Functor.QUEUE_SIZE);
this._stopped = false;
this.pending = 0;
};
Functor.QUEUE_SIZE = 8;
Functor.prototype.call = function(error, message, callback, context) {
if (this._stopped) return;
var record = { error: error, message: message, callback: callback, context: context, done: false },
called = false,
self = this;
this._queue.push(record);
if (record.error) {
record.done = true;
this._stop();
return this._flushQueue();
}
var handler = function(err, msg) {
if (!(called ^ (called = true))) return;
if (err) {
self._stop();
record.error = err;
record.message = null;
} else {
record.message = msg;
}
record.done = true;
self._flushQueue();
};
try {
this._session[this._method](message, handler);
} catch (err) {
handler(err);
}
};
Functor.prototype._stop = function() {
this.pending = this._queue.length;
this._stopped = true;
};
Functor.prototype._flushQueue = function() {
var queue = this._queue, record;
while (queue.length > 0 && queue.peek().done) {
record = queue.shift();
if (record.error) {
this.pending = 0;
queue.clear();
} else {
this.pending -= 1;
}
record.callback.call(record.context, record.error, record.message);
}
};
module.exports = Functor;
/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
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];
module.exports = Frame;
/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Buffer = __webpack_require__(1).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];
module.exports = Message;
/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Buffer = __webpack_require__(1).Buffer,
Stream = __webpack_require__(5).Stream,
url = __webpack_require__(6),
util = __webpack_require__(0),
Base = __webpack_require__(2),
Headers = __webpack_require__(9),
HttpParser = __webpack_require__(10);
var PORTS = { 'ws:': 80, 'wss:': 443 };
var Proxy = function(client, origin, options) {
this._client = client;
this._http = new HttpParser('response');
this._origin = (typeof client.url === 'object') ? client.url : url.parse(client.url);
this._url = (typeof origin === 'object') ? origin : url.parse(origin);
this._options = options || {};
this._state = 0;
this.readable = this.writable = true;
this._paused = false;
this._headers = new Headers();
this._headers.set('Host', this._origin.host);
this._headers.set('Connection', 'keep-alive');
this._headers.set('Proxy-Connection', 'keep-alive');
var auth = this._url.auth && Buffer.from(this._url.auth, 'utf8').toString('base64');
if (auth) this._headers.set('Proxy-Authorization', 'Basic ' + auth);
};
util.inherits(Proxy, Stream);
var instance = {
setHeader: function(name, value) {
if (this._state !== 0) return false;
this._headers.set(name, value);
return true;
},
start: function() {
if (this._state !== 0) return false;
this._state = 1;
var origin = this._origin,
port = origin.port || PORTS[origin.protocol],
start = 'CONNECT ' + origin.hostname + ':' + port + ' HTTP/1.1';
var headers = [start, this._headers.toString(), ''];
this.emit('data', Buffer.from(headers.join('\r\n'), 'utf8'));
return true;
},
pause: function() {
this._paused = true;
},
resume: function() {
this._paused = false;
this.emit('drain');
},
write: function(chunk) {
if (!this.writable) return false;
this._http.parse(chunk);
if (!this._http.isComplete()) return !this._paused;
this.statusCode = this._http.statusCode;
this.headers = this._http.headers;
if (this.statusCode === 200) {
this.emit('connect', new Base.ConnectEvent());
} else {
var message = "Can't establish a connection to the server at " + this._origin.href;
this.emit('error', new Error(message));
}
this.end();
return !this._paused;
},
end: function(chunk) {
if (!this.writable) return;
if (chunk !== undefined) this.write(chunk);
this.readable = this.writable = false;
this.emit('close');
this.emit('end');
},
destroy: function() {
this.end();
}
};
for (var key in instance)
Proxy.prototype[key] = instance[key];
module.exports = Proxy;
/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var util = __webpack_require__(0),
HttpParser = __webpack_require__(10),
Base = __webpack_require__(2),
Draft75 = __webpack_require__(15),
Draft76 = __webpack_require__(38),
Hybi = __webpack_require__(12);
var Server = function(options) {
Base.call(this, null, null, options);
this._http = new HttpParser('request');
};
util.inherits(Server, Base);
var instance = {
EVENTS: ['open', 'message', 'error', 'close', 'ping', 'pong'],
_bindEventListeners: function() {
this.messages.on('error', function() {});
this.on('error', function() {});
},
parse: function(chunk) {
if (this._delegate) return this._delegate.parse(chunk);
this._http.parse(chunk);
if (!this._http.isComplete()) return;
this.method = this._http.method;
this.url = this._http.url;
this.headers = this._http.headers;
this.body = this._http.body;
var self = this;
this._delegate = Server.http(this, this._options);
this._delegate.messages = this.messages;
this._delegate.io = this.io;
this._open();
this.EVENTS.forEach(function(event) {
this._delegate.on(event, function(e) { self.emit(event, e) });
}, this);
this.protocol = this._delegate.protocol;
this.version = this._delegate.version;
this.parse(this._http.body);
this.emit('connect', new Base.ConnectEvent());
},
_open: function() {
this.__queue.forEach(function(msg) {
this._delegate[msg[0]].apply(this._delegate, msg[1]);
}, this);
this.__queue = [];
}
};
['addExtension', 'setHeader', 'start', 'frame', 'text', 'binary', 'ping', 'close'].forEach(function(method) {
instance[method] = function() {
if (this._delegate) {
return this._delegate[method].apply(this._delegate, arguments);
} else {
this.__queue.push([method, arguments]);
return true;
}
};
});
for (var key in instance)
Server.prototype[key] = instance[key];
Server.isSecureRequest = function(request) {
if (request.connection && request.connection.authorized !== undefined) return true;
if (request.socket && request.socket.secure) return true;
var headers = request.headers;
if (!headers) return false;
if (headers['https'] === 'on') return true;
if (headers['x-forwarded-ssl'] === 'on') return true;
if (headers['x-forwarded-scheme'] === 'https') return true;
if (headers['x-forwarded-proto'] === 'https') return true;
return false;
};
Server.determineUrl = function(request) {
var scheme = this.isSecureRequest(request) ? 'wss:' : 'ws:';
return scheme + '//' + request.headers.host + request.url;
};
Server.http = function(request, options) {
options = options || {};
if (options.requireMasking === undefined) options.requireMasking = true;
var headers = request.headers,
version = headers['sec-websocket-version'],
key = headers['sec-websocket-key'],
key1 = headers['sec-websocket-key1'],
key2 = headers['sec-websocket-key2'],
url = this.determineUrl(request);
if (version || key)
return new Hybi(request, url, options);
else if (key1 || key2)
return new Draft76(request, url, options);
else
return new Draft75(request, url, options);
};
module.exports = Server;
/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Buffer = __webpack_require__(1).Buffer,
Base = __webpack_require__(2),
Draft75 = __webpack_require__(15),
crypto = __webpack_require__(3),
util = __webpack_require__(0);
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];
module.exports = Draft76;
/***/ }),
/* 39 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var util = __webpack_require__(0),
net = __webpack_require__(40),
tls = __webpack_require__(41),
url = __webpack_require__(6),
driver = __webpack_require__(4),
API = __webpack_require__(11),
Event = __webpack_require__(7);
var DEFAULT_PORTS = {'http:': 80, 'https:': 443, 'ws:':80, 'wss:': 443},
SECURE_PROTOCOLS = ['https:', 'wss:'];
var Client = function(_url, protocols, options) {
options = options || {};
this.url = _url;
this._driver = driver.client(this.url, {maxLength: options.maxLength, protocols: protocols});
['open', 'error'].forEach(function(event) {
this._driver.on(event, function() {
self.headers = self._driver.headers;
self.statusCode = self._driver.statusCode;
});
}, this);
var proxy = options.proxy || {},
endpoint = url.parse(proxy.origin || this.url),
port = endpoint.port || DEFAULT_PORTS[endpoint.protocol],
secure = SECURE_PROTOCOLS.indexOf(endpoint.protocol) >= 0,
onConnect = function() { self._onConnect() },
netOptions = options.net || {},
originTLS = options.tls || {},
socketTLS = proxy.origin ? (proxy.tls || {}) : originTLS,
self = this;
netOptions.host = socketTLS.host = endpoint.hostname;
netOptions.port = socketTLS.port = port;
originTLS.ca = originTLS.ca || options.ca;
socketTLS.servername = socketTLS.servername || endpoint.hostname;
this._stream = secure
? tls.connect(socketTLS, onConnect)
: net.connect(netOptions, onConnect);
if (proxy.origin) this._configureProxy(proxy, originTLS);
API.call(this, options);
};
util.inherits(Client, API);
Client.prototype._onConnect = function() {
var worker = this._proxy || this._driver;
worker.start();
};
Client.prototype._configureProxy = function(proxy, originTLS) {
var uri = url.parse(this.url),
secure = SECURE_PROTOCOLS.indexOf(uri.protocol) >= 0,
self = this,
name;
this._proxy = this._driver.proxy(proxy.origin);
if (proxy.headers) {
for (name in proxy.headers) this._proxy.setHeader(name, proxy.headers[name]);
}
this._proxy.pipe(this._stream, {end: false});
this._stream.pipe(this._proxy);
this._proxy.on('connect', function() {
if (secure) {
var options = {socket: self._stream, servername: uri.hostname};
for (name in originTLS) options[name] = originTLS[name];
self._stream = tls.connect(options);
self._configureStream();
}
self._driver.io.pipe(self._stream);
self._stream.pipe(self._driver.io);
self._driver.start();
});
this._proxy.on('error', function(error) {
self._driver.emit('error', error);
});
};
module.exports = Client;
/***/ }),
/* 40 */
/***/ (function(module, exports) {
module.exports = require("net");
/***/ }),
/* 41 */
/***/ (function(module, exports) {
module.exports = require("tls");
/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Stream = __webpack_require__(5).Stream,
util = __webpack_require__(0),
driver = __webpack_require__(4),
Headers = __webpack_require__(9),
API = __webpack_require__(11),
EventTarget = __webpack_require__(16),
Event = __webpack_require__(7);
var EventSource = function(request, response, options) {
this.writable = true;
options = options || {};
this._stream = response.socket;
this._ping = options.ping || this.DEFAULT_PING;
this._retry = options.retry || this.DEFAULT_RETRY;
var scheme = driver.isSecureRequest(request) ? 'https:' : 'http:';
this.url = scheme + '//' + request.headers.host + request.url;
this.lastEventId = request.headers['last-event-id'] || '';
this.readyState = API.CONNECTING;
var headers = new Headers(),
self = this;
if (options.headers) {
for (var key in options.headers) headers.set(key, options.headers[key]);
}
if (!this._stream || !this._stream.writable) return;
process.nextTick(function() { self._open() });
this._stream.setTimeout(0);
this._stream.setNoDelay(true);
var handshake = 'HTTP/1.1 200 OK\r\n' +
'Content-Type: text/event-stream\r\n' +
'Cache-Control: no-cache, no-store\r\n' +
'Connection: close\r\n' +
headers.toString() +
'\r\n' +
'retry: ' + Math.floor(this._retry * 1000) + '\r\n\r\n';
this._write(handshake);
this._stream.on('drain', function() { self.emit('drain') });
if (this._ping)
this._pingTimer = setInterval(function() { self.ping() }, this._ping * 1000);
['error', 'end'].forEach(function(event) {
self._stream.on(event, function() { self.close() });
});
};
util.inherits(EventSource, Stream);
EventSource.isEventSource = function(request) {
if (request.method !== 'GET') return false;
var accept = (request.headers.accept || '').split(/\s*,\s*/);
return accept.indexOf('text/event-stream') >= 0;
};
var instance = {
DEFAULT_PING: 10,
DEFAULT_RETRY: 5,
_write: function(chunk) {
if (!this.writable) return false;
try {
return this._stream.write(chunk, 'utf8');
} catch (e) {
return false;
}
},
_open: function() {
if (this.readyState !== API.CONNECTING) return;
this.readyState = API.OPEN;
var event = new Event('open');
event.initEvent('open', false, false);
this.dispatchEvent(event);
},
write: function(message) {
return this.send(message);
},
end: function(message) {
if (message !== undefined) this.write(message);
this.close();
},
send: function(message, options) {
if (this.readyState > API.OPEN) return false;
message = String(message).replace(/(\r\n|\r|\n)/g, '$1data: ');
options = options || {};
var frame = '';
if (options.event) frame += 'event: ' + options.event + '\r\n';
if (options.id) frame += 'id: ' + options.id + '\r\n';
frame += 'data: ' + message + '\r\n\r\n';
return this._write(frame);
},
ping: function() {
return this._write(':\r\n\r\n');
},
close: function() {
if (this.readyState > API.OPEN) return false;
this.readyState = API.CLOSED;
this.writable = false;
if (this._pingTimer) clearInterval(this._pingTimer);
if (this._stream) this._stream.end();
var event = new Event('close');
event.initEvent('close', false, false);
this.dispatchEvent(event);
return true;
}
};
for (var method in instance) EventSource.prototype[method] = instance[method];
for (var key in EventTarget) EventSource.prototype[key] = EventTarget[key];
module.exports = EventSource;
/***/ }),
/* 43 */
/***/ (function(module, exports) {
module.exports = require("child_process");
/***/ }),
/* 44 */
/***/ (function(module, exports) {
module.exports = require("fs");
/***/ }),
/* 45 */
/***/ (function(module, exports) {
module.exports = require("http");
/***/ }),
/* 46 */
/***/ (function(module, exports) {
module.exports = require("https");
/***/ }),
/* 47 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, "default", function() { return /* binding */ pusher_with_encryption_PusherWithEncryption; });
// CONCATENATED MODULE: ./src/core/base64.ts
function encode(s) {
return btoa(utob(s));
}
var fromCharCode = String.fromCharCode;
var b64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
var b64tab = {};
for (var base64_i = 0, l = b64chars.length; base64_i < l; base64_i++) {
b64tab[b64chars.charAt(base64_i)] = base64_i;
}
var cb_utob = function (c) {
var cc = c.charCodeAt(0);
return cc < 0x80
? c
: cc < 0x800
? fromCharCode(0xc0 | (cc >>> 6)) + fromCharCode(0x80 | (cc & 0x3f))
: fromCharCode(0xe0 | ((cc >>> 12) & 0x0f)) +
fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) +
fromCharCode(0x80 | (cc & 0x3f));
};
var utob = function (u) {
return u.replace(/[^\x00-\x7F]/g, cb_utob);
};
var cb_encode = function (ccc) {
var padlen = [0, 2, 1][ccc.length % 3];
var ord = (ccc.charCodeAt(0) << 16) |
((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8) |
(ccc.length > 2 ? ccc.charCodeAt(2) : 0);
var chars = [
b64chars.charAt(ord >>> 18),
b64chars.charAt((ord >>> 12) & 63),
padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),
padlen >= 1 ? '=' : b64chars.charAt(ord & 63)
];
return chars.join('');
};
var btoa = global.btoa ||
function (b) {
return b.replace(/[\s\S]{1,3}/g, cb_encode);
};
// CONCATENATED MODULE: ./src/core/utils/timers/abstract_timer.ts
class Timer {
constructor(set, clear, delay, callback) {
this.clear = clear;
this.timer = set(() => {
if (this.timer) {
this.timer = callback(this.timer);
}
}, delay);
}
isRunning() {
return this.timer !== null;
}
ensureAborted() {
if (this.timer) {
this.clear(this.timer);
this.timer = null;
}
}
}
/* harmony default export */ var abstract_timer = (Timer);
// CONCATENATED MODULE: ./src/core/utils/timers/index.ts
function timers_clearTimeout(timer) {
global.clearTimeout(timer);
}
function timers_clearInterval(timer) {
global.clearInterval(timer);
}
class timers_OneOffTimer extends abstract_timer {
constructor(delay, callback) {
super(setTimeout, timers_clearTimeout, delay, function (timer) {
callback();
return null;
});
}
}
class timers_PeriodicTimer extends abstract_timer {
constructor(delay, callback) {
super(setInterval, timers_clearInterval, delay, function (timer) {
callback();
return timer;
});
}
}
// CONCATENATED MODULE: ./src/core/util.ts
var Util = {
now() {
if (Date.now) {
return Date.now();
}
else {
return new Date().valueOf();
}
},
defer(callback) {
return new timers_OneOffTimer(0, callback);
},
method(name, ...args) {
var boundArguments = Array.prototype.slice.call(arguments, 1);
return function (object) {
return object[name].apply(object, boundArguments.concat(arguments));
};
}
};
/* harmony default export */ var util = (Util);
// CONCATENATED MODULE: ./src/core/utils/collections.ts
function extend(target, ...sources) {
for (var i = 0; i < sources.length; i++) {
var extensions = sources[i];
for (var property in extensions) {
if (extensions[property] &&
extensions[property].constructor &&
extensions[property].constructor === Object) {
target[property] = extend(target[property] || {}, extensions[property]);
}
else {
target[property] = extensions[property];
}
}
}
return target;
}
function stringify() {
var m = ['Pusher'];
for (var i = 0; i < arguments.length; i++) {
if (typeof arguments[i] === 'string') {
m.push(arguments[i]);
}
else {
m.push(safeJSONStringify(arguments[i]));
}
}
return m.join(' : ');
}
function arrayIndexOf(array, item) {
var nativeIndexOf = Array.prototype.indexOf;
if (array === null) {
return -1;
}
if (nativeIndexOf && array.indexOf === nativeIndexOf) {
return array.indexOf(item);
}
for (var i = 0, l = array.length; i < l; i++) {
if (array[i] === item) {
return i;
}
}
return -1;
}
function objectApply(object, f) {
for (var key in object) {
if (Object.prototype.hasOwnProperty.call(object, key)) {
f(object[key], key, object);
}
}
}
function keys(object) {
var keys = [];
objectApply(object, function (_, key) {
keys.push(key);
});
return keys;
}
function values(object) {
var values = [];
objectApply(object, function (value) {
values.push(value);
});
return values;
}
function apply(array, f, context) {
for (var i = 0; i < array.length; i++) {
f.call(context || global, array[i], i, array);
}
}
function map(array, f) {
var result = [];
for (var i = 0; i < array.length; i++) {
result.push(f(array[i], i, array, result));
}
return result;
}
function mapObject(object, f) {
var result = {};
objectApply(object, function (value, key) {
result[key] = f(value);
});
return result;
}
function filter(array, test) {
test =
test ||
function (value) {
return !!value;
};
var result = [];
for (var i = 0; i < array.length; i++) {
if (test(array[i], i, array, result)) {
result.push(array[i]);
}
}
return result;
}
function filterObject(object, test) {
var result = {};
objectApply(object, function (value, key) {
if ((test && test(value, key, object, result)) || Boolean(value)) {
result[key] = value;
}
});
return result;
}
function flatten(object) {
var result = [];
objectApply(object, function (value, key) {
result.push([key, value]);
});
return result;
}
function any(array, test) {
for (var i = 0; i < array.length; i++) {
if (test(array[i], i, array)) {
return true;
}
}
return false;
}
function collections_all(array, test) {
for (var i = 0; i < array.length; i++) {
if (!test(array[i], i, array)) {
return false;
}
}
return true;
}
function encodeParamsObject(data) {
return mapObject(data, function (value) {
if (typeof value === 'object') {
value = safeJSONStringify(value);
}
return encodeURIComponent(encode(value.toString()));
});
}
function buildQueryString(data) {
var params = filterObject(data, function (value) {
return value !== undefined;
});
var query = map(flatten(encodeParamsObject(params)), util.method('join', '=')).join('&');
return query;
}
function decycleObject(object) {
var objects = [], paths = [];
return (function derez(value, path) {
var i, name, nu;
switch (typeof value) {
case 'object':
if (!value) {
return null;
}
for (i = 0; i < objects.length; i += 1) {
if (objects[i] === value) {
return { $ref: paths[i] };
}
}
objects.push(value);
paths.push(path);
if (Object.prototype.toString.apply(value) === '[object Array]') {
nu = [];
for (i = 0; i < value.length; i += 1) {
nu[i] = derez(value[i], path + '[' + i + ']');
}
}
else {
nu = {};
for (name in value) {
if (Object.prototype.hasOwnProperty.call(value, name)) {
nu[name] = derez(value[name], path + '[' + JSON.stringify(name) + ']');
}
}
}
return nu;
case 'number':
case 'string':
case 'boolean':
return value;
}
})(object, '$');
}
function safeJSONStringify(source) {
try {
return JSON.stringify(source);
}
catch (e) {
return JSON.stringify(decycleObject(source));
}
}
// CONCATENATED MODULE: ./src/core/defaults.ts
var Defaults = {
VERSION: "8.4.0-rc2",
PROTOCOL: 7,
wsPort: 80,
wssPort: 443,
wsPath: '',
httpHost: 'sockjs.pusher.com',
httpPort: 80,
httpsPort: 443,
httpPath: '/pusher',
stats_host: 'stats.pusher.com',
authEndpoint: '/pusher/auth',
authTransport: 'ajax',
activityTimeout: 120000,
pongTimeout: 30000,
unavailableTimeout: 10000,
userAuthentication: {
endpoint: '/pusher/user-auth',
transport: 'ajax'
},
channelAuthorization: {
endpoint: '/pusher/auth',
transport: 'ajax'
},
cdn_http: "http://js.pusher.com",
cdn_https: "https://js.pusher.com",
dependency_suffix: ""
};
/* harmony default export */ var defaults = (Defaults);
// CONCATENATED MODULE: ./src/core/transports/url_schemes.ts
function getGenericURL(baseScheme, params, path) {
var scheme = baseScheme + (params.useTLS ? 's' : '');
var host = params.useTLS ? params.hostTLS : params.hostNonTLS;
return scheme + '://' + host + path;
}
function getGenericPath(key, queryString) {
var path = '/app/' + key;
var query = '?protocol=' +
defaults.PROTOCOL +
'&client=js' +
'&version=' +
defaults.VERSION +
(queryString ? '&' + queryString : '');
return path + query;
}
var ws = {
getInitial: function (key, params) {
var path = (params.httpPath || '') + getGenericPath(key, 'flash=false');
return getGenericURL('ws', params, path);
}
};
var http = {
getInitial: function (key, params) {
var path = (params.httpPath || '/pusher') + getGenericPath(key);
return getGenericURL('http', params, path);
}
};
var sockjs = {
getInitial: function (key, params) {
return getGenericURL('http', params, params.httpPath || '/pusher');
},
getPath: function (key, params) {
return getGenericPath(key);
}
};
// CONCATENATED MODULE: ./src/core/events/callback_registry.ts
class callback_registry_CallbackRegistry {
constructor() {
this._callbacks = {};
}
get(name) {
return this._callbacks[prefix(name)];
}
add(name, callback, context) {
var prefixedEventName = prefix(name);
this._callbacks[prefixedEventName] =
this._callbacks[prefixedEventName] || [];
this._callbacks[prefixedEventName].push({
fn: callback,
context: context
});
}
remove(name, callback, context) {
if (!name && !callback && !context) {
this._callbacks = {};
return;
}
var names = name ? [prefix(name)] : keys(this._callbacks);
if (callback || context) {
this.removeCallback(names, callback, context);
}
else {
this.removeAllCallbacks(names);
}
}
removeCallback(names, callback, context) {
apply(names, function (name) {
this._callbacks[name] = filter(this._callbacks[name] || [], function (binding) {
return ((callback && callback !== binding.fn) ||
(context && context !== binding.context));
});
if (this._callbacks[name].length === 0) {
delete this._callbacks[name];
}
}, this);
}
removeAllCallbacks(names) {
apply(names, function (name) {
delete this._callbacks[name];
}, this);
}
}
function prefix(name) {
return '_' + name;
}
// CONCATENATED MODULE: ./src/core/events/dispatcher.ts
class dispatcher_Dispatcher {
constructor(failThrough) {
this.callbacks = new callback_registry_CallbackRegistry();
this.global_callbacks = [];
this.failThrough = failThrough;
}
bind(eventName, callback, context) {
this.callbacks.add(eventName, callback, context);
return this;
}
bind_global(callback) {
this.global_callbacks.push(callback);
return this;
}
unbind(eventName, callback, context) {
this.callbacks.remove(eventName, callback, context);
return this;
}
unbind_global(callback) {
if (!callback) {
this.global_callbacks = [];
return this;
}
this.global_callbacks = filter(this.global_callbacks || [], c => c !== callback);
return this;
}
unbind_all() {
this.unbind();
this.unbind_global();
return this;
}
emit(eventName, data, metadata) {
for (var i = 0; i < this.global_callbacks.length; i++) {
this.global_callbacks[i](eventName, data);
}
var callbacks = this.callbacks.get(eventName);
var args = [];
if (metadata) {
args.push(data, metadata);
}
else if (data) {
args.push(data);
}
if (callbacks && callbacks.length > 0) {
for (var i = 0; i < callbacks.length; i++) {
callbacks[i].fn.apply(callbacks[i].context || global, args);
}
}
else if (this.failThrough) {
this.failThrough(eventName, data);
}
return this;
}
}
// CONCATENATED MODULE: ./src/core/logger.ts
class logger_Logger {
constructor() {
this.globalLog = (message) => {
if (global.console && global.console.log) {
global.console.log(message);
}
};
}
debug(...args) {
this.log(this.globalLog, args);
}
warn(...args) {
this.log(this.globalLogWarn, args);
}
error(...args) {
this.log(this.globalLogError, args);
}
globalLogWarn(message) {
if (global.console && global.console.warn) {
global.console.warn(message);
}
else {
this.globalLog(message);
}
}
globalLogError(message) {
if (global.console && global.console.error) {
global.console.error(message);
}
else {
this.globalLogWarn(message);
}
}
log(defaultLoggingFunction, ...args) {
var message = stringify.apply(this, arguments);
if (core_pusher.log) {
core_pusher.log(message);
}
else if (core_pusher.logToConsole) {
const log = defaultLoggingFunction.bind(this);
log(message);
}
}
}
/* harmony default export */ var logger = (new logger_Logger());
// CONCATENATED MODULE: ./src/core/transports/transport_connection.ts
class transport_connection_TransportConnection extends dispatcher_Dispatcher {
constructor(hooks, name, priority, key, options) {
super();
this.initialize = node_runtime.transportConnectionInitializer;
this.hooks = hooks;
this.name = name;
this.priority = priority;
this.key = key;
this.options = options;
this.state = 'new';
this.timeline = options.timeline;
this.activityTimeout = options.activityTimeout;
this.id = this.timeline.generateUniqueID();
}
handlesActivityChecks() {
return Boolean(this.hooks.handlesActivityChecks);
}
supportsPing() {
return Boolean(this.hooks.supportsPing);
}
connect() {
if (this.socket || this.state !== 'initialized') {
return false;
}
var url = this.hooks.urls.getInitial(this.key, this.options);
try {
this.socket = this.hooks.getSocket(url, this.options);
}
catch (e) {
util.defer(() => {
this.onError(e);
this.changeState('closed');
});
return false;
}
this.bindListeners();
logger.debug('Connecting', { transport: this.name, url });
this.changeState('connecting');
return true;
}
close() {
if (this.socket) {
this.socket.close();
return true;
}
else {
return false;
}
}
send(data) {
if (this.state === 'open') {
util.defer(() => {
if (this.socket) {
this.socket.send(data);
}
});
return true;
}
else {
return false;
}
}
ping() {
if (this.state === 'open' && this.supportsPing()) {
this.socket.ping();
}
}
onOpen() {
if (this.hooks.beforeOpen) {
this.hooks.beforeOpen(this.socket, this.hooks.urls.getPath(this.key, this.options));
}
this.changeState('open');
this.socket.onopen = undefined;
}
onError(error) {
this.emit('error', { type: 'WebSocketError', error: error });
this.timeline.error(this.buildTimelineMessage({ error: error.toString() }));
}
onClose(closeEvent) {
if (closeEvent) {
this.changeState('closed', {
code: closeEvent.code,
reason: closeEvent.reason,
wasClean: closeEvent.wasClean
});
}
else {
this.changeState('closed');
}
this.unbindListeners();
this.socket = undefined;
}
onMessage(message) {
this.emit('message', message);
}
onActivity() {
this.emit('activity');
}
bindListeners() {
this.socket.onopen = () => {
this.onOpen();
};
this.socket.onerror = error => {
this.onError(error);
};
this.socket.onclose = closeEvent => {
this.onClose(closeEvent);
};
this.socket.onmessage = message => {
this.onMessage(message);
};
if (this.supportsPing()) {
this.socket.onactivity = () => {
this.onActivity();
};
}
}
unbindListeners() {
if (this.socket) {
this.socket.onopen = undefined;
this.socket.onerror = undefined;
this.socket.onclose = undefined;
this.socket.onmessage = undefined;
if (this.supportsPing()) {
this.socket.onactivity = undefined;
}
}
}
changeState(state, params) {
this.state = state;
this.timeline.info(this.buildTimelineMessage({
state: state,
params: params
}));
this.emit(state, params);
}
buildTimelineMessage(message) {
return extend({ cid: this.id }, message);
}
}
// CONCATENATED MODULE: ./src/core/transports/transport.ts
class transport_Transport {
constructor(hooks) {
this.hooks = hooks;
}
isSupported(environment) {
return this.hooks.isSupported(environment);
}
createConnection(name, priority, key, options) {
return new transport_connection_TransportConnection(this.hooks, name, priority, key, options);
}
}
// CONCATENATED MODULE: ./src/runtimes/isomorphic/transports/transports.ts
var WSTransport = new transport_Transport({
urls: ws,
handlesActivityChecks: false,
supportsPing: false,
isInitialized: function () {
return Boolean(node_runtime.getWebSocketAPI());
},
isSupported: function () {
return Boolean(node_runtime.getWebSocketAPI());
},
getSocket: function (url) {
return node_runtime.createWebSocket(url);
}
});
var httpConfiguration = {
urls: http,
handlesActivityChecks: false,
supportsPing: true,
isInitialized: function () {
return true;
}
};
var streamingConfiguration = extend({
getSocket: function (url) {
return node_runtime.HTTPFactory.createStreamingSocket(url);
}
}, httpConfiguration);
var pollingConfiguration = extend({
getSocket: function (url) {
return node_runtime.HTTPFactory.createPollingSocket(url);
}
}, httpConfiguration);
var xhrConfiguration = {
isSupported: function () {
return node_runtime.isXHRSupported();
}
};
var XHRStreamingTransport = new transport_Transport((extend({}, streamingConfiguration, xhrConfiguration)));
var XHRPollingTransport = new transport_Transport(extend({}, pollingConfiguration, xhrConfiguration));
var Transports = {
ws: WSTransport,
xhr_streaming: XHRStreamingTransport,
xhr_polling: XHRPollingTransport
};
/* harmony default export */ var transports = (Transports);
// CONCATENATED MODULE: ./src/core/transports/assistant_to_the_transport_manager.ts
class assistant_to_the_transport_manager_AssistantToTheTransportManager {
constructor(manager, transport, options) {
this.manager = manager;
this.transport = transport;
this.minPingDelay = options.minPingDelay;
this.maxPingDelay = options.maxPingDelay;
this.pingDelay = undefined;
}
createConnection(name, priority, key, options) {
options = extend({}, options, {
activityTimeout: this.pingDelay
});
var connection = this.transport.createConnection(name, priority, key, options);
var openTimestamp = null;
var onOpen = function () {
connection.unbind('open', onOpen);
connection.bind('closed', onClosed);
openTimestamp = util.now();
};
var onClosed = closeEvent => {
connection.unbind('closed', onClosed);
if (closeEvent.code === 1002 || closeEvent.code === 1003) {
this.manager.reportDeath();
}
else if (!closeEvent.wasClean && openTimestamp) {
var lifespan = util.now() - openTimestamp;
if (lifespan < 2 * this.maxPingDelay) {
this.manager.reportDeath();
this.pingDelay = Math.max(lifespan / 2, this.minPingDelay);
}
}
};
connection.bind('open', onOpen);
return connection;
}
isSupported(environment) {
return this.manager.isAlive() && this.transport.isSupported(environment);
}
}
// CONCATENATED MODULE: ./src/core/connection/protocol/protocol.ts
const Protocol = {
decodeMessage: function (messageEvent) {
try {
var messageData = JSON.parse(messageEvent.data);
var pusherEventData = messageData.data;
if (typeof pusherEventData === 'string') {
try {
pusherEventData = JSON.parse(messageData.data);
}
catch (e) { }
}
var pusherEvent = {
event: messageData.event,
channel: messageData.channel,
data: pusherEventData
};
if (messageData.user_id) {
pusherEvent.user_id = messageData.user_id;
}
return pusherEvent;
}
catch (e) {
throw { type: 'MessageParseError', error: e, data: messageEvent.data };
}
},
encodeMessage: function (event) {
return JSON.stringify(event);
},
processHandshake: function (messageEvent) {
var message = Protocol.decodeMessage(messageEvent);
if (message.event === 'pusher:connection_established') {
if (!message.data.activity_timeout) {
throw 'No activity timeout specified in handshake';
}
return {
action: 'connected',
id: message.data.socket_id,
activityTimeout: message.data.activity_timeout * 1000
};
}
else if (message.event === 'pusher:error') {
return {
action: this.getCloseAction(message.data),
error: this.getCloseError(message.data)
};
}
else {
throw 'Invalid handshake';
}
},
getCloseAction: function (closeEvent) {
if (closeEvent.code < 4000) {
if (closeEvent.code >= 1002 && closeEvent.code <= 1004) {
return 'backoff';
}
else {
return null;
}
}
else if (closeEvent.code === 4000) {
return 'tls_only';
}
else if (closeEvent.code < 4100) {
return 'refused';
}
else if (closeEvent.code < 4200) {
return 'backoff';
}
else if (closeEvent.code < 4300) {
return 'retry';
}
else {
return 'refused';
}
},
getCloseError: function (closeEvent) {
if (closeEvent.code !== 1000 && closeEvent.code !== 1001) {
return {
type: 'PusherError',
data: {
code: closeEvent.code,
message: closeEvent.reason || closeEvent.message
}
};
}
else {
return null;
}
}
};
/* harmony default export */ var protocol = (Protocol);
// CONCATENATED MODULE: ./src/core/connection/connection.ts
class connection_Connection extends dispatcher_Dispatcher {
constructor(id, transport) {
super();
this.id = id;
this.transport = transport;
this.activityTimeout = transport.activityTimeout;
this.bindListeners();
}
handlesActivityChecks() {
return this.transport.handlesActivityChecks();
}
send(data) {
return this.transport.send(data);
}
send_event(name, data, channel) {
var event = { event: name, data: data };
if (channel) {
event.channel = channel;
}
logger.debug('Event sent', event);
return this.send(protocol.encodeMessage(event));
}
ping() {
if (this.transport.supportsPing()) {
this.transport.ping();
}
else {
this.send_event('pusher:ping', {});
}
}
close() {
this.transport.close();
}
bindListeners() {
var listeners = {
message: (messageEvent) => {
var pusherEvent;
try {
pusherEvent = protocol.decodeMessage(messageEvent);
}
catch (e) {
this.emit('error', {
type: 'MessageParseError',
error: e,
data: messageEvent.data
});
}
if (pusherEvent !== undefined) {
logger.debug('Event recd', pusherEvent);
switch (pusherEvent.event) {
case 'pusher:error':
this.emit('error', {
type: 'PusherError',
data: pusherEvent.data
});
break;
case 'pusher:ping':
this.emit('ping');
break;
case 'pusher:pong':
this.emit('pong');
break;
}
this.emit('message', pusherEvent);
}
},
activity: () => {
this.emit('activity');
},
error: error => {
this.emit('error', error);
},
closed: closeEvent => {
unbindListeners();
if (closeEvent && closeEvent.code) {
this.handleCloseEvent(closeEvent);
}
this.transport = null;
this.emit('closed');
}
};
var unbindListeners = () => {
objectApply(listeners, (listener, event) => {
this.transport.unbind(event, listener);
});
};
objectApply(listeners, (listener, event) => {
this.transport.bind(event, listener);
});
}
handleCloseEvent(closeEvent) {
var action = protocol.getCloseAction(closeEvent);
var error = protocol.getCloseError(closeEvent);
if (error) {
this.emit('error', error);
}
if (action) {
this.emit(action, { action: action, error: error });
}
}
}
// CONCATENATED MODULE: ./src/core/connection/handshake/index.ts
class handshake_Handshake {
constructor(transport, callback) {
this.transport = transport;
this.callback = callback;
this.bindListeners();
}
close() {
this.unbindListeners();
this.transport.close();
}
bindListeners() {
this.onMessage = m => {
this.unbindListeners();
var result;
try {
result = protocol.processHandshake(m);
}
catch (e) {
this.finish('error', { error: e });
this.transport.close();
return;
}
if (result.action === 'connected') {
this.finish('connected', {
connection: new connection_Connection(result.id, this.transport),
activityTimeout: result.activityTimeout
});
}
else {
this.finish(result.action, { error: result.error });
this.transport.close();
}
};
this.onClosed = closeEvent => {
this.unbindListeners();
var action = protocol.getCloseAction(closeEvent) || 'backoff';
var error = protocol.getCloseError(closeEvent);
this.finish(action, { error: error });
};
this.transport.bind('message', this.onMessage);
this.transport.bind('closed', this.onClosed);
}
unbindListeners() {
this.transport.unbind('message', this.onMessage);
this.transport.unbind('closed', this.onClosed);
}
finish(action, params) {
this.callback(extend({ transport: this.transport, action: action }, params));
}
}
// CONCATENATED MODULE: ./src/core/timeline/timeline_sender.ts
class timeline_sender_TimelineSender {
constructor(timeline, options) {
this.timeline = timeline;
this.options = options || {};
}
send(useTLS, callback) {
if (this.timeline.isEmpty()) {
return;
}
this.timeline.send(node_runtime.TimelineTransport.getAgent(this, useTLS), callback);
}
}
// CONCATENATED MODULE: ./src/core/errors.ts
class BadEventName extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class BadChannelName extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class RequestTimedOut extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class TransportPriorityTooLow extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class TransportClosed extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class UnsupportedFeature extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class UnsupportedTransport extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class UnsupportedStrategy extends Error {
constructor(msg) {
super(msg);
Object.setPrototypeOf(this, new.target.prototype);
}
}
class HTTPAuthError extends Error {
constructor(status, msg) {
super(msg);
this.status = status;
Object.setPrototypeOf(this, new.target.prototype);
}
}
// CONCATENATED MODULE: ./src/core/utils/url_store.ts
const urlStore = {
baseUrl: 'https://pusher.com',
urls: {
authenticationEndpoint: {
path: '/docs/channels/server_api/authenticating_users'
},
authorizationEndpoint: {
path: '/docs/channels/server_api/authorizing-users/'
},
javascriptQuickStart: {
path: '/docs/javascript_quick_start'
},
triggeringClientEvents: {
path: '/docs/client_api_guide/client_events#trigger-events'
},
encryptedChannelSupport: {
fullUrl: 'https://github.com/pusher/pusher-js/tree/cc491015371a4bde5743d1c87a0fbac0feb53195#encrypted-channel-support'
}
}
};
const buildLogSuffix = function (key) {
const urlPrefix = 'See:';
const urlObj = urlStore.urls[key];
if (!urlObj)
return '';
let url;
if (urlObj.fullUrl) {
url = urlObj.fullUrl;
}
else if (urlObj.path) {
url = urlStore.baseUrl + urlObj.path;
}
if (!url)
return '';
return `${urlPrefix} ${url}`;
};
/* harmony default export */ var url_store = ({ buildLogSuffix });
// CONCATENATED MODULE: ./src/core/channels/channel.ts
class channel_Channel extends dispatcher_Dispatcher {
constructor(name, pusher) {
super(function (event, data) {
logger.debug('No callbacks on ' + name + ' for ' + event);
});
this.name = name;
this.pusher = pusher;
this.subscribed = false;
this.subscriptionPending = false;
this.subscriptionCancelled = false;
}
authorize(socketId, callback) {
return callback(null, { auth: '' });
}
trigger(event, data) {
if (event.indexOf('client-') !== 0) {
throw new BadEventName("Event '" + event + "' does not start with 'client-'");
}
if (!this.subscribed) {
var suffix = url_store.buildLogSuffix('triggeringClientEvents');
logger.warn(`Client event triggered before channel 'subscription_succeeded' event . ${suffix}`);
}
return this.pusher.send_event(event, data, this.name);
}
disconnect() {
this.subscribed = false;
this.subscriptionPending = false;
}
handleEvent(event) {
var eventName = event.event;
var data = event.data;
if (eventName === 'pusher_internal:subscription_succeeded') {
this.handleSubscriptionSucceededEvent(event);
}
else if (eventName === 'pusher_internal:subscription_count') {
this.handleSubscriptionCountEvent(event);
}
else if (eventName.indexOf('pusher_internal:') !== 0) {
var metadata = {};
this.emit(eventName, data, metadata);
}
}
handleSubscriptionSucceededEvent(event) {
this.subscriptionPending = false;
this.subscribed = true;
if (this.subscriptionCancelled) {
this.pusher.unsubscribe(this.name);
}
else {
this.emit('pusher:subscription_succeeded', event.data);
}
}
handleSubscriptionCountEvent(event) {
if (event.data.subscription_count) {
this.subscriptionCount = event.data.subscription_count;
}
this.emit('pusher:subscription_count', event.data);
}
subscribe() {
if (this.subscribed) {
return;
}
this.subscriptionPending = true;
this.subscriptionCancelled = false;
this.authorize(this.pusher.connection.socket_id, (error, data) => {
if (error) {
this.subscriptionPending = false;
logger.error(error.toString());
this.emit('pusher:subscription_error', Object.assign({}, {
type: 'AuthError',
error: error.message
}, error instanceof HTTPAuthError ? { status: error.status } : {}));
}
else {
this.pusher.send_event('pusher:subscribe', {
auth: data.auth,
channel_data: data.channel_data,
channel: this.name
});
}
});
}
unsubscribe() {
this.subscribed = false;
this.pusher.send_event('pusher:unsubscribe', {
channel: this.name
});
}
cancelSubscription() {
this.subscriptionCancelled = true;
}
reinstateSubscription() {
this.subscriptionCancelled = false;
}
}
// CONCATENATED MODULE: ./src/core/channels/private_channel.ts
class private_channel_PrivateChannel extends channel_Channel {
authorize(socketId, callback) {
return this.pusher.config.channelAuthorizer({
channelName: this.name,
socketId: socketId
}, callback);
}
}
// CONCATENATED MODULE: ./src/core/channels/members.ts
class members_Members {
constructor() {
this.reset();
}
get(id) {
if (Object.prototype.hasOwnProperty.call(this.members, id)) {
return {
id: id,
info: this.members[id]
};
}
else {
return null;
}
}
each(callback) {
objectApply(this.members, (member, id) => {
callback(this.get(id));
});
}
setMyID(id) {
this.myID = id;
}
onSubscription(subscriptionData) {
this.members = subscriptionData.presence.hash;
this.count = subscriptionData.presence.count;
this.me = this.get(this.myID);
}
addMember(memberData) {
if (this.get(memberData.user_id) === null) {
this.count++;
}
this.members[memberData.user_id] = memberData.user_info;
return this.get(memberData.user_id);
}
removeMember(memberData) {
var member = this.get(memberData.user_id);
if (member) {
delete this.members[memberData.user_id];
this.count--;
}
return member;
}
reset() {
this.members = {};
this.count = 0;
this.myID = null;
this.me = null;
}
}
// CONCATENATED MODULE: ./src/core/channels/presence_channel.ts
var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
class presence_channel_PresenceChannel extends private_channel_PrivateChannel {
constructor(name, pusher) {
super(name, pusher);
this.members = new members_Members();
}
authorize(socketId, callback) {
super.authorize(socketId, (error, authData) => __awaiter(this, void 0, void 0, function* () {
if (!error) {
authData = authData;
if (authData.channel_data != null) {
var channelData = JSON.parse(authData.channel_data);
this.members.setMyID(channelData.user_id);
}
else {
yield this.pusher.user.signinDonePromise;
if (this.pusher.user.user_data != null) {
this.members.setMyID(this.pusher.user.user_data.id);
}
else {
let suffix = url_store.buildLogSuffix('authorizationEndpoint');
logger.error(`Invalid auth response for channel '${this.name}', ` +
`expected 'channel_data' field. ${suffix}, ` +
`or the user should be signed in.`);
callback('Invalid auth response');
return;
}
}
}
callback(error, authData);
}));
}
handleEvent(event) {
var eventName = event.event;
if (eventName.indexOf('pusher_internal:') === 0) {
this.handleInternalEvent(event);
}
else {
var data = event.data;
var metadata = {};
if (event.user_id) {
metadata.user_id = event.user_id;
}
this.emit(eventName, data, metadata);
}
}
handleInternalEvent(event) {
var eventName = event.event;
var data = event.data;
switch (eventName) {
case 'pusher_internal:subscription_succeeded':
this.handleSubscriptionSucceededEvent(event);
break;
case 'pusher_internal:subscription_count':
this.handleSubscriptionCountEvent(event);
break;
case 'pusher_internal:member_added':
var addedMember = this.members.addMember(data);
this.emit('pusher:member_added', addedMember);
break;
case 'pusher_internal:member_removed':
var removedMember = this.members.removeMember(data);
if (removedMember) {
this.emit('pusher:member_removed', removedMember);
}
break;
}
}
handleSubscriptionSucceededEvent(event) {
this.subscriptionPending = false;
this.subscribed = true;
if (this.subscriptionCancelled) {
this.pusher.unsubscribe(this.name);
}
else {
this.members.onSubscription(event.data);
this.emit('pusher:subscription_succeeded', this.members);
}
}
disconnect() {
this.members.reset();
super.disconnect();
}
}
// EXTERNAL MODULE: ./node_modules/@stablelib/utf8/lib/utf8.js
var utf8 = __webpack_require__(17);
// EXTERNAL MODULE: ./node_modules/@stablelib/base64/lib/base64.js
var base64 = __webpack_require__(8);
// CONCATENATED MODULE: ./src/core/channels/encrypted_channel.ts
class encrypted_channel_EncryptedChannel extends private_channel_PrivateChannel {
constructor(name, pusher, nacl) {
super(name, pusher);
this.key = null;
this.nacl = nacl;
}
authorize(socketId, callback) {
super.authorize(socketId, (error, authData) => {
if (error) {
callback(error, authData);
return;
}
let sharedSecret = authData['shared_secret'];
if (!sharedSecret) {
callback(new Error(`No shared_secret key in auth payload for encrypted channel: ${this.name}`), null);
return;
}
this.key = Object(base64["decode"])(sharedSecret);
delete authData['shared_secret'];
callback(null, authData);
});
}
trigger(event, data) {
throw new UnsupportedFeature('Client events are not currently supported for encrypted channels');
}
handleEvent(event) {
var eventName = event.event;
var data = event.data;
if (eventName.indexOf('pusher_internal:') === 0 ||
eventName.indexOf('pusher:') === 0) {
super.handleEvent(event);
return;
}
this.handleEncryptedEvent(eventName, data);
}
handleEncryptedEvent(event, data) {
if (!this.key) {
logger.debug('Received encrypted event before key has been retrieved from the authEndpoint');
return;
}
if (!data.ciphertext || !data.nonce) {
logger.error('Unexpected format for encrypted event, expected object with `ciphertext` and `nonce` fields, got: ' +
data);
return;
}
let cipherText = Object(base64["decode"])(data.ciphertext);
if (cipherText.length < this.nacl.secretbox.overheadLength) {
logger.error(`Expected encrypted event ciphertext length to be ${this.nacl.secretbox.overheadLength}, got: ${cipherText.length}`);
return;
}
let nonce = Object(base64["decode"])(data.nonce);
if (nonce.length < this.nacl.secretbox.nonceLength) {
logger.error(`Expected encrypted event nonce length to be ${this.nacl.secretbox.nonceLength}, got: ${nonce.length}`);
return;
}
let bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
if (bytes === null) {
logger.debug('Failed to decrypt an event, probably because it was encrypted with a different key. Fetching a new key from the authEndpoint...');
this.authorize(this.pusher.connection.socket_id, (error, authData) => {
if (error) {
logger.error(`Failed to make a request to the authEndpoint: ${authData}. Unable to fetch new key, so dropping encrypted event`);
return;
}
bytes = this.nacl.secretbox.open(cipherText, nonce, this.key);
if (bytes === null) {
logger.error(`Failed to decrypt event with new key. Dropping encrypted event`);
return;
}
this.emit(event, this.getDataToEmit(bytes));
return;
});
return;
}
this.emit(event, this.getDataToEmit(bytes));
}
getDataToEmit(bytes) {
let raw = Object(utf8["decode"])(bytes);
try {
return JSON.parse(raw);
}
catch (_a) {
return raw;
}
}
}
// CONCATENATED MODULE: ./src/core/connection/connection_manager.ts
class connection_manager_ConnectionManager extends dispatcher_Dispatcher {
constructor(key, options) {
super();
this.state = 'initialized';
this.connection = null;
this.key = key;
this.options = options;
this.timeline = this.options.timeline;
this.usingTLS = this.options.useTLS;
this.errorCallbacks = this.buildErrorCallbacks();
this.connectionCallbacks = this.buildConnectionCallbacks(this.errorCallbacks);
this.handshakeCallbacks = this.buildHandshakeCallbacks(this.errorCallbacks);
var Network = node_runtime.getNetwork();
Network.bind('online', () => {
this.timeline.info({ netinfo: 'online' });
if (this.state === 'connecting' || this.state === 'unavailable') {
this.retryIn(0);
}
});
Network.bind('offline', () => {
this.timeline.info({ netinfo: 'offline' });
if (this.connection) {
this.sendActivityCheck();
}
});
this.updateStrategy();
}
switchCluster(key) {
this.key = key;
this.updateStrategy();
this.retryIn(0);
}
connect() {
if (this.connection || this.runner) {
return;
}
if (!this.strategy.isSupported()) {
this.updateState('failed');
return;
}
this.updateState('connecting');
this.startConnecting();
this.setUnavailableTimer();
}
send(data) {
if (this.connection) {
return this.connection.send(data);
}
else {
return false;
}
}
send_event(name, data, channel) {
if (this.connection) {
return this.connection.send_event(name, data, channel);
}
else {
return false;
}
}
disconnect() {
this.disconnectInternally();
this.updateState('disconnected');
}
isUsingTLS() {
return this.usingTLS;
}
startConnecting() {
var callback = (error, handshake) => {
if (error) {
this.runner = this.strategy.connect(0, callback);
}
else {
if (handshake.action === 'error') {
this.emit('error', {
type: 'HandshakeError',
error: handshake.error
});
this.timeline.error({ handshakeError: handshake.error });
}
else {
this.abortConnecting();
this.handshakeCallbacks[handshake.action](handshake);
}
}
};
this.runner = this.strategy.connect(0, callback);
}
abortConnecting() {
if (this.runner) {
this.runner.abort();
this.runner = null;
}
}
disconnectInternally() {
this.abortConnecting();
this.clearRetryTimer();
this.clearUnavailableTimer();
if (this.connection) {
var connection = this.abandonConnection();
connection.close();
}
}
updateStrategy() {
this.strategy = this.options.getStrategy({
key: this.key,
timeline: this.timeline,
useTLS: this.usingTLS
});
}
retryIn(delay) {
this.timeline.info({ action: 'retry', delay: delay });
if (delay > 0) {
this.emit('connecting_in', Math.round(delay / 1000));
}
this.retryTimer = new timers_OneOffTimer(delay || 0, () => {
this.disconnectInternally();
this.connect();
});
}
clearRetryTimer() {
if (this.retryTimer) {
this.retryTimer.ensureAborted();
this.retryTimer = null;
}
}
setUnavailableTimer() {
this.unavailableTimer = new timers_OneOffTimer(this.options.unavailableTimeout, () => {
this.updateState('unavailable');
});
}
clearUnavailableTimer() {
if (this.unavailableTimer) {
this.unavailableTimer.ensureAborted();
}
}
sendActivityCheck() {
this.stopActivityCheck();
this.connection.ping();
this.activityTimer = new timers_OneOffTimer(this.options.pongTimeout, () => {
this.timeline.error({ pong_timed_out: this.options.pongTimeout });
this.retryIn(0);
});
}
resetActivityCheck() {
this.stopActivityCheck();
if (this.connection && !this.connection.handlesActivityChecks()) {
this.activityTimer = new timers_OneOffTimer(this.activityTimeout, () => {
this.sendActivityCheck();
});
}
}
stopActivityCheck() {
if (this.activityTimer) {
this.activityTimer.ensureAborted();
}
}
buildConnectionCallbacks(errorCallbacks) {
return extend({}, errorCallbacks, {
message: message => {
this.resetActivityCheck();
this.emit('message', message);
},
ping: () => {
this.send_event('pusher:pong', {});
},
activity: () => {
this.resetActivityCheck();
},
error: error => {
this.emit('error', error);
},
closed: () => {
this.abandonConnection();
if (this.shouldRetry()) {
this.retryIn(1000);
}
}
});
}
buildHandshakeCallbacks(errorCallbacks) {
return extend({}, errorCallbacks, {
connected: (handshake) => {
this.activityTimeout = Math.min(this.options.activityTimeout, handshake.activityTimeout, handshake.connection.activityTimeout || Infinity);
this.clearUnavailableTimer();
this.setConnection(handshake.connection);
this.socket_id = this.connection.id;
this.updateState('connected', { socket_id: this.socket_id });
}
});
}
buildErrorCallbacks() {
let withErrorEmitted = callback => {
return (result) => {
if (result.error) {
this.emit('error', { type: 'WebSocketError', error: result.error });
}
callback(result);
};
};
return {
tls_only: withErrorEmitted(() => {
this.usingTLS = true;
this.updateStrategy();
this.retryIn(0);
}),
refused: withErrorEmitted(() => {
this.disconnect();
}),
backoff: withErrorEmitted(() => {
this.retryIn(1000);
}),
retry: withErrorEmitted(() => {
this.retryIn(0);
})
};
}
setConnection(connection) {
this.connection = connection;
for (var event in this.connectionCallbacks) {
this.connection.bind(event, this.connectionCallbacks[event]);
}
this.resetActivityCheck();
}
abandonConnection() {
if (!this.connection) {
return;
}
this.stopActivityCheck();
for (var event in this.connectionCallbacks) {
this.connection.unbind(event, this.connectionCallbacks[event]);
}
var connection = this.connection;
this.connection = null;
return connection;
}
updateState(newState, data) {
var previousState = this.state;
this.state = newState;
if (previousState !== newState) {
var newStateDescription = newState;
if (newStateDescription === 'connected') {
newStateDescription += ' with new socket ID ' + data.socket_id;
}
logger.debug('State changed', previousState + ' -> ' + newStateDescription);
this.timeline.info({ state: newState, params: data });
this.emit('state_change', { previous: previousState, current: newState });
this.emit(newState, data);
}
}
shouldRetry() {
return this.state === 'connecting' || this.state === 'connected';
}
}
// CONCATENATED MODULE: ./src/core/channels/channels.ts
class channels_Channels {
constructor() {
this.channels = {};
}
add(name, pusher) {
if (!this.channels[name]) {
this.channels[name] = createChannel(name, pusher);
}
return this.channels[name];
}
all() {
return values(this.channels);
}
find(name) {
return this.channels[name];
}
remove(name) {
var channel = this.channels[name];
delete this.channels[name];
return channel;
}
disconnect() {
objectApply(this.channels, function (channel) {
channel.disconnect();
});
}
}
function createChannel(name, pusher) {
if (name.indexOf('private-encrypted-') === 0) {
if (pusher.config.nacl) {
return factory.createEncryptedChannel(name, pusher, pusher.config.nacl);
}
let errMsg = 'Tried to subscribe to a private-encrypted- channel but no nacl implementation available';
let suffix = url_store.buildLogSuffix('encryptedChannelSupport');
throw new UnsupportedFeature(`${errMsg}. ${suffix}`);
}
else if (name.indexOf('private-') === 0) {
return factory.createPrivateChannel(name, pusher);
}
else if (name.indexOf('presence-') === 0) {
return factory.createPresenceChannel(name, pusher);
}
else if (name.indexOf('#') === 0) {
throw new BadChannelName('Cannot create a channel with name "' + name + '".');
}
else {
return factory.createChannel(name, pusher);
}
}
// CONCATENATED MODULE: ./src/core/utils/factory.ts
var Factory = {
createChannels() {
return new channels_Channels();
},
createConnectionManager(key, options) {
return new connection_manager_ConnectionManager(key, options);
},
createChannel(name, pusher) {
return new channel_Channel(name, pusher);
},
createPrivateChannel(name, pusher) {
return new private_channel_PrivateChannel(name, pusher);
},
createPresenceChannel(name, pusher) {
return new presence_channel_PresenceChannel(name, pusher);
},
createEncryptedChannel(name, pusher, nacl) {
return new encrypted_channel_EncryptedChannel(name, pusher, nacl);
},
createTimelineSender(timeline, options) {
return new timeline_sender_TimelineSender(timeline, options);
},
createHandshake(transport, callback) {
return new handshake_Handshake(transport, callback);
},
createAssistantToTheTransportManager(manager, transport, options) {
return new assistant_to_the_transport_manager_AssistantToTheTransportManager(manager, transport, options);
}
};
/* harmony default export */ var factory = (Factory);
// CONCATENATED MODULE: ./src/core/transports/transport_manager.ts
class transport_manager_TransportManager {
constructor(options) {
this.options = options || {};
this.livesLeft = this.options.lives || Infinity;
}
getAssistant(transport) {
return factory.createAssistantToTheTransportManager(this, transport, {
minPingDelay: this.options.minPingDelay,
maxPingDelay: this.options.maxPingDelay
});
}
isAlive() {
return this.livesLeft > 0;
}
reportDeath() {
this.livesLeft -= 1;
}
}
// CONCATENATED MODULE: ./src/core/strategies/sequential_strategy.ts
class sequential_strategy_SequentialStrategy {
constructor(strategies, options) {
this.strategies = strategies;
this.loop = Boolean(options.loop);
this.failFast = Boolean(options.failFast);
this.timeout = options.timeout;
this.timeoutLimit = options.timeoutLimit;
}
isSupported() {
return any(this.strategies, util.method('isSupported'));
}
connect(minPriority, callback) {
var strategies = this.strategies;
var current = 0;
var timeout = this.timeout;
var runner = null;
var tryNextStrategy = (error, handshake) => {
if (handshake) {
callback(null, handshake);
}
else {
current = current + 1;
if (this.loop) {
current = current % strategies.length;
}
if (current < strategies.length) {
if (timeout) {
timeout = timeout * 2;
if (this.timeoutLimit) {
timeout = Math.min(timeout, this.timeoutLimit);
}
}
runner = this.tryStrategy(strategies[current], minPriority, { timeout, failFast: this.failFast }, tryNextStrategy);
}
else {
callback(true);
}
}
};
runner = this.tryStrategy(strategies[current], minPriority, { timeout: timeout, failFast: this.failFast }, tryNextStrategy);
return {
abort: function () {
runner.abort();
},
forceMinPriority: function (p) {
minPriority = p;
if (runner) {
runner.forceMinPriority(p);
}
}
};
}
tryStrategy(strategy, minPriority, options, callback) {
var timer = null;
var runner = null;
if (options.timeout > 0) {
timer = new timers_OneOffTimer(options.timeout, function () {
runner.abort();
callback(true);
});
}
runner = strategy.connect(minPriority, function (error, handshake) {
if (error && timer && timer.isRunning() && !options.failFast) {
return;
}
if (timer) {
timer.ensureAborted();
}
callback(error, handshake);
});
return {
abort: function () {
if (timer) {
timer.ensureAborted();
}
runner.abort();
},
forceMinPriority: function (p) {
runner.forceMinPriority(p);
}
};
}
}
// CONCATENATED MODULE: ./src/core/strategies/best_connected_ever_strategy.ts
class best_connected_ever_strategy_BestConnectedEverStrategy {
constructor(strategies) {
this.strategies = strategies;
}
isSupported() {
return any(this.strategies, util.method('isSupported'));
}
connect(minPriority, callback) {
return connect(this.strategies, minPriority, function (i, runners) {
return function (error, handshake) {
runners[i].error = error;
if (error) {
if (allRunnersFailed(runners)) {
callback(true);
}
return;
}
apply(runners, function (runner) {
runner.forceMinPriority(handshake.transport.priority);
});
callback(null, handshake);
};
});
}
}
function connect(strategies, minPriority, callbackBuilder) {
var runners = map(strategies, function (strategy, i, _, rs) {
return strategy.connect(minPriority, callbackBuilder(i, rs));
});
return {
abort: function () {
apply(runners, abortRunner);
},
forceMinPriority: function (p) {
apply(runners, function (runner) {
runner.forceMinPriority(p);
});
}
};
}
function allRunnersFailed(runners) {
return collections_all(runners, function (runner) {
return Boolean(runner.error);
});
}
function abortRunner(runner) {
if (!runner.error && !runner.aborted) {
runner.abort();
runner.aborted = true;
}
}
// CONCATENATED MODULE: ./src/core/strategies/websocket_prioritized_cached_strategy.ts
class websocket_prioritized_cached_strategy_WebSocketPrioritizedCachedStrategy {
constructor(strategy, transports, options) {
this.strategy = strategy;
this.transports = transports;
this.ttl = options.ttl || 1800 * 1000;
this.usingTLS = options.useTLS;
this.timeline = options.timeline;
}
isSupported() {
return this.strategy.isSupported();
}
connect(minPriority, callback) {
var usingTLS = this.usingTLS;
var info = fetchTransportCache(usingTLS);
var cacheSkipCount = info && info.cacheSkipCount ? info.cacheSkipCount : 0;
var strategies = [this.strategy];
if (info && info.timestamp + this.ttl >= util.now()) {
var transport = this.transports[info.transport];
if (transport) {
if (['ws', 'wss'].includes(info.transport) || cacheSkipCount > 3) {
this.timeline.info({
cached: true,
transport: info.transport,
latency: info.latency
});
strategies.push(new sequential_strategy_SequentialStrategy([transport], {
timeout: info.latency * 2 + 1000,
failFast: true
}));
}
else {
cacheSkipCount++;
}
}
}
var startTimestamp = util.now();
var runner = strategies
.pop()
.connect(minPriority, function cb(error, handshake) {
if (error) {
flushTransportCache(usingTLS);
if (strategies.length > 0) {
startTimestamp = util.now();
runner = strategies.pop().connect(minPriority, cb);
}
else {
callback(error);
}
}
else {
storeTransportCache(usingTLS, handshake.transport.name, util.now() - startTimestamp, cacheSkipCount);
callback(null, handshake);
}
});
return {
abort: function () {
runner.abort();
},
forceMinPriority: function (p) {
minPriority = p;
if (runner) {
runner.forceMinPriority(p);
}
}
};
}
}
function getTransportCacheKey(usingTLS) {
return 'pusherTransport' + (usingTLS ? 'TLS' : 'NonTLS');
}
function fetchTransportCache(usingTLS) {
var storage = node_runtime.getLocalStorage();
if (storage) {
try {
var serializedCache = storage[getTransportCacheKey(usingTLS)];
if (serializedCache) {
return JSON.parse(serializedCache);
}
}
catch (e) {
flushTransportCache(usingTLS);
}
}
return null;
}
function storeTransportCache(usingTLS, transport, latency, cacheSkipCount) {
var storage = node_runtime.getLocalStorage();
if (storage) {
try {
storage[getTransportCacheKey(usingTLS)] = safeJSONStringify({
timestamp: util.now(),
transport: transport,
latency: latency,
cacheSkipCount: cacheSkipCount
});
}
catch (e) {
}
}
}
function flushTransportCache(usingTLS) {
var storage = node_runtime.getLocalStorage();
if (storage) {
try {
delete storage[getTransportCacheKey(usingTLS)];
}
catch (e) {
}
}
}
// CONCATENATED MODULE: ./src/core/strategies/delayed_strategy.ts
class delayed_strategy_DelayedStrategy {
constructor(strategy, { delay: number }) {
this.strategy = strategy;
this.options = { delay: number };
}
isSupported() {
return this.strategy.isSupported();
}
connect(minPriority, callback) {
var strategy = this.strategy;
var runner;
var timer = new timers_OneOffTimer(this.options.delay, function () {
runner = strategy.connect(minPriority, callback);
});
return {
abort: function () {
timer.ensureAborted();
if (runner) {
runner.abort();
}
},
forceMinPriority: function (p) {
minPriority = p;
if (runner) {
runner.forceMinPriority(p);
}
}
};
}
}
// CONCATENATED MODULE: ./src/core/strategies/if_strategy.ts
class IfStrategy {
constructor(test, trueBranch, falseBranch) {
this.test = test;
this.trueBranch = trueBranch;
this.falseBranch = falseBranch;
}
isSupported() {
var branch = this.test() ? this.trueBranch : this.falseBranch;
return branch.isSupported();
}
connect(minPriority, callback) {
var branch = this.test() ? this.trueBranch : this.falseBranch;
return branch.connect(minPriority, callback);
}
}
// CONCATENATED MODULE: ./src/core/strategies/first_connected_strategy.ts
class FirstConnectedStrategy {
constructor(strategy) {
this.strategy = strategy;
}
isSupported() {
return this.strategy.isSupported();
}
connect(minPriority, callback) {
var runner = this.strategy.connect(minPriority, function (error, handshake) {
if (handshake) {
runner.abort();
}
callback(error, handshake);
});
return runner;
}
}
// CONCATENATED MODULE: ./src/runtimes/isomorphic/default_strategy.ts
function testSupportsStrategy(strategy) {
return function () {
return strategy.isSupported();
};
}
var getDefaultStrategy = function (config, baseOptions, defineTransport) {
var definedTransports = {};
function defineTransportStrategy(name, type, priority, options, manager) {
var transport = defineTransport(config, name, type, priority, options, manager);
definedTransports[name] = transport;
return transport;
}
var ws_options = Object.assign({}, baseOptions, {
hostNonTLS: config.wsHost + ':' + config.wsPort,
hostTLS: config.wsHost + ':' + config.wssPort,
httpPath: config.wsPath
});
var wss_options = extend({}, ws_options, {
useTLS: true
});
var http_options = Object.assign({}, baseOptions, {
hostNonTLS: config.httpHost + ':' + config.httpPort,
hostTLS: config.httpHost + ':' + config.httpsPort,
httpPath: config.httpPath
});
var timeouts = {
loop: true,
timeout: 15000,
timeoutLimit: 60000
};
var ws_manager = new transport_manager_TransportManager({
minPingDelay: 10000,
maxPingDelay: config.activityTimeout
});
var streaming_manager = new transport_manager_TransportManager({
lives: 2,
minPingDelay: 10000,
maxPingDelay: config.activityTimeout
});
var ws_transport = defineTransportStrategy('ws', 'ws', 3, ws_options, ws_manager);
var wss_transport = defineTransportStrategy('wss', 'ws', 3, wss_options, ws_manager);
var xhr_streaming_transport = defineTransportStrategy('xhr_streaming', 'xhr_streaming', 1, http_options, streaming_manager);
var xhr_polling_transport = defineTransportStrategy('xhr_polling', 'xhr_polling', 1, http_options);
var ws_loop = new sequential_strategy_SequentialStrategy([ws_transport], timeouts);
var wss_loop = new sequential_strategy_SequentialStrategy([wss_transport], timeouts);
var streaming_loop = new sequential_strategy_SequentialStrategy([xhr_streaming_transport], timeouts);
var polling_loop = new sequential_strategy_SequentialStrategy([xhr_polling_transport], timeouts);
var http_loop = new sequential_strategy_SequentialStrategy([
new IfStrategy(testSupportsStrategy(streaming_loop), new best_connected_ever_strategy_BestConnectedEverStrategy([
streaming_loop,
new delayed_strategy_DelayedStrategy(polling_loop, { delay: 4000 })
]), polling_loop)
], timeouts);
var wsStrategy;
if (baseOptions.useTLS) {
wsStrategy = new best_connected_ever_strategy_BestConnectedEverStrategy([
ws_loop,
new delayed_strategy_DelayedStrategy(http_loop, { delay: 2000 })
]);
}
else {
wsStrategy = new best_connected_ever_strategy_BestConnectedEverStrategy([
ws_loop,
new delayed_strategy_DelayedStrategy(wss_loop, { delay: 2000 }),
new delayed_strategy_DelayedStrategy(http_loop, { delay: 5000 })
]);
}
return new websocket_prioritized_cached_strategy_WebSocketPrioritizedCachedStrategy(new FirstConnectedStrategy(new IfStrategy(testSupportsStrategy(ws_transport), wsStrategy, http_loop)), definedTransports, {
ttl: 1800000,
timeline: baseOptions.timeline,
useTLS: baseOptions.useTLS
});
};
/* harmony default export */ var default_strategy = (getDefaultStrategy);
// CONCATENATED MODULE: ./src/runtimes/isomorphic/transports/transport_connection_initializer.ts
/* harmony default export */ var transport_connection_initializer = (function () {
var self = this;
self.timeline.info(self.buildTimelineMessage({
transport: self.name + (self.options.useTLS ? 's' : '')
}));
if (self.hooks.isInitialized()) {
self.changeState('initialized');
}
else {
self.onClose();
}
});
// CONCATENATED MODULE: ./src/core/http/http_request.ts
const MAX_BUFFER_LENGTH = 256 * 1024;
class http_request_HTTPRequest extends dispatcher_Dispatcher {
constructor(hooks, method, url) {
super();
this.hooks = hooks;
this.method = method;
this.url = url;
}
start(payload) {
this.position = 0;
this.xhr = this.hooks.getRequest(this);
this.unloader = () => {
this.close();
};
node_runtime.addUnloadListener(this.unloader);
this.xhr.open(this.method, this.url, true);
if (this.xhr.setRequestHeader) {
this.xhr.setRequestHeader('Content-Type', 'application/json');
}
this.xhr.send(payload);
}
close() {
if (this.unloader) {
node_runtime.removeUnloadListener(this.unloader);
this.unloader = null;
}
if (this.xhr) {
this.hooks.abortRequest(this.xhr);
this.xhr = null;
}
}
onChunk(status, data) {
while (true) {
var chunk = this.advanceBuffer(data);
if (chunk) {
this.emit('chunk', { status: status, data: chunk });
}
else {
break;
}
}
if (this.isBufferTooLong(data)) {
this.emit('buffer_too_long');
}
}
advanceBuffer(buffer) {
var unreadData = buffer.slice(this.position);
var endOfLinePosition = unreadData.indexOf('\n');
if (endOfLinePosition !== -1) {
this.position += endOfLinePosition + 1;
return unreadData.slice(0, endOfLinePosition);
}
else {
return null;
}
}
isBufferTooLong(buffer) {
return this.position === buffer.length && buffer.length > MAX_BUFFER_LENGTH;
}
}
// CONCATENATED MODULE: ./src/core/http/state.ts
var State;
(function (State) {
State[State["CONNECTING"] = 0] = "CONNECTING";
State[State["OPEN"] = 1] = "OPEN";
State[State["CLOSED"] = 3] = "CLOSED";
})(State || (State = {}));
/* harmony default export */ var state = (State);
// CONCATENATED MODULE: ./src/core/http/http_socket.ts
var autoIncrement = 1;
class http_socket_HTTPSocket {
constructor(hooks, url) {
this.hooks = hooks;
this.session = randomNumber(1000) + '/' + randomString(8);
this.location = getLocation(url);
this.readyState = state.CONNECTING;
this.openStream();
}
send(payload) {
return this.sendRaw(JSON.stringify([payload]));
}
ping() {
this.hooks.sendHeartbeat(this);
}
close(code, reason) {
this.onClose(code, reason, true);
}
sendRaw(payload) {
if (this.readyState === state.OPEN) {
try {
node_runtime.createSocketRequest('POST', getUniqueURL(getSendURL(this.location, this.session))).start(payload);
return true;
}
catch (e) {
return false;
}
}
else {
return false;
}
}
reconnect() {
this.closeStream();
this.openStream();
}
onClose(code, reason, wasClean) {
this.closeStream();
this.readyState = state.CLOSED;
if (this.onclose) {
this.onclose({
code: code,
reason: reason,
wasClean: wasClean
});
}
}
onChunk(chunk) {
if (chunk.status !== 200) {
return;
}
if (this.readyState === state.OPEN) {
this.onActivity();
}
var payload;
var type = chunk.data.slice(0, 1);
switch (type) {
case 'o':
payload = JSON.parse(chunk.data.slice(1) || '{}');
this.onOpen(payload);
break;
case 'a':
payload = JSON.parse(chunk.data.slice(1) || '[]');
for (var i = 0; i < payload.length; i++) {
this.onEvent(payload[i]);
}
break;
case 'm':
payload = JSON.parse(chunk.data.slice(1) || 'null');
this.onEvent(payload);
break;
case 'h':
this.hooks.onHeartbeat(this);
break;
case 'c':
payload = JSON.parse(chunk.data.slice(1) || '[]');
this.onClose(payload[0], payload[1], true);
break;
}
}
onOpen(options) {
if (this.readyState === state.CONNECTING) {
if (options && options.hostname) {
this.location.base = replaceHost(this.location.base, options.hostname);
}
this.readyState = state.OPEN;
if (this.onopen) {
this.onopen();
}
}
else {
this.onClose(1006, 'Server lost session', true);
}
}
onEvent(event) {
if (this.readyState === state.OPEN && this.onmessage) {
this.onmessage({ data: event });
}
}
onActivity() {
if (this.onactivity) {
this.onactivity();
}
}
onError(error) {
if (this.onerror) {
this.onerror(error);
}
}
openStream() {
this.stream = node_runtime.createSocketRequest('POST', getUniqueURL(this.hooks.getReceiveURL(this.location, this.session)));
this.stream.bind('chunk', chunk => {
this.onChunk(chunk);
});
this.stream.bind('finished', status => {
this.hooks.onFinished(this, status);
});
this.stream.bind('buffer_too_long', () => {
this.reconnect();
});
try {
this.stream.start();
}
catch (error) {
util.defer(() => {
this.onError(error);
this.onClose(1006, 'Could not start streaming', false);
});
}
}
closeStream() {
if (this.stream) {
this.stream.unbind_all();
this.stream.close();
this.stream = null;
}
}
}
function getLocation(url) {
var parts = /([^\?]*)\/*(\??.*)/.exec(url);
return {
base: parts[1],
queryString: parts[2]
};
}
function getSendURL(url, session) {
return url.base + '/' + session + '/xhr_send';
}
function getUniqueURL(url) {
var separator = url.indexOf('?') === -1 ? '?' : '&';
return url + separator + 't=' + +new Date() + '&n=' + autoIncrement++;
}
function replaceHost(url, hostname) {
var urlParts = /(https?:\/\/)([^\/:]+)((\/|:)?.*)/.exec(url);
return urlParts[1] + hostname + urlParts[3];
}
function randomNumber(max) {
return node_runtime.randomInt(max);
}
function randomString(length) {
var result = [];
for (var i = 0; i < length; i++) {
result.push(randomNumber(32).toString(32));
}
return result.join('');
}
/* harmony default export */ var http_socket = (http_socket_HTTPSocket);
// CONCATENATED MODULE: ./src/core/http/http_streaming_socket.ts
var http_streaming_socket_hooks = {
getReceiveURL: function (url, session) {
return url.base + '/' + session + '/xhr_streaming' + url.queryString;
},
onHeartbeat: function (socket) {
socket.sendRaw('[]');
},
sendHeartbeat: function (socket) {
socket.sendRaw('[]');
},
onFinished: function (socket, status) {
socket.onClose(1006, 'Connection interrupted (' + status + ')', false);
}
};
/* harmony default export */ var http_streaming_socket = (http_streaming_socket_hooks);
// CONCATENATED MODULE: ./src/core/http/http_polling_socket.ts
var http_polling_socket_hooks = {
getReceiveURL: function (url, session) {
return url.base + '/' + session + '/xhr' + url.queryString;
},
onHeartbeat: function () {
},
sendHeartbeat: function (socket) {
socket.sendRaw('[]');
},
onFinished: function (socket, status) {
if (status === 200) {
socket.reconnect();
}
else {
socket.onClose(1006, 'Connection interrupted (' + status + ')', false);
}
}
};
/* harmony default export */ var http_polling_socket = (http_polling_socket_hooks);
// CONCATENATED MODULE: ./src/runtimes/isomorphic/http/http_xhr_request.ts
var http_xhr_request_hooks = {
getRequest: function (socket) {
var Constructor = node_runtime.getXHRAPI();
var xhr = new Constructor();
xhr.onreadystatechange = xhr.onprogress = function () {
switch (xhr.readyState) {
case 3:
if (xhr.responseText && xhr.responseText.length > 0) {
socket.onChunk(xhr.status, xhr.responseText);
}
break;
case 4:
if (xhr.responseText && xhr.responseText.length > 0) {
socket.onChunk(xhr.status, xhr.responseText);
}
socket.emit('finished', xhr.status);
socket.close();
break;
}
};
return xhr;
},
abortRequest: function (xhr) {
xhr.onreadystatechange = null;
xhr.abort();
}
};
/* harmony default export */ var http_xhr_request = (http_xhr_request_hooks);
// CONCATENATED MODULE: ./src/runtimes/isomorphic/http/http.ts
var HTTP = {
createStreamingSocket(url) {
return this.createSocket(http_streaming_socket, url);
},
createPollingSocket(url) {
return this.createSocket(http_polling_socket, url);
},
createSocket(hooks, url) {
return new http_socket(hooks, url);
},
createXHR(method, url) {
return this.createRequest(http_xhr_request, method, url);
},
createRequest(hooks, method, url) {
return new http_request_HTTPRequest(hooks, method, url);
}
};
/* harmony default export */ var http_http = (HTTP);
// CONCATENATED MODULE: ./src/runtimes/isomorphic/runtime.ts
var Isomorphic = {
getDefaultStrategy: default_strategy,
Transports: transports,
transportConnectionInitializer: transport_connection_initializer,
HTTPFactory: http_http,
setup(PusherClass) {
PusherClass.ready();
},
getLocalStorage() {
return undefined;
},
getClientFeatures() {
return keys(filterObject({ ws: transports.ws }, function (t) {
return t.isSupported({});
}));
},
getProtocol() {
return 'http:';
},
isXHRSupported() {
return true;
},
createSocketRequest(method, url) {
if (this.isXHRSupported()) {
return this.HTTPFactory.createXHR(method, url);
}
else {
throw 'Cross-origin HTTP requests are not supported';
}
},
createXHR() {
var Constructor = this.getXHRAPI();
return new Constructor();
},
createWebSocket(url) {
var Constructor = this.getWebSocketAPI();
return new Constructor(url);
},
addUnloadListener(listener) { },
removeUnloadListener(listener) { }
};
/* harmony default export */ var runtime = (Isomorphic);
// EXTERNAL MODULE: ./node_modules/faye-websocket/lib/faye/websocket.js
var websocket = __webpack_require__(18);
// EXTERNAL MODULE: ./node_modules/xmlhttprequest/lib/XMLHttpRequest.js
var XMLHttpRequest = __webpack_require__(19);
// CONCATENATED MODULE: ./src/runtimes/node/net_info.ts
class net_info_NetInfo extends dispatcher_Dispatcher {
isOnline() {
return true;
}
}
var net_info_Network = new net_info_NetInfo();
// CONCATENATED MODULE: ./src/core/auth/options.ts
var AuthRequestType;
(function (AuthRequestType) {
AuthRequestType["UserAuthentication"] = "user-authentication";
AuthRequestType["ChannelAuthorization"] = "channel-authorization";
})(AuthRequestType || (AuthRequestType = {}));
// CONCATENATED MODULE: ./src/runtimes/isomorphic/auth/xhr_auth.ts
const ajax = function (context, query, authOptions, authRequestType, callback) {
const xhr = node_runtime.createXHR();
xhr.open('POST', authOptions.endpoint, true);
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
for (var headerName in authOptions.headers) {
xhr.setRequestHeader(headerName, authOptions.headers[headerName]);
}
if (authOptions.headersProvider != null) {
let dynamicHeaders = authOptions.headersProvider();
for (var headerName in dynamicHeaders) {
xhr.setRequestHeader(headerName, dynamicHeaders[headerName]);
}
}
xhr.onreadystatechange = function () {
if (xhr.readyState === 4) {
if (xhr.status === 200) {
let data;
let parsed = false;
try {
data = JSON.parse(xhr.responseText);
parsed = true;
}
catch (e) {
callback(new HTTPAuthError(200, `JSON returned from ${authRequestType.toString()} endpoint was invalid, yet status code was 200. Data was: ${xhr.responseText}`), null);
}
if (parsed) {
callback(null, data);
}
}
else {
let suffix = '';
switch (authRequestType) {
case AuthRequestType.UserAuthentication:
suffix = url_store.buildLogSuffix('authenticationEndpoint');
break;
case AuthRequestType.ChannelAuthorization:
suffix = `Clients must be authorized to join private or presence channels. ${url_store.buildLogSuffix('authorizationEndpoint')}`;
break;
}
callback(new HTTPAuthError(xhr.status, `Unable to retrieve auth string from ${authRequestType.toString()} endpoint - ` +
`received status: ${xhr.status} from ${authOptions.endpoint}. ${suffix}`), null);
}
}
};
xhr.send(query);
return xhr;
};
/* harmony default export */ var xhr_auth = (ajax);
// CONCATENATED MODULE: ./src/runtimes/isomorphic/timeline/xhr_timeline.ts
var getAgent = function (sender, useTLS) {
return function (data, callback) {
var scheme = 'http' + (useTLS ? 's' : '') + '://';
var url = scheme + (sender.host || sender.options.host) + sender.options.path;
var query = buildQueryString(data);
url += '/' + 2 + '?' + query;
var xhr = node_runtime.createXHR();
xhr.open('GET', url, true);
xhr.onreadystatechange = function () {
if (xhr.readyState === 4) {
let { status, responseText } = xhr;
if (status !== 200) {
logger.debug(`TimelineSender Error: received ${status} from stats.pusher.com`);
return;
}
try {
var { host } = JSON.parse(responseText);
}
catch (e) {
logger.debug(`TimelineSenderError: invalid response ${responseText}`);
}
if (host) {
sender.host = host;
}
}
};
xhr.send();
};
};
var xhr_timeline_xhr = {
name: 'xhr',
getAgent
};
/* harmony default export */ var xhr_timeline = (xhr_timeline_xhr);
// EXTERNAL MODULE: external "crypto"
var external_crypto_ = __webpack_require__(3);
// CONCATENATED MODULE: ./src/runtimes/node/runtime.ts
const { getDefaultStrategy: runtime_getDefaultStrategy, Transports: runtime_Transports, setup, getProtocol, isXHRSupported, getLocalStorage, createXHR, createWebSocket, addUnloadListener, removeUnloadListener, transportConnectionInitializer, createSocketRequest, HTTPFactory } = runtime;
const NodeJS = {
getDefaultStrategy: runtime_getDefaultStrategy,
Transports: runtime_Transports,
setup,
getProtocol,
isXHRSupported,
createSocketRequest,
getLocalStorage,
createXHR,
createWebSocket,
addUnloadListener,
removeUnloadListener,
transportConnectionInitializer,
HTTPFactory,
TimelineTransport: xhr_timeline,
getAuthorizers() {
return { ajax: xhr_auth };
},
getWebSocketAPI() {
return websocket["Client"];
},
getXHRAPI() {
return XMLHttpRequest["XMLHttpRequest"];
},
getNetwork() {
return net_info_Network;
},
randomInt(max) {
return Object(external_crypto_["randomInt"])(max);
}
};
/* harmony default export */ var node_runtime = (NodeJS);
// CONCATENATED MODULE: ./src/core/timeline/level.ts
var TimelineLevel;
(function (TimelineLevel) {
TimelineLevel[TimelineLevel["ERROR"] = 3] = "ERROR";
TimelineLevel[TimelineLevel["INFO"] = 6] = "INFO";
TimelineLevel[TimelineLevel["DEBUG"] = 7] = "DEBUG";
})(TimelineLevel || (TimelineLevel = {}));
/* harmony default export */ var timeline_level = (TimelineLevel);
// CONCATENATED MODULE: ./src/core/timeline/timeline.ts
class timeline_Timeline {
constructor(key, session, options) {
this.key = key;
this.session = session;
this.events = [];
this.options = options || {};
this.sent = 0;
this.uniqueID = 0;
}
log(level, event) {
if (level <= this.options.level) {
this.events.push(extend({}, event, { timestamp: util.now() }));
if (this.options.limit && this.events.length > this.options.limit) {
this.events.shift();
}
}
}
error(event) {
this.log(timeline_level.ERROR, event);
}
info(event) {
this.log(timeline_level.INFO, event);
}
debug(event) {
this.log(timeline_level.DEBUG, event);
}
isEmpty() {
return this.events.length === 0;
}
send(sendfn, callback) {
var data = extend({
session: this.session,
bundle: this.sent + 1,
key: this.key,
lib: 'js',
version: this.options.version,
cluster: this.options.cluster,
features: this.options.features,
timeline: this.events
}, this.options.params);
this.events = [];
sendfn(data, (error, result) => {
if (!error) {
this.sent++;
}
if (callback) {
callback(error, result);
}
});
return true;
}
generateUniqueID() {
this.uniqueID++;
return this.uniqueID;
}
}
// CONCATENATED MODULE: ./src/core/strategies/transport_strategy.ts
class transport_strategy_TransportStrategy {
constructor(name, priority, transport, options) {
this.name = name;
this.priority = priority;
this.transport = transport;
this.options = options || {};
}
isSupported() {
return this.transport.isSupported({
useTLS: this.options.useTLS
});
}
connect(minPriority, callback) {
if (!this.isSupported()) {
return failAttempt(new UnsupportedStrategy(), callback);
}
else if (this.priority < minPriority) {
return failAttempt(new TransportPriorityTooLow(), callback);
}
var connected = false;
var transport = this.transport.createConnection(this.name, this.priority, this.options.key, this.options);
var handshake = null;
var onInitialized = function () {
transport.unbind('initialized', onInitialized);
transport.connect();
};
var onOpen = function () {
handshake = factory.createHandshake(transport, function (result) {
connected = true;
unbindListeners();
callback(null, result);
});
};
var onError = function (error) {
unbindListeners();
callback(error);
};
var onClosed = function () {
unbindListeners();
var serializedTransport;
serializedTransport = safeJSONStringify(transport);
callback(new TransportClosed(serializedTransport));
};
var unbindListeners = function () {
transport.unbind('initialized', onInitialized);
transport.unbind('open', onOpen);
transport.unbind('error', onError);
transport.unbind('closed', onClosed);
};
transport.bind('initialized', onInitialized);
transport.bind('open', onOpen);
transport.bind('error', onError);
transport.bind('closed', onClosed);
transport.initialize();
return {
abort: () => {
if (connected) {
return;
}
unbindListeners();
if (handshake) {
handshake.close();
}
else {
transport.close();
}
},
forceMinPriority: p => {
if (connected) {
return;
}
if (this.priority < p) {
if (handshake) {
handshake.close();
}
else {
transport.close();
}
}
}
};
}
}
function failAttempt(error, callback) {
util.defer(function () {
callback(error);
});
return {
abort: function () { },
forceMinPriority: function () { }
};
}
// CONCATENATED MODULE: ./src/core/strategies/strategy_builder.ts
const { Transports: strategy_builder_Transports } = node_runtime;
var strategy_builder_defineTransport = function (config, name, type, priority, options, manager) {
var transportClass = strategy_builder_Transports[type];
if (!transportClass) {
throw new UnsupportedTransport(type);
}
var enabled = (!config.enabledTransports ||
arrayIndexOf(config.enabledTransports, name) !== -1) &&
(!config.disabledTransports ||
arrayIndexOf(config.disabledTransports, name) === -1);
var transport;
if (enabled) {
options = Object.assign({ ignoreNullOrigin: config.ignoreNullOrigin }, options);
transport = new transport_strategy_TransportStrategy(name, priority, manager ? manager.getAssistant(transportClass) : transportClass, options);
}
else {
transport = strategy_builder_UnsupportedStrategy;
}
return transport;
};
var strategy_builder_UnsupportedStrategy = {
isSupported: function () {
return false;
},
connect: function (_, callback) {
var deferred = util.defer(function () {
callback(new UnsupportedStrategy());
});
return {
abort: function () {
deferred.ensureAborted();
},
forceMinPriority: function () { }
};
}
};
// CONCATENATED MODULE: ./src/core/options.ts
function validateOptions(options) {
if (options == null) {
throw 'You must pass an options object';
}
if (options.cluster == null) {
throw 'Options object must provide a cluster';
}
if ('disableStats' in options) {
logger.warn('The disableStats option is deprecated in favor of enableStats');
}
}
// CONCATENATED MODULE: ./src/core/auth/user_authenticator.ts
const composeChannelQuery = (params, authOptions) => {
var query = 'socket_id=' + encodeURIComponent(params.socketId);
for (var key in authOptions.params) {
query +=
'&' +
encodeURIComponent(key) +
'=' +
encodeURIComponent(authOptions.params[key]);
}
if (authOptions.paramsProvider != null) {
let dynamicParams = authOptions.paramsProvider();
for (var key in dynamicParams) {
query +=
'&' +
encodeURIComponent(key) +
'=' +
encodeURIComponent(dynamicParams[key]);
}
}
return query;
};
const UserAuthenticator = (authOptions) => {
if (typeof node_runtime.getAuthorizers()[authOptions.transport] === 'undefined') {
throw `'${authOptions.transport}' is not a recognized auth transport`;
}
return (params, callback) => {
const query = composeChannelQuery(params, authOptions);
node_runtime.getAuthorizers()[authOptions.transport](node_runtime, query, authOptions, AuthRequestType.UserAuthentication, callback);
};
};
/* harmony default export */ var user_authenticator = (UserAuthenticator);
// CONCATENATED MODULE: ./src/core/auth/channel_authorizer.ts
const channel_authorizer_composeChannelQuery = (params, authOptions) => {
var query = 'socket_id=' + encodeURIComponent(params.socketId);
query += '&channel_name=' + encodeURIComponent(params.channelName);
for (var key in authOptions.params) {
query +=
'&' +
encodeURIComponent(key) +
'=' +
encodeURIComponent(authOptions.params[key]);
}
if (authOptions.paramsProvider != null) {
let dynamicParams = authOptions.paramsProvider();
for (var key in dynamicParams) {
query +=
'&' +
encodeURIComponent(key) +
'=' +
encodeURIComponent(dynamicParams[key]);
}
}
return query;
};
const ChannelAuthorizer = (authOptions) => {
if (typeof node_runtime.getAuthorizers()[authOptions.transport] === 'undefined') {
throw `'${authOptions.transport}' is not a recognized auth transport`;
}
return (params, callback) => {
const query = channel_authorizer_composeChannelQuery(params, authOptions);
node_runtime.getAuthorizers()[authOptions.transport](node_runtime, query, authOptions, AuthRequestType.ChannelAuthorization, callback);
};
};
/* harmony default export */ var channel_authorizer = (ChannelAuthorizer);
// CONCATENATED MODULE: ./src/core/auth/deprecated_channel_authorizer.ts
const ChannelAuthorizerProxy = (pusher, authOptions, channelAuthorizerGenerator) => {
const deprecatedAuthorizerOptions = {
authTransport: authOptions.transport,
authEndpoint: authOptions.endpoint,
auth: {
params: authOptions.params,
headers: authOptions.headers
}
};
return (params, callback) => {
const channel = pusher.channel(params.channelName);
const channelAuthorizer = channelAuthorizerGenerator(channel, deprecatedAuthorizerOptions);
channelAuthorizer.authorize(params.socketId, callback);
};
};
// CONCATENATED MODULE: ./src/core/config.ts
function getConfig(opts, pusher) {
let config = {
activityTimeout: opts.activityTimeout || defaults.activityTimeout,
cluster: opts.cluster,
httpPath: opts.httpPath || defaults.httpPath,
httpPort: opts.httpPort || defaults.httpPort,
httpsPort: opts.httpsPort || defaults.httpsPort,
pongTimeout: opts.pongTimeout || defaults.pongTimeout,
statsHost: opts.statsHost || defaults.stats_host,
unavailableTimeout: opts.unavailableTimeout || defaults.unavailableTimeout,
wsPath: opts.wsPath || defaults.wsPath,
wsPort: opts.wsPort || defaults.wsPort,
wssPort: opts.wssPort || defaults.wssPort,
enableStats: getEnableStatsConfig(opts),
httpHost: getHttpHost(opts),
useTLS: shouldUseTLS(opts),
wsHost: getWebsocketHost(opts),
userAuthenticator: buildUserAuthenticator(opts),
channelAuthorizer: buildChannelAuthorizer(opts, pusher)
};
if ('disabledTransports' in opts)
config.disabledTransports = opts.disabledTransports;
if ('enabledTransports' in opts)
config.enabledTransports = opts.enabledTransports;
if ('ignoreNullOrigin' in opts)
config.ignoreNullOrigin = opts.ignoreNullOrigin;
if ('timelineParams' in opts)
config.timelineParams = opts.timelineParams;
if ('nacl' in opts) {
config.nacl = opts.nacl;
}
return config;
}
function getHttpHost(opts) {
if (opts.httpHost) {
return opts.httpHost;
}
if (opts.cluster) {
return `sockjs-${opts.cluster}.pusher.com`;
}
return defaults.httpHost;
}
function getWebsocketHost(opts) {
if (opts.wsHost) {
return opts.wsHost;
}
return getWebsocketHostFromCluster(opts.cluster);
}
function getWebsocketHostFromCluster(cluster) {
return `ws-${cluster}.pusher.com`;
}
function shouldUseTLS(opts) {
if (node_runtime.getProtocol() === 'https:') {
return true;
}
else if (opts.forceTLS === false) {
return false;
}
return true;
}
function getEnableStatsConfig(opts) {
if ('enableStats' in opts) {
return opts.enableStats;
}
if ('disableStats' in opts) {
return !opts.disableStats;
}
return false;
}
const hasCustomHandler = (auth) => {
return 'customHandler' in auth && auth['customHandler'] != null;
};
function buildUserAuthenticator(opts) {
const userAuthentication = Object.assign(Object.assign({}, defaults.userAuthentication), opts.userAuthentication);
if (hasCustomHandler(userAuthentication)) {
return userAuthentication['customHandler'];
}
return user_authenticator(userAuthentication);
}
function buildChannelAuth(opts, pusher) {
let channelAuthorization;
if ('channelAuthorization' in opts) {
channelAuthorization = Object.assign(Object.assign({}, defaults.channelAuthorization), opts.channelAuthorization);
}
else {
channelAuthorization = {
transport: opts.authTransport || defaults.authTransport,
endpoint: opts.authEndpoint || defaults.authEndpoint
};
if ('auth' in opts) {
if ('params' in opts.auth)
channelAuthorization.params = opts.auth.params;
if ('headers' in opts.auth)
channelAuthorization.headers = opts.auth.headers;
}
if ('authorizer' in opts) {
return {
customHandler: ChannelAuthorizerProxy(pusher, channelAuthorization, opts.authorizer)
};
}
}
return channelAuthorization;
}
function buildChannelAuthorizer(opts, pusher) {
const channelAuthorization = buildChannelAuth(opts, pusher);
if (hasCustomHandler(channelAuthorization)) {
return channelAuthorization['customHandler'];
}
return channel_authorizer(channelAuthorization);
}
// CONCATENATED MODULE: ./src/core/watchlist.ts
class watchlist_WatchlistFacade extends dispatcher_Dispatcher {
constructor(pusher) {
super(function (eventName, data) {
logger.debug(`No callbacks on watchlist events for ${eventName}`);
});
this.pusher = pusher;
this.bindWatchlistInternalEvent();
}
handleEvent(pusherEvent) {
pusherEvent.data.events.forEach(watchlistEvent => {
this.emit(watchlistEvent.name, watchlistEvent);
});
}
bindWatchlistInternalEvent() {
this.pusher.connection.bind('message', pusherEvent => {
var eventName = pusherEvent.event;
if (eventName === 'pusher_internal:watchlist_events') {
this.handleEvent(pusherEvent);
}
});
}
}
// CONCATENATED MODULE: ./src/core/utils/flat_promise.ts
function flatPromise() {
let resolve, reject;
const promise = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
return { promise, resolve, reject };
}
/* harmony default export */ var flat_promise = (flatPromise);
// CONCATENATED MODULE: ./src/core/user.ts
class user_UserFacade extends dispatcher_Dispatcher {
constructor(pusher) {
super(function (eventName, data) {
logger.debug('No callbacks on user for ' + eventName);
});
this.signin_requested = false;
this.user_data = null;
this.serverToUserChannel = null;
this.signinDonePromise = null;
this._signinDoneResolve = null;
this._onAuthorize = (err, authData) => {
if (err) {
logger.warn(`Error during signin: ${err}`);
this._cleanup();
return;
}
this.pusher.send_event('pusher:signin', {
auth: authData.auth,
user_data: authData.user_data
});
};
this.pusher = pusher;
this.pusher.connection.bind('state_change', ({ previous, current }) => {
if (previous !== 'connected' && current === 'connected') {
this._signin();
}
if (previous === 'connected' && current !== 'connected') {
this._cleanup();
this._newSigninPromiseIfNeeded();
}
});
this.watchlist = new watchlist_WatchlistFacade(pusher);
this.pusher.connection.bind('message', event => {
var eventName = event.event;
if (eventName === 'pusher:signin_success') {
this._onSigninSuccess(event.data);
}
if (this.serverToUserChannel &&
this.serverToUserChannel.name === event.channel) {
this.serverToUserChannel.handleEvent(event);
}
});
}
signin() {
if (this.signin_requested) {
return;
}
this.signin_requested = true;
this._signin();
}
_signin() {
if (!this.signin_requested) {
return;
}
this._newSigninPromiseIfNeeded();
if (this.pusher.connection.state !== 'connected') {
return;
}
this.pusher.config.userAuthenticator({
socketId: this.pusher.connection.socket_id
}, this._onAuthorize);
}
_onSigninSuccess(data) {
try {
this.user_data = JSON.parse(data.user_data);
}
catch (e) {
logger.error(`Failed parsing user data after signin: ${data.user_data}`);
this._cleanup();
return;
}
if (typeof this.user_data.id !== 'string' || this.user_data.id === '') {
logger.error(`user_data doesn't contain an id. user_data: ${this.user_data}`);
this._cleanup();
return;
}
this._signinDoneResolve();
this._subscribeChannels();
}
_subscribeChannels() {
const ensure_subscribed = channel => {
if (channel.subscriptionPending && channel.subscriptionCancelled) {
channel.reinstateSubscription();
}
else if (!channel.subscriptionPending &&
this.pusher.connection.state === 'connected') {
channel.subscribe();
}
};
this.serverToUserChannel = new channel_Channel(`#server-to-user-${this.user_data.id}`, this.pusher);
this.serverToUserChannel.bind_global((eventName, data) => {
if (eventName.indexOf('pusher_internal:') === 0 ||
eventName.indexOf('pusher:') === 0) {
return;
}
this.emit(eventName, data);
});
ensure_subscribed(this.serverToUserChannel);
}
_cleanup() {
this.user_data = null;
if (this.serverToUserChannel) {
this.serverToUserChannel.unbind_all();
this.serverToUserChannel.disconnect();
this.serverToUserChannel = null;
}
if (this.signin_requested) {
this._signinDoneResolve();
}
}
_newSigninPromiseIfNeeded() {
if (!this.signin_requested) {
return;
}
if (this.signinDonePromise && !this.signinDonePromise.done) {
return;
}
const { promise, resolve, reject: _ } = flat_promise();
promise.done = false;
const setDone = () => {
promise.done = true;
};
promise.then(setDone).catch(setDone);
this.signinDonePromise = promise;
this._signinDoneResolve = resolve;
}
}
// CONCATENATED MODULE: ./src/core/pusher.ts
class pusher_Pusher {
static ready() {
pusher_Pusher.isReady = true;
for (var i = 0, l = pusher_Pusher.instances.length; i < l; i++) {
pusher_Pusher.instances[i].connect();
}
}
static getClientFeatures() {
return keys(filterObject({ ws: node_runtime.Transports.ws }, function (t) {
return t.isSupported({});
}));
}
constructor(app_key, options) {
checkAppKey(app_key);
validateOptions(options);
this.key = app_key;
this.options = options;
this.config = getConfig(this.options, this);
this.channels = factory.createChannels();
this.global_emitter = new dispatcher_Dispatcher();
this.sessionID = node_runtime.randomInt(1000000000);
this.timeline = new timeline_Timeline(this.key, this.sessionID, {
cluster: this.config.cluster,
features: pusher_Pusher.getClientFeatures(),
params: this.config.timelineParams || {},
limit: 50,
level: timeline_level.INFO,
version: defaults.VERSION
});
if (this.config.enableStats) {
this.timelineSender = factory.createTimelineSender(this.timeline, {
host: this.config.statsHost,
path: '/timeline/v2/' + node_runtime.TimelineTransport.name
});
}
var getStrategy = (options) => {
return node_runtime.getDefaultStrategy(this.config, options, strategy_builder_defineTransport);
};
this.connection = factory.createConnectionManager(this.key, {
getStrategy: getStrategy,
timeline: this.timeline,
activityTimeout: this.config.activityTimeout,
pongTimeout: this.config.pongTimeout,
unavailableTimeout: this.config.unavailableTimeout,
useTLS: Boolean(this.config.useTLS)
});
this.connection.bind('connected', () => {
this.subscribeAll();
if (this.timelineSender) {
this.timelineSender.send(this.connection.isUsingTLS());
}
});
this.connection.bind('message', event => {
var eventName = event.event;
var internal = eventName.indexOf('pusher_internal:') === 0;
if (event.channel) {
var channel = this.channel(event.channel);
if (channel) {
channel.handleEvent(event);
}
}
if (!internal) {
this.global_emitter.emit(event.event, event.data);
}
});
this.connection.bind('connecting', () => {
this.channels.disconnect();
});
this.connection.bind('disconnected', () => {
this.channels.disconnect();
});
this.connection.bind('error', err => {
logger.warn(err);
});
pusher_Pusher.instances.push(this);
this.timeline.info({ instances: pusher_Pusher.instances.length });
this.user = new user_UserFacade(this);
if (pusher_Pusher.isReady) {
this.connect();
}
}
switchCluster(options) {
const { appKey, cluster } = options;
this.key = appKey;
this.options = Object.assign(Object.assign({}, this.options), { cluster });
this.config = getConfig(this.options, this);
this.connection.switchCluster(this.key);
}
channel(name) {
return this.channels.find(name);
}
allChannels() {
return this.channels.all();
}
connect() {
this.connection.connect();
if (this.timelineSender) {
if (!this.timelineSenderTimer) {
var usingTLS = this.connection.isUsingTLS();
var timelineSender = this.timelineSender;
this.timelineSenderTimer = new timers_PeriodicTimer(60000, function () {
timelineSender.send(usingTLS);
});
}
}
}
disconnect() {
this.connection.disconnect();
if (this.timelineSenderTimer) {
this.timelineSenderTimer.ensureAborted();
this.timelineSenderTimer = null;
}
}
bind(event_name, callback, context) {
this.global_emitter.bind(event_name, callback, context);
return this;
}
unbind(event_name, callback, context) {
this.global_emitter.unbind(event_name, callback, context);
return this;
}
bind_global(callback) {
this.global_emitter.bind_global(callback);
return this;
}
unbind_global(callback) {
this.global_emitter.unbind_global(callback);
return this;
}
unbind_all(callback) {
this.global_emitter.unbind_all();
return this;
}
subscribeAll() {
var channelName;
for (channelName in this.channels.channels) {
if (this.channels.channels.hasOwnProperty(channelName)) {
this.subscribe(channelName);
}
}
}
subscribe(channel_name) {
var channel = this.channels.add(channel_name, this);
if (channel.subscriptionPending && channel.subscriptionCancelled) {
channel.reinstateSubscription();
}
else if (!channel.subscriptionPending &&
this.connection.state === 'connected') {
channel.subscribe();
}
return channel;
}
unsubscribe(channel_name) {
var channel = this.channels.find(channel_name);
if (channel && channel.subscriptionPending) {
channel.cancelSubscription();
}
else {
channel = this.channels.remove(channel_name);
if (channel && channel.subscribed) {
channel.unsubscribe();
}
}
}
send_event(event_name, data, channel) {
return this.connection.send_event(event_name, data, channel);
}
shouldUseTLS() {
return this.config.useTLS;
}
signin() {
this.user.signin();
}
}
pusher_Pusher.instances = [];
pusher_Pusher.isReady = false;
pusher_Pusher.logToConsole = false;
pusher_Pusher.Runtime = node_runtime;
pusher_Pusher.ScriptReceivers = node_runtime.ScriptReceivers;
pusher_Pusher.DependenciesReceivers = node_runtime.DependenciesReceivers;
pusher_Pusher.auth_callbacks = node_runtime.auth_callbacks;
/* harmony default export */ var core_pusher = (pusher_Pusher);
function checkAppKey(key) {
if (key === null || key === undefined) {
throw 'You must pass your app key when you instantiate Pusher.';
}
}
node_runtime.setup(pusher_Pusher);
// EXTERNAL MODULE: ./node_modules/tweetnacl/nacl-fast.js
var nacl_fast = __webpack_require__(20);
// CONCATENATED MODULE: ./src/core/pusher-with-encryption.ts
class pusher_with_encryption_PusherWithEncryption extends core_pusher {
constructor(app_key, options) {
core_pusher.logToConsole = pusher_with_encryption_PusherWithEncryption.logToConsole;
core_pusher.log = pusher_with_encryption_PusherWithEncryption.log;
validateOptions(options);
options.nacl = nacl_fast;
super(app_key, options);
}
}
/***/ })
/******/ ]);
//# sourceMappingURL=pusher.js.map |