@cendarsoss/pusher-js 8.4.13 → 8.4.14

package/dist/node/pusher.js

@@ -41,14 +41,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);
@@ -89,14 +84,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) {
@@ -239,10 +226,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) {
@@ -270,10 +254,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) + "]");
             }
           }
         }
@@ -298,14 +279,11 @@ var Defaults = {
   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,
@@ -370,30 +348,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) {
@@ -422,10 +389,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() {
@@ -458,7 +422,7 @@ let config = {
   logToConsole: false
 };
 function setLoggerConfig(newConfig) {
-  config = { ...config, ...newConfig };
+  config = Object.assign(Object.assign({}, config), newConfig);
 }
 class Logger {
   constructor() {
@@ -516,24 +480,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;
@@ -553,10 +505,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();
@@ -565,11 +513,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(() => {
@@ -582,7 +525,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();
@@ -590,10 +532,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;
@@ -653,12 +592,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) {
@@ -669,22 +606,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);
   }
@@ -711,33 +635,23 @@ var httpConfiguration = {
     return true;
   }
 };
-var streamingConfiguration = extend(
-  {
-    getSocket: function(url) {
-      return NodeJS.HTTPFactory.createStreamingSocket(url);
-    }
-  },
-  httpConfiguration
-);
-var pollingConfiguration = extend(
-  {
-    getSocket: function(url) {
-      return NodeJS.HTTPFactory.createPollingSocket(url);
-    }
-  },
-  httpConfiguration
-);
+var streamingConfiguration = extend({
+  getSocket: function(url) {
+    return NodeJS.HTTPFactory.createStreamingSocket(url);
+  }
+}, httpConfiguration);
+var pollingConfiguration = extend({
+  getSocket: function(url) {
+    return NodeJS.HTTPFactory.createPollingSocket(url);
+  }
+}, httpConfiguration);
 var xhrConfiguration = {
   isSupported: function() {
     return NodeJS.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$2 = {
   ws: WSTransport,
   xhr_streaming: XHRStreamingTransport,
@@ -751,26 +665,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);
@@ -792,35 +691,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;
@@ -835,13 +712,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;
       }
@@ -853,29 +729,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") {
@@ -896,16 +752,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) {
@@ -925,15 +771,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 {
@@ -956,27 +793,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) {
@@ -985,11 +807,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();
@@ -997,7 +814,6 @@ class Connection extends Dispatcher {
       this.send_event("pusher:ping", {});
     }
   }
-  /** Closes the connection. */
   close() {
     this.transport.close();
   }
@@ -1113,9 +929,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 {
@@ -1127,10 +941,7 @@ class TimelineSender {
     if (this.timeline.isEmpty()) {
       return;
     }
-    this.timeline.send(
-      NodeJS.TimelineTransport.getAgent(this, useTLS),
-      callback
-    );
+    this.timeline.send(NodeJS.TimelineTransport.getAgent(this, useTLS), callback);
   }
 }
 class BadEventName extends Error {
@@ -1205,14 +1016,16 @@ 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 = { buildLogSuffix };
@@ -1228,37 +1041,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.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;
@@ -1286,87 +1085,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 {
@@ -1377,26 +1147,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++;
@@ -1404,7 +1167,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) {
@@ -1413,7 +1175,6 @@ class Members {
     }
     return member;
   }
-  /** Resets the collection to the initial state. For internal use only. */
   reset() {
     this.members = {};
     this.count = 0;
@@ -1421,49 +1182,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.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) {
@@ -1509,56 +1281,36 @@ 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();
   }
 }
 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 = base64.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 = 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"
-    );
-  }
-  /** Handles an event. For internal use only.
-   *
-   * @param {PusherEvent} event
-   */
+    throw new UnsupportedFeature("Client events are not currently supported for encrypted channels");
+  }
   handleEvent(event) {
     var eventName = event.event;
     var data = event.data;
@@ -1570,48 +1322,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 = base64.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 = base64.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));
@@ -1621,13 +1359,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 = utf8.decode(bytes);
     try {
       return JSON.parse(raw);
-    } catch {
+    } catch (_a) {
       return raw;
     }
   }
@@ -1642,9 +1378,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 = NodeJS.getNetwork();
     Network2.bind("online", () => {
@@ -1661,11 +1395,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;
@@ -1678,10 +1407,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);
@@ -1689,13 +1414,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);
@@ -1703,7 +1421,6 @@ class ConnectionManager extends Dispatcher {
       return false;
     }
   }
-  /** Closes the connection. */
   disconnect() {
     this.disconnectInternally();
     this.updateState("disconnected");
@@ -1825,11 +1542,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;
@@ -1890,10 +1603,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);
@@ -1907,43 +1617,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();
@@ -1963,9 +1653,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);
   }
@@ -1986,8 +1674,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);
@@ -2004,25 +1692,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;
   }
@@ -2058,23 +1736,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();
@@ -2194,12 +1862,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++;
         }
@@ -2216,12 +1882,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);
       }
     });
@@ -2331,15 +1992,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;
   }
 }
@@ -2351,14 +2009,7 @@ function testSupportsStrategy(strategy) {
 var getDefaultStrategy$1 = 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;
   }
@@ -2389,53 +2040,20 @@ var getDefaultStrategy$1 = 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 xhr_streaming_transport = defineTransportStrategy(
-    "xhr_streaming",
-    "xhr_streaming",
-    1,
-    http_options,
-    streaming_manager
-  );
-  var xhr_polling_transport = defineTransportStrategy(
-    "xhr_polling",
-    "xhr_polling",
-    1,
-    http_options
-  );
+  var ws_transport = defineTransportStrategy("ws", "ws", 3, ws_options, ws_manager);
+  var wss_transport = defineTransportStrategy("wss", "ws", 3, wss_options, ws_manager);
+  var xhr_streaming_transport = defineTransportStrategy("xhr_streaming", "xhr_streaming", 1, http_options, streaming_manager);
+  var xhr_polling_transport = defineTransportStrategy("xhr_polling", "xhr_polling", 1, http_options);
   var ws_loop = new SequentialStrategy([ws_transport], timeouts);
   var wss_loop = new SequentialStrategy([wss_transport], timeouts);
-  var streaming_loop = new SequentialStrategy(
-    [xhr_streaming_transport],
-    timeouts
-  );
+  var streaming_loop = new SequentialStrategy([xhr_streaming_transport], timeouts);
   var polling_loop = new SequentialStrategy([xhr_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_loop = new SequentialStrategy([
+    new IfStrategy(testSupportsStrategy(streaming_loop), new BestConnectedEverStrategy([
+      streaming_loop,
+      new DelayedStrategy(polling_loop, { delay: 4e3 })
+    ]), polling_loop)
+  ], timeouts);
   var wsStrategy;
   if (baseOptions.useTLS) {
     wsStrategy = new BestConnectedEverStrategy([
@@ -2449,25 +2067,17 @@ var getDefaultStrategy$1 = function(config2, baseOptions, defineTransport2) {
       new DelayedStrategy(http_loop, { delay: 5e3 })
     ]);
   }
-  return new WebSocketPrioritizedCachedStrategy(
-    new FirstConnectedStrategy(
-      new IfStrategy(testSupportsStrategy(ws_transport), wsStrategy, http_loop)
-    ),
-    definedTransports,
-    {
-      ttl: 18e5,
-      timeline: baseOptions.timeline,
-      useTLS: baseOptions.useTLS
-    }
-  );
+  return new WebSocketPrioritizedCachedStrategy(new FirstConnectedStrategy(new IfStrategy(testSupportsStrategy(ws_transport), wsStrategy, http_loop)), definedTransports, {
+    ttl: 18e5,
+    timeline: baseOptions.timeline,
+    useTLS: baseOptions.useTLS
+  });
 };
 function transportConnectionInitializer$1() {
   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 {
@@ -2532,19 +2142,20 @@ 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 = {}));
+const State$1 = State;
 var autoIncrement = 1;
 class HTTPSocket {
   constructor(hooks2, url) {
     this.hooks = hooks2;
     this.session = randomNumber(1e3) + "/" + randomString(8);
     this.location = getLocation(url);
-    this.readyState = State.CONNECTING;
+    this.readyState = State$1.CONNECTING;
     this.openStream();
   }
   send(payload) {
@@ -2556,14 +2167,10 @@ class HTTPSocket {
   close(code, reason) {
     this.onClose(code, reason, true);
   }
-  /** For internal use only */
   sendRaw(payload) {
-    if (this.readyState === State.OPEN) {
+    if (this.readyState === State$1.OPEN) {
       try {
-        NodeJS.createSocketRequest(
-          "POST",
-          getUniqueURL(getSendURL(this.location, this.session))
-        ).start(payload);
+        NodeJS.createSocketRequest("POST", getUniqueURL(getSendURL(this.location, this.session))).start(payload);
         return true;
       } catch (e) {
         return false;
@@ -2572,15 +2179,13 @@ 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;
+    this.readyState = State$1.CLOSED;
     if (this.onclose) {
       this.onclose({
         code,
@@ -2593,7 +2198,7 @@ class HTTPSocket {
     if (chunk.status !== 200) {
       return;
     }
-    if (this.readyState === State.OPEN) {
+    if (this.readyState === State$1.OPEN) {
       this.onActivity();
     }
     var payload;
@@ -2623,11 +2228,11 @@ class HTTPSocket {
     }
   }
   onOpen(options) {
-    if (this.readyState === State.CONNECTING) {
+    if (this.readyState === State$1.CONNECTING) {
       if (options && options.hostname) {
         this.location.base = replaceHost(this.location.base, options.hostname);
       }
-      this.readyState = State.OPEN;
+      this.readyState = State$1.OPEN;
       if (this.onopen) {
         this.onopen();
       }
@@ -2636,7 +2241,7 @@ class HTTPSocket {
     }
   }
   onEvent(event) {
-    if (this.readyState === State.OPEN && this.onmessage) {
+    if (this.readyState === State$1.OPEN && this.onmessage) {
       this.onmessage({ data: event });
     }
   }
@@ -2651,10 +2256,7 @@ class HTTPSocket {
     }
   }
   openStream() {
-    this.stream = NodeJS.createSocketRequest(
-      "POST",
-      getUniqueURL(this.hooks.getReceiveURL(this.location, this.session))
-    );
+    this.stream = NodeJS.createSocketRequest("POST", getUniqueURL(this.hooks.getReceiveURL(this.location, this.session)));
     this.stream.bind("chunk", (chunk) => {
       this.onChunk(chunk);
     });
@@ -2796,11 +2398,9 @@ var Isomorphic = {
     return void 0;
   },
   getClientFeatures() {
-    return keys(
-      filterObject({ ws: Transports$2.ws }, function(t) {
-        return t.isSupported({});
-      })
-    );
+    return keys(filterObject({ ws: Transports$2.ws }, function(t) {
+      return t.isSupported({});
+    }));
   },
   getProtocol() {
     return "http:";
@@ -2834,11 +2434,11 @@ class NetInfo extends Dispatcher {
   }
 }
 var Network = new NetInfo();
-var AuthRequestType = /* @__PURE__ */ ((AuthRequestType2) => {
+var AuthRequestType;
+(function(AuthRequestType2) {
   AuthRequestType2["UserAuthentication"] = "user-authentication";
   AuthRequestType2["ChannelAuthorization"] = "channel-authorization";
-  return AuthRequestType2;
-})(AuthRequestType || {});
+})(AuthRequestType || (AuthRequestType = {}));
 const ajax = function(context, query, authOptions, authRequestType, callback) {
   const xhr2 = NodeJS.createXHR();
   xhr2.open("POST", authOptions.endpoint, true);
@@ -2861,13 +2461,7 @@ const ajax = function(context, query, authOptions, authRequestType, callback) {
           data = JSON.parse(xhr2.responseText);
           parsed = true;
         } catch (e) {
-          callback(
-            new HTTPAuthError(
-              200,
-              `JSON returned from ${authRequestType.toString()} endpoint was invalid, yet status code was 200. Data was: ${xhr2.responseText}`
-            ),
-            null
-          );
+          callback(new HTTPAuthError(200, `JSON returned from ${authRequestType.toString()} endpoint was invalid, yet status code was 200. Data was: ${xhr2.responseText}`), null);
         }
         if (parsed) {
           callback(null, data);
@@ -2879,18 +2473,10 @@ const ajax = function(context, query, authOptions, authRequestType, callback) {
             suffix = UrlStore.buildLogSuffix("authenticationEndpoint");
             break;
           case AuthRequestType.ChannelAuthorization:
-            suffix = `Clients must be authorized to join private or presence channels. ${UrlStore.buildLogSuffix(
-              "authorizationEndpoint"
-            )}`;
+            suffix = `Clients must be authorized to join private or presence channels. ${UrlStore.buildLogSuffix("authorizationEndpoint")}`;
             break;
         }
-        callback(
-          new HTTPAuthError(
-            xhr2.status,
-            `Unable to retrieve auth string from ${authRequestType.toString()} endpoint - received status: ${xhr2.status} from ${authOptions.endpoint}. ${suffix}`
-          ),
-          null
-        );
+        callback(new HTTPAuthError(xhr2.status, `Unable to retrieve auth string from ${authRequestType.toString()} endpoint - received status: ${xhr2.status} from ${authOptions.endpoint}. ${suffix}`), null);
       }
     }
   };
@@ -2909,9 +2495,7 @@ var getAgent = function(sender, useTLS) {
       if (xhr2.readyState === 4) {
         let { status, responseText } = xhr2;
         if (status !== 200) {
-          Logger$1.debug(
-            `TimelineSender Error: received ${status} from stats.pusher.com`
-          );
+          Logger$1.debug(`TimelineSender Error: received ${status} from stats.pusher.com`);
           return;
         }
         try {
@@ -2977,12 +2561,13 @@ const NodeJS = {
     return crypto.randomInt(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;
@@ -2994,40 +2579,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) {
@@ -3051,20 +2631,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);
@@ -3072,12 +2643,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);
@@ -3158,16 +2724,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;
   }
@@ -3198,9 +2756,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) => {
@@ -3222,13 +2778,7 @@ const UserAuthenticator = (authOptions) => {
   }
   return (params, callback) => {
     const query = composeChannelQuery$1(params, authOptions);
-    NodeJS.getAuthorizers()[authOptions.transport](
-      NodeJS,
-      query,
-      authOptions,
-      AuthRequestType.UserAuthentication,
-      callback
-    );
+    NodeJS.getAuthorizers()[authOptions.transport](NodeJS, query, authOptions, AuthRequestType.UserAuthentication, callback);
   };
 };
 const composeChannelQuery = (params, authOptions) => {
@@ -3251,13 +2801,7 @@ const ChannelAuthorizer = (authOptions) => {
   }
   return (params, callback) => {
     const query = composeChannelQuery(params, authOptions);
-    NodeJS.getAuthorizers()[authOptions.transport](
-      NodeJS,
-      query,
-      authOptions,
-      AuthRequestType.ChannelAuthorization,
-      callback
-    );
+    NodeJS.getAuthorizers()[authOptions.transport](NodeJS, query, authOptions, AuthRequestType.ChannelAuthorization, callback);
   };
 };
 const ChannelAuthorizerProxy = (pusher, authOptions, channelAuthorizerGenerator) => {
@@ -3301,7 +2845,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;
   }
@@ -3343,10 +2888,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"];
   }
@@ -3355,26 +2897,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;
 }
@@ -3472,12 +3008,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 {
@@ -3488,9 +3021,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;
     }
@@ -3505,10 +3036,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;
@@ -3549,7 +3077,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;
@@ -3557,12 +3085,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)) {
@@ -3574,18 +3099,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;
@@ -3613,9 +3131,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);
@@ -3623,56 +3138,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,
@@ -3724,9 +3215,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)`);
     }
   }
 }
@@ -3751,14 +3240,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"],
@@ -3779,14 +3267,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()) {
@@ -3799,9 +3282,6 @@ class DeltaCompressionManager {
     }
     return available;
   }
-  /**
-   * Enable delta compression
-   */
   enable() {
     if (this.enabled || !this.options.enabled) {
       return;
@@ -3810,9 +3290,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;
@@ -3822,26 +3300,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,
@@ -3856,16 +3324,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 delta = 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", {
@@ -3886,44 +3352,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;
         }
@@ -3932,10 +3381,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 {
@@ -3945,11 +3391,7 @@ class DeltaCompressionManager {
         throw decodeError;
       }
       if (channelState.conflationKey) {
-        channelState.updateConflationCache(
-          conflationKey,
-          reconstructedMessage,
-          sequence
-        );
+        channelState.updateConflationCache(conflationKey, reconstructedMessage, sequence);
       } else {
         channelState.setBase(reconstructedMessage, sequence);
       }
@@ -3970,17 +3412,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 {
@@ -3997,7 +3432,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
       });
@@ -4005,14 +3440,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 {
@@ -4041,12 +3474,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,
@@ -4068,42 +3496,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,
@@ -4115,9 +3528,6 @@ class DeltaCompressionManager {
     };
     this.updateStats();
   }
-  /**
-   * Clear channel state
-   */
   clearChannelState(channel) {
     if (channel) {
       this.channelStates.delete(channel);
@@ -4125,29 +3535,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) {
@@ -4156,15 +3554,6 @@ class DeltaCompressionManager {
   }
 }
 class Pusher {
-  static {
-    this.instances = [];
-  }
-  static {
-    this.isReady = false;
-  }
-  static {
-    this._logToConsole = false;
-  }
   static get logToConsole() {
     return this._logToConsole;
   }
@@ -4179,18 +3568,6 @@ class Pusher {
     this._log = fn;
     setLoggerConfig({ logToConsole: this._logToConsole, log: fn });
   }
-  static {
-    this.Runtime = NodeJS;
-  }
-  static {
-    this.ScriptReceivers = NodeJS.ScriptReceivers;
-  }
-  static {
-    this.DependenciesReceivers = NodeJS.DependenciesReceivers;
-  }
-  static {
-    this.auth_callbacks = NodeJS.auth_callbacks;
-  }
   static ready() {
     Pusher.isReady = true;
     for (var i = 0, l = Pusher.instances.length; i < l; i++) {
@@ -4198,11 +3575,9 @@ class Pusher {
     }
   }
   static getClientFeatures() {
-    return keys(
-      filterObject({ ws: NodeJS.Transports.ws }, function(t) {
-        return t.isSupported({});
-      })
-    );
+    return keys(filterObject({ ws: NodeJS.Transports.ws }, function(t) {
+      return t.isSupported({});
+    }));
   }
   constructor(app_key, options) {
     checkAppKey(app_key);
@@ -4217,7 +3592,7 @@ class Pusher {
       features: Pusher.getClientFeatures(),
       params: this.config.timelineParams || {},
       limit: 50,
-      level: TimelineLevel.INFO,
+      level: TimelineLevel$1.INFO,
       version: Defaults.VERSION
     });
     if (this.config.enableStats) {
@@ -4238,17 +3613,15 @@ 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();
       }
     });
@@ -4266,18 +3639,12 @@ 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;
         }
@@ -4300,21 +3667,10 @@ 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) {
@@ -4425,25 +3781,25 @@ 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 = NodeJS;
+Pusher.ScriptReceivers = NodeJS.ScriptReceivers;
+Pusher.DependenciesReceivers = NodeJS.DependenciesReceivers;
+Pusher.auth_callbacks = NodeJS.auth_callbacks;
 function checkAppKey(key) {
   if (key === null || key === void 0) {
     throw "You must pass your app key when you instantiate Pusher.";