pusher_rails 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3cabf21e41ef487b94bf5fbb948228d57ad343b9
-  data.tar.gz: 01a24e6d002d6d2a22882f9e63bb73c51bccda79
+  metadata.gz: 3179ba51d8e8259fdcbd446b60e6e5c87a18886e
+  data.tar.gz: 2a672bd542b91f62a5ab8c26aba5ad1650bf5ea7
 SHA512:
-  metadata.gz: 1020d025a5b2491b67595a4cc7646789984b48c9e4d840da8be9803db4b51c3920c9e3e5ffc2630e1726f3aae241cee5e7e27477254da73f1bd3b7aad2d1e9ea
-  data.tar.gz: 9884af8e5537f39f2fdecaaf5c71a69035ccd24cfc2efe1c49eac11fa01a78638c3f442d9cc124b7838e33a7d9cee24971fa6b9e59bb988d325f508c89142674
+  metadata.gz: 7eec94660281c2fa773cc2a5d6d0fa4cd5dfbfb73d98abfd6703de63b0ca6b81d568b2b340c3194421e80b255a77b9d6d4c5de95443be85b3cf5efee01f27209
+  data.tar.gz: 13b1878f0357078485f6d3e8108d9f77e0c103ab3c1f39a108083973a17bca67f0c7a9fbcc0f903ad00d66cb84a8ff01fbbd054ac4958a7c17751f265b573adb

data/.gitignore

@@ -1 +1,2 @@
 *.gem
+.rvmrc

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+v0.2.5
+======
+- Upgraded to pusher-gem 0.9.4
+
+v0.2.4
+======
+- Upgraded to pusher.js 1.12.2
+
+v0.2.3
+======
+- Upgraded to pusher.js 1.12.1
+- Upgraded to pusher-gem 0.9.3
+
 v0.2.2
 ======
 - Upgraded to pusher.js 1.12.0

data/README.md

@@ -2,8 +2,8 @@
 =====================
 
 Adds:
-- [pusher-gem v0.9.2](https://github.com/pusher/pusher-gem/tree/v0.9.2)
-- [pusher.js v1.12.0](https://github.com/pusher/pusher-js/tree/v1.12.0)
+- [pusher-gem v0.9.4](https://github.com/pusher/pusher-gem/tree/v0.9.4)
+- [pusher.js v1.12.2](https://github.com/pusher/pusher-js/tree/v1.12.2)
 - [backpusher.js](https://github.com/pusher/backpusher)
 
 This pulls in the *pusher-gem* as well as adding *pusher.js* and *backpusher.js* to the assets pipeline of your Rails 3.1+ app.
@@ -21,7 +21,7 @@ Licenses
 ========
 
     /*!
-     * Pusher JavaScript Library v1.12.0
+     * Pusher JavaScript Library v1.12.2
      * http://pusherapp.com/
      *
      * Copyright 2011, Pusher

data/pusher_rails.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name          = 'pusher_rails'
-  s.version       = '0.3.0'
+  s.version       = '1.0.0'
   s.platform      = Gem::Platform::RUBY
   s.authors       = ["David Grandinetti"]
   s.email         = ["dave@wegoto12.com"]

data/vendor/assets/javascripts/pusher.js

@@ -1,924 +1,2946 @@
 /*!
- * Pusher JavaScript Library v1.12.7
+ * Pusher JavaScript Library v2.0.0
  * http://pusherapp.com/
  *
- * Copyright 2011, Pusher
+ * Copyright 2013, Pusher
  * Released under the MIT licence.
  */
 
 ;(function() {
-  if (Function.prototype.scopedTo === undefined) {
-    Function.prototype.scopedTo = function(context, args) {
-      var f = this;
-      return function() {
-        return f.apply(context, Array.prototype.slice.call(args || [])
-                       .concat(Array.prototype.slice.call(arguments)));
-      };
-    };
-  }
+  function Pusher(app_key, options) {
+    var self = this;
 
-  var Pusher = function(app_key, options) {
     this.options = options || {};
     this.key = app_key;
     this.channels = new Pusher.Channels();
-    this.global_emitter = new Pusher.EventsDispatcher()
+    this.global_emitter = new Pusher.EventsDispatcher();
+    this.sessionID = Math.floor(Math.random() * 1000000000);
 
-    var self = this;
+    checkAppKey(this.key);
+
+    var getStrategy = function(options) {
+      return Pusher.StrategyBuilder.build(
+        Pusher.getDefaultStrategy(),
+        Pusher.Util.extend({}, self.options, options)
+      );
+    };
+    var getTimeline = function() {
+      return new Pusher.Timeline(self.key, self.sessionID, {
+        features: Pusher.Util.getClientFeatures(),
+        params: self.options.timelineParams || {},
+        limit: 25,
+        level: Pusher.Timeline.INFO,
+        version: Pusher.VERSION
+      });
+    };
+    var getTimelineSender = function(timeline, options) {
+      if (self.options.disableStats) {
+        return null;
+      }
+      return new Pusher.TimelineSender(timeline, {
+        encrypted: self.isEncrypted() || !!options.encrypted,
+        host: Pusher.stats_host,
+        path: "/timeline"
+      });
+    };
+
+    this.connection = new Pusher.ConnectionManager(
+      this.key,
+      Pusher.Util.extend(
+        { getStrategy: getStrategy,
+          getTimeline: getTimeline,
+          getTimelineSender: getTimelineSender,
+          activityTimeout: Pusher.activity_timeout,
+          pongTimeout: Pusher.pong_timeout,
+          unavailableTimeout: Pusher.unavailable_timeout
+        },
+        this.options,
+        { encrypted: this.isEncrypted() }
+      )
+    );
+
+    this.connection.bind('connected', function() {
+      self.subscribeAll();
+    });
+    this.connection.bind('message', function(params) {
+      var internal = (params.event.indexOf('pusher_internal:') === 0);
+      if (params.channel) {
+        var channel = self.channel(params.channel);
+        if (channel) {
+          channel.emit(params.event, params.data);
+        }
+      }
+      // Emit globaly [deprecated]
+      if (!internal) self.global_emitter.emit(params.event, params.data);
+    });
+    this.connection.bind('disconnected', function() {
+      self.channels.disconnect();
+    });
+    this.connection.bind('error', function(err) {
+      Pusher.warn('Error', err);
+    });
+
+    Pusher.instances.push(this);
 
-    this.checkAppKey();
+    if (Pusher.isReady) self.connect();
+  }
+  var prototype = Pusher.prototype;
 
-    this.connection = new Pusher.Connection(this.key, this.options);
+  Pusher.instances = [];
+  Pusher.isReady = false;
 
-    // Setup / teardown connection
-    this.connection
-      .bind('connected', function() {
-        self.subscribeAll();
-      })
-      .bind('message', function(params) {
-        var internal = (params.event.indexOf('pusher_internal:') === 0);
-        if (params.channel) {
-          var channel;
-          if (channel = self.channel(params.channel)) {
-            channel.emit(params.event, params.data);
+  // To receive log output provide a Pusher.log function, for example
+  // Pusher.log = function(m){console.log(m)}
+  Pusher.debug = function() {
+    if (!Pusher.log) {
+      return;
+    }
+    Pusher.log(Pusher.Util.stringify.apply(this, arguments));
+  };
+
+  Pusher.warn = function() {
+    if (window.console && window.console.warn) {
+      window.console.warn(Pusher.Util.stringify.apply(this, arguments));
+    } else {
+      if (!Pusher.log) {
+        return;
+      }
+      Pusher.log(Pusher.Util.stringify.apply(this, arguments));
+    }
+  };
+
+  Pusher.ready = function() {
+    Pusher.isReady = true;
+    for (var i = 0, l = Pusher.instances.length; i < l; i++) {
+      Pusher.instances[i].connect();
+    }
+  };
+
+  prototype.channel = function(name) {
+    return this.channels.find(name);
+  };
+
+  prototype.connect = function() {
+    this.connection.connect();
+  };
+
+  prototype.disconnect = function() {
+    this.connection.disconnect();
+  };
+
+  prototype.bind = function(event_name, callback) {
+    this.global_emitter.bind(event_name, callback);
+    return this;
+  };
+
+  prototype.bind_all = function(callback) {
+    this.global_emitter.bind_all(callback);
+    return this;
+  };
+
+  prototype.subscribeAll = function() {
+    var channelName;
+    for (channelName in this.channels.channels) {
+      if (this.channels.channels.hasOwnProperty(channelName)) {
+        this.subscribe(channelName);
+      }
+    }
+  };
+
+  prototype.subscribe = function(channel_name) {
+    var self = this;
+    var channel = this.channels.add(channel_name, this);
+
+    if (this.connection.state === 'connected') {
+      channel.authorize(
+        this.connection.socket_id,
+        this.options,
+        function(err, data) {
+          if (err) {
+            channel.emit('pusher:subscription_error', data);
+          } else {
+            self.send_event('pusher:subscribe', {
+              channel: channel_name,
+              auth: data.auth,
+              channel_data: data.channel_data
+            });
           }
         }
-        // Emit globaly [deprecated]
-        if (!internal) self.global_emitter.emit(params.event, params.data);
-      })
-      .bind('disconnected', function() {
-        self.channels.disconnect();
-      })
-      .bind('error', function(err) {
-        Pusher.warn('Error', err);
+      );
+    }
+    return channel;
+  };
+
+  prototype.unsubscribe = function(channel_name) {
+    this.channels.remove(channel_name);
+    if (this.connection.state === 'connected') {
+      this.send_event('pusher:unsubscribe', {
+        channel: channel_name
       });
+    }
+  };
 
-    Pusher.instances.push(this);
+  prototype.send_event = function(event_name, data, channel) {
+    return this.connection.send_event(event_name, data, channel);
+  };
 
-    if (Pusher.isReady) self.connect();
+  prototype.isEncrypted = function() {
+    if (Pusher.Util.getDocumentLocation().protocol === "https:") {
+      return true;
+    } else {
+      return !!this.options.encrypted;
+    }
   };
-  Pusher.instances = [];
-  Pusher.prototype = {
-    channel: function(name) {
-      return this.channels.find(name);
+
+  function checkAppKey(key) {
+    if (key === null || key === undefined) {
+      Pusher.warn(
+        'Warning', 'You must pass your app key when you instantiate Pusher.'
+      );
+    }
+  }
+
+  this.Pusher = Pusher;
+}).call(this);
+
+;(function() {
+  Pusher.Util = {
+    now: function() {
+      if (Date.now) {
+        return Date.now();
+      } else {
+        return new Date().valueOf();
+      }
     },
 
-    connect: function() {
-      this.connection.connect();
+    /** Merges multiple objects into the target argument.
+     *
+     * For properties that are plain Objects, performs a deep-merge. For the
+     * rest it just copies the value of the property.
+     *
+     * To extend prototypes use it as following:
+     *   Pusher.Util.extend(Target.prototype, Base.prototype)
+     *
+     * You can also use it to merge objects without altering them:
+     *   Pusher.Util.extend({}, object1, object2)
+     *
+     * @param  {Object} target
+     * @return {Object} the target argument
+     */
+    extend: function(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var extensions = arguments[i];
+        for (var property in extensions) {
+          if (extensions[property] && extensions[property].constructor &&
+              extensions[property].constructor === Object) {
+            target[property] = Pusher.Util.extend(
+              target[property] || {}, extensions[property]
+            );
+          } else {
+            target[property] = extensions[property];
+          }
+        }
+      }
+      return target;
     },
 
-    disconnect: function() {
-      this.connection.disconnect();
+    stringify: function() {
+      var m = ["Pusher"];
+      for (var i = 0; i < arguments.length; i++) {
+        if (typeof arguments[i] === "string") {
+          m.push(arguments[i]);
+        } else {
+          if (window.JSON === undefined) {
+            m.push(arguments[i].toString());
+          } else {
+            m.push(JSON.stringify(arguments[i]));
+          }
+        }
+      }
+      return m.join(" : ");
+    },
+
+    arrayIndexOf: function(array, item) { // MSIE doesn't have array.indexOf
+      var nativeIndexOf = Array.prototype.indexOf;
+      if (array === null) {
+        return -1;
+      }
+      if (nativeIndexOf && array.indexOf === nativeIndexOf) {
+        return array.indexOf(item);
+      }
+      for (var i = 0, l = array.length; i < l; i++) {
+        if (array[i] === item) {
+          return i;
+        }
+      }
+      return -1;
     },
 
-    bind: function(event_name, callback) {
-      this.global_emitter.bind(event_name, callback);
-      return this;
+    keys: function(object) {
+      var result = [];
+      for (var key in object) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+          result.push(key);
+        }
+      }
+      return result;
+    },
+
+    /** Applies a function f to all elements of an array.
+     *
+     * Function f gets 3 arguments passed:
+     * - element from the array
+     * - index of the element
+     * - reference to the array
+     *
+     * @param {Array} array
+     * @param {Function} f
+     */
+    apply: function(array, f) {
+      for (var i = 0; i < array.length; i++) {
+        f(array[i], i, array);
+      }
+    },
+
+    /** Applies a function f to all properties of an object.
+     *
+     * Function f gets 3 arguments passed:
+     * - element from the object
+     * - key of the element
+     * - reference to the object
+     *
+     * @param {Object} object
+     * @param {Function} f
+     */
+    objectApply: function(object, f) {
+      for (var key in object) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+          f(object[key], key, object);
+        }
+      }
+    },
+
+    /** Maps all elements of the array and returns the result.
+     *
+     * Function f gets 4 arguments passed:
+     * - element from the array
+     * - index of the element
+     * - reference to the source array
+     * - reference to the destination array
+     *
+     * @param {Array} array
+     * @param {Function} f
+     */
+    map: function(array, f) {
+      var result = [];
+      for (var i = 0; i < array.length; i++) {
+        result.push(f(array[i], i, array, result));
+      }
+      return result;
+    },
+
+    /** Maps all elements of the object and returns the result.
+     *
+     * Function f gets 4 arguments passed:
+     * - element from the object
+     * - key of the element
+     * - reference to the source object
+     * - reference to the destination object
+     *
+     * @param {Object} object
+     * @param {Function} f
+     */
+    mapObject: function(object, f) {
+      var result = {};
+      for (var key in object) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+          result[key] = f(object[key]);
+        }
+      }
+      return result;
+    },
+
+    /** Filters elements of the array using a test function.
+     *
+     * Function test gets 4 arguments passed:
+     * - element from the array
+     * - index of the element
+     * - reference to the source array
+     * - reference to the destination array
+     *
+     * @param {Array} array
+     * @param {Function} f
+     */
+    filter: function(array, test) {
+      test = test || function(value) { return !!value; };
+
+      var result = [];
+      for (var i = 0; i < array.length; i++) {
+        if (test(array[i], i, array, result)) {
+          result.push(array[i]);
+        }
+      }
+      return result;
+    },
+
+    /** Filters properties of the object using a test function.
+     *
+     * Function test gets 4 arguments passed:
+     * - element from the object
+     * - key of the element
+     * - reference to the source object
+     * - reference to the destination object
+     *
+     * @param {Object} object
+     * @param {Function} f
+     */
+    filterObject: function(object, test) {
+      test = test || function(value) { return !!value; };
+
+      var result = {};
+      for (var key in object) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+          if (test(object[key], key, object, result)) {
+            result[key] = object[key];
+          }
+        }
+      }
+      return result;
+    },
+
+    /** Flattens an object into a two-dimensional array.
+     *
+     * @param  {Object} object
+     * @return {Array} resulting array of [key, value] pairs
+     */
+    flatten: function(object) {
+      var result = [];
+      for (var key in object) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+          result.push([key, object[key]]);
+        }
+      }
+      return result;
+    },
+
+    /** Checks whether any element of the array passes the test.
+     *
+     * Function test gets 3 arguments passed:
+     * - element from the array
+     * - index of the element
+     * - reference to the source array
+     *
+     * @param {Array} array
+     * @param {Function} f
+     */
+    any: function(array, test) {
+      for (var i = 0; i < array.length; i++) {
+        if (test(array[i], i, array)) {
+          return true;
+        }
+      }
+      return false;
+    },
+
+    /** Checks whether all elements of the array pass the test.
+     *
+     * Function test gets 3 arguments passed:
+     * - element from the array
+     * - index of the element
+     * - reference to the source array
+     *
+     * @param {Array} array
+     * @param {Function} f
+     */
+    all: function(array, test) {
+      for (var i = 0; i < array.length; i++) {
+        if (!test(array[i], i, array)) {
+          return false;
+        }
+      }
+      return true;
+    },
+
+    /** 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: function(name) {
+      var boundArguments = Array.prototype.slice.call(arguments, 1);
+      return function(object) {
+        return object[name].apply(object, boundArguments.concat(arguments));
+      };
+    },
+
+    getDocument: function() {
+      return document;
+    },
+
+    getDocumentLocation: function() {
+      return Pusher.Util.getDocument().location;
     },
 
-    bind_all: function(callback) {
-      this.global_emitter.bind_all(callback);
-      return this;
+    getLocalStorage: function() {
+      return window.localStorage;
     },
 
-    subscribeAll: function() {
-      var channelName;
-      for (channelName in this.channels.channels) {
-        if (this.channels.channels.hasOwnProperty(channelName)) {
-          this.subscribe(channelName);
+    getClientFeatures: function() {
+      return Pusher.Util.keys(
+        Pusher.Util.filterObject(
+          { "ws": Pusher.WSTransport, "flash": Pusher.FlashTransport },
+          function (t) { return t.isSupported(); }
+        )
+      );
+    }
+  };
+}).call(this);
+
+;(function() {
+  Pusher.VERSION = '2.0.0';
+  Pusher.PROTOCOL = 6;
+
+  // WS connection parameters
+  Pusher.host = 'ws.pusherapp.com';
+  Pusher.ws_port = 80;
+  Pusher.wss_port = 443;
+  // SockJS fallback parameters
+  Pusher.sockjs_host = 'sockjs.pusher.com';
+  Pusher.sockjs_http_port = 80;
+  Pusher.sockjs_https_port = 443;
+  Pusher.sockjs_path = "/pusher";
+  // Stats
+  Pusher.stats_host = 'stats.pusher.com';
+  // Other settings
+  Pusher.channel_auth_endpoint = '/pusher/auth';
+  Pusher.cdn_http = 'http://js.pusher.com/';
+  Pusher.cdn_https = 'https://d3dy5gmtp8yhk7.cloudfront.net/';
+  Pusher.dependency_suffix = '';
+  Pusher.channel_auth_transport = 'ajax';
+  Pusher.activity_timeout = 120000;
+  Pusher.pong_timeout = 30000;
+  Pusher.unavailable_timeout = 10000;
+
+  Pusher.getDefaultStrategy = function() {
+    return [
+      [":def", "ws_options", {
+        hostUnencrypted: Pusher.host + ":" + Pusher.ws_port,
+        hostEncrypted: Pusher.host + ":" + Pusher.wss_port
+      }],
+      [":def", "sockjs_options", {
+        hostUnencrypted: Pusher.sockjs_host + ":" + Pusher.sockjs_http_port,
+        hostEncrypted: Pusher.sockjs_host + ":" + Pusher.sockjs_https_port
+      }],
+      [":def", "timeouts", {
+        loop: true,
+        timeout: 15000,
+        timeoutLimit: 60000
+      }],
+
+      [":def", "ws_manager", [":transport_manager", { lives: 2 }]],
+      [":def_transport", "ws", "ws", 3, ":ws_options", ":ws_manager"],
+      [":def_transport", "flash", "flash", 2, ":ws_options", ":ws_manager"],
+      [":def_transport", "sockjs", "sockjs", 1, ":sockjs_options"],
+      [":def", "ws_loop", [":sequential", ":timeouts", ":ws"]],
+      [":def", "flash_loop", [":sequential", ":timeouts", ":flash"]],
+      [":def", "sockjs_loop", [":sequential", ":timeouts", ":sockjs"]],
+
+      [":def", "strategy",
+        [":cached", 1800000,
+          [":first_connected",
+            [":if", [":is_supported", ":ws"], [
+                ":best_connected_ever", ":ws_loop", [":delayed", 2000, [":sockjs_loop"]]
+              ], [":if", [":is_supported", ":flash"], [
+                ":best_connected_ever", ":flash_loop", [":delayed", 2000, [":sockjs_loop"]]
+              ], [
+                ":sockjs_loop"
+              ]
+            ]]
+          ]
+        ]
+      ]
+    ];
+  };
+}).call(this);
+
+;(function() {
+  function buildExceptionClass(name) {
+    var klass = function(message) {
+      Error.call(this, message);
+      this.name = name;
+    };
+    Pusher.Util.extend(klass.prototype, Error.prototype);
+
+    return klass;
+  }
+
+  /** Error classes used throughout pusher-js library. */
+  Pusher.Errors = {
+    UnsupportedTransport: buildExceptionClass("UnsupportedTransport"),
+    UnsupportedStrategy: buildExceptionClass("UnsupportedStrategy"),
+    TransportPriorityTooLow: buildExceptionClass("TransportPriorityTooLow"),
+    TransportClosed: buildExceptionClass("TransportClosed")
+  };
+}).call(this);
+
+;(function() {
+  /** Manages callback bindings and event emitting.
+   *
+   * @param Function failThrough called when no listeners are bound to an event
+   */
+  function EventsDispatcher(failThrough) {
+    this.callbacks = new CallbackRegistry();
+    this.global_callbacks = [];
+    this.failThrough = failThrough;
+  }
+  var prototype = EventsDispatcher.prototype;
+
+  prototype.bind = function(eventName, callback) {
+    this.callbacks.add(eventName, callback);
+    return this;
+  };
+
+  prototype.bind_all = function(callback) {
+    this.global_callbacks.push(callback);
+    return this;
+  };
+
+  prototype.unbind = function(eventName, callback) {
+    this.callbacks.remove(eventName, callback);
+    return this;
+  };
+
+  prototype.emit = function(eventName, data) {
+    var i;
+
+    for (i = 0; i < this.global_callbacks.length; i++) {
+      this.global_callbacks[i](eventName, data);
+    }
+
+    var callbacks = this.callbacks.get(eventName);
+    if (callbacks && callbacks.length > 0) {
+      for (i = 0; i < callbacks.length; i++) {
+        callbacks[i](data);
+      }
+    } else if (this.failThrough) {
+      this.failThrough(eventName, data);
+    }
+
+    return this;
+  };
+
+  /** Callback registry helper. */
+
+  function CallbackRegistry() {
+    this._callbacks = {};
+  }
+
+  CallbackRegistry.prototype.get = function(eventName) {
+    return this._callbacks[this._prefix(eventName)];
+  };
+
+  CallbackRegistry.prototype.add = function(eventName, callback) {
+    var prefixedEventName = this._prefix(eventName);
+    this._callbacks[prefixedEventName] = this._callbacks[prefixedEventName] || [];
+    this._callbacks[prefixedEventName].push(callback);
+  };
+
+  CallbackRegistry.prototype.remove = function(eventName, callback) {
+    if(this.get(eventName)) {
+      var index = Pusher.Util.arrayIndexOf(this.get(eventName), callback);
+      var callbacksCopy = this._callbacks[this._prefix(eventName)].slice(0);
+      callbacksCopy.splice(index, 1);
+      this._callbacks[this._prefix(eventName)] = callbacksCopy;
+    }
+  };
+
+  CallbackRegistry.prototype._prefix = function(eventName) {
+    return "_" + eventName;
+  };
+
+  Pusher.EventsDispatcher = EventsDispatcher;
+}).call(this);
+
+;(function() {
+  /** Handles loading dependency files.
+   *
+   * Options:
+   * - cdn_http - url to HTTP CND
+   * - cdn_https - url to HTTPS CDN
+   * - version - version of pusher-js
+   * - suffix - suffix appended to all names of dependency files
+   *
+   * @param {Object} options
+   */
+  function DependencyLoader(options) {
+    this.options = options;
+    this.loading = {};
+    this.loaded = {};
+  }
+  var prototype = DependencyLoader.prototype;
+
+  /** Loads the dependency from CDN.
+   *
+   * @param  {String} name
+   * @param  {Function} callback
+   */
+  prototype.load = function(name, callback) {
+    var self = this;
+
+    if (this.loaded[name]) {
+      callback();
+      return;
+    }
+
+    if (!this.loading[name]) {
+      this.loading[name] = [];
+    }
+    this.loading[name].push(callback);
+    if (this.loading[name].length > 1) {
+      return;
+    }
+
+    require(this.getPath(name), function() {
+      for (var i = 0; i < self.loading[name].length; i++) {
+        self.loading[name][i]();
+      }
+      delete self.loading[name];
+      self.loaded[name] = true;
+    });
+  };
+
+  /** Returns a root URL for pusher-js CDN.
+   *
+   * @returns {String}
+   */
+  prototype.getRoot = function(options) {
+    var cdn;
+    var protocol = Pusher.Util.getDocumentLocation().protocol;
+    if ((options && options.encrypted) || protocol === "https:") {
+      cdn = this.options.cdn_https;
+    } else {
+      cdn = this.options.cdn_http;
+    }
+    // make sure there are no double slashes
+    return cdn.replace(/\/*$/, "") + "/" + this.options.version;
+  };
+
+  /** Returns a full path to a dependency file.
+   *
+   * @param {String} name
+   * @returns {String}
+   */
+  prototype.getPath = function(name, options) {
+    return this.getRoot(options) + '/' + name + this.options.suffix + '.js';
+  };
+
+  function handleScriptLoaded(elem, callback) {
+    if (Pusher.Util.getDocument().addEventListener) {
+      elem.addEventListener('load', callback, false);
+    } else {
+      elem.attachEvent('onreadystatechange', function () {
+        if (elem.readyState === 'loaded' || elem.readyState === 'complete') {
+          callback();
+        }
+      });
+    }
+  }
+
+  function require(src, callback) {
+    var document = Pusher.Util.getDocument();
+    var head = document.getElementsByTagName('head')[0];
+    var script = document.createElement('script');
+
+    script.setAttribute('src', src);
+    script.setAttribute("type","text/javascript");
+    script.setAttribute('async', true);
+
+    handleScriptLoaded(script, function() {
+      // workaround for an Opera issue
+      setTimeout(callback, 0);
+    });
+
+    head.appendChild(script);
+  }
+
+  Pusher.DependencyLoader = DependencyLoader;
+}).call(this);
+
+;(function() {
+  Pusher.Dependencies = new Pusher.DependencyLoader({
+    cdn_http: Pusher.cdn_http,
+    cdn_https: Pusher.cdn_https,
+    version: Pusher.VERSION,
+    suffix: Pusher.dependency_suffix
+  });
+
+  // Support Firefox versions which prefix WebSocket
+  if (!window.WebSocket && window.MozWebSocket) {
+    window.WebSocket = window.MozWebSocket;
+  }
+
+  function initialize() {
+    Pusher.ready();
+  }
+
+  // Allows calling a function when the document body is available
+   function onDocumentBody(callback) {
+    if (document.body) {
+      callback();
+    } else {
+      setTimeout(function() {
+        onDocumentBody(callback);
+      }, 0);
+    }
+  }
+
+  function initializeOnDocumentBody() {
+    onDocumentBody(initialize);
+  }
+
+  if (!window.JSON) {
+    Pusher.Dependencies.load("json2", initializeOnDocumentBody);
+  } else {
+    initializeOnDocumentBody();
+  }
+})();
+
+;(function() {
+  /** Cross-browser compatible timer abstraction.
+   *
+   * @param {Number} delay
+   * @param {Function} callback
+   */
+  function Timer(delay, callback) {
+    var self = this;
+
+    this.timeout = setTimeout(function() {
+      if (self.timeout !== null) {
+        callback();
+        self.timeout = null;
+      }
+    }, delay);
+  }
+  var prototype = Timer.prototype;
+
+  /** Returns whether the timer is still running.
+   *
+   * @return {Boolean}
+   */
+  prototype.isRunning = function() {
+    return this.timeout !== null;
+  };
+
+  /** Aborts a timer when it's running. */
+  prototype.ensureAborted = function() {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+  };
+
+  Pusher.Timer = Timer;
+}).call(this);
+
+(function() {
+
+  var Base64 = {
+    encode: function (s) {
+      return btoa(utob(s));
+    }
+  };
+
+  var fromCharCode = String.fromCharCode;
+
+  var b64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  var b64tab = {};
+
+  for (var i = 0, l = b64chars.length; i < l; i++) {
+    b64tab[b64chars.charAt(i)] = i;
+  }
+
+  var cb_utob = function(c) {
+    var cc = c.charCodeAt(0);
+    return cc < 0x80 ? c
+        : cc < 0x800 ? fromCharCode(0xc0 | (cc >>> 6)) +
+                       fromCharCode(0x80 | (cc & 0x3f))
+        : fromCharCode(0xe0 | ((cc >>> 12) & 0x0f)) +
+          fromCharCode(0x80 | ((cc >>>  6) & 0x3f)) +
+          fromCharCode(0x80 | ( cc         & 0x3f));
+  };
+
+  var utob = function(u) {
+    return u.replace(/[^\x00-\x7F]/g, cb_utob);
+  };
+
+  var cb_encode = function(ccc) {
+    var padlen = [0, 2, 1][ccc.length % 3];
+    var ord = ccc.charCodeAt(0) << 16
+      | ((ccc.length > 1 ? ccc.charCodeAt(1) : 0) << 8)
+      | ((ccc.length > 2 ? ccc.charCodeAt(2) : 0));
+    var chars = [
+      b64chars.charAt( ord >>> 18),
+      b64chars.charAt((ord >>> 12) & 63),
+      padlen >= 2 ? '=' : b64chars.charAt((ord >>> 6) & 63),
+      padlen >= 1 ? '=' : b64chars.charAt(ord & 63)
+    ];
+    return chars.join('');
+  };
+
+  var btoa = window.btoa || function(b) {
+    return b.replace(/[\s\S]{1,3}/g, cb_encode);
+  };
+
+  Pusher.Base64 = Base64;
+
+}).call(this);
+
+(function() {
+
+  function JSONPRequest(options) {
+    this.options = options;
+  }
+
+  JSONPRequest.send = function(options, callback) {
+    var request = new Pusher.JSONPRequest({
+      url: options.url,
+      receiver: options.receiverName,
+      tagPrefix: options.tagPrefix
+    });
+    var id = options.receiver.register(function(error, result) {
+      request.cleanup();
+      callback(error, result);
+    });
+
+    return request.send(id, options.data, function(error) {
+      var callback = options.receiver.unregister(id);
+      if (callback) {
+        callback(error);
+      }
+    });
+  };
+
+  var prototype = JSONPRequest.prototype;
+
+  prototype.send = function(id, data, callback) {
+    if (this.script) {
+      return false;
+    }
+
+    var tagPrefix = this.options.tagPrefix || "_pusher_jsonp_";
+
+    var params = Pusher.Util.extend(
+      {}, data, { receiver: this.options.receiver }
+    );
+    var query = Pusher.Util.map(
+      Pusher.Util.flatten(
+        encodeData(
+          Pusher.Util.filterObject(params, function(value) {
+            return value !== undefined;
+          })
+        )
+      ),
+      Pusher.Util.method("join", "=")
+    ).join("&");
+
+    this.script = document.createElement("script");
+    this.script.id = tagPrefix + id;
+    this.script.src = this.options.url + "/" + id + "?" + query;
+    this.script.type = "text/javascript";
+    this.script.charset = "UTF-8";
+    this.script.onerror = this.script.onload = callback;
+
+    // Opera<11.6 hack for missing onerror callback
+    if (this.script.async === undefined && document.attachEvent) {
+      if (/opera/i.test(navigator.userAgent)) {
+        var receiverName = this.options.receiver || "Pusher.JSONP.receive";
+        this.errorScript = document.createElement("script");
+        this.errorScript.text = receiverName + "(" + id + ", true);";
+        this.script.async = this.errorScript.async = false;
+      }
+    }
+
+    var self = this;
+    this.script.onreadystatechange = function() {
+      if (self.script && /loaded|complete/.test(self.script.readyState)) {
+        callback(true);
+      }
+    };
+
+    var head = document.getElementsByTagName('head')[0];
+    head.insertBefore(this.script, head.firstChild);
+    if (this.errorScript) {
+      head.insertBefore(this.errorScript, this.script.nextSibling);
+    }
+
+    return true;
+  };
+
+  prototype.cleanup = function() {
+    if (this.script && this.script.parentNode) {
+      this.script.parentNode.removeChild(this.script);
+      this.script = null;
+    }
+    if (this.errorScript && this.errorScript.parentNode) {
+      this.errorScript.parentNode.removeChild(this.errorScript);
+      this.errorScript = null;
+    }
+  };
+
+  function encodeData(data) {
+    return Pusher.Util.mapObject(data, function(value) {
+      if (typeof value === "object") {
+        value = JSON.stringify(value);
+      }
+      return encodeURIComponent(Pusher.Base64.encode(value.toString()));
+    });
+  }
+
+  Pusher.JSONPRequest = JSONPRequest;
+
+}).call(this);
+
+(function() {
+
+  function JSONPReceiver() {
+    this.lastId = 0;
+    this.callbacks = {};
+  }
+
+  var prototype = JSONPReceiver.prototype;
+
+  prototype.register = function(callback) {
+    this.lastId++;
+    var id = this.lastId;
+    this.callbacks[id] = callback;
+    return id;
+  };
+
+  prototype.unregister = function(id) {
+    if (this.callbacks[id]) {
+      var callback = this.callbacks[id];
+      delete this.callbacks[id];
+      return callback;
+    } else {
+      return null;
+    }
+  };
+
+  prototype.receive = function(id, error, data) {
+    var callback = this.unregister(id);
+    if (callback) {
+      callback(error, data);
+    }
+  };
+
+  Pusher.JSONPReceiver = JSONPReceiver;
+  Pusher.JSONP = new JSONPReceiver();
+
+}).call(this);
+
+(function() {
+  function Timeline(key, session, options) {
+    this.key = key;
+    this.session = session;
+    this.events = [];
+    this.options = options || {};
+    this.sent = 0;
+    this.uniqueID = 0;
+  }
+  var prototype = Timeline.prototype;
+
+  // Log levels
+  Timeline.ERROR = 3;
+  Timeline.INFO = 6;
+  Timeline.DEBUG = 7;
+
+  prototype.log = function(level, event) {
+    if (this.options.level === undefined || level <= this.options.level) {
+      this.events.push(
+        Pusher.Util.extend({}, event, {
+          timestamp: Pusher.Util.now(),
+          level: level
+        })
+      );
+      if (this.options.limit && this.events.length > this.options.limit) {
+        this.events.shift();
+      }
+    }
+  };
+
+  prototype.error = function(event) {
+    this.log(Timeline.ERROR, event);
+  };
+
+  prototype.info = function(event) {
+    this.log(Timeline.INFO, event);
+  };
+
+  prototype.debug = function(event) {
+    this.log(Timeline.DEBUG, event);
+  };
+
+  prototype.isEmpty = function() {
+    return this.events.length === 0;
+  };
+
+  prototype.send = function(sendJSONP, callback) {
+    var self = this;
+
+    var data = {};
+    if (this.sent === 0) {
+      data = Pusher.Util.extend({
+        key: this.key,
+        features: this.options.features,
+        version: this.options.version
+      }, this.options.params || {});
+    }
+    data.session = this.session;
+    data.timeline = this.events;
+    data = Pusher.Util.filterObject(data, function(v) {
+      return v !== undefined;
+    });
+
+    this.events = [];
+    sendJSONP(data, function(error, result) {
+      if (!error) {
+        self.sent++;
+      }
+      callback(error, result);
+    });
+
+    return true;
+  };
+
+  prototype.generateUniqueID = function() {
+    this.uniqueID++;
+    return this.uniqueID;
+  };
+
+  Pusher.Timeline = Timeline;
+}).call(this);
+
+(function() {
+  function TimelineSender(timeline, options) {
+    this.timeline = timeline;
+    this.options = options || {};
+  }
+  var prototype = TimelineSender.prototype;
+
+  prototype.send = function(callback) {
+    if (this.timeline.isEmpty()) {
+      return;
+    }
+
+    var options = this.options;
+    var scheme = "http" + (this.isEncrypted() ? "s" : "") + "://";
+
+    var sendJSONP = function(data, callback) {
+      return Pusher.JSONPRequest.send({
+        data: data,
+        url: scheme + options.host + options.path,
+        receiver: Pusher.JSONP
+      }, callback);
+    };
+    this.timeline.send(sendJSONP, callback);
+  };
+
+  prototype.isEncrypted = function() {
+    return !!this.options.encrypted;
+  };
+
+  Pusher.TimelineSender = TimelineSender;
+}).call(this);
+
+;(function() {
+  /** Launches all substrategies and emits prioritized connected transports.
+   *
+   * @param {Array} strategies
+   */
+  function BestConnectedEverStrategy(strategies) {
+    this.strategies = strategies;
+  }
+  var prototype = BestConnectedEverStrategy.prototype;
+
+  prototype.isSupported = function() {
+    return Pusher.Util.any(this.strategies, Pusher.Util.method("isSupported"));
+  };
+
+  prototype.connect = function(minPriority, callback) {
+    return connect(this.strategies, minPriority, function(i, runners) {
+      return function(error, connection) {
+        runners[i].error = error;
+        if (error) {
+          if (allRunnersFailed(runners)) {
+            callback(true);
+          }
+          return;
+        }
+        Pusher.Util.apply(runners, function(runner) {
+          runner.forceMinPriority(connection.priority);
+        });
+        callback(null, connection);
+      };
+    });
+  };
+
+  /** Connects to all strategies in parallel.
+   *
+   * Callback builder should be a function that takes two arguments: index
+   * and a list of runners. It should return another function that will be
+   * passed to the substrategy with given index. Runners can be aborted using
+   * abortRunner(s) functions from this class.
+   *
+   * @param  {Array} strategies
+   * @param  {Function} callbackBuilder
+   * @return {Object} strategy runner
+   */
+  function connect(strategies, minPriority, callbackBuilder) {
+    var runners = Pusher.Util.map(strategies, function(strategy, i, _, rs) {
+      return strategy.connect(minPriority, callbackBuilder(i, rs));
+    });
+    return {
+      abort: function() {
+        Pusher.Util.apply(runners, abortRunner);
+      },
+      forceMinPriority: function(p) {
+        Pusher.Util.apply(runners, function(runner) {
+          runner.forceMinPriority(p);
+        });
+      }
+    };
+  }
+
+  function allRunnersFailed(runners) {
+    return Pusher.Util.all(runners, function(runner) {
+      return Boolean(runner.error);
+    });
+  }
+
+  function abortRunner(runner) {
+    if (!runner.error && !runner.aborted) {
+      runner.abort();
+      runner.aborted = true;
+    }
+  }
+
+  Pusher.BestConnectedEverStrategy = BestConnectedEverStrategy;
+}).call(this);
+
+;(function() {
+  /** Caches last successful transport and uses it for following attempts.
+   *
+   * @param {Strategy} strategy
+   * @param {Object} transports
+   * @param {Object} options
+   */
+  function CachedStrategy(strategy, transports, options) {
+    this.strategy = strategy;
+    this.transports = transports;
+    this.ttl = options.ttl || 1800*1000;
+    this.timeline = options.timeline;
+  }
+  var prototype = CachedStrategy.prototype;
+
+  prototype.isSupported = function() {
+    return this.strategy.isSupported();
+  };
+
+  prototype.connect = function(minPriority, callback) {
+    var info = fetchTransportInfo();
+
+    var strategies = [this.strategy];
+    if (info && info.timestamp + this.ttl >= Pusher.Util.now()) {
+      var transport = this.transports[info.transport];
+      if (transport) {
+        this.timeline.info({ cached: true, transport: info.transport });
+        strategies.push(new Pusher.SequentialStrategy([transport], {
+          timeout: info.latency * 2,
+          failFast: true
+        }));
+      }
+    }
+
+    var startTimestamp = Pusher.Util.now();
+    var runner = strategies.pop().connect(
+      minPriority,
+      function cb(error, connection) {
+        if (error) {
+          flushTransportInfo();
+          if (strategies.length > 0) {
+            startTimestamp = Pusher.Util.now();
+            runner = strategies.pop().connect(minPriority, cb);
+          } else {
+            callback(error);
+          }
+        } else {
+          var latency = Pusher.Util.now() - startTimestamp;
+          storeTransportInfo(connection.name, latency);
+          callback(null, connection);
+        }
+      }
+    );
+
+    return {
+      abort: function() {
+        runner.abort();
+      },
+      forceMinPriority: function(p) {
+        minPriority = p;
+        if (runner) {
+          runner.forceMinPriority(p);
+        }
+      }
+    };
+  };
+
+  function fetchTransportInfo() {
+    var storage = Pusher.Util.getLocalStorage();
+    if (storage) {
+      var info = storage.pusherTransport;
+      if (info) {
+        return JSON.parse(storage.pusherTransport);
+      }
+    }
+    return null;
+  }
+
+  function storeTransportInfo(transport, latency) {
+    var storage = Pusher.Util.getLocalStorage();
+    if (storage) {
+      storage.pusherTransport = JSON.stringify({
+        timestamp: Pusher.Util.now(),
+        transport: transport,
+        latency: latency
+      });
+    }
+  }
+
+  function flushTransportInfo() {
+    var storage = Pusher.Util.getLocalStorage();
+    if (storage) {
+      delete storage.pusherTransport;
+    }
+  }
+
+  Pusher.CachedStrategy = CachedStrategy;
+}).call(this);
+
+;(function() {
+  /** Runs substrategy after specified delay.
+   *
+   * Options:
+   * - delay - time in miliseconds to delay the substrategy attempt
+   *
+   * @param {Strategy} strategy
+   * @param {Object} options
+   */
+  function DelayedStrategy(strategy, options) {
+    this.strategy = strategy;
+    this.options = { delay: options.delay };
+  }
+  var prototype = DelayedStrategy.prototype;
+
+  prototype.isSupported = function() {
+    return this.strategy.isSupported();
+  };
+
+  prototype.connect = function(minPriority, callback) {
+    var strategy = this.strategy;
+    var runner;
+    var timer = new Pusher.Timer(this.options.delay, function() {
+      runner = strategy.connect(minPriority, callback);
+    });
+
+    return {
+      abort: function() {
+        timer.ensureAborted();
+        if (runner) {
+          runner.abort();
+        }
+      },
+      forceMinPriority: function(p) {
+        minPriority = p;
+        if (runner) {
+          runner.forceMinPriority(p);
+        }
+      }
+    };
+  };
+
+  Pusher.DelayedStrategy = DelayedStrategy;
+}).call(this);
+
+;(function() {
+  /** Launches the substrategy and terminates on the first open connection.
+   *
+   * @param {Strategy} strategy
+   */
+  function FirstConnectedStrategy(strategy) {
+    this.strategy = strategy;
+  }
+  var prototype = FirstConnectedStrategy.prototype;
+
+  prototype.isSupported = function() {
+    return this.strategy.isSupported();
+  };
+
+  prototype.connect = function(minPriority, callback) {
+    var runner = this.strategy.connect(
+      minPriority,
+      function(error, connection) {
+        if (connection) {
+          runner.abort();
+        }
+        callback(error, connection);
+      }
+    );
+    return runner;
+  };
+
+  Pusher.FirstConnectedStrategy = FirstConnectedStrategy;
+}).call(this);
+
+;(function() {
+  /** Proxies method calls to one of substrategies basing on the test function.
+   *
+   * @param {Function} test
+   * @param {Strategy} trueBranch strategy used when test returns true
+   * @param {Strategy} falseBranch strategy used when test returns false
+   */
+  function IfStrategy(test, trueBranch, falseBranch) {
+    this.test = test;
+    this.trueBranch = trueBranch;
+    this.falseBranch = falseBranch;
+  }
+  var prototype = IfStrategy.prototype;
+
+  prototype.isSupported = function() {
+    var branch = this.test() ? this.trueBranch : this.falseBranch;
+    return branch.isSupported();
+  };
+
+  prototype.connect = function(minPriority, callback) {
+    var branch = this.test() ? this.trueBranch : this.falseBranch;
+    return branch.connect(minPriority, callback);
+  };
+
+  Pusher.IfStrategy = IfStrategy;
+}).call(this);
+
+;(function() {
+  /** Loops through strategies with optional timeouts.
+   *
+   * Options:
+   * - loop - whether it should loop through the substrategy list
+   * - timeout - initial timeout for a single substrategy
+   * - timeoutLimit - maximum timeout
+   *
+   * @param {Strategy[]} strategies
+   * @param {Object} options
+   */
+  function SequentialStrategy(strategies, options) {
+    this.strategies = strategies;
+    this.loop = Boolean(options.loop);
+    this.failFast = Boolean(options.failFast);
+    this.timeout = options.timeout;
+    this.timeoutLimit = options.timeoutLimit;
+  }
+  var prototype = SequentialStrategy.prototype;
+
+  prototype.isSupported = function() {
+    return Pusher.Util.any(this.strategies, Pusher.Util.method("isSupported"));
+  };
+
+  prototype.connect = function(minPriority, callback) {
+    var self = this;
+
+    var strategies = this.strategies;
+    var current = 0;
+    var timeout = this.timeout;
+    var runner = null;
+
+    var tryNextStrategy = function(error, connection) {
+      if (connection) {
+        callback(null, connection);
+      } else {
+        current = current + 1;
+        if (self.loop) {
+          current = current % strategies.length;
+        }
+
+        if (current < strategies.length) {
+          if (timeout) {
+            timeout = timeout * 2;
+            if (self.timeoutLimit) {
+              timeout = Math.min(timeout, self.timeoutLimit);
+            }
+          }
+          runner = self.tryStrategy(
+            strategies[current],
+            minPriority,
+            { timeout: timeout, failFast: self.failFast },
+            tryNextStrategy
+          );
+        } else {
+          callback(true);
+        }
+      }
+    };
+
+    runner = this.tryStrategy(
+      strategies[current],
+      minPriority,
+      { timeout: timeout, failFast: this.failFast },
+      tryNextStrategy
+    );
+
+    return {
+      abort: function() {
+        runner.abort();
+      },
+      forceMinPriority: function(p) {
+        minPriority = p;
+        if (runner) {
+          runner.forceMinPriority(p);
+        }
+      }
+    };
+  };
+
+  /** @private */
+  prototype.tryStrategy = function(strategy, minPriority, options, callback) {
+    var timer = null;
+    var runner = null;
+
+    runner = strategy.connect(minPriority, function(error, connection) {
+      if (error && timer && timer.isRunning() && !options.failFast) {
+        // advance to the next strategy after the timeout
+        return;
+      }
+      if (timer) {
+        timer.ensureAborted();
+      }
+      callback(error, connection);
+    });
+
+    if (options.timeout > 0) {
+      timer = new Pusher.Timer(options.timeout, function() {
+        runner.abort();
+        callback(true);
+      });
+    }
+
+    return {
+      abort: function() {
+        if (timer) {
+          timer.ensureAborted();
+        }
+        runner.abort();
+      },
+      forceMinPriority: function(p) {
+        runner.forceMinPriority(p);
+      }
+    };
+  };
+
+  Pusher.SequentialStrategy = SequentialStrategy;
+}).call(this);
+
+;(function() {
+  /** Provides a strategy interface for transports.
+   *
+   * @param {String} name
+   * @param {Number} priority
+   * @param {Class} transport
+   * @param {Object} options
+   */
+  function TransportStrategy(name, priority, transport, options) {
+    this.name = name;
+    this.priority = priority;
+    this.transport = transport;
+    this.options = options || {};
+  }
+  var prototype = TransportStrategy.prototype;
+
+  /** Returns whether the transport is supported in the browser.
+   *
+   * @returns {Boolean}
+   */
+  prototype.isSupported = function() {
+    return this.transport.isSupported({
+      disableFlash: !!this.options.disableFlash
+    });
+  };
+
+  /** Launches a connection attempt and returns a strategy runner.
+   *
+   * @param  {Function} callback
+   * @return {Object} strategy runner
+   */
+  prototype.connect = function(minPriority, callback) {
+    if (!this.transport.isSupported()) {
+      return failAttempt(new Pusher.Errors.UnsupportedStrategy(), callback);
+    } else if (this.priority < minPriority) {
+      return failAttempt(new Pusher.Errors.TransportPriorityTooLow(), callback);
+    }
+
+    var self = this;
+    var connection = this.transport.createConnection(
+      this.name, this.priority, this.options.key, this.options
+    );
+
+    var onInitialized = function() {
+      connection.unbind("initialized", onInitialized);
+      connection.connect();
+    };
+    var onOpen = function() {
+      unbindListeners();
+      callback(null, connection);
+    };
+    var onError = function(error) {
+      unbindListeners();
+      callback(error);
+    };
+    var onClosed = function() {
+      unbindListeners();
+      callback(new Pusher.Errors.TransportClosed(this.transport));
+    };
+
+    var unbindListeners = function() {
+      connection.unbind("initialized", onInitialized);
+      connection.unbind("open", onOpen);
+      connection.unbind("error", onError);
+      connection.unbind("closed", onClosed);
+    };
+
+    connection.bind("initialized", onInitialized);
+    connection.bind("open", onOpen);
+    connection.bind("error", onError);
+    connection.bind("closed", onClosed);
+
+    // connect will be called automatically after initialization
+    connection.initialize();
+
+    return {
+      abort: function() {
+        if (connection.state === "open") {
+          return;
+        }
+        unbindListeners();
+        connection.close();
+      },
+      forceMinPriority: function(p) {
+        if (connection.state === "open") {
+          return;
+        }
+        if (self.priority < p) {
+          // TODO close connection in a nicer way
+          connection.close();
         }
       }
-    },
-
-    subscribe: function(channel_name) {
-      var self = this;
-      var channel = this.channels.add(channel_name, this);
+    };
+  };
 
-      if (this.connection.state === 'connected') {
-        channel.authorize(this.connection.socket_id, this.options, function(err, data) {
-          if (err) {
-            channel.emit('pusher:subscription_error', data);
-          } else {
-            self.send_event('pusher:subscribe', {
-              channel: channel_name,
-              auth: data.auth,
-              channel_data: data.channel_data
-            });
-          }
-        });
-      }
-      return channel;
-    },
+  function failAttempt(error, callback) {
+    new Pusher.Timer(0, function() {
+      callback(error);
+    });
+    return {
+      abort: function() {},
+      forceMinPriority: function() {}
+    };
+  }
 
-    unsubscribe: function(channel_name) {
-      this.channels.remove(channel_name);
-      if (this.connection.state === 'connected') {
-        this.send_event('pusher:unsubscribe', {
-          channel: channel_name
-        });
-      }
-    },
+  Pusher.TransportStrategy = TransportStrategy;
+}).call(this);
 
-    send_event: function(event_name, data, channel) {
-      return this.connection.send_event(event_name, data, channel);
-    },
+;(function() {
+  /** Handles common logic for all transports.
+   *
+   * Transport is a low-level connection object that wraps a connection method
+   * and exposes a simple evented interface for the connection state and
+   * messaging. It does not implement Pusher-specific WebSocket protocol.
+   *
+   * Additionally, it fetches resources needed for transport to work and exposes
+   * an interface for querying transport support and its features.
+   *
+   * This is an abstract class, please do not instantiate it.
+   *
+   * States:
+   * - new - initial state after constructing the object
+   * - initializing - during initialization phase, usually fetching resources
+   * - intialized - ready to establish a connection
+   * - connection - when connection is being established
+   * - open - when connection ready to be used
+   * - closed - after connection was closed be either side
+   *
+   * Emits:
+   * - error - after the connection raised an error
+   *
+   * Options:
+   * - encrypted - whether connection should use ssl
+   * - hostEncrypted - host to connect to when connection is encrypted
+   * - hostUnencrypted - host to connect to when connection is not encrypted
+   *
+   * @param {String} key application key
+   * @param {Object} options
+   */
+  function AbstractTransport(name, priority, key, options) {
+    Pusher.EventsDispatcher.call(this);
 
-    checkAppKey: function() {
-      if (!this.key) {
-        // do not allow undefined, null or empty string
-        Pusher.warn('Warning', 'You must pass your app key when you instantiate Pusher.');
-      }
-    }
+    this.name = name;
+    this.priority = priority;
+    this.key = key;
+    this.state = "new";
+    this.timeline = options.timeline;
+    this.id = this.timeline.generateUniqueID();
+
+    this.options = {
+      encrypted: Boolean(options.encrypted),
+      hostUnencrypted: options.hostUnencrypted,
+      hostEncrypted: options.hostEncrypted
+    };
+  }
+  var prototype = AbstractTransport.prototype;
+  Pusher.Util.extend(prototype, Pusher.EventsDispatcher.prototype);
+
+  /** Checks whether the transport is supported in the browser.
+   *
+   * @returns {Boolean}
+   */
+  AbstractTransport.isSupported = function() {
+    return false;
   };
 
-  Pusher.Util = {
-    extend: function extend(target, extensions) {
-      for (var property in extensions) {
-        if (extensions[property] && extensions[property].constructor &&
-            extensions[property].constructor === Object) {
-          target[property] = extend(target[property] || {}, extensions[property]);
-        } else {
-          target[property] = extensions[property];
-        }
-      }
-      return target;
-    },
+  /** Checks whether the transport handles ping/pong on itself.
+   *
+   * @return {Boolean}
+   */
+  prototype.supportsPing = function() {
+    return false;
+  };
 
-    stringify: function stringify() {
-      var m = ["Pusher"]
-      for (var i = 0; i < arguments.length; i++){
-        if (typeof arguments[i] === "string") {
-          m.push(arguments[i])
-        } else {
-          if (window['JSON'] == undefined) {
-            m.push(arguments[i].toString());
-          } else {
-            m.push(JSON.stringify(arguments[i]))
-          }
-        }
-      };
-      return m.join(" : ")
-    },
+  /** Initializes the transport.
+   *
+   * Fetches resources if needed and then transitions to initialized.
+   */
+  prototype.initialize = function() {
+    this.timeline.info(this.buildTimelineMessage({
+      transport: this.name + (this.options.encrypted ? "s" : "")
+    }));
+    this.timeline.debug(this.buildTimelineMessage({ method: "initialize" }));
+
+    this.changeState("initialized");
+  };
 
-    arrayIndexOf: function(array, item) { // MSIE doesn't have array.indexOf
-      var nativeIndexOf = Array.prototype.indexOf;
-      if (array == null) return -1;
-      if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
-      for (i = 0, l = array.length; i < l; i++) if (array[i] === item) return i;
-      return -1;
+  /** Tries to establish a connection.
+   *
+   * @returns {Boolean} false if transport is in invalid state
+   */
+  prototype.connect = function() {
+    var url = this.getURL(this.key, this.options);
+    this.timeline.debug(this.buildTimelineMessage({
+      method: "connect",
+      url: url
+    }));
+
+    if (this.socket || this.state !== "initialized") {
+      return false;
     }
+
+    this.socket = this.createSocket(url);
+    this.bindListeners();
+
+    Pusher.debug("Connecting", { transport: this.name, url: url });
+    this.changeState("connecting");
+    return true;
   };
 
-  // To receive log output provide a Pusher.log function, for example
-  // Pusher.log = function(m){console.log(m)}
-  Pusher.debug = function() {
-    if (!Pusher.log) return
-    Pusher.log(Pusher.Util.stringify.apply(this, arguments))
-  }
-  Pusher.warn = function() {
-    if (window.console && window.console.warn) {
-      window.console.warn(Pusher.Util.stringify.apply(this, arguments));
+  /** Closes the connection.
+   *
+   * @return {Boolean} true if there was a connection to close
+   */
+  prototype.close = function() {
+    this.timeline.debug(this.buildTimelineMessage({ method: "close" }));
+
+    if (this.socket) {
+      this.socket.close();
+      return true;
     } else {
-      if (!Pusher.log) return
-      Pusher.log(Pusher.Util.stringify.apply(this, arguments));
+      return false;
     }
   };
 
-  // Pusher defaults
-  Pusher.VERSION = '1.12.7';
-  // WS connection parameters
-  Pusher.host = 'ws.pusherapp.com';
-  Pusher.ws_port = 80;
-  Pusher.wss_port = 443;
-  // SockJS fallback parameters
-  Pusher.sockjs_host = 'sockjs.pusher.com';
-  Pusher.sockjs_http_port = 80
-  Pusher.sockjs_https_port = 443
-  Pusher.sockjs_path = "/pusher"
-  // Other settings
-  Pusher.channel_auth_endpoint = '/pusher/auth';
-  Pusher.cdn_http = 'http://js.pusher.com/'
-  Pusher.cdn_https = 'https://d3dy5gmtp8yhk7.cloudfront.net/'
-  Pusher.dependency_suffix = '';
-  Pusher.channel_auth_transport = 'ajax';
-  Pusher.activity_timeout = 120000;
-  Pusher.pong_timeout = 30000;
+  /** Sends data over the open connection.
+   *
+   * @param {String} data
+   * @return {Boolean} true only when in the "open" state
+   */
+  prototype.send = function(data) {
+    this.timeline.debug(this.buildTimelineMessage({
+      method: "send",
+      data: data
+    }));
 
-  Pusher.isReady = false;
-  Pusher.ready = function() {
-    Pusher.isReady = true;
-    for (var i = 0, l = Pusher.instances.length; i < l; i++) {
-      Pusher.instances[i].connect();
+    if (this.state === "open") {
+      // Workaround for MobileSafari bug (see https://gist.github.com/2052006)
+      var self = this;
+      setTimeout(function() {
+        self.socket.send(data);
+      }, 0);
+      return true;
+    } else {
+      return false;
     }
   };
 
-  this.Pusher = Pusher;
-}).call(this);
-
-;(function() {
-/* Abstract event binding
-Example:
+  prototype.requestPing = function() {
+    this.emit("ping_request");
+  };
 
-    var MyEventEmitter = function(){};
-    MyEventEmitter.prototype = new Pusher.EventsDispatcher;
+  /** @protected */
+  prototype.onOpen = function() {
+    this.changeState("open");
+    this.socket.onopen = undefined;
+  };
 
-    var emitter = new MyEventEmitter();
+  /** @protected */
+  prototype.onError = function(error) {
+    this.emit("error", { type: 'WebSocketError', error: error });
+    this.timeline.error(this.buildTimelineMessage({
+      error: getErrorDetails(error)
+    }));
+  };
 
-    // Bind to single event
-    emitter.bind('foo_event', function(data){ alert(data)} );
+  /** @protected */
+  prototype.onClose = function(closeEvent) {
+    this.changeState("closed", closeEvent);
+    this.socket = undefined;
+  };
 
-    // Bind to all
-    emitter.bind_all(function(eventName, data){ alert(data) });
+  /** @protected */
+  prototype.onMessage = function(message) {
+    this.timeline.debug(this.buildTimelineMessage({ message: message.data }));
+    this.emit("message", message);
+  };
 
---------------------------------------------------------*/
+  /** @protected */
+  prototype.bindListeners = function() {
+    var self = this;
 
-  function CallbackRegistry() {
-    this._callbacks = {};
+    this.socket.onopen = function() { self.onOpen(); };
+    this.socket.onerror = function(error) { self.onError(error); };
+    this.socket.onclose = function(closeEvent) { self.onClose(closeEvent); };
+    this.socket.onmessage = function(message) { self.onMessage(message); };
   };
 
-  CallbackRegistry.prototype.get = function(eventName) {
-    return this._callbacks[this._prefix(eventName)];
+  /** @protected */
+  prototype.createSocket = function(url) {
+    return null;
   };
 
-  CallbackRegistry.prototype.add = function(eventName, callback) {
-    var prefixedEventName = this._prefix(eventName);
-    this._callbacks[prefixedEventName] = this._callbacks[prefixedEventName] || [];
-    this._callbacks[prefixedEventName].push(callback);
+  /** @protected */
+  prototype.getScheme = function() {
+    return this.options.encrypted ? "wss" : "ws";
   };
 
-  CallbackRegistry.prototype.remove = function(eventName, callback) {
-    if(this.get(eventName)) {
-      var index = Pusher.Util.arrayIndexOf(this.get(eventName), callback);
-      this._callbacks[this._prefix(eventName)].splice(index, 1);
+  /** @protected */
+  prototype.getBaseURL = function() {
+    var host;
+    if (this.options.encrypted) {
+      host = this.options.hostEncrypted;
+    } else {
+      host = this.options.hostUnencrypted;
     }
+    return this.getScheme() + "://" + host;
   };
 
-  CallbackRegistry.prototype._prefix = function(eventName) {
-    return "_" + eventName;
+  /** @protected */
+  prototype.getPath = function() {
+    return "/app/" + this.key;
   };
 
+  /** @protected */
+  prototype.getQueryString = function() {
+    return "?protocol=" + Pusher.PROTOCOL +
+      "&client=js&version=" + Pusher.VERSION;
+  };
 
-  function EventsDispatcher(failThrough) {
-    this.callbacks = new CallbackRegistry();
-    this.global_callbacks = [];
-    // Run this function when dispatching an event when no callbacks defined
-    this.failThrough = failThrough;
-  }
+  /** @protected */
+  prototype.getURL = function() {
+    return this.getBaseURL() + this.getPath() + this.getQueryString();
+  };
 
-  EventsDispatcher.prototype.bind = function(eventName, callback) {
-    this.callbacks.add(eventName, callback);
-    return this;// chainable
+  /** @protected */
+  prototype.changeState = function(state, params) {
+    this.state = state;
+    this.timeline.info(this.buildTimelineMessage({
+      state: state,
+      params: params
+    }));
+    this.emit(state, params);
   };
 
-  EventsDispatcher.prototype.unbind = function(eventName, callback) {
-    this.callbacks.remove(eventName, callback);
-    return this;
+  /** @protected */
+  prototype.buildTimelineMessage = function(message) {
+    return Pusher.Util.extend({ cid: this.id }, message);
   };
 
-  EventsDispatcher.prototype.emit = function(eventName, data) {
-    // Global callbacks
-    for (var i = 0; i < this.global_callbacks.length; i++) {
-      this.global_callbacks[i](eventName, data);
+  function getErrorDetails(error) {
+    if (typeof error === "string") {
+      return error;
     }
-
-    // Event callbacks
-    var callbacks = this.callbacks.get(eventName);
-    if (callbacks) {
-      for (var i = 0; i < callbacks.length; i++) {
-        callbacks[i](data);
-      }
-    } else if (this.failThrough) {
-      this.failThrough(eventName, data)
+    if (typeof error === "object") {
+      return Pusher.Util.mapObject(error, function(value) {
+        var valueType = typeof value;
+        if (valueType === "object" || valueType == "function") {
+          return valueType;
+        }
+        return value;
+      });
     }
+    return typeof error;
+  }
 
-    return this;
-  };
-
-  EventsDispatcher.prototype.bind_all = function(callback) {
-    this.global_callbacks.push(callback);
-    return this;
-  };
-
-  this.Pusher.EventsDispatcher = EventsDispatcher;
+  Pusher.AbstractTransport = AbstractTransport;
 }).call(this);
 
 ;(function() {
-  var Pusher = this.Pusher;
-
-  /*-----------------------------------------------
-    Helpers:
-  -----------------------------------------------*/
-
-  function capitalize(str) {
-    return str.substr(0, 1).toUpperCase() + str.substr(1);
+  /** Transport using Flash to emulate WebSockets.
+   *
+   * @see AbstractTransport
+   */
+  function FlashTransport(name, priority, key, options) {
+    Pusher.AbstractTransport.call(this, name, priority, key, options);
   }
+  var prototype = FlashTransport.prototype;
+  Pusher.Util.extend(prototype, Pusher.AbstractTransport.prototype);
+
+  /** Creates a new instance of FlashTransport.
+   *
+   * @param  {String} key
+   * @param  {Object} options
+   * @return {FlashTransport}
+   */
+  FlashTransport.createConnection = function(name, priority, key, options) {
+    return new FlashTransport(name, priority, key, options);
+  };
 
-
-  function safeCall(method, obj, data) {
-    if (obj[method] !== undefined) {
-      obj[method](data);
+  /** Checks whether Flash is supported in the browser.
+   *
+   * It is possible to disable flash by passing an envrionment object with the
+   * disableFlash property set to true.
+   *
+   * @see AbstractTransport.isSupported
+   * @param {Object} environment
+   * @returns {Boolean}
+   */
+  FlashTransport.isSupported = function(environment) {
+    if (environment && environment.disableFlash) {
+      return false;
     }
-  }
+    try {
+      return !!(new ActiveXObject('ShockwaveFlash.ShockwaveFlash'));
+    } catch (e) {
+      return navigator.mimeTypes["application/x-shockwave-flash"] !== undefined;
+    }
+  };
 
-  /*-----------------------------------------------
-    The State Machine
-  -----------------------------------------------*/
-  function Machine(initialState, transitions, stateActions) {
-    Pusher.EventsDispatcher.call(this);
+  /** Fetches flashfallback dependency if needed.
+   *
+   * Sets WEB_SOCKET_SUPPRESS_CROSS_DOMAIN_SWF_ERROR to true (if not set before)
+   * and WEB_SOCKET_SWF_LOCATION to Pusher's cdn before loading Flash resources.
+   *
+   * @see AbstractTransport.prototype.initialize
+   */
+  prototype.initialize = function() {
+    var self = this;
 
-    this.state = undefined;
-    this.errors = [];
+    this.timeline.info(this.buildTimelineMessage({
+      transport: this.name + (this.options.encrypted ? "s" : "")
+    }));
+    this.timeline.debug(this.buildTimelineMessage({ method: "initialize" }));
+    this.changeState("initializing");
 
-    // functions for each state
-    this.stateActions = stateActions;
+    if (window.WEB_SOCKET_SUPPRESS_CROSS_DOMAIN_SWF_ERROR === undefined) {
+      window.WEB_SOCKET_SUPPRESS_CROSS_DOMAIN_SWF_ERROR = true;
+    }
+    window.WEB_SOCKET_SWF_LOCATION = Pusher.Dependencies.getRoot() +
+      "/WebSocketMain.swf";
+    Pusher.Dependencies.load("flashfallback", function() {
+      self.changeState("initialized");
+    });
+  };
 
-    // set up the transitions
-    this.transitions = transitions;
+  /** @protected */
+  prototype.createSocket = function(url) {
+    return new FlashWebSocket(url);
+  };
 
-    this.transition(initialState);
+  /** @protected */
+  prototype.getQueryString = function() {
+    return Pusher.AbstractTransport.prototype.getQueryString.call(this) +
+      "&flash=true";
   };
 
-  Machine.prototype.transition = function(nextState, data) {
-    var prevState = this.state;
-    var stateCallbacks = this.stateActions;
+  Pusher.FlashTransport = FlashTransport;
+}).call(this);
 
-    if (prevState && (Pusher.Util.arrayIndexOf(this.transitions[prevState], nextState) == -1)) {
-      this.emit('invalid_transition_attempt', {
-        oldState: prevState,
-        newState: nextState
-      });
+;(function() {
+  /** Fallback transport using SockJS.
+   *
+   * @see AbstractTransport
+   */
+  function SockJSTransport(name, priority, key, options) {
+    Pusher.AbstractTransport.call(this, name, priority, key, options);
+  }
+  var prototype = SockJSTransport.prototype;
+  Pusher.Util.extend(prototype, Pusher.AbstractTransport.prototype);
+
+  /** Creates a new instance of SockJSTransport.
+   *
+   * @param  {String} key
+   * @param  {Object} options
+   * @return {SockJSTransport}
+   */
+  SockJSTransport.createConnection = function(name, priority, key, options) {
+    return new SockJSTransport(name, priority, key, options);
+  };
 
-      throw new Error('Invalid transition [' + prevState + ' to ' + nextState + ']');
-    }
+  /** Assumes that SockJS is always supported.
+   *
+   * @returns {Boolean} always true
+   */
+  SockJSTransport.isSupported = function() {
+    return true;
+  };
 
-    // exit
-    safeCall(prevState + 'Exit', stateCallbacks, data);
+  /** Fetches sockjs dependency if needed.
+   *
+   * @see AbstractTransport.prototype.initialize
+   */
+  prototype.initialize = function() {
+    var self = this;
 
-    // tween
-    safeCall(prevState + 'To' + capitalize(nextState), stateCallbacks, data);
+    this.timeline.info(this.buildTimelineMessage({
+      transport: this.name + (this.options.encrypted ? "s" : "")
+    }));
+    this.timeline.debug(this.buildTimelineMessage({ method: "initialize" }));
 
-    // pre
-    safeCall(nextState + 'Pre', stateCallbacks, data);
+    this.changeState("initializing");
+    Pusher.Dependencies.load("sockjs", function() {
+      self.changeState("initialized");
+    });
+  };
 
-    // change state:
-    this.state = nextState;
+  /** Always returns true, since SockJS handles ping on its own.
+   *
+   * @returns {Boolean} always true
+   */
+  prototype.supportsPing = function() {
+    return true;
+  };
 
-    // handy to bind to
-    this.emit('state_change', {
-      oldState: prevState,
-      newState: nextState
+  /** @protected */
+  prototype.createSocket = function(url) {
+    // exclude iframe transports until we link to correct SockJS version
+    // inside the iframe
+    return new SockJS(url, null, {
+      js_path: Pusher.Dependencies.getPath("sockjs", {
+        encrypted: this.options.encrypted
+      })
     });
+  };
 
-    // Post:
-    safeCall(nextState + 'Post', stateCallbacks, data);
+  /** @protected */
+  prototype.getScheme = function() {
+    return this.options.encrypted ? "https" : "http";
   };
 
-  Machine.prototype.is = function(state) {
-    return this.state === state;
+  /** @protected */
+  prototype.getPath = function() {
+    return "/pusher";
   };
 
-  Machine.prototype.isNot = function(state) {
-    return this.state !== state;
+  /** @protected */
+  prototype.getQueryString = function() {
+    return "";
   };
 
-  Pusher.Util.extend(Machine.prototype, Pusher.EventsDispatcher.prototype);
+  /** Handles opening a SockJS connection to Pusher.
+   *
+   * Since SockJS does not handle custom paths, we send it immediately after
+   * establishing the connection.
+   *
+   * @protected
+   */
+  prototype.onOpen = function() {
+    this.socket.send(JSON.stringify({
+      path: Pusher.AbstractTransport.prototype.getPath.call(this) +
+        Pusher.AbstractTransport.prototype.getQueryString.call(this)
+    }));
+    this.changeState("open");
+    this.socket.onopen = undefined;
+  };
 
-  this.Pusher.Machine = Machine;
+  Pusher.SockJSTransport = SockJSTransport;
 }).call(this);
 
 ;(function() {
-  /*
-    A little bauble to interface with window.navigator.onLine,
-    window.ononline and window.onoffline.  Easier to mock.
-  */
+  /** WebSocket transport.
+   *
+   * @see AbstractTransport
+   */
+  function WSTransport(name, priority, key, options) {
+    Pusher.AbstractTransport.call(this, name, priority, key, options);
+  }
+  var prototype = WSTransport.prototype;
+  Pusher.Util.extend(prototype, Pusher.AbstractTransport.prototype);
+
+  /** Creates a new instance of WSTransport.
+   *
+   * @param  {String} key
+   * @param  {Object} options
+   * @return {WSTransport}
+   */
+  WSTransport.createConnection = function(name, priority, key, options) {
+    return new WSTransport(name, priority, key, options);
+  };
 
-  var NetInfo = function() {
-    var self = this;
-    Pusher.EventsDispatcher.call(this);
-    // This is okay, as IE doesn't support this stuff anyway.
-    if (window.addEventListener !== undefined) {
-      window.addEventListener("online", function() {
-        self.emit('online', null);
-      }, false);
-      window.addEventListener("offline", function() {
-        self.emit('offline', null);
-      }, false);
-    }
+  /** Checks whether the browser supports WebSockets in any form.
+   *
+   * @returns {Boolean} true if browser supports WebSockets
+   */
+  WSTransport.isSupported = function() {
+    return window.WebSocket !== undefined || window.MozWebSocket !== undefined;
   };
 
-  // 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).
-  NetInfo.prototype.isOnLine = function() {
-    if (window.navigator.onLine === undefined) {
-      return true;
-    } else {
-      return window.navigator.onLine;
-    }
+  /** @protected */
+  prototype.createSocket = function(url) {
+    var constructor = window.WebSocket || window.MozWebSocket;
+    return new constructor(url);
   };
 
-  Pusher.Util.extend(NetInfo.prototype, Pusher.EventsDispatcher.prototype);
+  /** @protected */
+  prototype.getQueryString = function() {
+    return Pusher.AbstractTransport.prototype.getQueryString.call(this) +
+      "&flash=false";
+  };
 
-  this.Pusher.NetInfo = NetInfo;
+  Pusher.WSTransport = WSTransport;
 }).call(this);
 
 ;(function() {
-  var Pusher = this.Pusher;
+  function AssistantToTheTransportManager(manager, transport, options) {
+    this.manager = manager;
+    this.transport = transport;
+    this.minPingDelay = options.minPingDelay || 10000;
+    this.maxPingDelay = options.maxPingDelay || Pusher.activity_timeout;
+    this.pingDelay = null;
+  }
+  var prototype = AssistantToTheTransportManager.prototype;
 
-  var machineTransitions = {
-    'initialized': ['waiting', 'failed'],
-    'waiting': ['connecting', 'permanentlyClosed'],
-    'connecting': ['open', 'permanentlyClosing', 'impermanentlyClosing', 'waiting'],
-    'open': ['connected', 'permanentlyClosing', 'impermanentlyClosing', 'waiting'],
-    'connected': ['permanentlyClosing', 'waiting'],
-    'impermanentlyClosing': ['waiting', 'permanentlyClosing'],
-    'permanentlyClosing': ['permanentlyClosed'],
-    'permanentlyClosed': ['waiting', 'failed'],
-    'failed': ['permanentlyClosed']
-  };
+  prototype.createConnection = function(name, priority, key, options) {
+    var connection = this.transport.createConnection(
+      name, priority, key, options
+    );
 
+    var self = this;
+    var openTimestamp = null;
+    var pingTimer = null;
 
-  var OPEN_TIMEOUT_INCREMENT = 2000;
-  var CONNECTED_TIMEOUT_INCREMENT = 2000;
+    var onOpen = function() {
+      connection.unbind("open", onOpen);
 
-  var MAX_OPEN_TIMEOUT = 10000;
-  var MAX_CONNECTED_TIMEOUT = 10000;
+      openTimestamp = Pusher.Util.now();
+      if (self.pingDelay) {
+        pingTimer = setInterval(function() {
+          if (pingTimer) {
+            connection.requestPing();
+          }
+        }, self.pingDelay);
+      }
 
-  function resetConnectionParameters(connection) {
-    connection.connectionWait = 0;
+      connection.bind("closed", onClosed);
+    };
+    var onClosed = function(closeEvent) {
+      connection.unbind("closed", onClosed);
+      if (pingTimer) {
+        clearInterval(pingTimer);
+        pingTimer = null;
+      }
 
-    if (Pusher.TransportType === 'native') {
-      connection.openTimeout = 4000;
-    } else if (Pusher.TransportType === 'flash') {
-      connection.openTimeout = 7000;
-    } else { // SockJS
-      connection.openTimeout = 6000;
-    }
-    connection.connectedTimeout = 2000;
-    connection.connectionSecure = connection.compulsorySecure;
-    connection.failedAttempts = 0;
-  }
+      if (closeEvent.wasClean) {
+        return;
+      }
 
-  function Connection(key, options) {
-    var self = this;
+      if (openTimestamp) {
+        var lifespan = Pusher.Util.now() - openTimestamp;
+        if (lifespan < 2 * self.maxPingDelay) {
+          self.manager.reportDeath();
+          self.pingDelay = Math.max(lifespan / 2, self.minPingDelay);
+        }
+      }
+    };
 
-    Pusher.EventsDispatcher.call(this);
+    connection.bind("open", onOpen);
+    return connection;
+  };
 
-    this.ping = true
-    this.options = Pusher.Util.extend({encrypted: false}, options);
+  prototype.isSupported = function() {
+    return this.manager.isAlive() && this.transport.isSupported();
+  };
 
-    this.netInfo = new Pusher.NetInfo();
+  Pusher.AssistantToTheTransportManager = AssistantToTheTransportManager;
+}).call(this);
 
-    this.netInfo.bind('online', function(){
-      if (self._machine.is('waiting')) {
-        self._machine.transition('connecting');
-        updateState('connecting');
-      }
+;(function() {
+  function TransportManager(options) {
+    this.options = options || {};
+    this.livesLeft = this.options.lives || Infinity;
+  }
+  var prototype = TransportManager.prototype;
+
+  prototype.getAssistant = function(transport) {
+    return new Pusher.AssistantToTheTransportManager(this, transport, {
+      minPingDelay: this.options.minPingDelay,
+      maxPingDelay: this.options.maxPingDelay
     });
+  };
 
-    this.netInfo.bind('offline', function() {
-      if (self._machine.is('connected')) {
-        // These are for Chrome 15, which ends up
-        // having two sockets hanging around.
-        self.socket.onclose = undefined;
-        self.socket.onmessage = undefined;
-        self.socket.onerror = undefined;
-        self.socket.onopen = undefined;
+  prototype.isAlive = function() {
+    return this.livesLeft > 0;
+  };
 
-        self.socket.close();
-        self.socket = undefined;
-        self._machine.transition('waiting');
-      }
-    });
+  prototype.reportDeath = function() {
+    this.livesLeft -= 1;
+  };
+
+  Pusher.TransportManager = TransportManager;
+}).call(this);
 
-    // define the state machine that runs the connection
-    this._machine = new Pusher.Machine('initialized', machineTransitions, {
-      initializedPre: function() {
-        self.compulsorySecure = self.options.encrypted;
+;(function() {
+  var StrategyBuilder = {
+    /** Transforms a JSON scheme to a strategy tree.
+     *
+     * @param {Array} scheme JSON strategy scheme
+     * @param {Object} options a hash of symbols to be included in the scheme
+     * @returns {Strategy} strategy tree that's represented by the scheme
+     */
+    build: function(scheme, options) {
+      var context = Pusher.Util.extend({}, globalContext, options);
+      return evaluate(scheme, context)[1].strategy;
+    }
+  };
 
-        self.key = key;
-        self.socket = null;
-        self.socket_id = null;
+  var transports = {
+    ws: Pusher.WSTransport,
+    flash: Pusher.FlashTransport,
+    sockjs: Pusher.SockJSTransport
+  };
 
-        self.state = 'initialized';
-      },
+  // DSL bindings
 
-      waitingPre: function() {
-        if (self.netInfo.isOnLine()) {
-          if (self.failedAttempts < 2) {
-            updateState('connecting');
-          } else {
-            updateState('unavailable');
-            // Delay 10s between connection attempts on entering unavailable
-            self.connectionWait = 10000;
-          }
+  function returnWithOriginalContext(f) {
+    return function(context) {
+      return [f.apply(this, arguments), context];
+    };
+  }
 
-          if (self.connectionWait > 0) {
-            self.emit('connecting_in', connectionDelay());
-          }
+  var globalContext = {
+    def: function(context, name, value) {
+      if (context[name] !== undefined) {
+        throw "Redefining symbol " + name;
+      }
+      context[name] = value;
+      return [undefined, context];
+    },
 
-          self._waitingTimer = setTimeout(function() {
-            // Even when unavailable we try connecting (not changing state)
-            self._machine.transition('connecting');
-          }, connectionDelay());
-        } else {
-          updateState('unavailable');
-        }
-      },
+    def_transport: function(context, name, type, priority, options, manager) {
+      var transportClass = transports[type];
+      if (!transportClass) {
+        throw new Pusher.Errors.UnsupportedTransport(type);
+      }
+      var transportOptions = Pusher.Util.extend({}, {
+        key: context.key,
+        encrypted: context.encrypted,
+        timeline: context.timeline,
+        disableFlash: context.disableFlash
+      }, options);
+      if (manager) {
+        transportClass = manager.getAssistant(transportClass);
+      }
+      var transport = new Pusher.TransportStrategy(
+        name, priority, transportClass, transportOptions
+      );
+      var newContext = context.def(context, name, transport)[1];
+      newContext.transports = context.transports || {};
+      newContext.transports[name] = transport;
+      return [undefined, newContext];
+    },
 
-      waitingExit: function() {
-        clearTimeout(self._waitingTimer);
-      },
+    transport_manager: returnWithOriginalContext(function(_, options) {
+      return new Pusher.TransportManager(options);
+    }),
 
-      connectingPre: function() {
-        // Case that a user manages to get to the connecting
-        // state even when offline.
-        if (self.netInfo.isOnLine() === false) {
-          self._machine.transition('waiting');
-          updateState('unavailable');
+    sequential: returnWithOriginalContext(function(_, options) {
+      var strategies = Array.prototype.slice.call(arguments, 2);
+      return new Pusher.SequentialStrategy(strategies, options);
+    }),
 
-          return;
-        }
+    cached: returnWithOriginalContext(function(context, ttl, strategy){
+      return new Pusher.CachedStrategy(strategy, context.transports, {
+        ttl: ttl,
+        timeline: context.timeline
+      });
+    }),
 
-        var path = connectPath(self.key);
-        if (Pusher.TransportType === 'sockjs') {
-          Pusher.debug('Connecting to sockjs', Pusher.sockjs);
-          var url = buildSockJSURL(self.connectionSecure);
-
-          self.ping = false
-          self.socket = new SockJS(url);
-          self.socket.onopen = function() {
-            // SockJS does not yet support custom paths and query params
-            self.socket.send(JSON.stringify({path: path}));
-            self._machine.transition('open');
-          }
-        } else {
-          var url = connectBaseURL(self.connectionSecure) + path;
-          Pusher.debug('Connecting', url);
-          self.socket = new Pusher.Transport(url);
-          self.socket.onopen = function() {
-            self._machine.transition('open');
-          }
-        }
+    first_connected: returnWithOriginalContext(function(_, strategy) {
+      return new Pusher.FirstConnectedStrategy(strategy);
+    }),
+
+    best_connected_ever: returnWithOriginalContext(function() {
+      var strategies = Array.prototype.slice.call(arguments, 1);
+      return new Pusher.BestConnectedEverStrategy(strategies);
+    }),
+
+    delayed: returnWithOriginalContext(function(_, delay, strategy) {
+      return new Pusher.DelayedStrategy(strategy, { delay: delay });
+    }),
+
+    "if": returnWithOriginalContext(function(_, test, trueBranch, falseBranch) {
+      return new Pusher.IfStrategy(test, trueBranch, falseBranch);
+    }),
+
+    is_supported: returnWithOriginalContext(function(_, strategy) {
+      return function() {
+        return strategy.isSupported();
+      };
+    })
+  };
 
-        self.socket.onclose = transitionToWaiting;
-        self.socket.onerror = ws_onError;
+  // DSL interpreter
 
-        // allow time to get ws_onOpen, otherwise close socket and try again
-        self._connectingTimer = setTimeout(TransitionToImpermanentlyClosing, self.openTimeout);
-      },
+  function isSymbol(expression) {
+    return (typeof expression === "string") && expression.charAt(0) === ":";
+  }
 
-      connectingExit: function() {
-        clearTimeout(self._connectingTimer);
-        self.socket.onopen = undefined; // unbind to avoid open events that are no longer relevant
-      },
+  function getSymbolValue(expression, context) {
+    return context[expression.slice(1)];
+  }
 
-      connectingToWaiting: function() {
-        updateConnectionParameters();
+  function evaluateListOfExpressions(expressions, context) {
+    if (expressions.length === 0) {
+      return [[], context];
+    }
+    var head = evaluate(expressions[0], context);
+    var tail = evaluateListOfExpressions(expressions.slice(1), head[1]);
+    return [[head[0]].concat(tail[0]), tail[1]];
+  }
 
-        // FUTURE: update only ssl
-      },
+  function evaluateString(expression, context) {
+    if (!isSymbol(expression)) {
+      return [expression, context];
+    }
+    var value = getSymbolValue(expression, context);
+    if (value === undefined) {
+      throw "Undefined symbol " + expression;
+    }
+    return [value, context];
+  }
 
-      connectingToImpermanentlyClosing: function() {
-        updateConnectionParameters();
+  function evaluateArray(expression, context) {
+    if (isSymbol(expression[0])) {
+      var f = getSymbolValue(expression[0], context);
+      if (expression.length > 1) {
+        if (typeof f !== "function") {
+          throw "Calling non-function " + expression[0];
+        }
+        var args = [Pusher.Util.extend({}, context)].concat(
+          Pusher.Util.map(expression.slice(1), function(arg) {
+            return evaluate(arg, Pusher.Util.extend({}, context))[0];
+          })
+        );
+        return f.apply(this, args);
+      } else {
+        return [f, context];
+      }
+    } else {
+      return evaluateListOfExpressions(expression, context);
+    }
+  }
 
-        // FUTURE: update only timeout
-      },
+  function evaluate(expression, context) {
+    var expressionType = typeof expression;
+    if (typeof expression === "string") {
+      return evaluateString(expression, context);
+    } else if (typeof expression === "object") {
+      if (expression instanceof Array && expression.length > 0) {
+        return evaluateArray(expression, context);
+      }
+    }
+    return [expression, context];
+  }
 
-      openPre: function() {
-        self.socket.onmessage = ws_onMessageOpen;
-        self.socket.onerror = ws_onError;
-        self.socket.onclose = transitionToWaiting;
+  Pusher.StrategyBuilder = StrategyBuilder;
+}).call(this);
 
-        // allow time to get connected-to-Pusher message, otherwise close socket, try again
-        self._openTimer = setTimeout(TransitionToImpermanentlyClosing, self.connectedTimeout);
-      },
+;(function() {
+  /**
+   * Provides Pusher protocol interface for transports.
+   *
+   * Emits following events:
+   * - connected - after establishing connection and receiving a socket id
+   * - message - on received messages
+   * - ping - on ping requests
+   * - pong - on pong responses
+   * - error - when the transport emits an error
+   * - closed - after closing the transport
+   * - ssl_only - after trying to connect without ssl to a ssl-only app
+   * - retry - when closed connection should be retried immediately
+   * - backoff - when closed connection should be retried with a delay
+   * - refused - when closed connection should not be retried
+   *
+   * @param {AbstractTransport} transport
+   */
+  function ProtocolWrapper(transport) {
+    Pusher.EventsDispatcher.call(this);
+    this.transport = transport;
+    this.bindListeners();
+  }
+  var prototype = ProtocolWrapper.prototype;
 
-      openExit: function() {
-        clearTimeout(self._openTimer);
-        self.socket.onmessage = undefined; // unbind to avoid messages that are no longer relevant
-      },
+  Pusher.Util.extend(prototype, Pusher.EventsDispatcher.prototype);
 
-      openToWaiting: function() {
-        updateConnectionParameters();
-      },
+  /** Returns whether used transport handles ping/pong by itself
+   *
+   * @returns {Boolean} true if ping is handled by the transport
+   */
+  prototype.supportsPing = function() {
+    return this.transport.supportsPing();
+  };
 
-      openToImpermanentlyClosing: function() {
-        updateConnectionParameters();
-      },
+  /** Sends raw data.
+   *
+   * @param {String} data
+   */
+  prototype.send = function(data) {
+    return this.transport.send(data);
+  };
 
-      connectedPre: function(socket_id) {
-        self.socket_id = socket_id;
+  /** Sends an event.
+   *
+   * @param {String} name
+   * @param {String} data
+   * @param {String} [channel]
+   * @returns {Boolean} whether message was sent or not
+   */
+  prototype.send_event = function(name, data, channel) {
+    var payload = {
+      event: name,
+      data: data
+    };
+    if (channel) {
+      payload.channel = channel;
+    }
 
-        self.socket.onmessage = ws_onMessageConnected;
-        self.socket.onerror = ws_onError;
-        self.socket.onclose = transitionToWaiting;
+    Pusher.debug('Event sent', payload);
+    return this.send(JSON.stringify(payload));
+  };
 
-        resetConnectionParameters(self);
-        self.connectedAt = new Date().getTime();
+  /** Closes the transport.  */
+  prototype.close = function() {
+    this.transport.close();
+  };
 
-        resetActivityCheck();
-      },
+  /** @private */
+  prototype.bindListeners = function() {
+    var self = this;
 
-      connectedPost: function() {
-        updateState('connected');
-      },
+    var onMessageOpen = function(message) {
+      message = self.parseMessage(message);
+
+      if (message !== undefined) {
+        if (message.event === 'pusher:connection_established') {
+          self.id = message.data.socket_id;
+          self.transport.unbind("message", onMessageOpen);
+          self.transport.bind("message", onMessageConnected);
+          self.transport.bind("ping_request", onPingRequest);
+          self.emit("connected", self.id);
+        } else if (message.event === "pusher:error") {
+          // From protocol 6 close codes are sent only once, so this only
+          // happens when connection does not support close codes
+          self.handleCloseCode(message.data.code, message.data.message);
+          self.transport.close();
+        }
+      }
+    };
+    var onMessageConnected = function(message) {
+      message = self.parseMessage(message);
 
-      connectedExit: function() {
-        stopActivityCheck();
-        updateState('disconnected');
-      },
+      if (message !== undefined) {
+        Pusher.debug('Event recd', message);
 
-      impermanentlyClosingPost: function() {
-        if (self.socket) {
-          self.socket.onclose = transitionToWaiting;
-          self.socket.close();
+        switch (message.event) {
+          case 'pusher:error':
+            self.emit('error', { type: 'PusherError', data: message.data });
+            break;
+          case 'pusher:ping':
+            self.emit("ping");
+            break;
+          case 'pusher:pong':
+            self.emit("pong");
+            break;
         }
-      },
+        self.emit('message', message);
+      }
+    };
+    var onPingRequest = function() {
+      self.emit("ping_request");
+    };
+    var onError = function(error) {
+      self.emit("error", { type: "WebSocketError", error: error });
+    };
+    var onClosed = function(error) {
+      if (error && error.code) {
+        self.handleCloseCode(error.code, error.reason);
+      }
+      self.transport.unbind("message", onMessageOpen);
+      self.transport.unbind("message", onMessageConnected);
+      self.transport.unbind("ping_request", onPingRequest);
+      self.transport.unbind("error", onError);
+      self.transport.unbind("closed", onClosed);
+      self.transport = null;
+      self.emit("closed");
+    };
 
-      permanentlyClosingPost: function() {
-        if (self.socket) {
-          self.socket.onclose = function() {
-            resetConnectionParameters(self);
-            self._machine.transition('permanentlyClosed');
-          };
+    this.transport.bind("message", onMessageOpen);
+    this.transport.bind("error", onError);
+    this.transport.bind("closed", onClosed);
+  };
 
-          self.socket.close();
-        } else {
-          resetConnectionParameters(self);
-          self._machine.transition('permanentlyClosed');
+  /** @private */
+  prototype.parseMessage = function(message) {
+    try {
+      var params = JSON.parse(message.data);
+
+      if (typeof params.data === 'string') {
+        try {
+          params.data = JSON.parse(params.data);
+        } catch (e) {
+          if (!(e instanceof SyntaxError)) {
+            throw e;
+          }
         }
-      },
+      }
 
-      failedPre: function() {
-        updateState('failed');
-        Pusher.debug('WebSockets are not available in this browser.');
-      },
+      return params;
+    } catch (e) {
+      this.emit(
+        'error', { type: 'MessageParseError', error: e, data: message.data}
+      );
+    }
+  };
 
-      permanentlyClosedPost: function() {
-        updateState('disconnected');
+  /** @private */
+  prototype.handleCloseCode = function(code, message) {
+    this.emit(
+      'error', { type: 'PusherError', data: { code: code, message: message } }
+    );
+
+    // See:
+    // 1. https://developer.mozilla.org/en-US/docs/WebSockets/WebSockets_reference/CloseEvent
+    // 2. http://pusher.com/docs/pusher_protocol
+    if (code < 4000) {
+      // ignore 1000 CLOSE_NORMAL, 1001 CLOSE_GOING_AWAY,
+      //        1005 CLOSE_NO_STATUS, 1006 CLOSE_ABNORMAL
+      // ignore 1007...3999
+      // handle 1002 CLOSE_PROTOCOL_ERROR, 1003 CLOSE_UNSUPPORTED,
+      //        1004 CLOSE_TOO_LARGE
+      if (code >= 1002 && code <= 1004) {
+        this.emit("backoff");
       }
-    });
+    } else if (code === 4000) {
+      this.emit("ssl_only");
+    } else if (code < 4100) {
+      this.emit("refused");
+    } else if (code < 4200) {
+      this.emit("backoff");
+    } else if (code < 4300) {
+      this.emit("retry");
+    } else {
+      // unknown error
+      this.emit("refused");
+    }
+  };
 
-    /*-----------------------------------------------
-      -----------------------------------------------*/
+  Pusher.ProtocolWrapper = ProtocolWrapper;
+}).call(this);
 
-    function updateConnectionParameters() {
-      if (self.openTimeout < MAX_OPEN_TIMEOUT) {
-        self.openTimeout += OPEN_TIMEOUT_INCREMENT;
-      }
+;(function() {
+  /** Manages connection to Pusher.
+   *
+   * Uses a strategy (currently only default), timers and network availability
+   * info to establish a connection and export its state. In case of failures,
+   * manages reconnection attempts.
+   *
+   * Exports state changes as following events:
+   * - "state_change", { previous: p, current: state }
+   * - state
+   *
+   * States:
+   * - initialized - initial state, never transitioned to
+   * - connecting - connection is being established
+   * - connected - connection has been fully established
+   * - disconnected - on requested disconnection or before reconnecting
+   * - unavailable - after connection timeout or when there's no network
+   *
+   * Options:
+   * - unavailableTimeout - time to transition to unavailable state
+   * - activityTimeout - time after which ping message should be sent
+   * - pongTimeout - time for Pusher to respond with pong before reconnecting
+   *
+   * @param {String} key application key
+   * @param {Object} options
+   */
+  function ConnectionManager(key, options) {
+    Pusher.EventsDispatcher.call(this);
 
-      if (self.connectedTimeout < MAX_CONNECTED_TIMEOUT) {
-        self.connectedTimeout += CONNECTED_TIMEOUT_INCREMENT;
-      }
+    this.key = key;
+    this.options = options || {};
+    this.state = "initialized";
+    this.connection = null;
+    this.encrypted = !!options.encrypted;
+    this.timeline = this.options.getTimeline();
 
-      // Toggle between ws & wss
-      if (self.compulsorySecure !== true) {
-        self.connectionSecure = !self.connectionSecure;
+    var self = this;
+
+    Pusher.Network.bind("online", function() {
+      if (self.state === "unavailable") {
+        self.connect();
+      }
+    });
+    Pusher.Network.bind("offline", function() {
+      if (self.shouldRetry()) {
+        self.disconnect();
+        self.updateState("unavailable");
       }
+    });
 
-      self.failedAttempts++;
+    var sendTimeline = function() {
+      if (self.timelineSender) {
+        self.timelineSender.send(function() {});
+      }
+    };
+    this.bind("connected", sendTimeline);
+    setInterval(sendTimeline, 60000);
+  }
+  var prototype = ConnectionManager.prototype;
+
+  Pusher.Util.extend(prototype, Pusher.EventsDispatcher.prototype);
+
+  /** Establishes a connection to Pusher.
+   *
+   * Does nothing when connection is already established. See top-level doc
+   * to find events emitted on connection attempts.
+   */
+  prototype.connect = function() {
+    if (this.connection) {
+      return;
+    }
+    if (this.state === "connecting") {
+      return;
     }
 
-    function connectBaseURL(isSecure) {
-      // Always connect with SSL if the current page served over https
-      var ssl = (isSecure || document.location.protocol === 'https:');
-      var port = ssl ? Pusher.wss_port : Pusher.ws_port;
-      var scheme = ssl ? 'wss://' : 'ws://';
+    var strategy = this.options.getStrategy({
+      key: this.key,
+      timeline: this.timeline,
+      encrypted: this.encrypted
+    });
 
-      return scheme + Pusher.host + ':' + port;
+    if (!strategy.isSupported()) {
+      this.updateState("failed");
+      return;
     }
-
-    function connectPath(key) {
-      var flash = (Pusher.TransportType === "flash") ? "true" : "false";
-      var path = '/app/' + key + '?protocol=5&client=js'
-        + '&version=' + Pusher.VERSION
-        + '&flash=' + flash;
-      return path;
+    if (Pusher.Network.isOnline() === false) {
+      this.updateState("unavailable");
+      return;
     }
 
-    function buildSockJSURL(isSecure) {
-      var ssl = (isSecure || document.location.protocol === 'https:');
-      var port = ssl ? Pusher.sockjs_https_port : Pusher.sockjs_http_port;
-      var scheme = ssl ? 'https://' : 'http://';
+    this.updateState("connecting");
+    this.timelineSender = this.options.getTimelineSender(
+      this.timeline,
+      { encrypted: this.encrypted },
+      this
+    );
 
-      return scheme + Pusher.sockjs_host + ':' + port + Pusher.sockjs_path;
-    }
+    var self = this;
+    var callback = function(error, transport) {
+      if (error) {
+        self.runner = strategy.connect(0, callback);
+      } else {
+        // we don't support switching connections yet
+        self.runner.abort();
+        self.setConnection(self.wrapTransport(transport));
+      }
+    };
+    this.runner = strategy.connect(0, callback);
 
-    // callback for close and retry.  Used on timeouts.
-    function TransitionToImpermanentlyClosing() {
-      self._machine.transition('impermanentlyClosing');
+    this.setUnavailableTimer();
+  };
+
+  /** Sends raw data.
+   *
+   * @param {String} data
+   */
+  prototype.send = function(data) {
+    if (this.connection) {
+      return this.connection.send(data);
+    } else {
+      return false;
     }
+  };
 
-    function resetActivityCheck() {
-      if (self._activityTimer) { clearTimeout(self._activityTimer); }
-      // Send ping after inactivity
-      if (self.ping) {
-        self._activityTimer = setTimeout(function() {
-          self.send_event('pusher:ping', {})
-          // Wait for pong response
-          self._activityTimer = setTimeout(function() {
-            self.socket.close();
-          }, (self.options.pong_timeout || Pusher.pong_timeout))
-        }, (self.options.activity_timeout || Pusher.activity_timeout))
-      }
+  /** Sends an event.
+   *
+   * @param {String} name
+   * @param {String} data
+   * @param {String} [channel]
+   * @returns {Boolean} whether message was sent or not
+   */
+  prototype.send_event = function(name, data, channel) {
+    if (this.connection) {
+      return this.connection.send_event(name, data, channel);
+    } else {
+      return false;
     }
+  };
 
-    function stopActivityCheck() {
-      if (self._activityTimer) { clearTimeout(self._activityTimer); }
+  /** Closes the connection. */
+  prototype.disconnect = function() {
+    if (this.runner) {
+      this.runner.abort();
+    }
+    this.clearRetryTimer();
+    this.clearUnavailableTimer();
+    this.stopActivityCheck();
+    this.updateState("disconnected");
+    // we're in disconnected state, so closing will not cause reconnecting
+    if (this.connection) {
+      this.connection.close();
+      this.connection = null;
     }
+  };
 
-    // Returns the delay before the next connection attempt should be made
-    //
-    // This function guards against attempting to connect more frequently than
-    // once every second
-    //
-    function connectionDelay() {
-      var delay = self.connectionWait;
-      if (delay === 0) {
-        if (self.connectedAt) {
-          var t = 1000;
-          var connectedFor = new Date().getTime() - self.connectedAt;
-          if (connectedFor < t) {
-            delay = t - connectedFor;
-          }
-        }
-      }
-      return delay;
-    }
-
-    /*-----------------------------------------------
-      WebSocket Callbacks
-      -----------------------------------------------*/
-
-    function handleCloseCode(code, message) {
-      // first inform the end-developer of this error
-      self.emit('error', {type: 'PusherError', data: {code: code, message: message}});
-
-      if (code === 4000) {
-        // SSL only app
-        self.compulsorySecure = true;
-        self.connectionSecure = true;
-        self.options.encrypted = true;
-
-        TransitionToImpermanentlyClosing();
-      } else if (code < 4100) {
-        // Permentently close connection
-        self._machine.transition('permanentlyClosing')
-      } else if (code < 4200) {
-        // Backoff before reconnecting
-        self.connectionWait = 1000;
-        self._machine.transition('waiting')
-      } else if (code < 4300) {
-        // Reconnect immediately
-        TransitionToImpermanentlyClosing();
-      } else {
-        // Unknown error
-        self._machine.transition('permanentlyClosing')
+  /** @private */
+  prototype.retryIn = function(delay) {
+    var self = this;
+    this.retryTimer = setTimeout(function() {
+      if (self.retryTimer === null) {
+        return;
       }
+      self.retryTimer = null;
+      self.disconnect();
+      self.connect();
+    }, delay || 0);
+  };
+
+  /** @private */
+  prototype.clearRetryTimer = function() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
     }
+  };
 
-    function ws_onMessageOpen(event) {
-      var params = parseWebSocketEvent(event);
-      if (params !== undefined) {
-        if (params.event === 'pusher:connection_established') {
-          self._machine.transition('connected', params.data.socket_id);
-        } else if (params.event === 'pusher:error') {
-          handleCloseCode(params.data.code, params.data.message)
-        }
+  /** @private */
+  prototype.setUnavailableTimer = function() {
+    var self = this;
+    this.unavailableTimer = setTimeout(function() {
+      if (!self.unavailableTimer) {
+        return;
       }
+      self.updateState("unavailable");
+      self.unavailableTimer = null;
+    }, this.options.unavailableTimeout);
+  };
+
+  /** @private */
+  prototype.clearUnavailableTimer = function() {
+    if (this.unavailableTimer) {
+      clearTimeout(this.unavailableTimer);
+      this.unavailableTimer = null;
     }
+  };
 
-    function ws_onMessageConnected(event) {
-      resetActivityCheck();
+  /** @private */
+  prototype.resetActivityCheck = function() {
+    this.stopActivityCheck();
+    // send ping after inactivity
+    if (!this.connection.supportsPing()) {
+      var self = this;
+      this.activityTimer = setTimeout(function() {
+        self.send_event('pusher:ping', {});
+        // wait for pong response
+        self.activityTimer = setTimeout(function() {
+          self.connection.close();
+        }, (self.options.pongTimeout));
+      }, (this.options.activityTimeout));
+    }
+  };
 
-      var params = parseWebSocketEvent(event);
-      if (params !== undefined) {
-        Pusher.debug('Event recd', params);
+  /** @private */
+  prototype.stopActivityCheck = function() {
+    if (this.activityTimer) {
+      clearTimeout(this.activityTimer);
+      this.activityTimer = null;
+    }
+  };
 
-        switch (params.event) {
-          case 'pusher:error':
-            self.emit('error', {type: 'PusherError', data: params.data});
-            break;
-          case 'pusher:ping':
-            self.send_event('pusher:pong', {})
-            break;
-        }
+  /** @private */
+  prototype.setConnection = function(connection) {
+    this.connection = connection;
 
-        self.emit('message', params);
+    var self = this;
+    var onConnected = function(id) {
+      self.clearUnavailableTimer();
+      self.socket_id = id;
+      self.updateState("connected");
+      self.resetActivityCheck();
+    };
+    var onMessage = function(message) {
+      // includes pong messages from server
+      self.resetActivityCheck();
+      self.emit('message', message);
+    };
+    var onPing = function() {
+      self.send_event('pusher:pong', {});
+    };
+    var onPingRequest = function() {
+      self.send_event('pusher:ping', {});
+    };
+    var onError = function(error) {
+      // just emit error to user - socket will already be closed by browser
+      self.emit("error", { type: "WebSocketError", error: error });
+    };
+    var onClosed = function() {
+      connection.unbind("connected", onConnected);
+      connection.unbind("message", onMessage);
+      connection.unbind("ping", onPing);
+      connection.unbind("ping_request", onPingRequest);
+      connection.unbind("error", onError);
+      connection.unbind("closed", onClosed);
+      self.connection = null;
+
+      if (self.shouldRetry()) {
+        self.retryIn(1000);
       }
-    }
+    };
 
+    // handling close conditions
+    var onSSLOnly = function() {
+      self.encrypted = true;
+      self.retryIn(0);
+    };
+    var onRefused = function() {
+      self.disconnect();
+    };
+    var onBackoff = function() {
+      self.retryIn(1000);
+    };
+    var onRetry = function() {
+      self.retryIn(0);
+    };
 
-    /**
-     * Parses an event from the WebSocket to get
-     * the JSON payload that we require
-     *
-     * @param {MessageEvent} event  The event from the WebSocket.onmessage handler.
-    **/
-    function parseWebSocketEvent(event) {
-      try {
-        var params = JSON.parse(event.data);
-
-        if (typeof params.data === 'string') {
-          try {
-            params.data = JSON.parse(params.data);
-          } catch (e) {
-            if (!(e instanceof SyntaxError)) {
-              throw e;
-            }
-          }
-        }
+    connection.bind("connected", onConnected);
+    connection.bind("message", onMessage);
+    connection.bind("ping", onPing);
+    connection.bind("ping_request", onPingRequest);
+    connection.bind("error", onError);
+    connection.bind("closed", onClosed);
 
-        return params;
-      } catch (e) {
-        self.emit('error', {type: 'MessageParseError', error: e, data: event.data});
-      }
-    }
+    connection.bind("ssl_only", onSSLOnly);
+    connection.bind("refused", onRefused);
+    connection.bind("backoff", onBackoff);
+    connection.bind("retry", onRetry);
 
-    function transitionToWaiting() {
-      self._machine.transition('waiting');
-    }
+    this.resetActivityCheck();
+  };
 
-    function ws_onError(error) {
-      // just emit error to user - socket will already be closed by browser
-      self.emit('error', { type: 'WebSocketError', error: error });
-    }
+  /** @private */
+  prototype.updateState = function(newState, data) {
+    var previousState = this.state;
 
-    // Updates the public state information exposed by connection
-    //
-    // This is distinct from the internal state information used by _machine
-    // to manage the connection
-    //
-    function updateState(newState, data) {
-      var prevState = self.state;
-      self.state = newState;
+    this.state = newState;
+    // Only emit when the state changes
+    if (previousState !== newState) {
+      Pusher.debug('State changed', previousState + ' -> ' + newState);
 
-      // Only emit when the state changes
-      if (prevState !== newState) {
-        Pusher.debug('State changed', prevState + ' -> ' + newState);
-        self.emit('state_change', {previous: prevState, current: newState});
-        self.emit(newState, data);
-      }
+      this.emit('state_change', { previous: previousState, current: newState });
+      this.emit(newState, data);
     }
   };
 
-  Connection.prototype.connect = function() {
-    // no WebSockets
-    if (!this._machine.is('failed') && !Pusher.Transport) {
-      this._machine.transition('failed');
-    }
-    // initial open of connection
-    else if(this._machine.is('initialized')) {
-      resetConnectionParameters(this);
-      this._machine.transition('waiting');
-    }
-    // user skipping connection wait
-    else if (this._machine.is('waiting') && this.netInfo.isOnLine() === true) {
-      this._machine.transition('connecting');
-    }
-    // user re-opening connection after closing it
-    else if(this._machine.is("permanentlyClosed")) {
-      resetConnectionParameters(this);
-      this._machine.transition('waiting');
-    }
+  /** @private */
+  prototype.shouldRetry = function() {
+    return this.state === "connecting" || this.state === "connected";
   };
 
-  Connection.prototype.send = function(data) {
-    if (this._machine.is('connected')) {
-      // Workaround for MobileSafari bug (see https://gist.github.com/2052006)
-      var self = this;
-      setTimeout(function() {
-        self.socket.send(data);
-      }, 0);
-      return true;
-    } else {
-      return false;
-    }
+  /** @private */
+  prototype.wrapTransport = function(transport) {
+    return new Pusher.ProtocolWrapper(transport);
   };
 
-  Connection.prototype.send_event = function(event_name, data, channel) {
-    var payload = {
-      event: event_name,
-      data: data
-    };
-    if (channel) payload['channel'] = channel;
+  Pusher.ConnectionManager = ConnectionManager;
+}).call(this);
 
-    Pusher.debug('Event sent', payload);
-    return this.send(JSON.stringify(payload));
-  }
+;(function() {
+  /** Really basic interface providing network availability info.
+   *
+   * Emits:
+   * - online - when browser goes online
+   * - offline - when browser goes offline
+   */
+  function NetInfo() {
+    Pusher.EventsDispatcher.call(this);
 
-  Connection.prototype.disconnect = function() {
-    if (this._machine.is('permanentlyClosed')) return;
+    var self = this;
+    // This is okay, as IE doesn't support this stuff anyway.
+    if (window.addEventListener !== undefined) {
+      window.addEventListener("online", function() {
+        self.emit('online');
+      }, false);
+      window.addEventListener("offline", function() {
+        self.emit('offline');
+      }, false);
+    }
+  }
+  Pusher.Util.extend(NetInfo.prototype, Pusher.EventsDispatcher.prototype);
 
-    if (this._machine.is('waiting') || this._machine.is('failed')) {
-      this._machine.transition('permanentlyClosed');
+  var prototype = NetInfo.prototype;
+
+  /** 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}
+   */
+  prototype.isOnline = function() {
+    if (window.navigator.onLine === undefined) {
+      return true;
     } else {
-      this._machine.transition('permanentlyClosing');
+      return window.navigator.onLine;
     }
   };
 
-  Pusher.Util.extend(Connection.prototype, Pusher.EventsDispatcher.prototype);
-  this.Pusher.Connection = Connection;
+  Pusher.NetInfo = NetInfo;
+  Pusher.Network = new NetInfo();
 }).call(this);
 
 ;(function() {
@@ -1191,130 +3213,3 @@ Example:
     }
   };
 }).call(this);
-// _require(dependencies, callback) takes an array of dependency urls and a
-// callback to call when all the dependecies have finished loading
-var _require = (function() {
-  function handleScriptLoaded(elem, callback) {
-    if (document.addEventListener) {
-      elem.addEventListener('load', callback, false);
-    } else {
-      elem.attachEvent('onreadystatechange', function () {
-        if (elem.readyState == 'loaded' || elem.readyState == 'complete') {
-          callback();
-        }
-      });
-    }
-  }
-
-  function addScript(src, callback) {
-    var head = document.getElementsByTagName('head')[0];
-    var script = document.createElement('script');
-    script.setAttribute('src', src);
-    script.setAttribute("type","text/javascript");
-    script.setAttribute('async', true);
-
-    handleScriptLoaded(script, function() {
-      callback();
-    });
-
-    head.appendChild(script);
-  }
-
-  return function(deps, callback) {
-    var deps_loaded = 0;
-    for (var i = 0; i < deps.length; i++) {
-      addScript(deps[i], function() {
-        if (deps.length == ++deps_loaded) {
-          // This setTimeout is a workaround for an Opera issue
-          setTimeout(callback, 0);
-        }
-      });
-    }
-  }
-})();
-
-;(function() {
-  // Support Firefox versions which prefix WebSocket
-  if (!window['WebSocket'] && window['MozWebSocket']) {
-    window['WebSocket'] = window['MozWebSocket']
-  }
-
-  if (window['WebSocket']) {
-    Pusher.Transport = window['WebSocket'];
-    Pusher.TransportType = 'native';
-  }
-
-  var cdn = (document.location.protocol == 'http:') ? Pusher.cdn_http : Pusher.cdn_https;
-  var root = cdn + Pusher.VERSION;
-  var deps = [];
-
-  if (!window['JSON']) {
-    deps.push(root + '/json2' + Pusher.dependency_suffix + '.js');
-  }
-  if (!window['WebSocket']) {
-    var flashSupported;
-    try {
-      flashSupported = Boolean(new ActiveXObject('ShockwaveFlash.ShockwaveFlash'));
-    } catch (e) {
-      flashSupported = navigator.mimeTypes["application/x-shockwave-flash"] !== undefined;
-    }
-
-    if (flashSupported) {
-      // Try to use web-socket-js (flash WebSocket emulation)
-      window.WEB_SOCKET_DISABLE_AUTO_INITIALIZATION = true;
-      window.WEB_SOCKET_SUPPRESS_CROSS_DOMAIN_SWF_ERROR = true;
-      deps.push(root + '/flashfallback' + Pusher.dependency_suffix + '.js');
-    } else {
-      // Use SockJS when Flash is not available
-      deps.push(root + '/sockjs' + Pusher.dependency_suffix + '.js');
-    }
-  }
-
-  var initialize = function() {
-    if (window['WebSocket']) {
-      // Initialize function in the case that we have native WebSocket support
-      return function() {
-        Pusher.ready();
-      }
-    } else {
-      // Initialize function for fallback case
-      return function() {
-        if (window['WebSocket']) {
-          // window['WebSocket'] is a flash emulation of WebSocket
-          Pusher.Transport = window['WebSocket'];
-          Pusher.TransportType = 'flash';
-
-          window.WEB_SOCKET_SWF_LOCATION = root + "/WebSocketMain.swf";
-          WebSocket.__addTask(function() {
-            Pusher.ready();
-          })
-          WebSocket.__initialize();
-        } else {
-          // Flash fallback was not loaded, using SockJS
-          Pusher.Transport = window.SockJS;
-          Pusher.TransportType = 'sockjs';
-          Pusher.ready();
-        }
-      }
-    }
-  }();
-
-  // Allows calling a function when the document body is available
-  var ondocumentbody = function(callback) {
-    var load_body = function() {
-      document.body ? callback() : setTimeout(load_body, 0);
-    }
-    load_body();
-  };
-
-  var initializeOnDocumentBody = function() {
-    ondocumentbody(initialize);
-  }
-
-  if (deps.length > 0) {
-    _require(deps, initializeOnDocumentBody);
-  } else {
-    initializeOnDocumentBody();
-  }
-})();
-