@cendarsoss/pusher-js 8.4.13 → 8.4.14

package/dist/web/pusher.mjs

@@ -23,24 +23,18 @@ class ScriptReceiverFactory {
     delete this[receiver.number];
   }
 }
-var ScriptReceivers = new ScriptReceiverFactory(
-  "_pusher_script_",
-  "Pusher.ScriptReceivers"
-);
+var ScriptReceivers = new ScriptReceiverFactory("_pusher_script_", "Pusher.ScriptReceivers");
 var Defaults = {
   VERSION: "8.4.0",
   PROTOCOL: 7,
   wsPort: 80,
   wssPort: 443,
   wsPath: "",
-  // DEPRECATED: SockJS fallback parameters
   httpHost: "sockjs.pusher.com",
   httpPort: 80,
   httpsPort: 443,
   httpPath: "/pusher",
-  // DEPRECATED: Stats
   stats_host: "stats.pusher.com",
-  // DEPRECATED: Other settings
   authEndpoint: "/pusher/auth",
   authTransport: "ajax",
   activityTimeout: 12e4,
@@ -54,7 +48,6 @@ var Defaults = {
     endpoint: "/pusher/auth",
     transport: "ajax"
   },
-  // CDN configuration
   cdn_http: "//js.pusher.com/",
   cdn_https: "//js.pusher.com/",
   dependency_suffix: ""
@@ -65,11 +58,6 @@ class DependencyLoader {
     this.receivers = options.receivers || ScriptReceivers;
     this.loading = {};
   }
-  /** Loads the dependency from CDN.
-   *
-   * @param  {String} name
-   * @param  {Function} callback
-   */
   load(name, options, callback) {
     var self = this;
     if (self.loading[name] && self.loading[name].length > 0) {
@@ -95,10 +83,6 @@ class DependencyLoader {
       request.send(receiver);
     }
   }
-  /** Returns a root URL for pusher-js CDN.
-   *
-   * @returns {String}
-   */
   getRoot(options) {
     var cdn;
     var protocol = Runtime.getDocument().location.protocol;
@@ -109,19 +93,11 @@ class DependencyLoader {
     }
     return cdn.replace(/\/*$/, "") + "/" + this.options.version;
   }
-  /** Returns a full path to a dependency file.
-   *
-   * @param {String} name
-   * @returns {String}
-   */
   getPath(name, options) {
     return this.getRoot(options) + "/" + name + this.options.suffix + ".js";
   }
 }
-var DependenciesReceivers = new ScriptReceiverFactory(
-  "_pusher_dependencies",
-  "Pusher.DependenciesReceivers"
-);
+var DependenciesReceivers = new ScriptReceiverFactory("_pusher_dependencies", "Pusher.DependenciesReceivers");
 var Dependencies = new DependencyLoader({
   cdn_http: Defaults.cdn_http,
   cdn_https: Defaults.cdn_https,
@@ -152,22 +128,24 @@ const urlStore = {
 const buildLogSuffix = function(key) {
   const urlPrefix = "See:";
   const urlObj = urlStore.urls[key];
-  if (!urlObj) return "";
+  if (!urlObj)
+    return "";
   let url;
   if (urlObj.fullUrl) {
     url = urlObj.fullUrl;
   } else if (urlObj.path) {
     url = urlStore.baseUrl + urlObj.path;
   }
-  if (!url) return "";
+  if (!url)
+    return "";
   return `${urlPrefix} ${url}`;
 };
 const urlStore$1 = { buildLogSuffix };
-var AuthRequestType = /* @__PURE__ */ ((AuthRequestType2) => {
+var AuthRequestType;
+(function(AuthRequestType2) {
   AuthRequestType2["UserAuthentication"] = "user-authentication";
   AuthRequestType2["ChannelAuthorization"] = "channel-authorization";
-  return AuthRequestType2;
-})(AuthRequestType || {});
+})(AuthRequestType || (AuthRequestType = {}));
 class BadEventName extends Error {
   constructor(msg) {
     super(msg);
@@ -245,13 +223,7 @@ const ajax = function(context, query, authOptions, authRequestType, callback) {
           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
-          );
+          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);
@@ -263,18 +235,10 @@ const ajax = function(context, query, authOptions, authRequestType, callback) {
             suffix = urlStore$1.buildLogSuffix("authenticationEndpoint");
             break;
           case AuthRequestType.ChannelAuthorization:
-            suffix = `Clients must be authorized to join private or presence channels. ${urlStore$1.buildLogSuffix(
-              "authorizationEndpoint"
-            )}`;
+            suffix = `Clients must be authorized to join private or presence channels. ${urlStore$1.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
-        );
+        callback(new HTTPAuthError(xhr.status, `Unable to retrieve auth string from ${authRequestType.toString()} endpoint - received status: ${xhr.status} from ${authOptions.endpoint}. ${suffix}`), null);
       }
     }
   };
@@ -316,14 +280,9 @@ class Timer {
       }
     }, delay);
   }
-  /** Returns whether the timer is still running.
-   *
-   * @return {Boolean}
-   */
   isRunning() {
     return this.timer !== null;
   }
-  /** Aborts a timer when it's running. */
   ensureAborted() {
     if (this.timer) {
       this.clear(this.timer);
@@ -364,14 +323,6 @@ var Util = {
   defer(callback) {
     return new OneOffTimer(0, callback);
   },
-  /** Builds a function that will proxy a method call to its first argument.
-   *
-   * Allows partial application of arguments, so additional arguments are
-   * prepended to the argument list.
-   *
-   * @param  {String} name method name
-   * @return {Function} proxy function
-   */
   method(name, ...args) {
     var boundArguments = Array.prototype.slice.call(arguments, 1);
     return function(object) {
@@ -514,10 +465,7 @@ function buildQueryString(data) {
   var params = filterObject(data, function(value) {
     return value !== void 0;
   });
-  var query = map(
-    flatten(encodeParamsObject(params)),
-    Util.method("join", "=")
-  ).join("&");
+  var query = map(flatten(encodeParamsObject(params)), Util.method("join", "=")).join("&");
   return query;
 }
 function decycleObject(object) {
@@ -545,10 +493,7 @@ function decycleObject(object) {
           nu = {};
           for (name in value) {
             if (Object.prototype.hasOwnProperty.call(value, name)) {
-              nu[name] = derez(
-                value[name],
-                path + "[" + JSON.stringify(name) + "]"
-              );
+              nu[name] = derez(value[name], path + "[" + JSON.stringify(name) + "]");
             }
           }
         }
@@ -571,7 +516,7 @@ let config = {
   logToConsole: false
 };
 function setLoggerConfig(newConfig) {
-  config = { ...config, ...newConfig };
+  config = Object.assign(Object.assign({}, config), newConfig);
 }
 class Logger {
   constructor() {
@@ -617,9 +562,7 @@ class Logger {
 const Logger$1 = new Logger();
 var jsonp$1 = function(context, query, authOptions, authRequestType, callback) {
   if (authOptions.headers !== void 0 || authOptions.headersProvider != null) {
-    Logger$1.warn(
-      `To send headers with the ${authRequestType.toString()} request, you must use AJAX, rather than JSONP.`
-    );
+    Logger$1.warn(`To send headers with the ${authRequestType.toString()} request, you must use AJAX, rather than JSONP.`);
   }
   var callbackName = context.nextAuthCallbackID.toString();
   context.nextAuthCallbackID++;
@@ -673,7 +616,6 @@ class ScriptRequest {
       head.insertBefore(self.errorScript, self.script.nextSibling);
     }
   }
-  /** Cleans up the DOM remains of the script request. */
   cleanup() {
     if (this.script) {
       this.script.onload = this.script.onerror = null;
@@ -689,31 +631,6 @@ class ScriptRequest {
     this.errorScript = null;
   }
 }
-class JSONPRequest {
-  constructor(url, data) {
-    this.url = url;
-    this.data = data;
-  }
-  /** Sends the actual JSONP request.
-   *
-   * @param {ScriptReceiver} receiver
-   */
-  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);
-  }
-  /** Cleans up the DOM remains of the JSONP request. */
-  cleanup() {
-    if (this.request) {
-      this.request.cleanup();
-    }
-  }
-}
 var getAgent = function(sender, useTLS) {
   return function(data, callback) {
     var scheme = "http" + (useTLS ? "s" : "") + "://";
@@ -794,30 +711,19 @@ class CallbackRegistry {
     }
   }
   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
-    );
+    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
-    );
+    apply(names, function(name) {
+      delete this._callbacks[name];
+    }, this);
   }
 }
 function prefix(name) {
@@ -846,10 +752,7 @@ class Dispatcher {
       this.global_callbacks = [];
       return this;
     }
-    this.global_callbacks = filter(
-      this.global_callbacks || [],
-      (c) => c !== callback
-    );
+    this.global_callbacks = filter(this.global_callbacks || [], (c) => c !== callback);
     return this;
   }
   unbind_all() {
@@ -892,24 +795,12 @@ class TransportConnection extends Dispatcher {
     this.activityTimeout = options.activityTimeout;
     this.id = this.timeline.generateUniqueID();
   }
-  /** Checks whether the transport handles activity checks by itself.
-   *
-   * @return {Boolean}
-   */
   handlesActivityChecks() {
     return Boolean(this.hooks.handlesActivityChecks);
   }
-  /** Checks whether the transport supports the ping/pong API.
-   *
-   * @return {Boolean}
-   */
   supportsPing() {
     return Boolean(this.hooks.supportsPing);
   }
-  /** Tries to establish a connection.
-   *
-   * @returns {Boolean} false if transport is in invalid state
-   */
   connect() {
     if (this.socket || this.state !== "initialized") {
       return false;
@@ -929,10 +820,6 @@ class TransportConnection extends Dispatcher {
     this.changeState("connecting");
     return true;
   }
-  /** Closes the connection.
-   *
-   * @return {Boolean} true if there was a connection to close
-   */
   close() {
     if (this.socket) {
       this.socket.close();
@@ -941,11 +828,6 @@ class TransportConnection extends Dispatcher {
       return false;
     }
   }
-  /** Sends data over the open connection.
-   *
-   * @param {String} data
-   * @return {Boolean} true only when in the "open" state
-   */
   send(data) {
     if (this.state === "open") {
       Util.defer(() => {
@@ -958,7 +840,6 @@ class TransportConnection extends Dispatcher {
       return false;
     }
   }
-  /** Sends a ping if the connection is open and transport supports it. */
   ping() {
     if (this.state === "open" && this.supportsPing()) {
       this.socket.ping();
@@ -966,10 +847,7 @@ class TransportConnection extends Dispatcher {
   }
   onOpen() {
     if (this.hooks.beforeOpen) {
-      this.hooks.beforeOpen(
-        this.socket,
-        this.hooks.urls.getPath(this.key, this.options)
-      );
+      this.hooks.beforeOpen(this.socket, this.hooks.urls.getPath(this.key, this.options));
     }
     this.changeState("open");
     this.socket.onopen = void 0;
@@ -1029,12 +907,10 @@ class TransportConnection extends Dispatcher {
   }
   changeState(state, params) {
     this.state = state;
-    this.timeline.info(
-      this.buildTimelineMessage({
-        state,
-        params
-      })
-    );
+    this.timeline.info(this.buildTimelineMessage({
+      state,
+      params
+    }));
     this.emit(state, params);
   }
   buildTimelineMessage(message) {
@@ -1045,22 +921,9 @@ class Transport {
   constructor(hooks2) {
     this.hooks = hooks2;
   }
-  /** Returns whether the transport is supported in the environment.
-   *
-   * @param {Object} envronment te environment details (encryption, settings)
-   * @returns {Boolean} true when the transport is supported
-   */
   isSupported(environment) {
     return this.hooks.isSupported(environment);
   }
-  /** Creates a transport connection.
-   *
-   * @param {String} name
-   * @param {Number} priority
-   * @param {String} key the application key
-   * @param {Object} options
-   * @returns {TransportConnection}
-   */
   createConnection(name, priority, key, options) {
     return new TransportConnection(this.hooks, name, priority, key, options);
   }
@@ -1087,33 +950,23 @@ var httpConfiguration = {
     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 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(
-  extend({}, streamingConfiguration, xhrConfiguration)
-);
-var XHRPollingTransport = new Transport(
-  extend({}, pollingConfiguration, xhrConfiguration)
-);
+var XHRStreamingTransport = new Transport(extend({}, streamingConfiguration, xhrConfiguration));
+var XHRPollingTransport = new Transport(extend({}, pollingConfiguration, xhrConfiguration));
 var Transports$1 = {
   ws: WSTransport,
   xhr_streaming: XHRStreamingTransport,
@@ -1139,11 +992,9 @@ var SockJSTransport = new Transport({
     });
   },
   beforeOpen: function(socket, path) {
-    socket.send(
-      JSON.stringify({
-        path
-      })
-    );
+    socket.send(JSON.stringify({
+      path
+    }));
   }
 });
 var xdrConfiguration = {
@@ -1152,12 +1003,8 @@ var xdrConfiguration = {
     return yes;
   }
 };
-var XDRStreamingTransport = new Transport(
-  extend({}, streamingConfiguration, xdrConfiguration)
-);
-var XDRPollingTransport = new Transport(
-  extend({}, pollingConfiguration, xdrConfiguration)
-);
+var XDRStreamingTransport = new Transport(extend({}, streamingConfiguration, xdrConfiguration));
+var XDRPollingTransport = new Transport(extend({}, pollingConfiguration, xdrConfiguration));
 Transports$1.xdr_streaming = XDRStreamingTransport;
 Transports$1.xdr_polling = XDRPollingTransport;
 Transports$1.sockjs = SockJSTransport;
@@ -1166,30 +1013,14 @@ class NetInfo extends Dispatcher {
     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
-      );
+      window.addEventListener("online", function() {
+        self.emit("online");
+      }, false);
+      window.addEventListener("offline", function() {
+        self.emit("offline");
+      }, false);
     }
   }
-  /** Returns whether browser is online or not
-   *
-   * Offline means definitely offline (no connection to router).
-   * Inverse does NOT mean definitely online (only currently supported in Safari
-   * and even there only means the device has a connection to the router).
-   *
-   * @return {Boolean}
-   */
   isOnline() {
     if (window.navigator.onLine === void 0) {
       return true;
@@ -1207,26 +1038,11 @@ class AssistantToTheTransportManager {
     this.maxPingDelay = options.maxPingDelay;
     this.pingDelay = void 0;
   }
-  /** Creates a transport connection.
-   *
-   * This function has the same API as Transport#createConnection.
-   *
-   * @param {String} name
-   * @param {Number} priority
-   * @param {String} key the application key
-   * @param {Object} options
-   * @returns {TransportConnection}
-   */
   createConnection(name, priority, key, options) {
     options = extend({}, options, {
       activityTimeout: this.pingDelay
     });
-    var connection = this.transport.createConnection(
-      name,
-      priority,
-      key,
-      options
-    );
+    var connection = this.transport.createConnection(name, priority, key, options);
     var openTimestamp = null;
     var onOpen = function() {
       connection.unbind("open", onOpen);
@@ -1248,35 +1064,13 @@ class AssistantToTheTransportManager {
     connection.bind("open", onOpen);
     return connection;
   }
-  /** Returns whether the transport is supported in the environment.
-   *
-   * This function has the same API as Transport#isSupported. Might return false
-   * when the manager decides to kill the transport.
-   *
-   * @param {Object} environment the environment details (encryption, settings)
-   * @returns {Boolean} true when the transport is supported
-   */
   isSupported(environment) {
     return this.manager.isAlive() && this.transport.isSupported(environment);
   }
 }
 const Protocol = {
-  /**
-   * Decodes a message in a Pusher format.
-   *
-   * The MessageEvent we receive from the transport should contain a pusher event
-   * (https://pusher.com/docs/pusher_protocol#events) serialized as JSON in the
-   * data field
-   *
-   * The pusher event may contain a data field too, and it may also be
-   * serialised as JSON
-   *
-   * Throws errors when messages are not parse'able.
-   *
-   * @param  {MessageEvent} messageEvent
-   * @return {PusherEvent}
-   */
   decodeMessage: function(messageEvent) {
+    var _a, _b;
     try {
       var messageData = JSON.parse(messageEvent.data);
       var pusherEventData = messageData.data;
@@ -1291,13 +1085,12 @@ const Protocol = {
         channel: messageData.channel,
         data: pusherEventData,
         rawMessage: messageEvent.data
-        // Preserve raw message for delta compression
       };
       if (messageData.user_id) {
         pusherEvent.user_id = messageData.user_id;
       }
-      const sequence = messageData.__delta_seq ?? messageData.sequence;
-      const conflationKey = messageData.__conflation_key ?? messageData.conflation_key;
+      const sequence = (_a = messageData.__delta_seq) !== null && _a !== void 0 ? _a : messageData.sequence;
+      const conflationKey = (_b = messageData.__conflation_key) !== null && _b !== void 0 ? _b : messageData.conflation_key;
       if (typeof sequence === "number") {
         pusherEvent.sequence = sequence;
       }
@@ -1309,29 +1102,9 @@ const Protocol = {
       throw { type: "MessageParseError", error: e, data: messageEvent.data };
     }
   },
-  /**
-   * Encodes a message to be sent.
-   *
-   * @param  {PusherEvent} event
-   * @return {String}
-   */
   encodeMessage: function(event) {
     return JSON.stringify(event);
   },
-  /**
-   * Processes a handshake message and returns appropriate actions.
-   *
-   * Returns an object with an 'action' and other action-specific properties.
-   *
-   * There are three outcomes when calling this function. First is a successful
-   * connection attempt, when pusher:connection_established is received, which
-   * results in a 'connected' action with an 'id' property. When passed a
-   * pusher:error event, it returns a result with action appropriate to the
-   * close code and an error. Otherwise, it raises an exception.
-   *
-   * @param {String} message
-   * @result Object
-   */
   processHandshake: function(messageEvent) {
     var message = Protocol.decodeMessage(messageEvent);
     if (message.event === "pusher:connection_established") {
@@ -1352,16 +1125,6 @@ const Protocol = {
       throw "Invalid handshake";
     }
   },
-  /**
-   * Dispatches the close event and returns an appropriate action name.
-   *
-   * See:
-   * 1. https://developer.mozilla.org/en-US/docs/WebSockets/WebSockets_reference/CloseEvent
-   * 2. http://pusher.com/docs/pusher_protocol
-   *
-   * @param  {CloseEvent} closeEvent
-   * @return {String} close action name
-   */
   getCloseAction: function(closeEvent) {
     if (closeEvent.code < 4e3) {
       if (closeEvent.code >= 1002 && closeEvent.code <= 1004) {
@@ -1381,15 +1144,6 @@ const Protocol = {
       return "refused";
     }
   },
-  /**
-   * Returns an error or null basing on the close event.
-   *
-   * Null is returned when connection was closed cleanly. Otherwise, an object
-   * with error details is returned.
-   *
-   * @param  {CloseEvent} closeEvent
-   * @return {Object} error object
-   */
   getCloseError: function(closeEvent) {
     if (closeEvent.code !== 1e3 && closeEvent.code !== 1001) {
       return {
@@ -1412,27 +1166,12 @@ class Connection extends Dispatcher {
     this.activityTimeout = transport.activityTimeout;
     this.bindListeners();
   }
-  /** Returns whether used transport handles activity checks by itself
-   *
-   * @returns {Boolean} true if activity checks are handled by the transport
-   */
   handlesActivityChecks() {
     return this.transport.handlesActivityChecks();
   }
-  /** Sends raw data.
-   *
-   * @param {String} data
-   */
   send(data) {
     return this.transport.send(data);
   }
-  /** Sends an event.
-   *
-   * @param {String} name
-   * @param {String} data
-   * @param {String} [channel]
-   * @returns {Boolean} whether message was sent or not
-   */
   send_event(name, data, channel) {
     var event = { event: name, data };
     if (channel) {
@@ -1441,11 +1180,6 @@ class Connection extends Dispatcher {
     Logger$1.debug("Event sent", event);
     return this.send(Protocol.encodeMessage(event));
   }
-  /** Sends a ping message to the server.
-   *
-   * Basing on the underlying transport, it might send either transport's
-   * protocol-specific ping or pusher:ping event.
-   */
   ping() {
     if (this.transport.supportsPing()) {
       this.transport.ping();
@@ -1453,7 +1187,6 @@ class Connection extends Dispatcher {
       this.send_event("pusher:ping", {});
     }
   }
-  /** Closes the connection. */
   close() {
     this.transport.close();
   }
@@ -1569,9 +1302,7 @@ class Handshake {
     this.transport.unbind("closed", this.onClosed);
   }
   finish(action, params) {
-    this.callback(
-      extend({ transport: this.transport, action }, params)
-    );
+    this.callback(extend({ transport: this.transport, action }, params));
   }
 }
 class TimelineSender {
@@ -1583,10 +1314,7 @@ class TimelineSender {
     if (this.timeline.isEmpty()) {
       return;
     }
-    this.timeline.send(
-      Runtime.TimelineTransport.getAgent(this, useTLS),
-      callback
-    );
+    this.timeline.send(Runtime.TimelineTransport.getAgent(this, useTLS), callback);
   }
 }
 class Channel extends Dispatcher {
@@ -1601,37 +1329,23 @@ class Channel extends Dispatcher {
     this.subscriptionCancelled = false;
     this.tagsFilter = null;
   }
-  /** Skips authorization, since public channels don't require it.
-   *
-   * @param {Function} callback
-   */
   authorize(socketId, callback) {
     return callback(null, { auth: "" });
   }
-  /** Triggers an event */
   trigger(event, data) {
     if (event.indexOf("client-") !== 0) {
-      throw new BadEventName(
-        "Event '" + event + "' does not start with 'client-'"
-      );
+      throw new BadEventName("Event '" + event + "' does not start with 'client-'");
     }
     if (!this.subscribed) {
       var suffix = urlStore$1.buildLogSuffix("triggeringClientEvents");
-      Logger$1.warn(
-        `Client event triggered before channel 'subscription_succeeded' event . ${suffix}`
-      );
+      Logger$1.warn(`Client event triggered before channel 'subscription_succeeded' event . ${suffix}`);
     }
     return this.pusher.send_event(event, data, this.name);
   }
-  /** Signals disconnection to the channel. For internal use only. */
   disconnect() {
     this.subscribed = false;
     this.subscriptionPending = false;
   }
-  /** Handles a PusherEvent. For internal use only.
-   *
-   * @param {PusherEvent} event
-   */
   handleEvent(event) {
     var eventName = event.event;
     var data = event.data;
@@ -1659,87 +1373,58 @@ class Channel extends Dispatcher {
     }
     this.emit("pusher:subscription_count", event.data);
   }
-  /** Sends a subscription request. For internal use only. */
   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$1.error(error.toString());
-          this.emit(
-            "pusher:subscription_error",
-            Object.assign(
-              {},
-              {
-                type: "AuthError",
-                error: error.message
-              },
-              error instanceof HTTPAuthError ? { status: error.status } : {}
-            )
-          );
-        } else {
-          const subscribeData = {
-            auth: data.auth,
-            channel_data: data.channel_data,
-            channel: this.name
-          };
-          if (this.tagsFilter) {
-            subscribeData.tags_filter = this.tagsFilter;
-          }
-          this.pusher.send_event("pusher:subscribe", subscribeData);
+    this.authorize(this.pusher.connection.socket_id, (error, data) => {
+      if (error) {
+        this.subscriptionPending = false;
+        Logger$1.error(error.toString());
+        this.emit("pusher:subscription_error", Object.assign({}, {
+          type: "AuthError",
+          error: error.message
+        }, error instanceof HTTPAuthError ? { status: error.status } : {}));
+      } else {
+        const subscribeData = {
+          auth: data.auth,
+          channel_data: data.channel_data,
+          channel: this.name
+        };
+        if (this.tagsFilter) {
+          subscribeData.tags_filter = this.tagsFilter;
         }
+        this.pusher.send_event("pusher:subscribe", subscribeData);
       }
-    );
+    });
   }
-  /** Sends an unsubscription request. For internal use only. */
   unsubscribe() {
     this.subscribed = false;
     this.pusher.send_event("pusher:unsubscribe", {
       channel: this.name
     });
   }
-  /** Cancels an in progress subscription. For internal use only. */
   cancelSubscription() {
     this.subscriptionCancelled = true;
   }
-  /** Reinstates an in progress subscripiton. For internal use only. */
   reinstateSubscription() {
     this.subscriptionCancelled = false;
   }
 }
 class PrivateChannel extends Channel {
-  /** Authorizes the connection to use the channel.
-   *
-   * @param  {String} socketId
-   * @param  {Function} callback
-   */
   authorize(socketId, callback) {
-    return this.pusher.config.channelAuthorizer(
-      {
-        channelName: this.name,
-        socketId
-      },
-      callback
-    );
+    return this.pusher.config.channelAuthorizer({
+      channelName: this.name,
+      socketId
+    }, callback);
   }
 }
 class Members {
   constructor() {
     this.reset();
   }
-  /** Returns member's info for given id.
-   *
-   * Resulting object containts two fields - id and info.
-   *
-   * @param {Number} id
-   * @return {Object} member's info or null
-   */
   get(id) {
     if (Object.prototype.hasOwnProperty.call(this.members, id)) {
       return {
@@ -1750,26 +1435,19 @@ class Members {
       return null;
     }
   }
-  /** Calls back for each member in unspecified order.
-   *
-   * @param  {Function} callback
-   */
   each(callback) {
     objectApply(this.members, (member, id) => {
       callback(this.get(id));
     });
   }
-  /** Updates the id for connected member. For internal use only. */
   setMyID(id) {
     this.myID = id;
   }
-  /** Handles subscription data. For internal use only. */
   onSubscription(subscriptionData) {
     this.members = subscriptionData.presence.hash;
     this.count = subscriptionData.presence.count;
     this.me = this.get(this.myID);
   }
-  /** Adds a new member to the collection. For internal use only. */
   addMember(memberData) {
     if (this.get(memberData.user_id) === null) {
       this.count++;
@@ -1777,7 +1455,6 @@ class Members {
     this.members[memberData.user_id] = memberData.user_info;
     return this.get(memberData.user_id);
   }
-  /** Adds a member from the collection. For internal use only. */
   removeMember(memberData) {
     var member = this.get(memberData.user_id);
     if (member) {
@@ -1786,7 +1463,6 @@ class Members {
     }
     return member;
   }
-  /** Resets the collection to the initial state. For internal use only. */
   reset() {
     this.members = {};
     this.count = 0;
@@ -1794,49 +1470,60 @@ class Members {
     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 PresenceChannel extends PrivateChannel {
-  /** Adds presence channel functionality to private channels.
-   *
-   * @param {String} name
-   * @param {Pusher} pusher
-   */
   constructor(name, pusher) {
     super(name, pusher);
     this.members = new Members();
   }
-  /** Authorizes the connection as a member of the channel.
-   *
-   * @param  {String} socketId
-   * @param  {Function} callback
-   */
   authorize(socketId, callback) {
-    super.authorize(socketId, async (error, authData) => {
+    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 {
-          await this.pusher.user.signinDonePromise;
+          yield this.pusher.user.signinDonePromise;
           if (this.pusher.user.user_data != null) {
             this.members.setMyID(this.pusher.user.user_data.id);
           } else {
             let suffix = urlStore$1.buildLogSuffix("authorizationEndpoint");
-            Logger$1.error(
-              `Invalid auth response for channel '${this.name}', expected 'channel_data' field. ${suffix}, or the user should be signed in.`
-            );
+            Logger$1.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);
-    });
+    }));
   }
-  /** Handles presence and subscription events. For internal use only.
-   *
-   * @param {PusherEvent} event
-   */
   handleEvent(event) {
     var eventName = event.event;
     if (eventName.indexOf("pusher_internal:") === 0) {
@@ -1882,7 +1569,6 @@ class PresenceChannel extends PrivateChannel {
       this.emit("pusher:subscription_succeeded", this.members);
     }
   }
-  /** Resets the channel state, including members map. For internal use only. */
   disconnect() {
     this.members.reset();
     super.disconnect();
@@ -2224,49 +1910,30 @@ function requireBase64() {
 }
 var base64Exports = requireBase64();
 class EncryptedChannel extends PrivateChannel {
-  constructor(name, pusher, nacl2) {
+  constructor(name, pusher, nacl) {
     super(name, pusher);
     this.key = null;
-    this.nacl = nacl2;
+    this.nacl = nacl;
   }
-  /** Authorizes the connection to use the channel.
-   *
-   * @param  {String} socketId
-   * @param  {Function} callback
-   */
   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 = base64Exports.decode(sharedSecret);
-        delete authData["shared_secret"];
-        callback(null, authData);
+    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 = base64Exports.decode(sharedSecret);
+      delete authData["shared_secret"];
+      callback(null, authData);
+    });
   }
   trigger(event, data) {
-    throw new UnsupportedFeature(
-      "Client events are not currently supported for encrypted channels"
-    );
+    throw new UnsupportedFeature("Client events are not currently supported for encrypted channels");
   }
-  /** Handles an event. For internal use only.
-   *
-   * @param {PusherEvent} event
-   */
   handleEvent(event) {
     var eventName = event.event;
     var data = event.data;
@@ -2278,48 +1945,34 @@ class EncryptedChannel extends PrivateChannel {
   }
   handleEncryptedEvent(event, data) {
     if (!this.key) {
-      Logger$1.debug(
-        "Received encrypted event before key has been retrieved from the authEndpoint"
-      );
+      Logger$1.debug("Received encrypted event before key has been retrieved from the authEndpoint");
       return;
     }
     if (!data.ciphertext || !data.nonce) {
-      Logger$1.error(
-        "Unexpected format for encrypted event, expected object with `ciphertext` and `nonce` fields, got: " + data
-      );
+      Logger$1.error("Unexpected format for encrypted event, expected object with `ciphertext` and `nonce` fields, got: " + data);
       return;
     }
     let cipherText = base64Exports.decode(data.ciphertext);
     if (cipherText.length < this.nacl.secretbox.overheadLength) {
-      Logger$1.error(
-        `Expected encrypted event ciphertext length to be ${this.nacl.secretbox.overheadLength}, got: ${cipherText.length}`
-      );
+      Logger$1.error(`Expected encrypted event ciphertext length to be ${this.nacl.secretbox.overheadLength}, got: ${cipherText.length}`);
       return;
     }
     let nonce = base64Exports.decode(data.nonce);
     if (nonce.length < this.nacl.secretbox.nonceLength) {
-      Logger$1.error(
-        `Expected encrypted event nonce length to be ${this.nacl.secretbox.nonceLength}, got: ${nonce.length}`
-      );
+      Logger$1.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$1.debug(
-        "Failed to decrypt an event, probably because it was encrypted with a different key. Fetching a new key from the authEndpoint..."
-      );
+      Logger$1.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$1.error(
-            `Failed to make a request to the authEndpoint: ${authData}. Unable to fetch new key, so dropping encrypted event`
-          );
+          Logger$1.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$1.error(
-            `Failed to decrypt event with new key. Dropping encrypted event`
-          );
+          Logger$1.error(`Failed to decrypt event with new key. Dropping encrypted event`);
           return;
         }
         this.emit(event, this.getDataToEmit(bytes));
@@ -2329,13 +1982,11 @@ class EncryptedChannel extends PrivateChannel {
     }
     this.emit(event, this.getDataToEmit(bytes));
   }
-  // Try and parse the decrypted bytes as JSON. If we can't parse it, just
-  // return the utf-8 string
   getDataToEmit(bytes) {
     let raw = utf8Exports.decode(bytes);
     try {
       return JSON.parse(raw);
-    } catch {
+    } catch (_a) {
       return raw;
     }
   }
@@ -2350,9 +2001,7 @@ class ConnectionManager extends Dispatcher {
     this.timeline = this.options.timeline;
     this.usingTLS = this.options.useTLS;
     this.errorCallbacks = this.buildErrorCallbacks();
-    this.connectionCallbacks = this.buildConnectionCallbacks(
-      this.errorCallbacks
-    );
+    this.connectionCallbacks = this.buildConnectionCallbacks(this.errorCallbacks);
     this.handshakeCallbacks = this.buildHandshakeCallbacks(this.errorCallbacks);
     var Network2 = Runtime.getNetwork();
     Network2.bind("online", () => {
@@ -2369,11 +2018,6 @@ class ConnectionManager extends Dispatcher {
     });
     this.updateStrategy();
   }
-  /** Establishes a connection to Pusher.
-   *
-   * Does nothing when connection is already established. See top-level doc
-   * to find events emitted on connection attempts.
-   */
   connect() {
     if (this.connection || this.runner) {
       return;
@@ -2386,10 +2030,6 @@ class ConnectionManager extends Dispatcher {
     this.startConnecting();
     this.setUnavailableTimer();
   }
-  /** Sends raw data.
-   *
-   * @param {String} data
-   */
   send(data) {
     if (this.connection) {
       return this.connection.send(data);
@@ -2397,13 +2037,6 @@ class ConnectionManager extends Dispatcher {
       return false;
     }
   }
-  /** Sends an event.
-   *
-   * @param {String} name
-   * @param {String} data
-   * @param {String} [channel]
-   * @returns {Boolean} whether message was sent or not
-   */
   send_event(name, data, channel) {
     if (this.connection) {
       return this.connection.send_event(name, data, channel);
@@ -2411,7 +2044,6 @@ class ConnectionManager extends Dispatcher {
       return false;
     }
   }
-  /** Closes the connection. */
   disconnect() {
     this.disconnectInternally();
     this.updateState("disconnected");
@@ -2533,11 +2165,7 @@ class ConnectionManager extends Dispatcher {
   buildHandshakeCallbacks(errorCallbacks) {
     return extend({}, errorCallbacks, {
       connected: (handshake) => {
-        this.activityTimeout = Math.min(
-          this.options.activityTimeout,
-          handshake.activityTimeout,
-          handshake.connection.activityTimeout || Infinity
-        );
+        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;
@@ -2598,10 +2226,7 @@ class ConnectionManager extends Dispatcher {
       if (newStateDescription === "connected") {
         newStateDescription += " with new socket ID " + data.socket_id;
       }
-      Logger$1.debug(
-        "State changed",
-        previousState + " -> " + newStateDescription
-      );
+      Logger$1.debug("State changed", previousState + " -> " + newStateDescription);
       this.timeline.info({ state: newState, params: data });
       this.emit("state_change", { previous: previousState, current: newState });
       this.emit(newState, data);
@@ -2615,43 +2240,23 @@ class Channels {
   constructor() {
     this.channels = {};
   }
-  /** Creates or retrieves an existing channel by its name.
-   *
-   * @param {String} name
-   * @param {Pusher} pusher
-   * @return {Channel}
-   */
   add(name, pusher) {
     if (!this.channels[name]) {
       this.channels[name] = createChannel(name, pusher);
     }
     return this.channels[name];
   }
-  /** Returns a list of all channels
-   *
-   * @return {Array}
-   */
   all() {
     return values(this.channels);
   }
-  /** Finds a channel by its name.
-   *
-   * @param {String} name
-   * @return {Channel} channel or null if it doesn't exist
-   */
   find(name) {
     return this.channels[name];
   }
-  /** Removes a channel from the map.
-   *
-   * @param {String} name
-   */
   remove(name) {
     var channel = this.channels[name];
     delete this.channels[name];
     return channel;
   }
-  /** Proxies disconnection signal to all channels. */
   disconnect() {
     objectApply(this.channels, function(channel) {
       channel.disconnect();
@@ -2671,9 +2276,7 @@ function createChannel(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 + '".'
-    );
+    throw new BadChannelName('Cannot create a channel with name "' + name + '".');
   } else {
     return Factory.createChannel(name, pusher);
   }
@@ -2694,8 +2297,8 @@ var Factory = {
   createPresenceChannel(name, pusher) {
     return new PresenceChannel(name, pusher);
   },
-  createEncryptedChannel(name, pusher, nacl2) {
-    return new EncryptedChannel(name, pusher, nacl2);
+  createEncryptedChannel(name, pusher, nacl) {
+    return new EncryptedChannel(name, pusher, nacl);
   },
   createTimelineSender(timeline, options) {
     return new TimelineSender(timeline, options);
@@ -2712,25 +2315,15 @@ class TransportManager {
     this.options = options || {};
     this.livesLeft = this.options.lives || Infinity;
   }
-  /** Creates a assistant for the transport.
-   *
-   * @param {Transport} transport
-   * @returns {AssistantToTheTransportManager}
-   */
   getAssistant(transport) {
     return Factory.createAssistantToTheTransportManager(this, transport, {
       minPingDelay: this.options.minPingDelay,
       maxPingDelay: this.options.maxPingDelay
     });
   }
-  /** Returns whether the transport has any lives left.
-   *
-   * @returns {Boolean}
-   */
   isAlive() {
     return this.livesLeft > 0;
   }
-  /** Takes one life from the transport. */
   reportDeath() {
     this.livesLeft -= 1;
   }
@@ -2766,23 +2359,13 @@ class SequentialStrategy {
               timeout = Math.min(timeout, this.timeoutLimit);
             }
           }
-          runner = this.tryStrategy(
-            strategies[current],
-            minPriority,
-            { timeout, failFast: this.failFast },
-            tryNextStrategy
-          );
+          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
-    );
+    runner = this.tryStrategy(strategies[current], minPriority, { timeout, failFast: this.failFast }, tryNextStrategy);
     return {
       abort: function() {
         runner.abort();
@@ -2902,12 +2485,10 @@ class WebSocketPrioritizedCachedStrategy {
             transport: info.transport,
             latency: info.latency
           });
-          strategies.push(
-            new SequentialStrategy([transport], {
-              timeout: info.latency * 2 + 1e3,
-              failFast: true
-            })
-          );
+          strategies.push(new SequentialStrategy([transport], {
+            timeout: info.latency * 2 + 1e3,
+            failFast: true
+          }));
         } else {
           cacheSkipCount++;
         }
@@ -2924,12 +2505,7 @@ class WebSocketPrioritizedCachedStrategy {
           callback(error);
         }
       } else {
-        storeTransportCache(
-          usingTLS,
-          handshake.transport.name,
-          Util.now() - startTimestamp,
-          cacheSkipCount
-        );
+        storeTransportCache(usingTLS, handshake.transport.name, Util.now() - startTimestamp, cacheSkipCount);
         callback(null, handshake);
       }
     });
@@ -3039,15 +2615,12 @@ class FirstConnectedStrategy {
     return this.strategy.isSupported();
   }
   connect(minPriority, callback) {
-    var runner = this.strategy.connect(
-      minPriority,
-      function(error, handshake) {
-        if (handshake) {
-          runner.abort();
-        }
-        callback(error, handshake);
+    var runner = this.strategy.connect(minPriority, function(error, handshake) {
+      if (handshake) {
+        runner.abort();
       }
-    );
+      callback(error, handshake);
+    });
     return runner;
   }
 }
@@ -3059,14 +2632,7 @@ function testSupportsStrategy(strategy) {
 var getDefaultStrategy = function(config2, baseOptions, defineTransport2) {
   var definedTransports = {};
   function defineTransportStrategy(name, type, priority, options, manager) {
-    var transport = defineTransport2(
-      config2,
-      name,
-      type,
-      priority,
-      options,
-      manager
-    );
+    var transport = defineTransport2(config2, name, type, priority, options, manager);
     definedTransports[name] = transport;
     return transport;
   }
@@ -3097,93 +2663,29 @@ var getDefaultStrategy = function(config2, baseOptions, defineTransport2) {
     minPingDelay: 1e4,
     maxPingDelay: config2.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_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 SequentialStrategy([ws_transport], timeouts);
   var wss_loop = new SequentialStrategy([wss_transport], timeouts);
   var sockjs_loop = new SequentialStrategy([sockjs_transport], timeouts);
-  var streaming_loop = new SequentialStrategy(
-    [
-      new IfStrategy(
-        testSupportsStrategy(xhr_streaming_transport),
-        xhr_streaming_transport,
-        xdr_streaming_transport
-      )
-    ],
-    timeouts
-  );
-  var polling_loop = new SequentialStrategy(
-    [
-      new IfStrategy(
-        testSupportsStrategy(xhr_polling_transport),
-        xhr_polling_transport,
-        xdr_polling_transport
-      )
-    ],
-    timeouts
-  );
-  var http_loop = new SequentialStrategy(
-    [
-      new IfStrategy(
-        testSupportsStrategy(streaming_loop),
-        new BestConnectedEverStrategy([
-          streaming_loop,
-          new DelayedStrategy(polling_loop, { delay: 4e3 })
-        ]),
-        polling_loop
-      )
-    ],
-    timeouts
-  );
-  var http_fallback_loop = new IfStrategy(
-    testSupportsStrategy(http_loop),
-    http_loop,
-    sockjs_loop
-  );
+  var streaming_loop = new SequentialStrategy([
+    new IfStrategy(testSupportsStrategy(xhr_streaming_transport), xhr_streaming_transport, xdr_streaming_transport)
+  ], timeouts);
+  var polling_loop = new SequentialStrategy([
+    new IfStrategy(testSupportsStrategy(xhr_polling_transport), xhr_polling_transport, xdr_polling_transport)
+  ], timeouts);
+  var http_loop = new SequentialStrategy([
+    new IfStrategy(testSupportsStrategy(streaming_loop), new BestConnectedEverStrategy([
+      streaming_loop,
+      new 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 BestConnectedEverStrategy([
@@ -3197,49 +2699,33 @@ var getDefaultStrategy = function(config2, baseOptions, defineTransport2) {
       new DelayedStrategy(http_fallback_loop, { delay: 5e3 })
     ]);
   }
-  return new WebSocketPrioritizedCachedStrategy(
-    new FirstConnectedStrategy(
-      new IfStrategy(
-        testSupportsStrategy(ws_transport),
-        wsStrategy,
-        http_fallback_loop
-      )
-    ),
-    definedTransports,
-    {
-      ttl: 18e5,
-      timeline: baseOptions.timeline,
-      useTLS: baseOptions.useTLS
-    }
-  );
+  return new WebSocketPrioritizedCachedStrategy(new FirstConnectedStrategy(new IfStrategy(testSupportsStrategy(ws_transport), wsStrategy, http_fallback_loop)), definedTransports, {
+    ttl: 18e5,
+    timeline: baseOptions.timeline,
+    useTLS: baseOptions.useTLS
+  });
 };
 function transportConnectionInitializer() {
   var self = this;
-  self.timeline.info(
-    self.buildTimelineMessage({
-      transport: self.name + (self.options.useTLS ? "s" : "")
-    })
-  );
+  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);
+    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();
   }
@@ -3332,12 +2818,12 @@ class HTTPRequest extends Dispatcher {
     return this.position === buffer.length && buffer.length > MAX_BUFFER_LENGTH;
   }
 }
-var State = /* @__PURE__ */ ((State2) => {
+var State;
+(function(State2) {
   State2[State2["CONNECTING"] = 0] = "CONNECTING";
   State2[State2["OPEN"] = 1] = "OPEN";
   State2[State2["CLOSED"] = 3] = "CLOSED";
-  return State2;
-})(State || {});
+})(State || (State = {}));
 var autoIncrement = 1;
 class HTTPSocket {
   constructor(hooks2, url) {
@@ -3356,14 +2842,10 @@ class HTTPSocket {
   close(code, reason) {
     this.onClose(code, reason, true);
   }
-  /** For internal use only */
   sendRaw(payload) {
     if (this.readyState === State.OPEN) {
       try {
-        Runtime.createSocketRequest(
-          "POST",
-          getUniqueURL(getSendURL(this.location, this.session))
-        ).start(payload);
+        Runtime.createSocketRequest("POST", getUniqueURL(getSendURL(this.location, this.session))).start(payload);
         return true;
       } catch (e) {
         return false;
@@ -3372,12 +2854,10 @@ class HTTPSocket {
       return false;
     }
   }
-  /** For internal use only */
   reconnect() {
     this.closeStream();
     this.openStream();
   }
-  /** For internal use only */
   onClose(code, reason, wasClean) {
     this.closeStream();
     this.readyState = State.CLOSED;
@@ -3451,10 +2931,7 @@ class HTTPSocket {
     }
   }
   openStream() {
-    this.stream = Runtime.createSocketRequest(
-      "POST",
-      getUniqueURL(this.hooks.getReceiveURL(this.location, this.session))
-    );
+    this.stream = Runtime.createSocketRequest("POST", getUniqueURL(this.hooks.getReceiveURL(this.location, this.session)));
     this.stream.bind("chunk", (chunk) => {
       this.onChunk(chunk);
     });
@@ -3587,6 +3064,146 @@ var HTTP = {
 HTTP.createXDR = function(method, url) {
   return this.createRequest(hooks$3, method, url);
 };
+var Runtime$1 = {
+  nextAuthCallbackID: 1,
+  auth_callbacks: {},
+  ScriptReceivers,
+  DependenciesReceivers,
+  getDefaultStrategy,
+  Transports: Transports$1,
+  transportConnectionInitializer,
+  HTTPFactory: HTTP,
+  TimelineTransport: jsonp,
+  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, jsonp: jsonp$1 };
+  },
+  onDocumentBody(callback) {
+    if (document.body) {
+      callback();
+    } else {
+      setTimeout(() => {
+        this.onDocumentBody(callback);
+      }, 0);
+    }
+  },
+  createJSONPRequest(url, data) {
+    return new 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 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);
+  }
+};
+class 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$1.createScriptRequest(url);
+    this.request.send(receiver);
+  }
+  cleanup() {
+    if (this.request) {
+      this.request.cleanup();
+    }
+  }
+}
 var Runtime = {
   // for jsonp auth
   nextAuthCallbackID: 1,
@@ -3708,12 +3325,13 @@ var Runtime = {
     return Math.floor(random() * max);
   }
 };
-var TimelineLevel = /* @__PURE__ */ ((TimelineLevel2) => {
+var TimelineLevel;
+(function(TimelineLevel2) {
   TimelineLevel2[TimelineLevel2["ERROR"] = 3] = "ERROR";
   TimelineLevel2[TimelineLevel2["INFO"] = 6] = "INFO";
   TimelineLevel2[TimelineLevel2["DEBUG"] = 7] = "DEBUG";
-  return TimelineLevel2;
-})(TimelineLevel || {});
+})(TimelineLevel || (TimelineLevel = {}));
+const TimelineLevel$1 = TimelineLevel;
 class Timeline {
   constructor(key, session, options) {
     this.key = key;
@@ -3725,40 +3343,35 @@ class Timeline {
   }
   log(level, event) {
     if (level <= this.options.level) {
-      this.events.push(
-        extend({}, event, { timestamp: Util.now() })
-      );
+      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(TimelineLevel.ERROR, event);
+    this.log(TimelineLevel$1.ERROR, event);
   }
   info(event) {
-    this.log(TimelineLevel.INFO, event);
+    this.log(TimelineLevel$1.INFO, event);
   }
   debug(event) {
-    this.log(TimelineLevel.DEBUG, event);
+    this.log(TimelineLevel$1.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
-    );
+    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) {
@@ -3782,20 +3395,11 @@ class TransportStrategy {
     this.transport = transport;
     this.options = options || {};
   }
-  /** Returns whether the transport is supported in the browser.
-   *
-   * @returns {Boolean}
-   */
   isSupported() {
     return this.transport.isSupported({
       useTLS: this.options.useTLS
     });
   }
-  /** Launches a connection attempt and returns a strategy runner.
-   *
-   * @param  {Function} callback
-   * @return {Object} strategy runner
-   */
   connect(minPriority, callback) {
     if (!this.isSupported()) {
       return failAttempt(new UnsupportedStrategy$1(), callback);
@@ -3803,12 +3407,7 @@ class TransportStrategy {
       return failAttempt(new TransportPriorityTooLow(), callback);
     }
     var connected = false;
-    var transport = this.transport.createConnection(
-      this.name,
-      this.priority,
-      this.options.key,
-      this.options
-    );
+    var transport = this.transport.createConnection(this.name, this.priority, this.options.key, this.options);
     var handshake = null;
     var onInitialized = function() {
       transport.unbind("initialized", onInitialized);
@@ -3889,16 +3488,8 @@ var defineTransport = function(config2, name, type, priority, options, manager)
   var enabled = (!config2.enabledTransports || arrayIndexOf(config2.enabledTransports, name) !== -1) && (!config2.disabledTransports || arrayIndexOf(config2.disabledTransports, name) === -1);
   var transport;
   if (enabled) {
-    options = Object.assign(
-      { ignoreNullOrigin: config2.ignoreNullOrigin },
-      options
-    );
-    transport = new TransportStrategy(
-      name,
-      priority,
-      manager ? manager.getAssistant(transportClass) : transportClass,
-      options
-    );
+    options = Object.assign({ ignoreNullOrigin: config2.ignoreNullOrigin }, options);
+    transport = new TransportStrategy(name, priority, manager ? manager.getAssistant(transportClass) : transportClass, options);
   } else {
     transport = UnsupportedStrategy2;
   }
@@ -3929,9 +3520,7 @@ function validateOptions(options) {
     throw "Options object must provide a cluster";
   }
   if ("disableStats" in options) {
-    Logger$1.warn(
-      "The disableStats option is deprecated in favor of enableStats"
-    );
+    Logger$1.warn("The disableStats option is deprecated in favor of enableStats");
   }
 }
 const composeChannelQuery$1 = (params, authOptions) => {
@@ -3953,13 +3542,7 @@ const UserAuthenticator = (authOptions) => {
   }
   return (params, callback) => {
     const query = composeChannelQuery$1(params, authOptions);
-    Runtime.getAuthorizers()[authOptions.transport](
-      Runtime,
-      query,
-      authOptions,
-      AuthRequestType.UserAuthentication,
-      callback
-    );
+    Runtime.getAuthorizers()[authOptions.transport](Runtime, query, authOptions, AuthRequestType.UserAuthentication, callback);
   };
 };
 const composeChannelQuery = (params, authOptions) => {
@@ -3982,13 +3565,7 @@ const ChannelAuthorizer = (authOptions) => {
   }
   return (params, callback) => {
     const query = composeChannelQuery(params, authOptions);
-    Runtime.getAuthorizers()[authOptions.transport](
-      Runtime,
-      query,
-      authOptions,
-      AuthRequestType.ChannelAuthorization,
-      callback
-    );
+    Runtime.getAuthorizers()[authOptions.transport](Runtime, query, authOptions, AuthRequestType.ChannelAuthorization, callback);
   };
 };
 const ChannelAuthorizerProxy = (pusher, authOptions, channelAuthorizerGenerator) => {
@@ -4032,7 +3609,8 @@ function getConfig(opts, pusher) {
     config2.enabledTransports = opts.enabledTransports;
   if ("ignoreNullOrigin" in opts)
     config2.ignoreNullOrigin = opts.ignoreNullOrigin;
-  if ("timelineParams" in opts) config2.timelineParams = opts.timelineParams;
+  if ("timelineParams" in opts)
+    config2.timelineParams = opts.timelineParams;
   if ("nacl" in opts) {
     config2.nacl = opts.nacl;
   }
@@ -4074,10 +3652,7 @@ function getEnableStatsConfig(opts) {
   return false;
 }
 function buildUserAuthenticator(opts) {
-  const userAuthentication = {
-    ...Defaults.userAuthentication,
-    ...opts.userAuthentication
-  };
+  const userAuthentication = Object.assign(Object.assign({}, Defaults.userAuthentication), opts.userAuthentication);
   if ("customHandler" in userAuthentication && userAuthentication["customHandler"] != null) {
     return userAuthentication["customHandler"];
   }
@@ -4086,26 +3661,20 @@ function buildUserAuthenticator(opts) {
 function buildChannelAuth(opts, pusher) {
   let channelAuthorization;
   if ("channelAuthorization" in opts) {
-    channelAuthorization = {
-      ...Defaults.channelAuthorization,
-      ...opts.channelAuthorization
-    };
+    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 ("params" in opts.auth)
+        channelAuthorization.params = opts.auth.params;
       if ("headers" in opts.auth)
         channelAuthorization.headers = opts.auth.headers;
     }
     if ("authorizer" in opts)
-      channelAuthorization.customHandler = ChannelAuthorizerProxy(
-        pusher,
-        channelAuthorization,
-        opts.authorizer
-      );
+      channelAuthorization.customHandler = ChannelAuthorizerProxy(pusher, channelAuthorization, opts.authorizer);
   }
   return channelAuthorization;
 }
@@ -4203,12 +3772,9 @@ class UserFacade extends Dispatcher {
     if (this.pusher.connection.state !== "connected") {
       return;
     }
-    this.pusher.config.userAuthenticator(
-      {
-        socketId: this.pusher.connection.socket_id
-      },
-      this._onAuthorize
-    );
+    this.pusher.config.userAuthenticator({
+      socketId: this.pusher.connection.socket_id
+    }, this._onAuthorize);
   }
   _onSigninSuccess(data) {
     try {
@@ -4219,9 +3785,7 @@ class UserFacade extends Dispatcher {
       return;
     }
     if (typeof this.user_data.id !== "string" || this.user_data.id === "") {
-      Logger$1.error(
-        `user_data doesn't contain an id. user_data: ${this.user_data}`
-      );
+      Logger$1.error(`user_data doesn't contain an id. user_data: ${this.user_data}`);
       this._cleanup();
       return;
     }
@@ -4236,10 +3800,7 @@ class UserFacade extends Dispatcher {
         channel.subscribe();
       }
     };
-    this.serverToUserChannel = new Channel(
-      `#server-to-user-${this.user_data.id}`,
-      this.pusher
-    );
+    this.serverToUserChannel = new 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;
@@ -4280,7 +3841,7 @@ class ChannelState {
   constructor(channelName) {
     this.channelName = channelName;
     this.conflationKey = null;
-    this.maxMessagesPerKey = 10;
+    this.maxMessagesPerKey = 30;
     this.conflationCaches = /* @__PURE__ */ new Map();
     this.baseMessage = null;
     this.baseSequence = null;
@@ -4288,12 +3849,9 @@ class ChannelState {
     this.deltaCount = 0;
     this.fullMessageCount = 0;
   }
-  /**
-   * Initialize cache from server sync
-   */
   initializeFromCacheSync(data) {
     this.conflationKey = data.conflation_key || null;
-    this.maxMessagesPerKey = data.max_messages_per_key || 10;
+    this.maxMessagesPerKey = Math.max(data.max_messages_per_key || 10, 30);
     this.conflationCaches.clear();
     if (data.states) {
       for (const [key, messages] of Object.entries(data.states)) {
@@ -4305,18 +3863,11 @@ class ChannelState {
       }
     }
   }
-  /**
-   * Set new base message (legacy - for non-conflation channels)
-   */
   setBase(message, sequence) {
     this.baseMessage = message;
     this.baseSequence = sequence;
     this.lastSequence = sequence;
   }
-  /**
-   * Get base message for a conflation key at specific index
-   * Note: baseIndex is the sequence number, not array index
-   */
   getBaseMessage(conflationKeyValue, baseIndex) {
     if (!this.conflationKey) {
       return this.baseMessage;
@@ -4344,9 +3895,6 @@ class ChannelState {
     }
     return message.content;
   }
-  /**
-   * Add or update message in conflation cache
-   */
   updateConflationCache(conflationKeyValue, message, sequence) {
     const key = conflationKeyValue || "";
     let cache = this.conflationCaches.get(key);
@@ -4354,56 +3902,32 @@ class ChannelState {
       cache = [];
       this.conflationCaches.set(key, cache);
     }
-    if (cache.length > 0) {
-      const lastCacheItem = cache[cache.length - 1];
-      if (sequence <= lastCacheItem.sequence) {
-        cache.length = 0;
-      }
-    }
     cache.push({ content: message, sequence });
     while (cache.length > this.maxMessagesPerKey) {
       cache.shift();
     }
   }
-  /**
-   * Check if we have a valid base
-   */
   hasBase() {
     if (this.conflationKey) {
       return this.conflationCaches.size > 0;
     }
     return this.baseMessage !== null && this.baseSequence !== null;
   }
-  /**
-   * Validate sequence number
-   */
   isValidSequence(sequence) {
     if (this.lastSequence === null) {
       return true;
     }
     return sequence > this.lastSequence;
   }
-  /**
-   * Update sequence after processing a message
-   */
   updateSequence(sequence) {
     this.lastSequence = sequence;
   }
-  /**
-   * Record delta received
-   */
   recordDelta() {
     this.deltaCount++;
   }
-  /**
-   * Record full message received
-   */
   recordFullMessage() {
     this.fullMessageCount++;
   }
-  /**
-   * Get statistics
-   */
   getStats() {
     return {
       channelName: this.channelName,
@@ -5190,9 +4714,7 @@ class FossilDeltaDecoder {
       }
       return bytesToString(result);
     } catch (error) {
-      throw new Error(
-        `Fossil delta decode failed: ${error.message} (base=${baseBytes.length}B delta=${deltaBytes.length}B)`
-      );
+      throw new Error(`Fossil delta decode failed: ${error.message} (base=${baseBytes.length}B delta=${deltaBytes.length}B)`);
     }
   }
 }
@@ -5217,14 +4739,13 @@ class Xdelta3Decoder {
       }
       return bytesToString(result);
     } catch (error) {
-      throw new Error(
-        `Xdelta3 decode failed: ${error.message} (base=${baseBytes.length}B delta=${deltaBytes.length}B)`
-      );
+      throw new Error(`Xdelta3 decode failed: ${error.message} (base=${baseBytes.length}B delta=${deltaBytes.length}B)`);
     }
   }
 }
 class DeltaCompressionManager {
   constructor(options = {}, sendEventCallback) {
+    this.defaultAlgorithm = "fossil";
     this.options = {
       enabled: options.enabled !== false,
       algorithms: options.algorithms || ["fossil", "xdelta3"],
@@ -5245,14 +4766,9 @@ class DeltaCompressionManager {
     this.sendEventCallback = sendEventCallback;
     this.availableAlgorithms = this.detectAvailableAlgorithms();
     if (this.availableAlgorithms.length === 0) {
-      Logger$1.warn(
-        "[DeltaCompression] No delta algorithms available. Please include fossil-delta or vcdiff-decoder libraries."
-      );
+      Logger$1.warn("[DeltaCompression] No delta algorithms available. Please include fossil-delta or vcdiff-decoder libraries.");
     }
   }
-  /**
-   * Detect which algorithm libraries are loaded
-   */
   detectAvailableAlgorithms() {
     const available = [];
     if (FossilDeltaDecoder.isAvailable()) {
@@ -5265,9 +4781,6 @@ class DeltaCompressionManager {
     }
     return available;
   }
-  /**
-   * Enable delta compression
-   */
   enable() {
     if (this.enabled || !this.options.enabled) {
       return;
@@ -5276,9 +4789,7 @@ class DeltaCompressionManager {
       this.log("No delta algorithms available, cannot enable");
       return;
     }
-    const supportedAlgorithms = this.availableAlgorithms.filter(
-      (algo) => this.options.algorithms.includes(algo)
-    );
+    const supportedAlgorithms = this.availableAlgorithms.filter((algo) => this.options.algorithms.includes(algo));
     if (supportedAlgorithms.length === 0) {
       this.log("No mutually supported algorithms");
       return;
@@ -5288,26 +4799,16 @@ class DeltaCompressionManager {
       algorithms: supportedAlgorithms
     });
   }
-  /**
-   * Disable delta compression
-   * Note: We intentionally do NOT clear channelStates here.
-   * This allows state to be preserved across enable/disable cycles,
-   * which is important for reconnection scenarios and user toggling.
-   * Use clearChannelState() if you need to explicitly clear state.
-   */
   disable() {
     this.enabled = false;
   }
-  /**
-   * Handle delta compression enabled confirmation
-   */
   handleEnabled(data) {
     this.enabled = data.enabled || true;
+    if (data.algorithm) {
+      this.defaultAlgorithm = data.algorithm;
+    }
     this.log("Delta compression enabled", data);
   }
-  /**
-   * Handle cache sync message (conflation keys)
-   */
   handleCacheSync(channel, data) {
     this.log("Received cache sync", {
       channel,
@@ -5322,16 +4823,14 @@ class DeltaCompressionManager {
     channelState.initializeFromCacheSync(data);
     this.log("Cache initialized", channelState.getStats());
   }
-  /**
-   * Handle delta-compressed message
-   */
   handleDeltaMessage(channel, deltaData) {
+    var _a;
     let deltaBytes = null;
     try {
       const event = deltaData.event;
       const delta2 = deltaData.delta;
       const sequence = deltaData.seq;
-      const algorithm = deltaData.algorithm || "fossil";
+      const algorithm = deltaData.algorithm || this.defaultAlgorithm || "fossil";
       const conflationKey = deltaData.conflation_key;
       const baseIndex = deltaData.base_index;
       this.log("Received delta message", {
@@ -5352,44 +4851,27 @@ class DeltaCompressionManager {
       if (channelState.conflationKey) {
         baseMessage = channelState.getBaseMessage(conflationKey, baseIndex);
         if (!baseMessage) {
-          this.error(
-            `No base message (conflation path) for channel ${channel}`,
-            {
-              path: "conflation",
+          this.error(`No base message for channel ${channel}, key ${conflationKey}, index ${baseIndex}`);
+          if (this.options.debug) {
+            this.log("Current conflation cache snapshot", {
               channel,
-              deltaConflationKey: conflationKey,
-              deltaBaseIndex: baseIndex,
-              deltaSeq: sequence,
-              channelStateConflationKey: channelState.conflationKey,
-              channelStateBaseMessage: channelState.baseMessage ? "exists" : null,
-              channelStateBaseSequence: channelState.baseSequence,
-              channelStateLastSequence: channelState.lastSequence,
-              conflationCacheKeys: Array.from(channelState.conflationCaches.keys()),
-              conflationCacheSizes: Array.from(
-                channelState.conflationCaches.entries()
-              ).map(([key, cache]) => ({ key, size: cache.length }))
-            }
-          );
+              conflationKey: channelState.conflationKey,
+              cacheSizes: Array.from(channelState.conflationCaches.entries()).map(([key, cache]) => ({ key, size: cache.length }))
+            });
+          }
           this.requestResync(channel);
           return null;
         }
       } else {
         baseMessage = channelState.baseMessage;
         if (!baseMessage) {
-          this.error(
-            `No base message (legacy path) for channel ${channel}`,
-            {
-              path: "legacy",
+          this.error(`No base message for channel ${channel}`);
+          if (this.options.debug) {
+            this.log("Channel state missing base", {
               channel,
-              deltaConflationKey: conflationKey,
-              deltaBaseIndex: baseIndex,
-              deltaSeq: sequence,
-              channelStateConflationKey: channelState.conflationKey,
-              channelStateBaseMessage: null,
-              channelStateBaseSequence: channelState.baseSequence,
-              channelStateLastSequence: channelState.lastSequence
-            }
-          );
+              lastSequence: channelState.lastSequence
+            });
+          }
           this.requestResync(channel);
           return null;
         }
@@ -5398,10 +4880,7 @@ class DeltaCompressionManager {
       let reconstructedMessage;
       try {
         if (algorithm === "fossil") {
-          reconstructedMessage = FossilDeltaDecoder.apply(
-            baseMessage,
-            deltaBytes
-          );
+          reconstructedMessage = FossilDeltaDecoder.apply(baseMessage, deltaBytes);
         } else if (algorithm === "xdelta3") {
           reconstructedMessage = Xdelta3Decoder.apply(baseMessage, deltaBytes);
         } else {
@@ -5411,11 +4890,7 @@ class DeltaCompressionManager {
         throw decodeError;
       }
       if (channelState.conflationKey) {
-        channelState.updateConflationCache(
-          conflationKey,
-          reconstructedMessage,
-          sequence
-        );
+        channelState.updateConflationCache(conflationKey, reconstructedMessage, sequence);
       } else {
         channelState.setBase(reconstructedMessage, sequence);
       }
@@ -5436,17 +4911,10 @@ class DeltaCompressionManager {
       });
       try {
         const parsedMessage = JSON.parse(reconstructedMessage);
-        let data = parsedMessage.data || parsedMessage;
-        if (typeof data === "string") {
-          try {
-            data = JSON.parse(data);
-          } catch (e) {
-          }
-        }
         return {
           event,
           channel,
-          data
+          data: parsedMessage.data || parsedMessage
         };
       } catch (e) {
         return {
@@ -5463,7 +4931,7 @@ class DeltaCompressionManager {
         algorithm: deltaData.algorithm,
         conflationKey: deltaData.conflation_key,
         baseIndex: deltaData.base_index,
-        deltaSize: deltaData.delta?.length,
+        deltaSize: (_a = deltaData.delta) === null || _a === void 0 ? void 0 : _a.length,
         decodedDeltaBytes: deltaBytes ? deltaBytes.length : "n/a",
         message: error.message
       });
@@ -5471,14 +4939,12 @@ class DeltaCompressionManager {
       return null;
     }
   }
-  /**
-   * Handle regular (full) message with delta sequence markers
-   */
   handleFullMessage(channel, rawMessage, sequence, conflationKey) {
+    var _a, _b, _c;
     if (!sequence && sequence !== 0) {
       try {
         const parsed = JSON.parse(rawMessage);
-        const candidate = typeof parsed.data === "string" ? JSON.parse(parsed.data).__delta_seq ?? parsed.__delta_seq : parsed.data?.__delta_seq ?? parsed.__delta_seq;
+        const candidate = typeof parsed.data === "string" ? (_a = JSON.parse(parsed.data).__delta_seq) !== null && _a !== void 0 ? _a : parsed.__delta_seq : (_c = (_b = parsed.data) === null || _b === void 0 ? void 0 : _b.__delta_seq) !== null && _c !== void 0 ? _c : parsed.__delta_seq;
         if (candidate === 0 || candidate) {
           sequence = candidate;
         } else {
@@ -5507,12 +4973,7 @@ class DeltaCompressionManager {
       channelState.conflationKey = "enabled";
     }
     if (channelState.conflationKey && finalConflationKey !== void 0) {
-      channelState.updateConflationCache(
-        finalConflationKey,
-        rawMessage,
-        // Store raw message directly
-        sequence
-      );
+      channelState.updateConflationCache(finalConflationKey, rawMessage, sequence);
       this.log("Stored full message (conflation)", {
         channel,
         conflationKey: finalConflationKey,
@@ -5534,42 +4995,27 @@ class DeltaCompressionManager {
     this.stats.totalBytesWithCompression += messageSize;
     this.updateStats();
   }
-  /**
-   * Request resync for a channel
-   */
   requestResync(channel) {
     this.log("Requesting resync for channel", channel);
     this.sendEventCallback("pusher:delta_sync_error", { channel });
     this.channelStates.delete(channel);
   }
-  /**
-   * Update and emit stats
-   */
   updateStats() {
     if (this.options.onStats) {
       this.options.onStats(this.getStats());
     }
   }
-  /**
-   * Get current statistics
-   */
   getStats() {
     const bandwidthSaved = this.stats.totalBytesWithoutCompression - this.stats.totalBytesWithCompression;
     const bandwidthSavedPercent = this.stats.totalBytesWithoutCompression > 0 ? bandwidthSaved / this.stats.totalBytesWithoutCompression * 100 : 0;
-    const channelStats = Array.from(this.channelStates.values()).map(
-      (state) => state.getStats()
-    );
-    return {
-      ...this.stats,
+    const channelStats = Array.from(this.channelStates.values()).map((state) => state.getStats());
+    return Object.assign(Object.assign({}, this.stats), {
       bandwidthSaved,
       bandwidthSavedPercent,
       channelCount: this.channelStates.size,
       channels: channelStats
-    };
+    });
   }
-  /**
-   * Reset statistics
-   */
   resetStats() {
     this.stats = {
       totalMessages: 0,
@@ -5581,9 +5027,6 @@ class DeltaCompressionManager {
     };
     this.updateStats();
   }
-  /**
-   * Clear channel state
-   */
   clearChannelState(channel) {
     if (channel) {
       this.channelStates.delete(channel);
@@ -5591,29 +5034,17 @@ class DeltaCompressionManager {
       this.channelStates.clear();
     }
   }
-  /**
-   * Check if delta compression is enabled
-   */
   isEnabled() {
     return this.enabled;
   }
-  /**
-   * Get available algorithms
-   */
   getAvailableAlgorithms() {
     return this.availableAlgorithms;
   }
-  /**
-   * Log message (if debug enabled)
-   */
   log(...args) {
     if (this.options.debug) {
       Logger$1.debug("[DeltaCompression]", ...args);
     }
   }
-  /**
-   * Log error
-   */
   error(...args) {
     Logger$1.error("[DeltaCompression]", ...args);
     if (this.options.onError) {
@@ -5621,7 +5052,7 @@ class DeltaCompressionManager {
     }
   }
 }
-const _Pusher = class _Pusher {
+class Pusher {
   static get logToConsole() {
     return this._logToConsole;
   }
@@ -5637,17 +5068,15 @@ const _Pusher = class _Pusher {
     setLoggerConfig({ logToConsole: this._logToConsole, log: fn });
   }
   static ready() {
-    _Pusher.isReady = true;
-    for (var i = 0, l = _Pusher.instances.length; i < l; i++) {
-      _Pusher.instances[i].connect();
+    Pusher.isReady = true;
+    for (var i = 0, l = Pusher.instances.length; i < l; i++) {
+      Pusher.instances[i].connect();
     }
   }
   static getClientFeatures() {
-    return keys(
-      filterObject({ ws: Runtime.Transports.ws }, function(t) {
-        return t.isSupported({});
-      })
-    );
+    return keys(filterObject({ ws: Runtime.Transports.ws }, function(t) {
+      return t.isSupported({});
+    }));
   }
   constructor(app_key, options) {
     checkAppKey(app_key);
@@ -5659,10 +5088,10 @@ const _Pusher = class _Pusher {
     this.sessionID = Runtime.randomInt(1e9);
     this.timeline = new Timeline(this.key, this.sessionID, {
       cluster: this.config.cluster,
-      features: _Pusher.getClientFeatures(),
+      features: Pusher.getClientFeatures(),
       params: this.config.timelineParams || {},
       limit: 50,
-      level: TimelineLevel.INFO,
+      level: TimelineLevel$1.INFO,
       version: Defaults.VERSION
     });
     if (this.config.enableStats) {
@@ -5683,17 +5112,15 @@ const _Pusher = class _Pusher {
       useTLS: Boolean(this.config.useTLS)
     });
     if (options.deltaCompression !== void 0) {
-      this.deltaCompression = new DeltaCompressionManager(
-        options.deltaCompression || {},
-        (event, data) => this.send_event(event, data)
-      );
+      this.deltaCompression = new DeltaCompressionManager(options.deltaCompression || {}, (event, data) => this.send_event(event, data));
     }
     this.connection.bind("connected", () => {
+      var _a;
       this.subscribeAll();
       if (this.timelineSender) {
         this.timelineSender.send(this.connection.isUsingTLS());
       }
-      if (this.deltaCompression && options.deltaCompression?.enabled === true) {
+      if (this.deltaCompression && ((_a = options.deltaCompression) === null || _a === void 0 ? void 0 : _a.enabled) === true) {
         this.deltaCompression.enable();
       }
     });
@@ -5711,18 +5138,12 @@ const _Pusher = class _Pusher {
           if (!channel) {
             return;
           }
-          const reconstructedEvent = this.deltaCompression.handleDeltaMessage(
-            event.channel,
-            event.data
-          );
+          const reconstructedEvent = this.deltaCompression.handleDeltaMessage(event.channel, event.data);
           if (reconstructedEvent) {
             if (channel) {
               channel.handleEvent(reconstructedEvent);
             }
-            this.global_emitter.emit(
-              reconstructedEvent.event,
-              reconstructedEvent.data
-            );
+            this.global_emitter.emit(reconstructedEvent.event, reconstructedEvent.data);
           }
           return;
         }
@@ -5745,21 +5166,10 @@ const _Pusher = class _Pusher {
           if (fullMessage && sequence !== void 0) {
             fullMessage = fullMessage.replace(/,"__delta_seq":\d+/g, "");
             fullMessage = fullMessage.replace(/"__delta_seq":\d+,/g, "");
-            fullMessage = fullMessage.replace(
-              /,"__conflation_key":"[^"]*"/g,
-              ""
-            );
-            fullMessage = fullMessage.replace(
-              /"__conflation_key":"[^"]*",/g,
-              ""
-            );
+            fullMessage = fullMessage.replace(/,"__conflation_key":"[^"]*"/g, "");
+            fullMessage = fullMessage.replace(/"__conflation_key":"[^"]*",/g, "");
           }
-          this.deltaCompression.handleFullMessage(
-            event.channel,
-            fullMessage,
-            sequence,
-            conflationKey
-          );
+          this.deltaCompression.handleFullMessage(event.channel, fullMessage, sequence, conflationKey);
         }
       }
       if (!internal) {
@@ -5775,10 +5185,10 @@ const _Pusher = class _Pusher {
     this.connection.bind("error", (err) => {
       Logger$1.warn(err);
     });
-    _Pusher.instances.push(this);
-    this.timeline.info({ instances: _Pusher.instances.length });
+    Pusher.instances.push(this);
+    this.timeline.info({ instances: Pusher.instances.length });
     this.user = new UserFacade(this);
-    if (_Pusher.isReady) {
+    if (Pusher.isReady) {
       this.connect();
     }
   }
@@ -5870,33 +5280,25 @@ const _Pusher = class _Pusher {
   signin() {
     this.user.signin();
   }
-  /**
-   * Get delta compression statistics
-   * @returns {DeltaStats} Statistics about delta compression bandwidth savings
-   */
   getDeltaStats() {
     if (!this.deltaCompression) {
       return null;
     }
     return this.deltaCompression.getStats();
   }
-  /**
-   * Reset delta compression statistics
-   */
   resetDeltaStats() {
     if (this.deltaCompression) {
       this.deltaCompression.resetStats();
     }
   }
-};
-_Pusher.instances = [];
-_Pusher.isReady = false;
-_Pusher._logToConsole = false;
-_Pusher.Runtime = Runtime;
-_Pusher.ScriptReceivers = Runtime.ScriptReceivers;
-_Pusher.DependenciesReceivers = Runtime.DependenciesReceivers;
-_Pusher.auth_callbacks = Runtime.auth_callbacks;
-let Pusher = _Pusher;
+}
+Pusher.instances = [];
+Pusher.isReady = false;
+Pusher._logToConsole = false;
+Pusher.Runtime = Runtime;
+Pusher.ScriptReceivers = Runtime.ScriptReceivers;
+Pusher.DependenciesReceivers = Runtime.DependenciesReceivers;
+Pusher.auth_callbacks = Runtime.auth_callbacks;
 function checkAppKey(key) {
   if (key === null || key === void 0) {
     throw "You must pass your app key when you instantiate Pusher.";