File manager - Edit - /home/u300416816/domains/travelwithacam.com/public_html/node_modules/.vite/deps/pusher-js.js
Back
import { __commonJS } from "./chunk-HKJ2B2AA.js"; // node_modules/pusher-js/dist/web/pusher.js var require_pusher = __commonJS({ "node_modules/pusher-js/dist/web/pusher.js"(exports, module) { (function webpackUniversalModuleDefinition(root, factory) { if (typeof exports === "object" && typeof module === "object") module.exports = factory(); else if (typeof define === "function" && define.amd) define([], factory); else if (typeof exports === "object") exports["Pusher"] = factory(); else root["Pusher"] = factory(); })(window, function() { return ( /******/ function(modules) { var installedModules = {}; function __webpack_require__(moduleId) { if (installedModules[moduleId]) { return installedModules[moduleId].exports; } var module2 = installedModules[moduleId] = { /******/ i: moduleId, /******/ l: false, /******/ exports: {} /******/ }; modules[moduleId].call(module2.exports, module2, module2.exports, __webpack_require__); module2.l = true; return module2.exports; } __webpack_require__.m = modules; __webpack_require__.c = installedModules; __webpack_require__.d = function(exports2, name, getter) { if (!__webpack_require__.o(exports2, name)) { Object.defineProperty(exports2, name, { enumerable: true, get: getter }); } }; __webpack_require__.r = function(exports2) { if (typeof Symbol !== "undefined" && Symbol.toStringTag) { Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" }); } Object.defineProperty(exports2, "__esModule", { value: true }); }; __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 = /* @__PURE__ */ Object.create(null); __webpack_require__.r(ns); Object.defineProperty(ns, "default", { enumerable: true, value }); if (mode & 2 && typeof value != "string") for (var key in value) __webpack_require__.d(ns, key, (function(key2) { return value[key2]; }).bind(null, key)); return ns; }; __webpack_require__.n = function(module2) { var getter = module2 && module2.__esModule ? ( /******/ function getDefault() { return module2["default"]; } ) : ( /******/ function getModuleExports() { return module2; } ); __webpack_require__.d(getter, "a", getter); return getter; }; __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; __webpack_require__.p = ""; return __webpack_require__(__webpack_require__.s = 2); }([ /* 0 */ /***/ function(module2, exports2, __webpack_require__) { "use strict"; var __extends = this && this.__extends || /* @__PURE__ */ function() { var extendStatics = function(d, b) { extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) { d2.__proto__ = b2; } || function(d2, b2) { for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[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(exports2, "__esModule", { value: true }); var INVALID_BYTE = 256; var Coder = ( /** @class */ function() { function Coder2(_paddingCharacter) { if (_paddingCharacter === void 0) { _paddingCharacter = "="; } this._paddingCharacter = _paddingCharacter; } Coder2.prototype.encodedLength = function(length) { if (!this._paddingCharacter) { return (length * 8 + 5) / 6 | 0; } return (length + 2) / 3 * 4 | 0; }; Coder2.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; }; Coder2.prototype.maxDecodedLength = function(length) { if (!this._paddingCharacter) { return (length * 6 + 7) / 8 | 0; } return length / 4 * 3 | 0; }; Coder2.prototype.decodedLength = function(s) { return this.maxDecodedLength(s.length - this._getPaddingLength(s)); }; Coder2.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; }; Coder2.prototype._encodeByte = function(b) { var result = b; result += 65; result += 25 - b >>> 8 & 0 - 65 - 26 + 97; result += 51 - b >>> 8 & 26 - 97 - 52 + 48; result += 61 - b >>> 8 & 52 - 48 - 62 + 43; result += 62 - b >>> 8 & 62 - 43 - 63 + 47; return String.fromCharCode(result); }; Coder2.prototype._decodeChar = function(c) { var result = INVALID_BYTE; result += (42 - c & c - 44) >>> 8 & -INVALID_BYTE + c - 43 + 62; result += (46 - c & c - 48) >>> 8 & -INVALID_BYTE + c - 47 + 63; result += (47 - c & c - 58) >>> 8 & -INVALID_BYTE + c - 48 + 52; result += (64 - c & c - 91) >>> 8 & -INVALID_BYTE + c - 65 + 0; result += (96 - c & c - 123) >>> 8 & -INVALID_BYTE + c - 97 + 26; return result; }; Coder2.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 Coder2; }() ); exports2.Coder = Coder; var stdCoder = new Coder(); function encode(data) { return stdCoder.encode(data); } exports2.encode = encode; function decode(s) { return stdCoder.decode(s); } exports2.decode = decode; var URLSafeCoder = ( /** @class */ function(_super) { __extends(URLSafeCoder2, _super); function URLSafeCoder2() { return _super !== null && _super.apply(this, arguments) || this; } URLSafeCoder2.prototype._encodeByte = function(b) { var result = b; result += 65; result += 25 - b >>> 8 & 0 - 65 - 26 + 97; result += 51 - b >>> 8 & 26 - 97 - 52 + 48; result += 61 - b >>> 8 & 52 - 48 - 62 + 45; result += 62 - b >>> 8 & 62 - 45 - 63 + 95; return String.fromCharCode(result); }; URLSafeCoder2.prototype._decodeChar = function(c) { var result = INVALID_BYTE; result += (44 - c & c - 46) >>> 8 & -INVALID_BYTE + c - 45 + 62; result += (94 - c & c - 96) >>> 8 & -INVALID_BYTE + c - 95 + 63; result += (47 - c & c - 58) >>> 8 & -INVALID_BYTE + c - 48 + 52; result += (64 - c & c - 91) >>> 8 & -INVALID_BYTE + c - 65 + 0; result += (96 - c & c - 123) >>> 8 & -INVALID_BYTE + c - 97 + 26; return result; }; return URLSafeCoder2; }(Coder) ); exports2.URLSafeCoder = URLSafeCoder; var urlSafeCoder = new URLSafeCoder(); function encodeURLSafe(data) { return urlSafeCoder.encode(data); } exports2.encodeURLSafe = encodeURLSafe; function decodeURLSafe(s) { return urlSafeCoder.decode(s); } exports2.decodeURLSafe = decodeURLSafe; exports2.encodedLength = function(length) { return stdCoder.encodedLength(length); }; exports2.maxDecodedLength = function(length) { return stdCoder.maxDecodedLength(length); }; exports2.decodedLength = function(s) { return stdCoder.decodedLength(s); }; }, /* 1 */ /***/ function(module2, exports2, __webpack_require__) { "use strict"; Object.defineProperty(exports2, "__esModule", { value: true }); var INVALID_UTF16 = "utf8: invalid string"; var INVALID_UTF8 = "utf8: invalid source encoding"; function encode(s) { var arr = new Uint8Array(encodedLength(s)); var pos = 0; for (var i = 0; i < s.length; i++) { var c = s.charCodeAt(i); if (c < 128) { arr[pos++] = c; } else if (c < 2048) { arr[pos++] = 192 | c >> 6; arr[pos++] = 128 | c & 63; } else if (c < 55296) { arr[pos++] = 224 | c >> 12; arr[pos++] = 128 | c >> 6 & 63; arr[pos++] = 128 | c & 63; } else { i++; c = (c & 1023) << 10; c |= s.charCodeAt(i) & 1023; c += 65536; arr[pos++] = 240 | c >> 18; arr[pos++] = 128 | c >> 12 & 63; arr[pos++] = 128 | c >> 6 & 63; arr[pos++] = 128 | c & 63; } } return arr; } exports2.encode = encode; function encodedLength(s) { var result = 0; for (var i = 0; i < s.length; i++) { var c = s.charCodeAt(i); if (c < 128) { result += 1; } else if (c < 2048) { result += 2; } else if (c < 55296) { result += 3; } else if (c <= 57343) { if (i >= s.length - 1) { throw new Error(INVALID_UTF16); } i++; result += 4; } else { throw new Error(INVALID_UTF16); } } return result; } exports2.encodedLength = encodedLength; function decode(arr) { var chars = []; for (var i = 0; i < arr.length; i++) { var b = arr[i]; if (b & 128) { var min = void 0; if (b < 224) { if (i >= arr.length) { throw new Error(INVALID_UTF8); } var n1 = arr[++i]; if ((n1 & 192) !== 128) { throw new Error(INVALID_UTF8); } b = (b & 31) << 6 | n1 & 63; min = 128; } else if (b < 240) { if (i >= arr.length - 1) { throw new Error(INVALID_UTF8); } var n1 = arr[++i]; var n2 = arr[++i]; if ((n1 & 192) !== 128 || (n2 & 192) !== 128) { throw new Error(INVALID_UTF8); } b = (b & 15) << 12 | (n1 & 63) << 6 | n2 & 63; min = 2048; } else if (b < 248) { if (i >= arr.length - 2) { throw new Error(INVALID_UTF8); } var n1 = arr[++i]; var n2 = arr[++i]; var n3 = arr[++i]; if ((n1 & 192) !== 128 || (n2 & 192) !== 128 || (n3 & 192) !== 128) { throw new Error(INVALID_UTF8); } b = (b & 15) << 18 | (n1 & 63) << 12 | (n2 & 63) << 6 | n3 & 63; min = 65536; } else { throw new Error(INVALID_UTF8); } if (b < min || b >= 55296 && b <= 57343) { throw new Error(INVALID_UTF8); } if (b >= 65536) { if (b > 1114111) { throw new Error(INVALID_UTF8); } b -= 65536; chars.push(String.fromCharCode(55296 | b >> 10)); b = 56320 | b & 1023; } } chars.push(String.fromCharCode(b)); } return chars.join(""); } exports2.decode = decode; }, /* 2 */ /***/ function(module2, exports2, __webpack_require__) { module2.exports = __webpack_require__(3).default; }, /* 3 */ /***/ function(module2, __webpack_exports__, __webpack_require__) { "use strict"; __webpack_require__.r(__webpack_exports__); class ScriptReceiverFactory { constructor(prefix2, name) { this.lastId = 0; this.prefix = prefix2; this.name = name; } create(callback) { this.lastId++; var number = this.lastId; var id = this.prefix + number; var name = this.name + "[" + number + "]"; var called = false; var callbackWrapper = function() { if (!called) { callback.apply(null, arguments); called = true; } }; this[number] = callbackWrapper; return { number, id, name, callback: callbackWrapper }; } remove(receiver) { delete this[receiver.number]; } } var ScriptReceivers = new ScriptReceiverFactory("_pusher_script_", "Pusher.ScriptReceivers"); 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: 12e4, pongTimeout: 3e4, unavailableTimeout: 1e4, 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: "" }; var defaults = Defaults; class dependency_loader_DependencyLoader { constructor(options) { this.options = options; this.receivers = options.receivers || ScriptReceivers; this.loading = {}; } load(name, options, callback) { var self = this; if (self.loading[name] && self.loading[name].length > 0) { self.loading[name].push(callback); } else { self.loading[name] = [callback]; var request = runtime.createScriptRequest(self.getPath(name, options)); var receiver = self.receivers.create(function(error) { self.receivers.remove(receiver); if (self.loading[name]) { var callbacks = self.loading[name]; delete self.loading[name]; var successCallback = function(wasSuccessful) { if (!wasSuccessful) { request.cleanup(); } }; for (var i = 0; i < callbacks.length; i++) { callbacks[i](error, successCallback); } } }); request.send(receiver); } } getRoot(options) { var cdn; var protocol = runtime.getDocument().location.protocol; if (options && options.useTLS || protocol === "https:") { cdn = this.options.cdn_https; } else { cdn = this.options.cdn_http; } return cdn.replace(/\/*$/, "") + "/" + this.options.version; } getPath(name, options) { return this.getRoot(options) + "/" + name + this.options.suffix + ".js"; } } var DependenciesReceivers = new ScriptReceiverFactory("_pusher_dependencies", "Pusher.DependenciesReceivers"); var Dependencies = new dependency_loader_DependencyLoader({ cdn_http: defaults.cdn_http, cdn_https: defaults.cdn_https, version: defaults.VERSION, suffix: defaults.dependency_suffix, receivers: DependenciesReceivers }); 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}`; }; var url_store = { buildLogSuffix }; var AuthRequestType; (function(AuthRequestType2) { AuthRequestType2["UserAuthentication"] = "user-authentication"; AuthRequestType2["ChannelAuthorization"] = "channel-authorization"; })(AuthRequestType || (AuthRequestType = {})); 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); } } const ajax = function(context, query, authOptions, authRequestType, callback) { const xhr = 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; }; var xhr_auth = ajax; 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 < 128 ? c : cc < 2048 ? fromCharCode(192 | cc >>> 6) + fromCharCode(128 | cc & 63) : fromCharCode(224 | cc >>> 12 & 15) + fromCharCode(128 | cc >>> 6 & 63) + fromCharCode(128 | cc & 63); }; 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 = window.btoa || function(b) { return b.replace(/[\s\S]{1,3}/g, cb_encode); }; 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; } } } var abstract_timer = Timer; function timers_clearTimeout(timer) { window.clearTimeout(timer); } function timers_clearInterval(timer) { window.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; }); } } var Util = { now() { if (Date.now) { return Date.now(); } else { return (/* @__PURE__ */ 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)); }; } }; var util = Util; 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, l2 = array.length; i < l2; 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 keys2 = []; objectApply(object, function(_, key) { keys2.push(key); }); return keys2; } function values(object) { var values2 = []; objectApply(object, function(value) { values2.push(value); }); return values2; } function apply(array, f, context) { for (var i = 0; i < array.length; i++) { f.call(context || window, 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 !== void 0; }); 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)); } } class logger_Logger { constructor() { this.globalLog = (message) => { if (window.console && window.console.log) { window.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 (window.console && window.console.warn) { window.console.warn(message); } else { this.globalLog(message); } } globalLogError(message) { if (window.console && window.console.error) { window.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); } } } var logger = new logger_Logger(); var jsonp = function(context, query, authOptions, authRequestType, callback) { if (authOptions.headers !== void 0 || authOptions.headersProvider != null) { logger.warn(`To send headers with the ${authRequestType.toString()} request, you must use AJAX, rather than JSONP.`); } var callbackName = context.nextAuthCallbackID.toString(); context.nextAuthCallbackID++; var document2 = context.getDocument(); var script = document2.createElement("script"); context.auth_callbacks[callbackName] = function(data) { callback(null, data); }; var callback_name = "Pusher.auth_callbacks['" + callbackName + "']"; script.src = authOptions.endpoint + "?callback=" + encodeURIComponent(callback_name) + "&" + query; var head = document2.getElementsByTagName("head")[0] || document2.documentElement; head.insertBefore(script, head.firstChild); }; var jsonp_auth = jsonp; class ScriptRequest { constructor(src) { this.src = src; } send(receiver) { var self = this; var errorString = "Error loading " + self.src; self.script = document.createElement("script"); self.script.id = receiver.id; self.script.src = self.src; self.script.type = "text/javascript"; self.script.charset = "UTF-8"; if (self.script.addEventListener) { self.script.onerror = function() { receiver.callback(errorString); }; self.script.onload = function() { receiver.callback(null); }; } else { self.script.onreadystatechange = function() { if (self.script.readyState === "loaded" || self.script.readyState === "complete") { receiver.callback(null); } }; } if (self.script.async === void 0 && document.attachEvent && /opera/i.test(navigator.userAgent)) { self.errorScript = document.createElement("script"); self.errorScript.id = receiver.id + "_error"; self.errorScript.text = receiver.name + "('" + errorString + "');"; self.script.async = self.errorScript.async = false; } else { self.script.async = true; } var head = document.getElementsByTagName("head")[0]; head.insertBefore(self.script, head.firstChild); if (self.errorScript) { head.insertBefore(self.errorScript, self.script.nextSibling); } } cleanup() { if (this.script) { this.script.onload = this.script.onerror = null; this.script.onreadystatechange = null; } if (this.script && this.script.parentNode) { this.script.parentNode.removeChild(this.script); } if (this.errorScript && this.errorScript.parentNode) { this.errorScript.parentNode.removeChild(this.errorScript); } this.script = null; this.errorScript = null; } } class jsonp_request_JSONPRequest { constructor(url, data) { this.url = url; this.data = data; } send(receiver) { if (this.request) { return; } var query = buildQueryString(this.data); var url = this.url + "/" + receiver.number + "?" + query; this.request = runtime.createScriptRequest(url); this.request.send(receiver); } cleanup() { if (this.request) { this.request.cleanup(); } } } 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 request = runtime.createJSONPRequest(url, data); var receiver = runtime.ScriptReceivers.create(function(error, result) { ScriptReceivers.remove(receiver); request.cleanup(); if (result && result.host) { sender.host = result.host; } if (callback) { callback(error, result); } }); request.send(receiver); }; }; var jsonp_timeline_jsonp = { name: "jsonp", getAgent }; var jsonp_timeline = jsonp_timeline_jsonp; 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); } }; 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 }); } 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; } 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 || window, args); } } else if (this.failThrough) { this.failThrough(eventName, data); } return this; } } class transport_connection_TransportConnection extends dispatcher_Dispatcher { constructor(hooks, name, priority, key, options) { super(); this.initialize = 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 = void 0; } onError(error) { this.emit("error", { type: "WebSocketError", 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 = void 0; } 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 = void 0; this.socket.onerror = void 0; this.socket.onclose = void 0; this.socket.onmessage = void 0; if (this.supportsPing()) { this.socket.onactivity = void 0; } } } changeState(state2, params) { this.state = state2; this.timeline.info(this.buildTimelineMessage({ state: state2, params })); this.emit(state2, params); } buildTimelineMessage(message) { return extend({ cid: this.id }, message); } } 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); } } var WSTransport = new transport_Transport({ urls: ws, handlesActivityChecks: false, supportsPing: false, isInitialized: function() { return Boolean(runtime.getWebSocketAPI()); }, isSupported: function() { return Boolean(runtime.getWebSocketAPI()); }, getSocket: function(url) { return runtime.createWebSocket(url); } }); var httpConfiguration = { urls: http, handlesActivityChecks: false, supportsPing: true, isInitialized: function() { return true; } }; var streamingConfiguration = extend({ getSocket: function(url) { return runtime.HTTPFactory.createStreamingSocket(url); } }, httpConfiguration); var pollingConfiguration = extend({ getSocket: function(url) { return runtime.HTTPFactory.createPollingSocket(url); } }, httpConfiguration); var xhrConfiguration = { isSupported: function() { return 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 }; var transports = Transports; var SockJSTransport = new transport_Transport({ file: "sockjs", urls: sockjs, handlesActivityChecks: true, supportsPing: false, isSupported: function() { return true; }, isInitialized: function() { return window.SockJS !== void 0; }, getSocket: function(url, options) { return new window.SockJS(url, null, { js_path: Dependencies.getPath("sockjs", { useTLS: options.useTLS }), ignore_null_origin: options.ignoreNullOrigin }); }, beforeOpen: function(socket, path) { socket.send(JSON.stringify({ path })); } }); var xdrConfiguration = { isSupported: function(environment) { var yes = runtime.isXDRSupported(environment.useTLS); return yes; } }; var XDRStreamingTransport = new transport_Transport(extend({}, streamingConfiguration, xdrConfiguration)); var XDRPollingTransport = new transport_Transport(extend({}, pollingConfiguration, xdrConfiguration)); transports.xdr_streaming = XDRStreamingTransport; transports.xdr_polling = XDRPollingTransport; transports.sockjs = SockJSTransport; var transports_transports = transports; class net_info_NetInfo extends dispatcher_Dispatcher { constructor() { super(); var self = this; if (window.addEventListener !== void 0) { window.addEventListener("online", function() { self.emit("online"); }, false); window.addEventListener("offline", function() { self.emit("offline"); }, false); } } isOnline() { if (window.navigator.onLine === void 0) { return true; } else { return window.navigator.onLine; } } } var net_info_Network = new net_info_NetInfo(); 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 = void 0; } 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); } } 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 * 1e3 }; } 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 < 4e3) { if (closeEvent.code >= 1002 && closeEvent.code <= 1004) { return "backoff"; } else { return null; } } else if (closeEvent.code === 4e3) { 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 !== 1e3 && closeEvent.code !== 1001) { return { type: "PusherError", data: { code: closeEvent.code, message: closeEvent.reason || closeEvent.message } }; } else { return null; } } }; var protocol_protocol = Protocol; 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 }; if (channel) { event.channel = channel; } logger.debug("Event sent", event); return this.send(protocol_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_protocol.decodeMessage(messageEvent); } catch (e) { this.emit("error", { type: "MessageParseError", error: e, data: messageEvent.data }); } if (pusherEvent !== void 0) { 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_protocol.getCloseAction(closeEvent); var error = protocol_protocol.getCloseError(closeEvent); if (error) { this.emit("error", error); } if (action) { this.emit(action, { action, error }); } } } 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_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_protocol.getCloseAction(closeEvent) || "backoff"; var error = protocol_protocol.getCloseError(closeEvent); this.finish(action, { 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 }, params)); } } class timeline_sender_TimelineSender { constructor(timeline, options) { this.timeline = timeline; this.options = options || {}; } send(useTLS, callback) { if (this.timeline.isEmpty()) { return; } this.timeline.send(runtime.TimelineTransport.getAgent(this, useTLS), callback); } } 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; } } class private_channel_PrivateChannel extends channel_Channel { authorize(socketId, callback) { return this.pusher.config.channelAuthorizer({ channelName: this.name, socketId }, callback); } } class members_Members { constructor() { this.reset(); } get(id) { if (Object.prototype.hasOwnProperty.call(this.members, id)) { return { 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; } } var __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(); } } var utf8 = __webpack_require__(1); var base64 = __webpack_require__(0); 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; } } } 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 = 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 }); if (delay > 0) { this.emit("connecting_in", Math.round(delay / 1e3)); } 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(1e3); } } }); } 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(1e3); }), 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"; } } 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); } } 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); } }; var factory = Factory; 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; } } 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, 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); } }; } } 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; } } class websocket_prioritized_cached_strategy_WebSocketPrioritizedCachedStrategy { constructor(strategy, transports2, options) { this.strategy = strategy; this.transports = transports2; this.ttl = options.ttl || 1800 * 1e3; 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 + 1e3, 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 = 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 = runtime.getLocalStorage(); if (storage) { try { storage[getTransportCacheKey(usingTLS)] = safeJSONStringify({ timestamp: util.now(), transport, latency, cacheSkipCount }); } catch (e) { } } } function flushTransportCache(usingTLS) { var storage = runtime.getLocalStorage(); if (storage) { try { delete storage[getTransportCacheKey(usingTLS)]; } catch (e) { } } } 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); } } }; } } 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); } } 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; } } 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 = Object.assign({}, ws_options, { useTLS: true }); var sockjs_options = Object.assign({}, baseOptions, { hostNonTLS: config.httpHost + ":" + config.httpPort, hostTLS: config.httpHost + ":" + config.httpsPort, httpPath: config.httpPath }); var timeouts = { loop: true, timeout: 15e3, timeoutLimit: 6e4 }; var ws_manager = new transport_manager_TransportManager({ minPingDelay: 1e4, maxPingDelay: config.activityTimeout }); var streaming_manager = new transport_manager_TransportManager({ lives: 2, minPingDelay: 1e4, 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 sockjs_transport = defineTransportStrategy("sockjs", "sockjs", 1, sockjs_options); var xhr_streaming_transport = defineTransportStrategy("xhr_streaming", "xhr_streaming", 1, sockjs_options, streaming_manager); var xdr_streaming_transport = defineTransportStrategy("xdr_streaming", "xdr_streaming", 1, sockjs_options, streaming_manager); var xhr_polling_transport = defineTransportStrategy("xhr_polling", "xhr_polling", 1, sockjs_options); var xdr_polling_transport = defineTransportStrategy("xdr_polling", "xdr_polling", 1, sockjs_options); var ws_loop = new sequential_strategy_SequentialStrategy([ws_transport], timeouts); var wss_loop = new sequential_strategy_SequentialStrategy([wss_transport], timeouts); var sockjs_loop = new sequential_strategy_SequentialStrategy([sockjs_transport], timeouts); var streaming_loop = new sequential_strategy_SequentialStrategy([ new IfStrategy(testSupportsStrategy(xhr_streaming_transport), xhr_streaming_transport, xdr_streaming_transport) ], timeouts); var polling_loop = new sequential_strategy_SequentialStrategy([ new IfStrategy(testSupportsStrategy(xhr_polling_transport), xhr_polling_transport, xdr_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: 4e3 }) ]), polling_loop) ], timeouts); var http_fallback_loop = new IfStrategy(testSupportsStrategy(http_loop), http_loop, sockjs_loop); var wsStrategy; if (baseOptions.useTLS) { wsStrategy = new best_connected_ever_strategy_BestConnectedEverStrategy([ ws_loop, new delayed_strategy_DelayedStrategy(http_fallback_loop, { delay: 2e3 }) ]); } else { wsStrategy = new best_connected_ever_strategy_BestConnectedEverStrategy([ ws_loop, new delayed_strategy_DelayedStrategy(wss_loop, { delay: 2e3 }), new delayed_strategy_DelayedStrategy(http_fallback_loop, { delay: 5e3 }) ]); } return new websocket_prioritized_cached_strategy_WebSocketPrioritizedCachedStrategy(new FirstConnectedStrategy(new IfStrategy(testSupportsStrategy(ws_transport), wsStrategy, http_fallback_loop)), definedTransports, { ttl: 18e5, timeline: baseOptions.timeline, useTLS: baseOptions.useTLS }); }; var default_strategy = getDefaultStrategy; 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 if (self.hooks.file) { self.changeState("initializing"); Dependencies.load(self.hooks.file, { useTLS: self.options.useTLS }, function(error, callback) { if (self.hooks.isInitialized()) { self.changeState("initialized"); callback(true); } else { if (error) { self.onError(error); } self.onClose(); callback(false); } }); } else { self.onClose(); } }; var http_xdomain_request_hooks = { getRequest: function(socket) { var xdr = new window.XDomainRequest(); xdr.ontimeout = function() { socket.emit("error", new RequestTimedOut()); socket.close(); }; xdr.onerror = function(e) { socket.emit("error", e); socket.close(); }; xdr.onprogress = function() { if (xdr.responseText && xdr.responseText.length > 0) { socket.onChunk(200, xdr.responseText); } }; xdr.onload = function() { if (xdr.responseText && xdr.responseText.length > 0) { socket.onChunk(200, xdr.responseText); } socket.emit("finished", 200); socket.close(); }; return xdr; }, abortRequest: function(xdr) { xdr.ontimeout = xdr.onerror = xdr.onprogress = xdr.onload = null; xdr.abort(); } }; var http_xdomain_request = http_xdomain_request_hooks; 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(); }; 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) { 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, 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; } } var State; (function(State2) { State2[State2["CONNECTING"] = 0] = "CONNECTING"; State2[State2["OPEN"] = 1] = "OPEN"; State2[State2["CLOSED"] = 3] = "CLOSED"; })(State || (State = {})); var state = State; var autoIncrement = 1; class http_socket_HTTPSocket { constructor(hooks, url) { this.hooks = hooks; this.session = randomNumber(1e3) + "/" + 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 { 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, reason, 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 = 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=" + +/* @__PURE__ */ new Date() + "&n=" + autoIncrement++; } function replaceHost(url, hostname) { var urlParts = /(https?:\/\/)([^\/:]+)((\/|:)?.*)/.exec(url); return urlParts[1] + hostname + urlParts[3]; } function randomNumber(max) { return runtime.randomInt(max); } function randomString(length) { var result = []; for (var i = 0; i < length; i++) { result.push(randomNumber(32).toString(32)); } return result.join(""); } var http_socket = http_socket_HTTPSocket; 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); } }; var http_streaming_socket = http_streaming_socket_hooks; 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); } } }; var http_polling_socket = http_polling_socket_hooks; var http_xhr_request_hooks = { getRequest: function(socket) { var Constructor = 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(); } }; var http_xhr_request = http_xhr_request_hooks; 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); } }; var http_http = HTTP; http_http.createXDR = function(method, url) { return this.createRequest(http_xdomain_request, method, url); }; var web_http_http = http_http; var Runtime = { nextAuthCallbackID: 1, auth_callbacks: {}, ScriptReceivers, DependenciesReceivers, getDefaultStrategy: default_strategy, Transports: transports_transports, transportConnectionInitializer: transport_connection_initializer, HTTPFactory: web_http_http, TimelineTransport: jsonp_timeline, getXHRAPI() { return window.XMLHttpRequest; }, getWebSocketAPI() { return window.WebSocket || window.MozWebSocket; }, setup(PusherClass) { window.Pusher = PusherClass; var initializeOnDocumentBody = () => { this.onDocumentBody(PusherClass.ready); }; if (!window.JSON) { Dependencies.load("json2", {}, initializeOnDocumentBody); } else { initializeOnDocumentBody(); } }, getDocument() { return document; }, getProtocol() { return this.getDocument().location.protocol; }, getAuthorizers() { return { ajax: xhr_auth, jsonp: jsonp_auth }; }, onDocumentBody(callback) { if (document.body) { callback(); } else { setTimeout(() => { this.onDocumentBody(callback); }, 0); } }, createJSONPRequest(url, data) { return new jsonp_request_JSONPRequest(url, data); }, createScriptRequest(src) { return new ScriptRequest(src); }, getLocalStorage() { try { return window.localStorage; } catch (e) { return void 0; } }, createXHR() { if (this.getXHRAPI()) { return this.createXMLHttpRequest(); } else { return this.createMicrosoftXHR(); } }, createXMLHttpRequest() { var Constructor = this.getXHRAPI(); return new Constructor(); }, createMicrosoftXHR() { return new ActiveXObject("Microsoft.XMLHTTP"); }, getNetwork() { return net_info_Network; }, createWebSocket(url) { var Constructor = this.getWebSocketAPI(); return new Constructor(url); }, createSocketRequest(method, url) { if (this.isXHRSupported()) { return this.HTTPFactory.createXHR(method, url); } else if (this.isXDRSupported(url.indexOf("https:") === 0)) { return this.HTTPFactory.createXDR(method, url); } else { throw "Cross-origin HTTP requests are not supported"; } }, isXHRSupported() { var Constructor = this.getXHRAPI(); return Boolean(Constructor) && new Constructor().withCredentials !== void 0; }, isXDRSupported(useTLS) { var protocol = useTLS ? "https:" : "http:"; var documentProtocol = this.getProtocol(); return Boolean(window["XDomainRequest"]) && documentProtocol === protocol; }, addUnloadListener(listener) { if (window.addEventListener !== void 0) { window.addEventListener("unload", listener, false); } else if (window.attachEvent !== void 0) { window.attachEvent("onunload", listener); } }, removeUnloadListener(listener) { if (window.addEventListener !== void 0) { window.removeEventListener("unload", listener, false); } else if (window.detachEvent !== void 0) { window.detachEvent("onunload", listener); } }, randomInt(max) { const random = function() { const crypto = window.crypto || window["msCrypto"]; const random2 = crypto.getRandomValues(new Uint32Array(1))[0]; return random2 / Math.pow(2, 32); }; return Math.floor(random() * max); } }; var runtime = Runtime; var TimelineLevel; (function(TimelineLevel2) { TimelineLevel2[TimelineLevel2["ERROR"] = 3] = "ERROR"; TimelineLevel2[TimelineLevel2["INFO"] = 6] = "INFO"; TimelineLevel2[TimelineLevel2["DEBUG"] = 7] = "DEBUG"; })(TimelineLevel || (TimelineLevel = {})); var timeline_level = TimelineLevel; 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; } } 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() { } }; } const { Transports: strategy_builder_Transports } = 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() { } }; } }; 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"); } } 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 runtime.getAuthorizers()[authOptions.transport] === "undefined") { throw `'${authOptions.transport}' is not a recognized auth transport`; } return (params, callback) => { const query = composeChannelQuery(params, authOptions); runtime.getAuthorizers()[authOptions.transport](runtime, query, authOptions, AuthRequestType.UserAuthentication, callback); }; }; var user_authenticator = UserAuthenticator; 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 runtime.getAuthorizers()[authOptions.transport] === "undefined") { throw `'${authOptions.transport}' is not a recognized auth transport`; } return (params, callback) => { const query = channel_authorizer_composeChannelQuery(params, authOptions); runtime.getAuthorizers()[authOptions.transport](runtime, query, authOptions, AuthRequestType.ChannelAuthorization, callback); }; }; var channel_authorizer = ChannelAuthorizer; 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); }; }; 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 (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); } 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); } }); } } function flatPromise() { let resolve, reject; const promise = new Promise((res, rej) => { resolve = res; reject = rej; }); return { promise, resolve, reject }; } var flat_promise = flatPromise; 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; } } class pusher_Pusher { static ready() { pusher_Pusher.isReady = true; for (var i = 0, l2 = pusher_Pusher.instances.length; i < l2; i++) { pusher_Pusher.instances[i].connect(); } } static getClientFeatures() { return keys(filterObject({ ws: 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 = runtime.randomInt(1e9); 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/" + runtime.TimelineTransport.name }); } var getStrategy = (options2) => { return runtime.getDefaultStrategy(this.config, options2, strategy_builder_defineTransport); }; this.connection = factory.createConnectionManager(this.key, { 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(6e4, 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 = runtime; pusher_Pusher.ScriptReceivers = runtime.ScriptReceivers; pusher_Pusher.DependenciesReceivers = runtime.DependenciesReceivers; pusher_Pusher.auth_callbacks = runtime.auth_callbacks; var core_pusher = __webpack_exports__["default"] = pusher_Pusher; function checkAppKey(key) { if (key === null || key === void 0) { throw "You must pass your app key when you instantiate Pusher."; } } runtime.setup(pusher_Pusher); } /******/ ]) ); }); } }); export default require_pusher(); /*! Bundled license information: pusher-js/dist/web/pusher.js: (*! * Pusher JavaScript Library v8.4.0-rc2 * https://pusher.com/ * * Copyright 2020, Pusher * Released under the MIT licence. *) */ //# sourceMappingURL=pusher-js.js.map
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings