Copy over all files from master

CHANGES.rst

+Changelog
+=========
+
+0.3 (unreleased)
+----------------
+
+- Add vCard support [jcbrand]
+- Remember custom status messages upon reload. [jcbrand] 
+- Remove jquery-ui dependency. [jcbrand]
+- Use backbone.localStorage to store the contacts roster, open chatboxes and
+  chat messages. [jcbrand]
+- Fixed user status handling, which wasn't 100% according to the
+  spec. [jcbrand]
+- Separate messages according to day in chats. [jcbrand]
+
+
+0.2 (2013-03-28)
+----------------
+
+- Performance enhancements and general script cleanup [ichim-david]
+- Add "Connecting to chat..." info [alecghica]
+- Various smaller improvements and bugfixes [jcbrand]
+
+
+0.1 (unreleased)
+----------------
+
+- Created [jcbrand]

CONTRIBUTING.rst

+===========================
+Contributing to Converse.js
+===========================
+
+Contributions to Converse.js are very welcome. Please follow the usual github
+workflow. Create your own local fork of this repository, make your changes and
+then submit a pull request.
+
+Before submitting a pull request
+================================
+
+Add tests for your bugfix or feature
+------------------------------------
+
+- Please try to add a test for any bug fixed or feature added. We use Jasmine
+  for testing.
+
+Check that the tests run
+------------------------
+
+- Check that the Jasmine BDD tests complete sucessfully. Open test.html in your
+  browser, and the tests will run automatically.

LICENSE_GPL.txt

+Converse.js
+A web-based XMPP instant messaging client.
+
+Copyright (C) 2012 Jan-Carel Brand.
+http://opkode.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

LICENSE_MIT.txt

+Converse.js
+A web-based XMPP instant messaging client.
+
+Copyright (C) 2012 Jan-Carel Brand.
+http://opkode.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+

Libraries/app.build.js

+({
+    appDir: "../",
+    baseUrl: "scripts/",
+    dir: "../../webapp-build",
+    //Comment out the optimize line if you want
+    //the code minified by UglifyJS
+    optimize: "none",
+
+    paths: {
+        "jquery": "empty:"
+    },
+
+    modules: [
+        //Optimize the application files. jQuery is not 
+        //included since it is already in require-jquery.js
+        {
+            name: "main"
+        }
+    ]
+})

Libraries/backbone.js

+//     Backbone.js 1.0.0
+
+//     (c) 2010-2013 Jeremy Ashkenas, DocumentCloud Inc.
+//     Backbone may be freely distributed under the MIT license.
+//     For all details and documentation:
+//     http://backbonejs.org
+
+(function(){
+
+  // Initial Setup
+  // -------------
+
+  // Save a reference to the global object (`window` in the browser, `exports`
+  // on the server).
+  var root = this;
+
+  // Save the previous value of the `Backbone` variable, so that it can be
+  // restored later on, if `noConflict` is used.
+  var previousBackbone = root.Backbone;
+
+  // Create local references to array methods we'll want to use later.
+  var array = [];
+  var push = array.push;
+  var slice = array.slice;
+  var splice = array.splice;
+
+  // The top-level namespace. All public Backbone classes and modules will
+  // be attached to this. Exported for both the browser and the server.
+  var Backbone;
+  if (typeof exports !== 'undefined') {
+    Backbone = exports;
+  } else {
+    Backbone = root.Backbone = {};
+  }
+
+  // Current version of the library. Keep in sync with `package.json`.
+  Backbone.VERSION = '1.0.0';
+
+  // Require Underscore, if we're on the server, and it's not already present.
+  var _ = root._;
+  if (!_ && (typeof require !== 'undefined')) _ = require('underscore');
+
+  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
+  // the `$` variable.
+  Backbone.$ = root.jQuery || root.Zepto || root.ender || root.$;
+
+  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
+  // to its previous owner. Returns a reference to this Backbone object.
+  Backbone.noConflict = function() {
+    root.Backbone = previousBackbone;
+    return this;
+  };
+
+  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
+  // will fake `"PUT"` and `"DELETE"` requests via the `_method` parameter and
+  // set a `X-Http-Method-Override` header.
+  Backbone.emulateHTTP = false;
+
+  // Turn on `emulateJSON` to support legacy servers that can't deal with direct
+  // `application/json` requests ... will encode the body as
+  // `application/x-www-form-urlencoded` instead and will send the model in a
+  // form param named `model`.
+  Backbone.emulateJSON = false;
+
+  // Backbone.Events
+  // ---------------
+
+  // A module that can be mixed in to *any object* in order to provide it with
+  // custom events. You may bind with `on` or remove with `off` callback
+  // functions to an event; `trigger`-ing an event fires all callbacks in
+  // succession.
+  //
+  //     var object = {};
+  //     _.extend(object, Backbone.Events);
+  //     object.on('expand', function(){ alert('expanded'); });
+  //     object.trigger('expand');
+  //
+  var Events = Backbone.Events = {
+
+    // Bind an event to a `callback` function. Passing `"all"` will bind
+    // the callback to all events fired.
+    on: function(name, callback, context) {
+      if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
+      this._events || (this._events = {});
+      var events = this._events[name] || (this._events[name] = []);
+      events.push({callback: callback, context: context, ctx: context || this});
+      return this;
+    },
+
+    // Bind an event to only be triggered a single time. After the first time
+    // the callback is invoked, it will be removed.
+    once: function(name, callback, context) {
+      if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
+      var self = this;
+      var once = _.once(function() {
+        self.off(name, once);
+        callback.apply(this, arguments);
+      });
+      once._callback = callback;
+      return this.on(name, once, context);
+    },
+
+    // Remove one or many callbacks. If `context` is null, removes all
+    // callbacks with that function. If `callback` is null, removes all
+    // callbacks for the event. If `name` is null, removes all bound
+    // callbacks for all events.
+    off: function(name, callback, context) {
+      var retain, ev, events, names, i, l, j, k;
+      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
+      if (!name && !callback && !context) {
+        this._events = {};
+        return this;
+      }
+
+      names = name ? [name] : _.keys(this._events);
+      for (i = 0, l = names.length; i < l; i++) {
+        name = names[i];
+        if (events = this._events[name]) {
+          this._events[name] = retain = [];
+          if (callback || context) {
+            for (j = 0, k = events.length; j < k; j++) {
+              ev = events[j];
+              if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
+                  (context && context !== ev.context)) {
+                retain.push(ev);
+              }
+            }
+          }
+          if (!retain.length) delete this._events[name];
+        }
+      }
+
+      return this;
+    },
+
+    // Trigger one or many events, firing all bound callbacks. Callbacks are
+    // passed the same arguments as `trigger` is, apart from the event name
+    // (unless you're listening on `"all"`, which will cause your callback to
+    // receive the true name of the event as the first argument).
+    trigger: function(name) {
+      if (!this._events) return this;
+      var args = slice.call(arguments, 1);
+      if (!eventsApi(this, 'trigger', name, args)) return this;
+      var events = this._events[name];
+      var allEvents = this._events.all;
+      if (events) triggerEvents(events, args);
+      if (allEvents) triggerEvents(allEvents, arguments);
+      return this;
+    },
+
+    // Tell this object to stop listening to either specific events ... or
+    // to every object it's currently listening to.
+    stopListening: function(obj, name, callback) {
+      var listeners = this._listeners;
+      if (!listeners) return this;
+      var deleteListener = !name && !callback;
+      if (typeof name === 'object') callback = this;
+      if (obj) (listeners = {})[obj._listenerId] = obj;
+      for (var id in listeners) {
+        listeners[id].off(name, callback, this);
+        if (deleteListener) delete this._listeners[id];
+      }
+      return this;
+    }
+
+  };
+
+  // Regular expression used to split event strings.
+  var eventSplitter = /\s+/;
+
+  // Implement fancy features of the Events API such as multiple event
+  // names `"change blur"` and jQuery-style event maps `{change: action}`
+  // in terms of the existing API.
+  var eventsApi = function(obj, action, name, rest) {
+    if (!name) return true;
+
+    // Handle event maps.
+    if (typeof name === 'object') {
+      for (var key in name) {
+        obj[action].apply(obj, [key, name[key]].concat(rest));
+      }
+      return false;
+    }
+
+    // Handle space separated event names.
+    if (eventSplitter.test(name)) {
+      var names = name.split(eventSplitter);
+      for (var i = 0, l = names.length; i < l; i++) {
+        obj[action].apply(obj, [names[i]].concat(rest));
+      }
+      return false;
+    }
+
+    return true;
+  };
+
+  // A difficult-to-believe, but optimized internal dispatch function for
+  // triggering events. Tries to keep the usual cases speedy (most internal
+  // Backbone events have 3 arguments).
+  var triggerEvents = function(events, args) {
+    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
+    switch (args.length) {
+      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
+      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
+      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
+      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
+      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
+    }
+  };
+
+  var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
+
+  // Inversion-of-control versions of `on` and `once`. Tell *this* object to
+  // listen to an event in another object ... keeping track of what it's
+  // listening to.
+  _.each(listenMethods, function(implementation, method) {
+    Events[method] = function(obj, name, callback) {
+      var listeners = this._listeners || (this._listeners = {});
+      var id = obj._listenerId || (obj._listenerId = _.uniqueId('l'));
+      listeners[id] = obj;
+      if (typeof name === 'object') callback = this;
+      obj[implementation](name, callback, this);
+      return this;
+    };
+  });
+
+  // Aliases for backwards compatibility.
+  Events.bind   = Events.on;
+  Events.unbind = Events.off;
+
+  // Allow the `Backbone` object to serve as a global event bus, for folks who
+  // want global "pubsub" in a convenient place.
+  _.extend(Backbone, Events);
+
+  // Backbone.Model
+  // --------------
+
+  // Backbone **Models** are the basic data object in the framework --
+  // frequently representing a row in a table in a database on your server.
+  // A discrete chunk of data and a bunch of useful, related methods for
+  // performing computations and transformations on that data.
+
+  // Create a new model with the specified attributes. A client id (`cid`)
+  // is automatically generated and assigned for you.
+  var Model = Backbone.Model = function(attributes, options) {
+    var defaults;
+    var attrs = attributes || {};
+    options || (options = {});
+    this.cid = _.uniqueId('c');
+    this.attributes = {};
+    _.extend(this, _.pick(options, modelOptions));
+    if (options.parse) attrs = this.parse(attrs, options) || {};
+    if (defaults = _.result(this, 'defaults')) {
+      attrs = _.defaults({}, attrs, defaults);
+    }
+    this.set(attrs, options);
+    this.changed = {};
+    this.initialize.apply(this, arguments);
+  };
+
+  // A list of options to be attached directly to the model, if provided.
+  var modelOptions = ['url', 'urlRoot', 'collection'];
+
+  // Attach all inheritable methods to the Model prototype.
+  _.extend(Model.prototype, Events, {
+
+    // A hash of attributes whose current and previous value differ.
+    changed: null,
+
+    // The value returned during the last failed validation.
+    validationError: null,
+
+    // The default name for the JSON `id` attribute is `"id"`. MongoDB and
+    // CouchDB users may want to set this to `"_id"`.
+    idAttribute: 'id',
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // Return a copy of the model's `attributes` object.
+    toJSON: function(options) {
+      return _.clone(this.attributes);
+    },
+
+    // Proxy `Backbone.sync` by default -- but override this if you need
+    // custom syncing semantics for *this* particular model.
+    sync: function() {
+      return Backbone.sync.apply(this, arguments);
+    },
+
+    // Get the value of an attribute.
+    get: function(attr) {
+      return this.attributes[attr];
+    },
+
+    // Get the HTML-escaped value of an attribute.
+    escape: function(attr) {
+      return _.escape(this.get(attr));
+    },
+
+    // Returns `true` if the attribute contains a value that is not null
+    // or undefined.
+    has: function(attr) {
+      return this.get(attr) != null;
+    },
+
+    // Set a hash of model attributes on the object, firing `"change"`. This is
+    // the core primitive operation of a model, updating the data and notifying
+    // anyone who needs to know about the change in state. The heart of the beast.
+    set: function(key, val, options) {
+      var attr, attrs, unset, changes, silent, changing, prev, current;
+      if (key == null) return this;
+
+      // Handle both `"key", value` and `{key: value}` -style arguments.
+      if (typeof key === 'object') {
+        attrs = key;
+        options = val;
+      } else {
+        (attrs = {})[key] = val;
+      }
+
+      options || (options = {});
+
+      // Run validation.
+      if (!this._validate(attrs, options)) return false;
+
+      // Extract attributes and options.
+      unset           = options.unset;
+      silent          = options.silent;
+      changes         = [];
+      changing        = this._changing;
+      this._changing  = true;
+
+      if (!changing) {
+        this._previousAttributes = _.clone(this.attributes);
+        this.changed = {};
+      }
+      current = this.attributes, prev = this._previousAttributes;
+
+      // Check for changes of `id`.
+      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
+
+      // For each `set` attribute, update or delete the current value.
+      for (attr in attrs) {
+        val = attrs[attr];
+        if (!_.isEqual(current[attr], val)) changes.push(attr);
+        if (!_.isEqual(prev[attr], val)) {
+          this.changed[attr] = val;
+        } else {
+          delete this.changed[attr];
+        }
+        unset ? delete current[attr] : current[attr] = val;
+      }
+
+      // Trigger all relevant attribute changes.
+      if (!silent) {
+        if (changes.length) this._pending = true;
+        for (var i = 0, l = changes.length; i < l; i++) {
+          this.trigger('change:' + changes[i], this, current[changes[i]], options);
+        }
+      }
+
+      // You might be wondering why there's a `while` loop here. Changes can
+      // be recursively nested within `"change"` events.
+      if (changing) return this;
+      if (!silent) {
+        while (this._pending) {
+          this._pending = false;
+          this.trigger('change', this, options);
+        }
+      }
+      this._pending = false;
+      this._changing = false;
+      return this;
+    },
+
+    // Remove an attribute from the model, firing `"change"`. `unset` is a noop
+    // if the attribute doesn't exist.
+    unset: function(attr, options) {
+      return this.set(attr, void 0, _.extend({}, options, {unset: true}));
+    },
+
+    // Clear all attributes on the model, firing `"change"`.
+    clear: function(options) {
+      var attrs = {};
+      for (var key in this.attributes) attrs[key] = void 0;
+      return this.set(attrs, _.extend({}, options, {unset: true}));
+    },
+
+    // Determine if the model has changed since the last `"change"` event.
+    // If you specify an attribute name, determine if that attribute has changed.
+    hasChanged: function(attr) {
+      if (attr == null) return !_.isEmpty(this.changed);
+      return _.has(this.changed, attr);
+    },
+
+    // Return an object containing all the attributes that have changed, or
+    // false if there are no changed attributes. Useful for determining what
+    // parts of a view need to be updated and/or what attributes need to be
+    // persisted to the server. Unset attributes will be set to undefined.
+    // You can also pass an attributes object to diff against the model,
+    // determining if there *would be* a change.
+    changedAttributes: function(diff) {
+      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
+      var val, changed = false;
+      var old = this._changing ? this._previousAttributes : this.attributes;
+      for (var attr in diff) {
+        if (_.isEqual(old[attr], (val = diff[attr]))) continue;
+        (changed || (changed = {}))[attr] = val;
+      }
+      return changed;
+    },
+
+    // Get the previous value of an attribute, recorded at the time the last
+    // `"change"` event was fired.
+    previous: function(attr) {
+      if (attr == null || !this._previousAttributes) return null;
+      return this._previousAttributes[attr];
+    },
+
+    // Get all of the attributes of the model at the time of the previous
+    // `"change"` event.
+    previousAttributes: function() {
+      return _.clone(this._previousAttributes);
+    },
+
+    // Fetch the model from the server. If the server's representation of the
+    // model differs from its current attributes, they will be overridden,
+    // triggering a `"change"` event.
+    fetch: function(options) {
+      options = options ? _.clone(options) : {};
+      if (options.parse === void 0) options.parse = true;
+      var model = this;
+      var success = options.success;
+      options.success = function(resp) {
+        if (!model.set(model.parse(resp, options), options)) return false;
+        if (success) success(model, resp, options);
+        model.trigger('sync', model, resp, options);
+      };
+      wrapError(this, options);
+      return this.sync('read', this, options);
+    },
+
+    // Set a hash of model attributes, and sync the model to the server.
+    // If the server returns an attributes hash that differs, the model's
+    // state will be `set` again.
+    save: function(key, val, options) {
+      var attrs, method, xhr, attributes = this.attributes;
+
+      // Handle both `"key", value` and `{key: value}` -style arguments.
+      if (key == null || typeof key === 'object') {
+        attrs = key;
+        options = val;
+      } else {
+        (attrs = {})[key] = val;
+      }
+
+      // If we're not waiting and attributes exist, save acts as `set(attr).save(null, opts)`.
+      if (attrs && (!options || !options.wait) && !this.set(attrs, options)) return false;
+
+      options = _.extend({validate: true}, options);
+
+      // Do not persist invalid models.
+      if (!this._validate(attrs, options)) return false;
+
+      // Set temporary attributes if `{wait: true}`.
+      if (attrs && options.wait) {
+        this.attributes = _.extend({}, attributes, attrs);
+      }
+
+      // After a successful server-side save, the client is (optionally)
+      // updated with the server-side state.
+      if (options.parse === void 0) options.parse = true;
+      var model = this;
+      var success = options.success;
+      options.success = function(resp) {
+        // Ensure attributes are restored during synchronous saves.
+        model.attributes = attributes;
+        var serverAttrs = model.parse(resp, options);
+        if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
+        if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
+          return false;
+        }
+        if (success) success(model, resp, options);
+        model.trigger('sync', model, resp, options);
+      };
+      wrapError(this, options);
+
+      method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
+      if (method === 'patch') options.attrs = attrs;
+      xhr = this.sync(method, this, options);
+
+      // Restore attributes.
+      if (attrs && options.wait) this.attributes = attributes;
+
+      return xhr;
+    },
+
+    // Destroy this model on the server if it was already persisted.
+    // Optimistically removes the model from its collection, if it has one.
+    // If `wait: true` is passed, waits for the server to respond before removal.
+    destroy: function(options) {
+      options = options ? _.clone(options) : {};
+      var model = this;
+      var success = options.success;
+
+      var destroy = function() {
+        model.trigger('destroy', model, model.collection, options);
+      };
+
+      options.success = function(resp) {
+        if (options.wait || model.isNew()) destroy();
+        if (success) success(model, resp, options);
+        if (!model.isNew()) model.trigger('sync', model, resp, options);
+      };
+
+      if (this.isNew()) {
+        options.success();
+        return false;
+      }
+      wrapError(this, options);
+
+      var xhr = this.sync('delete', this, options);
+      if (!options.wait) destroy();
+      return xhr;
+    },
+
+    // Default URL for the model's representation on the server -- if you're
+    // using Backbone's restful methods, override this to change the endpoint
+    // that will be called.
+    url: function() {
+      var base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || urlError();
+      if (this.isNew()) return base;
+      return base + (base.charAt(base.length - 1) === '/' ? '' : '/') + encodeURIComponent(this.id);
+    },
+
+    // **parse** converts a response into the hash of attributes to be `set` on
+    // the model. The default implementation is just to pass the response along.
+    parse: function(resp, options) {
+      return resp;
+    },
+
+    // Create a new model with identical attributes to this one.
+    clone: function() {
+      return new this.constructor(this.attributes);
+    },
+
+    // A model is new if it has never been saved to the server, and lacks an id.
+    isNew: function() {
+      return this.id == null;
+    },
+
+    // Check if the model is currently in a valid state.
+    isValid: function(options) {
+      return this._validate({}, _.extend(options || {}, { validate: true }));
+    },
+
+    // Run validation against the next complete set of model attributes,
+    // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
+    _validate: function(attrs, options) {
+      if (!options.validate || !this.validate) return true;
+      attrs = _.extend({}, this.attributes, attrs);
+      var error = this.validationError = this.validate(attrs, options) || null;
+      if (!error) return true;
+      this.trigger('invalid', this, error, _.extend(options || {}, {validationError: error}));
+      return false;
+    }
+
+  });
+
+  // Underscore methods that we want to implement on the Model.
+  var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];
+
+  // Mix in each Underscore method as a proxy to `Model#attributes`.
+  _.each(modelMethods, function(method) {
+    Model.prototype[method] = function() {
+      var args = slice.call(arguments);
+      args.unshift(this.attributes);
+      return _[method].apply(_, args);
+    };
+  });
+
+  // Backbone.Collection
+  // -------------------
+
+  // If models tend to represent a single row of data, a Backbone Collection is
+  // more analagous to a table full of data ... or a small slice or page of that
+  // table, or a collection of rows that belong together for a particular reason
+  // -- all of the messages in this particular folder, all of the documents
+  // belonging to this particular author, and so on. Collections maintain
+  // indexes of their models, both in order, and for lookup by `id`.
+
+  // Create a new **Collection**, perhaps to contain a specific type of `model`.
+  // If a `comparator` is specified, the Collection will maintain
+  // its models in sort order, as they're added and removed.
+  var Collection = Backbone.Collection = function(models, options) {
+    options || (options = {});
+    if (options.url) this.url = options.url;
+    if (options.model) this.model = options.model;
+    if (options.comparator !== void 0) this.comparator = options.comparator;
+    this._reset();
+    this.initialize.apply(this, arguments);
+    if (models) this.reset(models, _.extend({silent: true}, options));
+  };
+
+  // Default options for `Collection#set`.
+  var setOptions = {add: true, remove: true, merge: true};
+  var addOptions = {add: true, merge: false, remove: false};
+
+  // Define the Collection's inheritable methods.
+  _.extend(Collection.prototype, Events, {
+
+    // The default model for a collection is just a **Backbone.Model**.
+    // This should be overridden in most cases.
+    model: Model,
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // The JSON representation of a Collection is an array of the
+    // models' attributes.
+    toJSON: function(options) {
+      return this.map(function(model){ return model.toJSON(options); });
+    },
+
+    // Proxy `Backbone.sync` by default.
+    sync: function() {
+      return Backbone.sync.apply(this, arguments);
+    },
+
+    // Add a model, or list of models to the set.
+    add: function(models, options) {
+      return this.set(models, _.defaults(options || {}, addOptions));
+    },
+
+    // Remove a model, or a list of models from the set.
+    remove: function(models, options) {
+      models = _.isArray(models) ? models.slice() : [models];
+      options || (options = {});
+      var i, l, index, model;
+      for (i = 0, l = models.length; i < l; i++) {
+        model = this.get(models[i]);
+        if (!model) continue;
+        delete this._byId[model.id];
+        delete this._byId[model.cid];
+        index = this.indexOf(model);
+        this.models.splice(index, 1);
+        this.length--;
+        if (!options.silent) {
+          options.index = index;
+          model.trigger('remove', model, this, options);
+        }
+        this._removeReference(model);
+      }
+      return this;
+    },
+
+    // Update a collection by `set`-ing a new list of models, adding new ones,
+    // removing models that are no longer present, and merging models that
+    // already exist in the collection, as necessary. Similar to **Model#set**,
+    // the core operation for updating the data contained by the collection.
+    set: function(models, options) {
+      options = _.defaults(options || {}, setOptions);
+      if (options.parse) models = this.parse(models, options);
+      if (!_.isArray(models)) models = models ? [models] : [];
+      var i, l, model, attrs, existing, sort;
+      var at = options.at;
+      var sortable = this.comparator && (at == null) && options.sort !== false;
+      var sortAttr = _.isString(this.comparator) ? this.comparator : null;
+      var toAdd = [], toRemove = [], modelMap = {};
+
+      // Turn bare objects into model references, and prevent invalid models
+      // from being added.
+      for (i = 0, l = models.length; i < l; i++) {
+        if (!(model = this._prepareModel(models[i], options))) continue;
+
+        // If a duplicate is found, prevent it from being added and
+        // optionally merge it into the existing model.
+        if (existing = this.get(model)) {
+          if (options.remove) modelMap[existing.cid] = true;
+          if (options.merge) {
+            existing.set(model.attributes, options);
+            if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;
+          }
+
+        // This is a new model, push it to the `toAdd` list.
+        } else if (options.add) {
+          toAdd.push(model);
+
+          // Listen to added models' events, and index models for lookup by
+          // `id` and by `cid`.
+          model.on('all', this._onModelEvent, this);
+          this._byId[model.cid] = model;
+          if (model.id != null) this._byId[model.id] = model;
+        }
+      }
+
+      // Remove nonexistent models if appropriate.
+      if (options.remove) {
+        for (i = 0, l = this.length; i < l; ++i) {
+          if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
+        }
+        if (toRemove.length) this.remove(toRemove, options);
+      }
+
+      // See if sorting is needed, update `length` and splice in new models.
+      if (toAdd.length) {
+        if (sortable) sort = true;
+        this.length += toAdd.length;
+        if (at != null) {
+          splice.apply(this.models, [at, 0].concat(toAdd));
+        } else {
+          push.apply(this.models, toAdd);
+        }
+      }
+
+      // Silently sort the collection if appropriate.
+      if (sort) this.sort({silent: true});
+
+      if (options.silent) return this;
+
+      // Trigger `add` events.
+      for (i = 0, l = toAdd.length; i < l; i++) {
+        (model = toAdd[i]).trigger('add', model, this, options);
+      }
+
+      // Trigger `sort` if the collection was sorted.
+      if (sort) this.trigger('sort', this, options);
+      return this;
+    },
+
+    // When you have more items than you want to add or remove individually,
+    // you can reset the entire set with a new list of models, without firing
+    // any granular `add` or `remove` events. Fires `reset` when finished.
+    // Useful for bulk operations and optimizations.
+    reset: function(models, options) {
+      options || (options = {});
+      for (var i = 0, l = this.models.length; i < l; i++) {
+        this._removeReference(this.models[i]);
+      }
+      options.previousModels = this.models;
+      this._reset();
+      this.add(models, _.extend({silent: true}, options));
+      if (!options.silent) this.trigger('reset', this, options);
+      return this;
+    },
+
+    // Add a model to the end of the collection.
+    push: function(model, options) {
+      model = this._prepareModel(model, options);
+      this.add(model, _.extend({at: this.length}, options));
+      return model;
+    },
+
+    // Remove a model from the end of the collection.
+    pop: function(options) {
+      var model = this.at(this.length - 1);
+      this.remove(model, options);
+      return model;
+    },
+
+    // Add a model to the beginning of the collection.
+    unshift: function(model, options) {
+      model = this._prepareModel(model, options);
+      this.add(model, _.extend({at: 0}, options));
+      return model;
+    },
+
+    // Remove a model from the beginning of the collection.
+    shift: function(options) {
+      var model = this.at(0);
+      this.remove(model, options);
+      return model;
+    },
+
+    // Slice out a sub-array of models from the collection.
+    slice: function(begin, end) {
+      return this.models.slice(begin, end);
+    },
+
+    // Get a model from the set by id.
+    get: function(obj) {
+      if (obj == null) return void 0;
+      return this._byId[obj.id != null ? obj.id : obj.cid || obj];
+    },
+
+    // Get the model at the given index.
+    at: function(index) {
+      return this.models[index];
+    },
+
+    // Return models with matching attributes. Useful for simple cases of
+    // `filter`.
+    where: function(attrs, first) {
+      if (_.isEmpty(attrs)) return first ? void 0 : [];
+      return this[first ? 'find' : 'filter'](function(model) {
+        for (var key in attrs) {
+          if (attrs[key] !== model.get(key)) return false;
+        }
+        return true;
+      });
+    },
+
+    // Return the first model with matching attributes. Useful for simple cases
+    // of `find`.
+    findWhere: function(attrs) {
+      return this.where(attrs, true);
+    },
+
+    // Force the collection to re-sort itself. You don't need to call this under
+    // normal circumstances, as the set will maintain sort order as each item
+    // is added.
+    sort: function(options) {
+      if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
+      options || (options = {});
+
+      // Run sort based on type of `comparator`.
+      if (_.isString(this.comparator) || this.comparator.length === 1) {
+        this.models = this.sortBy(this.comparator, this);
+      } else {
+        this.models.sort(_.bind(this.comparator, this));
+      }
+
+      if (!options.silent) this.trigger('sort', this, options);
+      return this;
+    },
+
+    // Figure out the smallest index at which a model should be inserted so as
+    // to maintain order.
+    sortedIndex: function(model, value, context) {
+      value || (value = this.comparator);
+      var iterator = _.isFunction(value) ? value : function(model) {
+        return model.get(value);
+      };
+      return _.sortedIndex(this.models, model, iterator, context);
+    },
+
+    // Pluck an attribute from each model in the collection.
+    pluck: function(attr) {
+      return _.invoke(this.models, 'get', attr);
+    },
+
+    // Fetch the default set of models for this collection, resetting the
+    // collection when they arrive. If `reset: true` is passed, the response
+    // data will be passed through the `reset` method instead of `set`.
+    fetch: function(options) {
+      options = options ? _.clone(options) : {};
+      if (options.parse === void 0) options.parse = true;
+      var success = options.success;
+      var collection = this;
+      options.success = function(resp) {
+        var method = options.reset ? 'reset' : 'set';
+        collection[method](resp, options);
+        if (success) success(collection, resp, options);
+        collection.trigger('sync', collection, resp, options);
+      };
+      wrapError(this, options);
+      return this.sync('read', this, options);
+    },
+
+    // Create a new instance of a model in this collection. Add the model to the
+    // collection immediately, unless `wait: true` is passed, in which case we
+    // wait for the server to agree.
+    create: function(model, options) {
+      options = options ? _.clone(options) : {};
+      if (!(model = this._prepareModel(model, options))) return false;
+      if (!options.wait) this.add(model, options);
+      var collection = this;
+      var success = options.success;
+      options.success = function(resp) {
+        if (options.wait) collection.add(model, options);
+        if (success) success(model, resp, options);
+      };
+      model.save(null, options);
+      return model;
+    },
+
+    // **parse** converts a response into a list of models to be added to the
+    // collection. The default implementation is just to pass it through.
+    parse: function(resp, options) {
+      return resp;
+    },
+
+    // Create a new collection with an identical list of models as this one.
+    clone: function() {
+      return new this.constructor(this.models);
+    },
+
+    // Private method to reset all internal state. Called when the collection
+    // is first initialized or reset.
+    _reset: function() {
+      this.length = 0;
+      this.models = [];
+      this._byId  = {};
+    },
+
+    // Prepare a hash of attributes (or other model) to be added to this
+    // collection.
+    _prepareModel: function(attrs, options) {
+      if (attrs instanceof Model) {
+        if (!attrs.collection) attrs.collection = this;
+        return attrs;
+      }
+      options || (options = {});
+      options.collection = this;
+      var model = new this.model(attrs, options);
+      if (!model._validate(attrs, options)) {
+        this.trigger('invalid', this, attrs, options);
+        return false;
+      }
+      return model;
+    },
+
+    // Internal method to sever a model's ties to a collection.
+    _removeReference: function(model) {
+      if (this === model.collection) delete model.collection;
+      model.off('all', this._onModelEvent, this);
+    },
+
+    // Internal method called every time a model in the set fires an event.
+    // Sets need to update their indexes when models change ids. All other
+    // events simply proxy through. "add" and "remove" events that originate
+    // in other collections are ignored.
+    _onModelEvent: function(event, model, collection, options) {
+      if ((event === 'add' || event === 'remove') && collection !== this) return;
+      if (event === 'destroy') this.remove(model, options);
+      if (model && event === 'change:' + model.idAttribute) {
+        delete this._byId[model.previous(model.idAttribute)];
+        if (model.id != null) this._byId[model.id] = model;
+      }
+      this.trigger.apply(this, arguments);
+    }
+
+  });
+
+  // Underscore methods that we want to implement on the Collection.
+  // 90% of the core usefulness of Backbone Collections is actually implemented
+  // right here:
+  var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
+    'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
+    'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
+    'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
+    'tail', 'drop', 'last', 'without', 'indexOf', 'shuffle', 'lastIndexOf',
+    'isEmpty', 'chain'];
+
+  // Mix in each Underscore method as a proxy to `Collection#models`.
+  _.each(methods, function(method) {
+    Collection.prototype[method] = function() {
+      var args = slice.call(arguments);
+      args.unshift(this.models);
+      return _[method].apply(_, args);
+    };
+  });
+
+  // Underscore methods that take a property name as an argument.
+  var attributeMethods = ['groupBy', 'countBy', 'sortBy'];
+
+  // Use attributes instead of properties.
+  _.each(attributeMethods, function(method) {
+    Collection.prototype[method] = function(value, context) {
+      var iterator = _.isFunction(value) ? value : function(model) {
+        return model.get(value);
+      };
+      return _[method](this.models, iterator, context);
+    };
+  });
+
+  // Backbone.View
+  // -------------
+
+  // Backbone Views are almost more convention than they are actual code. A View
+  // is simply a JavaScript object that represents a logical chunk of UI in the
+  // DOM. This might be a single item, an entire list, a sidebar or panel, or
+  // even the surrounding frame which wraps your whole app. Defining a chunk of
+  // UI as a **View** allows you to define your DOM events declaratively, without
+  // having to worry about render order ... and makes it easy for the view to
+  // react to specific changes in the state of your models.
+
+  // Creating a Backbone.View creates its initial element outside of the DOM,
+  // if an existing element is not provided...
+  var View = Backbone.View = function(options) {
+    this.cid = _.uniqueId('view');
+    this._configure(options || {});
+    this._ensureElement();
+    this.initialize.apply(this, arguments);
+    this.delegateEvents();
+  };
+
+  // Cached regex to split keys for `delegate`.
+  var delegateEventSplitter = /^(\S+)\s*(.*)$/;
+
+  // List of view options to be merged as properties.
+  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
+
+  // Set up all inheritable **Backbone.View** properties and methods.
+  _.extend(View.prototype, Events, {
+
+    // The default `tagName` of a View's element is `"div"`.
+    tagName: 'div',
+
+    // jQuery delegate for element lookup, scoped to DOM elements within the
+    // current view. This should be prefered to global lookups where possible.
+    $: function(selector) {
+      return this.$el.find(selector);
+    },
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // **render** is the core function that your view should override, in order
+    // to populate its element (`this.el`), with the appropriate HTML. The
+    // convention is for **render** to always return `this`.
+    render: function() {
+      return this;
+    },
+
+    // Remove this view by taking the element out of the DOM, and removing any
+    // applicable Backbone.Events listeners.
+    remove: function() {
+      this.$el.remove();
+      this.stopListening();
+      return this;
+    },
+
+    // Change the view's element (`this.el` property), including event
+    // re-delegation.
+    setElement: function(element, delegate) {
+      if (this.$el) this.undelegateEvents();
+      this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
+      this.el = this.$el[0];
+      if (delegate !== false) this.delegateEvents();
+      return this;
+    },
+
+    // Set callbacks, where `this.events` is a hash of
+    //
+    // *{"event selector": "callback"}*
+    //
+    //     {
+    //       'mousedown .title':  'edit',
+    //       'click .button':     'save'
+    //       'click .open':       function(e) { ... }
+    //     }
+    //
+    // pairs. Callbacks will be bound to the view, with `this` set properly.
+    // Uses event delegation for efficiency.
+    // Omitting the selector binds the event to `this.el`.
+    // This only works for delegate-able events: not `focus`, `blur`, and
+    // not `change`, `submit`, and `reset` in Internet Explorer.
+    delegateEvents: function(events) {
+      if (!(events || (events = _.result(this, 'events')))) return this;
+      this.undelegateEvents();
+      for (var key in events) {
+        var method = events[key];
+        if (!_.isFunction(method)) method = this[events[key]];
+        if (!method) continue;
+
+        var match = key.match(delegateEventSplitter);
+        var eventName = match[1], selector = match[2];
+        method = _.bind(method, this);
+        eventName += '.delegateEvents' + this.cid;
+        if (selector === '') {
+          this.$el.on(eventName, method);
+        } else {
+          this.$el.on(eventName, selector, method);
+        }
+      }
+      return this;
+    },
+
+    // Clears all callbacks previously bound to the view with `delegateEvents`.
+    // You usually don't need to use this, but may wish to if you have multiple
+    // Backbone views attached to the same DOM element.
+    undelegateEvents: function() {
+      this.$el.off('.delegateEvents' + this.cid);
+      return this;
+    },
+
+    // Performs the initial configuration of a View with a set of options.
+    // Keys with special meaning *(e.g. model, collection, id, className)* are
+    // attached directly to the view.  See `viewOptions` for an exhaustive
+    // list.
+    _configure: function(options) {
+      if (this.options) options = _.extend({}, _.result(this, 'options'), options);
+      _.extend(this, _.pick(options, viewOptions));
+      this.options = options;
+    },
+
+    // Ensure that the View has a DOM element to render into.
+    // If `this.el` is a string, pass it through `$()`, take the first
+    // matching element, and re-assign it to `el`. Otherwise, create
+    // an element from the `id`, `className` and `tagName` properties.
+    _ensureElement: function() {
+      if (!this.el) {
+        var attrs = _.extend({}, _.result(this, 'attributes'));
+        if (this.id) attrs.id = _.result(this, 'id');
+        if (this.className) attrs['class'] = _.result(this, 'className');
+        var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
+        this.setElement($el, false);
+      } else {
+        this.setElement(_.result(this, 'el'), false);
+      }
+    }
+
+  });
+
+  // Backbone.sync
+  // -------------
+
+  // Override this function to change the manner in which Backbone persists
+  // models to the server. You will be passed the type of request, and the
+  // model in question. By default, makes a RESTful Ajax request
+  // to the model's `url()`. Some possible customizations could be:
+  //
+  // * Use `setTimeout` to batch rapid-fire updates into a single request.
+  // * Send up the models as XML instead of JSON.
+  // * Persist models via WebSockets instead of Ajax.
+  //
+  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
+  // as `POST`, with a `_method` parameter containing the true HTTP method,
+  // as well as all requests with the body as `application/x-www-form-urlencoded`
+  // instead of `application/json` with the model in a param named `model`.
+  // Useful when interfacing with server-side languages like **PHP** that make
+  // it difficult to read the body of `PUT` requests.
+  Backbone.sync = function(method, model, options) {
+    var type = methodMap[method];
+
+    // Default options, unless specified.
+    _.defaults(options || (options = {}), {
+      emulateHTTP: Backbone.emulateHTTP,
+      emulateJSON: Backbone.emulateJSON
+    });
+
+    // Default JSON-request options.
+    var params = {type: type, dataType: 'json'};
+
+    // Ensure that we have a URL.
+    if (!options.url) {
+      params.url = _.result(model, 'url') || urlError();
+    }
+
+    // Ensure that we have the appropriate request data.
+    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
+      params.contentType = 'application/json';
+      params.data = JSON.stringify(options.attrs || model.toJSON(options));
+    }
+
+    // For older servers, emulate JSON by encoding the request into an HTML-form.
+    if (options.emulateJSON) {
+      params.contentType = 'application/x-www-form-urlencoded';
+      params.data = params.data ? {model: params.data} : {};
+    }
+
+    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
+    // And an `X-HTTP-Method-Override` header.
+    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {
+      params.type = 'POST';
+      if (options.emulateJSON) params.data._method = type;
+      var beforeSend = options.beforeSend;
+      options.beforeSend = function(xhr) {
+        xhr.setRequestHeader('X-HTTP-Method-Override', type);
+        if (beforeSend) return beforeSend.apply(this, arguments);
+      };
+    }
+
+    // Don't process data on a non-GET request.
+    if (params.type !== 'GET' && !options.emulateJSON) {
+      params.processData = false;
+    }
+
+    // If we're sending a `PATCH` request, and we're in an old Internet Explorer
+    // that still has ActiveX enabled by default, override jQuery to use that
+    // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
+    if (params.type === 'PATCH' && window.ActiveXObject &&
+          !(window.external && window.external.msActiveXFilteringEnabled)) {
+      params.xhr = function() {
+        return new ActiveXObject("Microsoft.XMLHTTP");
+      };
+    }
+
+    // Make the request, allowing the user to override any Ajax options.
+    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
+    model.trigger('request', model, xhr, options);
+    return xhr;
+  };
+
+  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
+  var methodMap = {
+    'create': 'POST',
+    'update': 'PUT',
+    'patch':  'PATCH',
+    'delete': 'DELETE',
+    'read':   'GET'
+  };
+
+  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
+  // Override this if you'd like to use a different library.
+  Backbone.ajax = function() {
+    return Backbone.$.ajax.apply(Backbone.$, arguments);
+  };
+
+  // Backbone.Router
+  // ---------------
+
+  // Routers map faux-URLs to actions, and fire events when routes are
+  // matched. Creating a new one sets its `routes` hash, if not set statically.
+  var Router = Backbone.Router = function(options) {
+    options || (options = {});
+    if (options.routes) this.routes = options.routes;
+    this._bindRoutes();
+    this.initialize.apply(this, arguments);
+  };
+
+  // Cached regular expressions for matching named param parts and splatted
+  // parts of route strings.
+  var optionalParam = /\((.*?)\)/g;
+  var namedParam    = /(\(\?)?:\w+/g;
+  var splatParam    = /\*\w+/g;
+  var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
+
+  // Set up all inheritable **Backbone.Router** properties and methods.
+  _.extend(Router.prototype, Events, {
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // Manually bind a single named route to a callback. For example:
+    //
+    //     this.route('search/:query/p:num', 'search', function(query, num) {
+    //       ...
+    //     });
+    //
+    route: function(route, name, callback) {
+      if (!_.isRegExp(route)) route = this._routeToRegExp(route);
+      if (_.isFunction(name)) {
+        callback = name;
+        name = '';
+      }
+      if (!callback) callback = this[name];
+      var router = this;
+      Backbone.history.route(route, function(fragment) {
+        var args = router._extractParameters(route, fragment);
+        callback && callback.apply(router, args);
+        router.trigger.apply(router, ['route:' + name].concat(args));
+        router.trigger('route', name, args);
+        Backbone.history.trigger('route', router, name, args);
+      });
+      return this;
+    },
+
+    // Simple proxy to `Backbone.history` to save a fragment into the history.
+    navigate: function(fragment, options) {
+      Backbone.history.navigate(fragment, options);
+      return this;
+    },
+
+    // Bind all defined routes to `Backbone.history`. We have to reverse the
+    // order of the routes here to support behavior where the most general
+    // routes can be defined at the bottom of the route map.
+    _bindRoutes: function() {
+      if (!this.routes) return;
+      this.routes = _.result(this, 'routes');
+      var route, routes = _.keys(this.routes);
+      while ((route = routes.pop()) != null) {
+        this.route(route, this.routes[route]);
+      }
+    },
+
+    // Convert a route string into a regular expression, suitable for matching
+    // against the current location hash.
+    _routeToRegExp: function(route) {
+      route = route.replace(escapeRegExp, '\\$&')
+                   .replace(optionalParam, '(?:$1)?')
+                   .replace(namedParam, function(match, optional){
+                     return optional ? match : '([^\/]+)';
+                   })
+                   .replace(splatParam, '(.*?)');
+      return new RegExp('^' + route + '$');
+    },
+
+    // Given a route, and a URL fragment that it matches, return the array of
+    // extracted decoded parameters. Empty or unmatched parameters will be
+    // treated as `null` to normalize cross-browser behavior.
+    _extractParameters: function(route, fragment) {
+      var params = route.exec(fragment).slice(1);
+      return _.map(params, function(param) {
+        return param ? decodeURIComponent(param) : null;
+      });
+    }
+
+  });
+
+  // Backbone.History
+  // ----------------
+
+  // Handles cross-browser history management, based on either
+  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
+  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
+  // and URL fragments. If the browser supports neither (old IE, natch),
+  // falls back to polling.
+  var History = Backbone.History = function() {
+    this.handlers = [];
+    _.bindAll(this, 'checkUrl');
+
+    // Ensure that `History` can be used outside of the browser.
+    if (typeof window !== 'undefined') {
+      this.location = window.location;
+      this.history = window.history;
+    }
+  };
+
+  // Cached regex for stripping a leading hash/slash and trailing space.
+  var routeStripper = /^[#\/]|\s+$/g;
+
+  // Cached regex for stripping leading and trailing slashes.
+  var rootStripper = /^\/+|\/+$/g;
+
+  // Cached regex for detecting MSIE.
+  var isExplorer = /msie [\w.]+/;
+
+  // Cached regex for removing a trailing slash.
+  var trailingSlash = /\/$/;
+
+  // Has the history handling already been started?
+  History.started = false;
+
+  // Set up all inheritable **Backbone.History** properties and methods.
+  _.extend(History.prototype, Events, {
+
+    // The default interval to poll for hash changes, if necessary, is
+    // twenty times a second.
+    interval: 50,
+
+    // Gets the true hash value. Cannot use location.hash directly due to bug
+    // in Firefox where location.hash will always be decoded.
+    getHash: function(window) {
+      var match = (window || this).location.href.match(/#(.*)$/);
+      return match ? match[1] : '';
+    },
+
+    // Get the cross-browser normalized URL fragment, either from the URL,
+    // the hash, or the override.
+    getFragment: function(fragment, forcePushState) {
+      if (fragment == null) {
+        if (this._hasPushState || !this._wantsHashChange || forcePushState) {
+          fragment = this.location.pathname;
+          var root = this.root.replace(trailingSlash, '');
+          if (!fragment.indexOf(root)) fragment = fragment.substr(root.length);
+        } else {
+          fragment = this.getHash();
+        }
+      }
+      return fragment.replace(routeStripper, '');
+    },
+
+    // Start the hash change handling, returning `true` if the current URL matches
+    // an existing route, and `false` otherwise.
+    start: function(options) {
+      if (History.started) throw new Error("Backbone.history has already been started");
+      History.started = true;
+
+      // Figure out the initial configuration. Do we need an iframe?
+      // Is pushState desired ... is it available?
+      this.options          = _.extend({}, {root: '/'}, this.options, options);
+      this.root             = this.options.root;
+      this._wantsHashChange = this.options.hashChange !== false;
+      this._wantsPushState  = !!this.options.pushState;
+      this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);
+      var fragment          = this.getFragment();
+      var docMode           = document.documentMode;
+      var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
+
+      // Normalize root to always include a leading and trailing slash.
+      this.root = ('/' + this.root + '/').replace(rootStripper, '/');
+
+      if (oldIE && this._wantsHashChange) {
+        this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
+        this.navigate(fragment);
+      }
+
+      // Depending on whether we're using pushState or hashes, and whether
+      // 'onhashchange' is supported, determine how we check the URL state.
+      if (this._hasPushState) {
+        Backbone.$(window).on('popstate', this.checkUrl);
+      } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
+        Backbone.$(window).on('hashchange', this.checkUrl);
+      } else if (this._wantsHashChange) {
+        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
+      }
+
+      // Determine if we need to change the base url, for a pushState link
+      // opened by a non-pushState browser.
+      this.fragment = fragment;
+      var loc = this.location;
+      var atRoot = loc.pathname.replace(/[^\/]$/, '$&/') === this.root;
+
+      // If we've started off with a route from a `pushState`-enabled browser,
+      // but we're currently in a browser that doesn't support it...
+      if (this._wantsHashChange && this._wantsPushState && !this._hasPushState && !atRoot) {
+        this.fragment = this.getFragment(null, true);
+        this.location.replace(this.root + this.location.search + '#' + this.fragment);
+        // Return immediately as browser will do redirect to new url
+        return true;
+
+      // Or if we've started out with a hash-based route, but we're currently
+      // in a browser where it could be `pushState`-based instead...
+      } else if (this._wantsPushState && this._hasPushState && atRoot && loc.hash) {
+        this.fragment = this.getHash().replace(routeStripper, '');
+        this.history.replaceState({}, document.title, this.root + this.fragment + loc.search);
+      }
+
+      if (!this.options.silent) return this.loadUrl();
+    },
+
+    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
+    // but possibly useful for unit testing Routers.
+    stop: function() {
+      Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
+      clearInterval(this._checkUrlInterval);
+      History.started = false;
+    },
+
+    // Add a route to be tested when the fragment changes. Routes added later
+    // may override previous routes.
+    route: function(route, callback) {
+      this.handlers.unshift({route: route, callback: callback});
+    },
+
+    // Checks the current URL to see if it has changed, and if it has,
+    // calls `loadUrl`, normalizing across the hidden iframe.
+    checkUrl: function(e) {
+      var current = this.getFragment();
+      if (current === this.fragment && this.iframe) {
+        current = this.getFragment(this.getHash(this.iframe));
+      }
+      if (current === this.fragment) return false;
+      if (this.iframe) this.navigate(current);
+      this.loadUrl() || this.loadUrl(this.getHash());
+    },
+
+    // Attempt to load the current URL fragment. If a route succeeds with a
+    // match, returns `true`. If no defined routes matches the fragment,
+    // returns `false`.
+    loadUrl: function(fragmentOverride) {
+      var fragment = this.fragment = this.getFragment(fragmentOverride);
+      var matched = _.any(this.handlers, function(handler) {
+        if (handler.route.test(fragment)) {
+          handler.callback(fragment);
+          return true;
+        }
+      });
+      return matched;
+    },
+
+    // Save a fragment into the hash history, or replace the URL state if the
+    // 'replace' option is passed. You are responsible for properly URL-encoding
+    // the fragment in advance.
+    //
+    // The options object can contain `trigger: true` if you wish to have the
+    // route callback be fired (not usually desirable), or `replace: true`, if
+    // you wish to modify the current URL without adding an entry to the history.
+    navigate: function(fragment, options) {
+      if (!History.started) return false;
+      if (!options || options === true) options = {trigger: options};
+      fragment = this.getFragment(fragment || '');
+      if (this.fragment === fragment) return;
+      this.fragment = fragment;
+      var url = this.root + fragment;
+
+      // If pushState is available, we use it to set the fragment as a real URL.
+      if (this._hasPushState) {
+        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
+
+      // If hash changes haven't been explicitly disabled, update the hash
+      // fragment to store history.
+      } else if (this._wantsHashChange) {
+        this._updateHash(this.location, fragment, options.replace);
+        if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
+          // Opening and closing the iframe tricks IE7 and earlier to push a
+          // history entry on hash-tag change.  When replace is true, we don't
+          // want this.
+          if(!options.replace) this.iframe.document.open().close();
+          this._updateHash(this.iframe.location, fragment, options.replace);
+        }
+
+      // If you've told us that you explicitly don't want fallback hashchange-
+      // based history, then `navigate` becomes a page refresh.
+      } else {
+        return this.location.assign(url);
+      }
+      if (options.trigger) this.loadUrl(fragment);
+    },
+
+    // Update the hash location, either replacing the current entry, or adding
+    // a new one to the browser history.
+    _updateHash: function(location, fragment, replace) {
+      if (replace) {
+        var href = location.href.replace(/(javascript:|#).*$/, '');
+        location.replace(href + '#' + fragment);
+      } else {
+        // Some browsers require that `hash` contains a leading #.
+        location.hash = '#' + fragment;
+      }
+    }
+
+  });
+
+  // Create the default Backbone.history.
+  Backbone.history = new History;
+
+  // Helpers
+  // -------
+
+  // Helper function to correctly set up the prototype chain, for subclasses.
+  // Similar to `goog.inherits`, but uses a hash of prototype properties and
+  // class properties to be extended.
+  var extend = function(protoProps, staticProps) {
+    var parent = this;
+    var child;
+
+    // The constructor function for the new subclass is either defined by you
+    // (the "constructor" property in your `extend` definition), or defaulted
+    // by us to simply call the parent's constructor.
+    if (protoProps && _.has(protoProps, 'constructor')) {
+      child = protoProps.constructor;
+    } else {
+      child = function(){ return parent.apply(this, arguments); };
+    }
+
+    // Add static properties to the constructor function, if supplied.
+    _.extend(child, parent, staticProps);
+
+    // Set the prototype chain to inherit from `parent`, without calling
+    // `parent`'s constructor function.
+    var Surrogate = function(){ this.constructor = child; };
+    Surrogate.prototype = parent.prototype;
+    child.prototype = new Surrogate;
+
+    // Add prototype properties (instance properties) to the subclass,
+    // if supplied.
+    if (protoProps) _.extend(child.prototype, protoProps);
+
+    // Set a convenience property in case the parent's prototype is needed
+    // later.
+    child.__super__ = parent.prototype;
+
+    return child;
+  };
+
+  // Set up inheritance for the model, collection, router, view and history.
+  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
+
+  // Throw an error when a URL is needed, and none is supplied.
+  var urlError = function() {
+    throw new Error('A "url" property or function must be specified');
+  };
+
+  // Wrap an optional error callback with a fallback error event.
+  var wrapError = function (model, options) {
+    var error = options.error;
+    options.error = function(resp) {
+      if (error) error(model, resp, options);
+      model.trigger('error', model, resp, options);
+    };
+  };
+
+}).call(this);

Libraries/backbone.localStorage.js

+/**
+ * Backbone localStorage Adapter
+ * Version 1.1.0
+ *
+ * https://github.com/jeromegn/Backbone.localStorage
+ */
+(function (root, factory) {
+   if (typeof define === "function" && define.amd) {
+      // AMD. Register as an anonymous module.
+      define(["underscore","backbone"], function(_, Backbone) {
+        // Use global variables if the locals is undefined.
+        return factory(_ || root._, Backbone || root.Backbone);
+      });
+   } else {
+      // RequireJS isn't being used. Assume underscore and backbone is loaded in <script> tags
+      factory(_, Backbone);
+   }
+}(this, function(_, Backbone) {
+// A simple module to replace `Backbone.sync` with *localStorage*-based
+// persistence. Models are given GUIDS, and saved into a JSON object. Simple
+// as that.
+
+// Hold reference to Underscore.js and Backbone.js in the closure in order
+// to make things work even if they are removed from the global namespace
+
+// Generate four random hex digits.
+function S4() {
+   return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
+};
+
+// Generate a pseudo-GUID by concatenating random hexadecimal.
+function guid() {
+   return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
+};
+
+// Our Store is represented by a single JS object in *localStorage*. Create it
+// with a meaningful name, like the name you'd give a table.
+// window.Store is deprectated, use Backbone.LocalStorage instead
+Backbone.LocalStorage = window.Store = function(name) {
+  this.name = name;
+  var store = this.localStorage().getItem(this.name);
+  this.records = (store && store.split(",")) || [];
+};
+
+_.extend(Backbone.LocalStorage.prototype, {
+
+  // Save the current state of the **Store** to *localStorage*.
+  save: function() {
+    this.localStorage().setItem(this.name, this.records.join(","));
+  },
+
+  // Add a model, giving it a (hopefully)-unique GUID, if it doesn't already
+  // have an id of it's own.
+  create: function(model) {
+    if (!model.id) {
+      model.id = guid();
+      model.set(model.idAttribute, model.id);
+    }
+    this.localStorage().setItem(this.name+"-"+model.id, JSON.stringify(model));
+    this.records.push(model.id.toString());
+    this.save();
+    return this.find(model);
+  },
+
+  // Update a model by replacing its copy in `this.data`.
+  update: function(model) {
+    this.localStorage().setItem(this.name+"-"+model.id, JSON.stringify(model));
+    if (!_.include(this.records, model.id.toString()))
+      this.records.push(model.id.toString()); this.save();
+    return this.find(model);
+  },
+
+  // Retrieve a model from `this.data` by id.
+  find: function(model) {
+    return this.jsonData(this.localStorage().getItem(this.name+"-"+model.id));
+  },
+
+  // Return the array of all models currently in storage.
+  findAll: function() {
+    return _(this.records).chain()
+      .map(function(id){
+        return this.jsonData(this.localStorage().getItem(this.name+"-"+id));
+      }, this)
+      .compact()
+      .value();
+  },
+
+  // Delete a model from `this.data`, returning it.
+  destroy: function(model) {
+    if (model.isNew())
+      return false
+    this.localStorage().removeItem(this.name+"-"+model.id);
+    this.records = _.reject(this.records, function(id){
+      return id === model.id.toString();
+    });
+    this.save();
+    return model;
+  },
+
+  localStorage: function() {
+    return localStorage;
+  },
+  
+  // fix for "illegal access" error on Android when JSON.parse is passed null
+  jsonData: function (data) {
+      return data && JSON.parse(data);
+  }
+
+});
+
+// localSync delegate to the model or collection's
+// *localStorage* property, which should be an instance of `Store`.
+// window.Store.sync and Backbone.localSync is deprectated, use Backbone.LocalStorage.sync instead
+Backbone.LocalStorage.sync = window.Store.sync = Backbone.localSync = function(method, model, options) {
+  var store = model.localStorage || model.collection.localStorage;
+
+  var resp, errorMessage, syncDfd = $.Deferred && $.Deferred(); //If $ is having Deferred - use it. 
+
+  try {
+
+    switch (method) {
+      case "read":
+        resp = model.id != undefined ? store.find(model) : store.findAll();
+        break;
+      case "create":
+        resp = store.create(model);
+        break;
+      case "update":
+        resp = store.update(model);
+        break;
+      case "delete":
+        resp = store.destroy(model);
+        break;
+    }
+
+  } catch(error) {
+    if (error.code === DOMException.QUOTA_EXCEEDED_ERR && window.localStorage.length === 0)
+      errorMessage = "Private browsing is unsupported";
+    else
+      errorMessage = error.message;
+  }
+
+  if (resp) {
+    if (options && options.success)
+      if (Backbone.VERSION === "0.9.10") {
+        options.success(model, resp, options);
+      } else {
+        options.success(resp);
+      }
+    if (syncDfd)
+      syncDfd.resolve(resp);
+
+  } else {
+    errorMessage = errorMessage ? errorMessage
+                                : "Record Not Found";
+    
+    if (options && options.error)
+      if (Backbone.VERSION === "0.9.10") {
+        options.error(model, errorMessage, options);
+      } else {
+        options.error(errorMessage);
+      }
+      
+    if (syncDfd)
+      syncDfd.reject(errorMessage);
+  }
+  
+  // add compatibility with $.ajax
+  // always execute callback for success and error
+  if (options && options.complete) options.complete(resp);
+
+  return syncDfd && syncDfd.promise();
+};
+
+Backbone.ajaxSync = Backbone.sync;
+
+Backbone.getSyncMethod = function(model) {
+  if(model.localStorage || (model.collection && model.collection.localStorage)) {
+    return Backbone.localSync;
+  }
+
+  return Backbone.ajaxSync;
+};
+
+// Override 'Backbone.sync' to default to localSync,
+// the original 'Backbone.sync' is still available in 'Backbone.ajaxSync'
+Backbone.sync = function(method, model, options) {
+  return Backbone.getSyncMethod(model).apply(this, [method, model, options]);
+};
+
+return Backbone.LocalStorage;
+}));

Libraries/jarnxmpp.core.handlers.js

+/*global $:false, document:false, window:false, portal_url:false,
+$msg:false, Strophe:false, setTimeout:false, navigator:false, jarn:false, google:false, jarnxmpp:false, jQuery:false, sessionStorage:false, $iq:false, $pres:false, Image:false, */
+
+(function (jarnxmpp, $, portal_url) {
+
+    portal_url = portal_url || '';
+
+    jarnxmpp.Storage = {
+        storage: null,
+        init: function () {
+            try {
+                if ('sessionStorage' in window && window.sessionStorage !== null && JSON in window && window.JSON !== null) {
+                    jarnxmpp.Storage.storage = sessionStorage;
+                    if (!('_user_info' in jarnxmpp.Storage.storage)) {
+                        jarnxmpp.Storage.set('_user_info', {});
+                    }
+                    if (!('_vCards' in jarnxmpp.Storage.storage)) {
+                        jarnxmpp.Storage.set('_vCards', {});
+                    }
+                    if (!('_subscriptions' in jarnxmpp.Storage.storage)) {
+                        jarnxmpp.Storage.set('_subscriptions', null);
+                    }
+                }
+            } catch (e) {}
+        },
+
+        get: function (key) {
+            if (key in sessionStorage) {
+                return JSON.parse(sessionStorage[key]);
+            }
+            return null;
+        },
+
+        set: function (key, value) {
+            sessionStorage[key] = JSON.stringify(value);
+        },
+
+        xmppGet: function (key, callback) {
+            var stanza = $iq({type: 'get'})
+                .c('query', {xmlns: 'jabber:iq:private'})
+                .c('jarnxmpp', {xmlns: 'http://jarn.com/ns/jarnxmpp:prefs:' + key})
+                .tree();
+            jarnxmpp.connection.sendIQ(stanza, function success(result) {
+                callback($('jarnxmpp ' + 'value', result).first().text());
+            });
+        },
+
+        xmppSet: function (key, value) {
+            var stanza = $iq({type: 'set'})
+                .c('query', {xmlns: 'jabber:iq:private'})
+                .c('jarnxmpp', {xmlns: 'http://jarn.com/ns/jarnxmpp:prefs:' + key})
+                .c('value', value)
+                .tree();
+            jarnxmpp.connection.sendIQ(stanza);
+        }
+    };
+
+    jarnxmpp.Storage.init();
+
+    jarnxmpp.Presence = {
+        online: {},
+        _user_info: {},
+
+        onlineCount: function () {
+            var me = Strophe.getNodeFromJid(jarnxmpp.connection.jid),
+                counter = 0,
+                user;
+            for (user in jarnxmpp.Presence.online) {
+                if ((jarnxmpp.Presence.online.hasOwnProperty(user)) && user !== me) {
+                    counter += 1;
+                }
+            }
+            return counter;
+        },
+
+        getUserInfo: function (user_id, callback) {
+            // User info on browsers without storage
+            if (jarnxmpp.Storage.storage === null) {
+                if (user_id in jarnxmpp.Presence._user_info) {
+                    callback(jarnxmpp.Presence._user_info[user_id]);
+                } else {
+                    $.getJSON(portal_url + "/xmpp-userinfo?user_id=" + user_id, function (data) {
+                        jarnxmpp.Presence._user_info[user_id] = data;
+                        callback(data);
+                    });
+                }
+            } else {
+                var _user_info = jarnxmpp.Storage.get('_user_info');
+                if (user_id in _user_info) {
+                    callback(_user_info[user_id]);
+                } else {
+                    $.getJSON(portal_url + "/xmpp-userinfo?user_id=" + user_id, function (data) {
+                        _user_info[user_id] = data;
+                        jarnxmpp.Storage.set('_user_info', _user_info);
+                        callback(data);
+                    });
+                }
+            }
+        }
+    };
+
+    jarnxmpp.vCard = {
+
+        _vCards: {},
+
+        _getVCard: function (jid, callback) {
+            var stanza =
+                $iq({type: 'get', to: jid})
+                .c('vCard', {xmlns: 'vcard-temp'}).tree();
+            jarnxmpp.connection.sendIQ(stanza, function (data) {
+                var result = {};
+                $('vCard[xmlns="vcard-temp"]', data).children().each(function (idx, element) {
+                    result[element.nodeName] = element.textContent;
+                });
+                if (typeof (callback) !== 'undefined') {
+                    callback(result);
+                }
+            });
+        },
+
+        getVCard: function (jid, callback) {
+            jid = Strophe.getBareJidFromJid(jid);
+            if (jarnxmpp.Storage.storage === null) {
+                if (jid in jarnxmpp.vCard._vCards) {
+                    callback(jarnxmpp.vCard._vCards[jid]);
+                } else {
+                    jarnxmpp.vCard._getVCard(jid, function (result) {
+                        jarnxmpp.vCard._vCards[jid] = result;
+                        callback(result);
+                    });
+                }
+            } else {
+                var _vCards = jarnxmpp.Storage.get('_vCards');
+                if (jid in _vCards) {
+                    callback(_vCards[jid]);
+                } else {
+                    jarnxmpp.vCard._getVCard(jid, function (result) {
+                        _vCards[jid] = result;
+                        jarnxmpp.Storage.set('_vCards', _vCards);
+                        callback(result);
+                    });
+                }
+            }
+        },
+
+        setVCard: function (params, photoUrl) {
+            var key,
+                vCard = Strophe.xmlElement('vCard', [['xmlns', 'vcard-temp'], ['version', '2.0']]);
+            for (key in params) {
+                if (params.hasOwnProperty(key)) {
+                    vCard.appendChild(Strophe.xmlElement(key, [], params[key]));
+                }
+            }
+            var send = function () {
+                var stanza = $iq({type: 'set'}).cnode(vCard).tree();
+                jarnxmpp.connection.sendIQ(stanza);
+            };
+            if (typeof (photoUrl) === 'undefined') {
+                send();
+            } else {
+                jarnxmpp.vCard.getBase64Image(photoUrl, function (base64img) {
+                    base64img = base64img.replace(/^data:image\/png;base64,/, "");
+                    var photo = Strophe.xmlElement('PHOTO');
+                    photo.appendChild(Strophe.xmlElement('TYPE', [], 'image/png'));
+                    photo.appendChild(Strophe.xmlElement('BINVAL', [], base64img));
+                    vCard.appendChild(photo);
+                    send();
+                });
+            }
+        },
+
+        getBase64Image: function (url, callback) {
+            // Create the element, then draw it on a canvas to get the base64 data.
+            var img = new Image();
+            $(img).load(function () {
+                var canvas = document.createElement('canvas');
+                canvas.width = img.width;
+                canvas.height = img.height;
+                var ctx = canvas.getContext("2d");
+                ctx.drawImage(img, 0, 0);
+                callback(canvas.toDataURL('image/png'));
+            }).attr('src', url);
+        }
+    };
+
+    jarnxmpp.onConnect = function (status) {
+        if ((status === Strophe.Status.ATTACHED) || (status === Strophe.Status.CONNECTED)) {
+            $(window).bind('beforeunload', function () {
+                $(document).trigger('jarnxmpp.disconnecting');
+                var presence = $pres({type: 'unavailable'});
+                jarnxmpp.connection.send(presence);
+                jarnxmpp.connection.disconnect();
+                jarnxmpp.connection.flush();
+            });
+            $(document).trigger('jarnxmpp.connected');
+        } else if (status === Strophe.Status.DISCONNECTED) {
+            $(document).trigger('jarnxmpp.disconnected');
+        }
+    };
+
+    jarnxmpp.rawInput = function (data) {
+        var event = jQuery.Event('jarnxmpp.dataReceived');
+        event.text = data;
+        $(document).trigger(event);
+    };
+
+    jarnxmpp.rawOutput = function (data) {
+        var event = jQuery.Event('jarnxmpp.dataSent');
+        event.text = data;
+        $(document).trigger(event);
+    };
+
+    $(document).bind('jarnxmpp.connected', function () {
+        // Logging
+        jarnxmpp.connection.rawInput = jarnxmpp.rawInput;
+        jarnxmpp.connection.rawOutput = jarnxmpp.rawOutput;
+    });
+
+    $(document).bind('jarnxmpp.disconnecting', function () {
+        if (jarnxmpp.Storage.storage !== null) {
+            jarnxmpp.Storage.set('online-count', jarnxmpp.Presence.onlineCount());
+        }
+    });
+
+    $(document).ready(function () {
+        var resource = jarnxmpp.Storage.get('xmppresource');
+        if (resource) {
+            data = {'resource': resource};
+        } else {
+            data = {};
+        }
+        $.ajax({
+            'url':portal_url + '/@@xmpp-loader',
+            'dataType': 'json',
+            'data': data,
+            'success': function (data) {
+                if (!(('rid' in data) && ('sid' in data) && ('BOSH_SERVICE' in data))) {
+                    return;
+                }
+                if (!resource) {
+                    jarnxmpp.Storage.set('xmppresource', Strophe.getResourceFromJid(data.jid));
+                }
+                jarnxmpp.BOSH_SERVICE = data.BOSH_SERVICE;
+                jarnxmpp.jid = data.jid;
+                jarnxmpp.connection = new Strophe.Connection(jarnxmpp.BOSH_SERVICE);
+                jarnxmpp.connection.attach(jarnxmpp.jid, data.sid, data.rid, jarnxmpp.onConnect);
+            }
+        });
+    });
+
+})(window.jarnxmpp = window.jarnxmpp || {}, jQuery, portal_url);

Libraries/jasmine-1.3.1/MIT.LICENSE

+Copyright (c) 2008-2011 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Libraries/jasmine-1.3.1/jasmine-html.js

+jasmine.HtmlReporterHelpers = {};
+
+jasmine.HtmlReporterHelpers.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) {
+        el.appendChild(child);
+      }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.HtmlReporterHelpers.getSpecStatus = function(child) {
+  var results = child.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+
+  return status;
+};
+
+jasmine.HtmlReporterHelpers.appendToSummary = function(child, childElement) {
+  var parentDiv = this.dom.summary;
+  var parentSuite = (typeof child.parentSuite == 'undefined') ? 'suite' : 'parentSuite';
+  var parent = child[parentSuite];
+
+  if (parent) {
+    if (typeof this.views.suites[parent.id] == 'undefined') {
+      this.views.suites[parent.id] = new jasmine.HtmlReporter.SuiteView(parent, this.dom, this.views);
+    }
+    parentDiv = this.views.suites[parent.id].element;
+  }
+
+  parentDiv.appendChild(childElement);
+};
+
+
+jasmine.HtmlReporterHelpers.addHelpers = function(ctor) {
+  for(var fn in jasmine.HtmlReporterHelpers) {
+    ctor.prototype[fn] = jasmine.HtmlReporterHelpers[fn];
+  }
+};
+
+jasmine.HtmlReporter = function(_doc) {
+  var self = this;
+  var doc = _doc || window.document;
+
+  var reporterView;
+
+  var dom = {};
+
+  // Jasmine Reporter Public Interface
+  self.logRunningSpecs = false;
+
+  self.reportRunnerStarting = function(runner) {
+    var specs = runner.specs() || [];
+
+    if (specs.length == 0) {
+      return;
+    }
+
+    createReporterDom(runner.env.versionString());
+    doc.body.appendChild(dom.reporter);
+    setExceptionHandling();
+
+    reporterView = new jasmine.HtmlReporter.ReporterView(dom);
+    reporterView.addSpecs(specs, self.specFilter);
+  };
+
+  self.reportRunnerResults = function(runner) {
+    reporterView && reporterView.complete();
+  };
+
+  self.reportSuiteResults = function(suite) {
+    reporterView.suiteComplete(suite);
+  };
+
+  self.reportSpecStarting = function(spec) {
+    if (self.logRunningSpecs) {
+      self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+    }
+  };
+
+  self.reportSpecResults = function(spec) {
+    reporterView.specComplete(spec);
+  };
+
+  self.log = function() {
+    var console = jasmine.getGlobal().console;
+    if (console && console.log) {
+      if (console.log.apply) {
+        console.log.apply(console, arguments);
+      } else {
+        console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+      }
+    }
+  };
+
+  self.specFilter = function(spec) {
+    if (!focusedSpecName()) {
+      return true;
+    }
+
+    return spec.getFullName().indexOf(focusedSpecName()) === 0;
+  };
+
+  return self;
+
+  function focusedSpecName() {
+    var specName;
+
+    (function memoizeFocusedSpec() {
+      if (specName) {
+        return;
+      }
+
+      var paramMap = [];
+      var params = jasmine.HtmlReporter.parameters(doc);
+
+      for (var i = 0; i < params.length; i++) {
+        var p = params[i].split('=');
+        paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+      }
+
+      specName = paramMap.spec;
+    })();
+
+    return specName;
+  }
+
+  function createReporterDom(version) {
+    dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' },
+      dom.banner = self.createDom('div', { className: 'banner' },
+        self.createDom('span', { className: 'title' }, "Jasmine "),
+        self.createDom('span', { className: 'version' }, version)),
+
+      dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}),
+      dom.alert = self.createDom('div', {className: 'alert'},
+        self.createDom('span', { className: 'exceptions' },
+          self.createDom('label', { className: 'label', 'for': 'no_try_catch' }, 'No try/catch'),
+          self.createDom('input', { id: 'no_try_catch', type: 'checkbox' }))),
+      dom.results = self.createDom('div', {className: 'results'},
+        dom.summary = self.createDom('div', { className: 'summary' }),
+        dom.details = self.createDom('div', { id: 'details' }))
+    );
+  }
+
+  function noTryCatch() {
+    return window.location.search.match(/catch=false/);
+  }
+
+  function searchWithCatch() {
+    var params = jasmine.HtmlReporter.parameters(window.document);
+    var removed = false;
+    var i = 0;
+
+    while (!removed && i < params.length) {
+      if (params[i].match(/catch=/)) {
+        params.splice(i, 1);
+        removed = true;
+      }
+      i++;
+    }
+    if (jasmine.CATCH_EXCEPTIONS) {
+      params.push("catch=false");
+    }
+
+    return params.join("&");
+  }
+
+  function setExceptionHandling() {
+    var chxCatch = document.getElementById('no_try_catch');
+
+    if (noTryCatch()) {
+      chxCatch.setAttribute('checked', true);
+      jasmine.CATCH_EXCEPTIONS = false;
+    }
+    chxCatch.onclick = function() {
+      window.location.search = searchWithCatch();
+    };
+  }
+};
+jasmine.HtmlReporter.parameters = function(doc) {
+  var paramStr = doc.location.search.substring(1);
+  var params = [];
+
+  if (paramStr.length > 0) {
+    params = paramStr.split('&');
+  }
+  return params;
+}
+jasmine.HtmlReporter.sectionLink = function(sectionName) {
+  var link = '?';
+  var params = [];
+
+  if (sectionName) {
+    params.push('spec=' + encodeURIComponent(sectionName));
+  }
+  if (!jasmine.CATCH_EXCEPTIONS) {
+    params.push("catch=false");
+  }
+  if (params.length > 0) {
+    link += params.join("&");
+  }
+
+  return link;
+};
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter);
+jasmine.HtmlReporter.ReporterView = function(dom) {
+  this.startedAt = new Date();
+  this.runningSpecCount = 0;
+  this.completeSpecCount = 0;
+  this.passedCount = 0;
+  this.failedCount = 0;
+  this.skippedCount = 0;
+
+  this.createResultsMenu = function() {
+    this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'},
+      this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: "#"}, '0 specs'),
+      ' | ',
+      this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: "#"}, '0 failing'));
+
+    this.summaryMenuItem.onclick = function() {
+      dom.reporter.className = dom.reporter.className.replace(/ showDetails/g, '');
+    };
+
+    this.detailsMenuItem.onclick = function() {
+      showDetails();
+    };
+  };
+
+  this.addSpecs = function(specs, specFilter) {
+    this.totalSpecCount = specs.length;
+
+    this.views = {
+      specs: {},
+      suites: {}
+    };
+
+    for (var i = 0; i < specs.length; i++) {
+      var spec = specs[i];
+      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views);
+      if (specFilter(spec)) {
+        this.runningSpecCount++;
+      }
+    }
+  };
+
+  this.specComplete = function(spec) {
+    this.completeSpecCount++;
+
+    if (isUndefined(this.views.specs[spec.id])) {
+      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom);
+    }
+
+    var specView = this.views.specs[spec.id];
+
+    switch (specView.status()) {
+      case 'passed':
+        this.passedCount++;
+        break;
+
+      case 'failed':
+        this.failedCount++;
+        break;
+
+      case 'skipped':
+        this.skippedCount++;
+        break;
+    }
+
+    specView.refresh();
+    this.refresh();
+  };
+
+  this.suiteComplete = function(suite) {
+    var suiteView = this.views.suites[suite.id];
+    if (isUndefined(suiteView)) {
+      return;
+    }
+    suiteView.refresh();
+  };
+
+  this.refresh = function() {
+
+    if (isUndefined(this.resultsMenu)) {
+      this.createResultsMenu();
+    }
+
+    // currently running UI
+    if (isUndefined(this.runningAlert)) {
+      this.runningAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "runningAlert bar" });
+      dom.alert.appendChild(this.runningAlert);
+    }
+    this.runningAlert.innerHTML = "Running " + this.completeSpecCount + " of " + specPluralizedFor(this.totalSpecCount);
+
+    // skipped specs UI
+    if (isUndefined(this.skippedAlert)) {
+      this.skippedAlert = this.createDom('a', { href: jasmine.HtmlReporter.sectionLink(), className: "skippedAlert bar" });
+    }
+
+    this.skippedAlert.innerHTML = "Skipping " + this.skippedCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
+
+    if (this.skippedCount === 1 && isDefined(dom.alert)) {
+      dom.alert.appendChild(this.skippedAlert);
+    }
+
+    // passing specs UI
+    if (isUndefined(this.passedAlert)) {
+      this.passedAlert = this.createDom('span', { href: jasmine.HtmlReporter.sectionLink(), className: "passingAlert bar" });
+    }
+    this.passedAlert.innerHTML = "Passing " + specPluralizedFor(this.passedCount);
+
+    // failing specs UI
+    if (isUndefined(this.failedAlert)) {
+      this.failedAlert = this.createDom('span', {href: "?", className: "failingAlert bar"});
+    }
+    this.failedAlert.innerHTML = "Failing " + specPluralizedFor(this.failedCount);
+
+    if (this.failedCount === 1 && isDefined(dom.alert)) {
+      dom.alert.appendChild(this.failedAlert);
+      dom.alert.appendChild(this.resultsMenu);
+    }
+
+    // summary info
+    this.summaryMenuItem.innerHTML = "" + specPluralizedFor(this.runningSpecCount);
+    this.detailsMenuItem.innerHTML = "" + this.failedCount + " failing";
+  };
+
+  this.complete = function() {
+    dom.alert.removeChild(this.runningAlert);
+
+    this.skippedAlert.innerHTML = "Ran " + this.runningSpecCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
+
+    if (this.failedCount === 0) {
+      dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, "Passing " + specPluralizedFor(this.passedCount)));
+    } else {
+      showDetails();
+    }
+
+    dom.banner.appendChild(this.createDom('span', {className: 'duration'}, "finished in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s"));
+  };
+
+  return this;
+
+  function showDetails() {
+    if (dom.reporter.className.search(/showDetails/) === -1) {
+      dom.reporter.className += " showDetails";
+    }
+  }
+
+  function isUndefined(obj) {
+    return typeof obj === 'undefined';
+  }
+
+  function isDefined(obj) {
+    return !isUndefined(obj);
+  }
+
+  function specPluralizedFor(count) {
+    var str = count + " spec";
+    if (count > 1) {
+      str += "s"
+    }
+    return str;
+  }
+
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView);
+
+
+jasmine.HtmlReporter.SpecView = function(spec, dom, views) {
+  this.spec = spec;
+  this.dom = dom;
+  this.views = views;
+
+  this.symbol = this.createDom('li', { className: 'pending' });
+  this.dom.symbolSummary.appendChild(this.symbol);
+
+  this.summary = this.createDom('div', { className: 'specSummary' },
+    this.createDom('a', {
+      className: 'description',
+      href: jasmine.HtmlReporter.sectionLink(this.spec.getFullName()),
+      title: this.spec.getFullName()
+    }, this.spec.description)
+  );
+
+  this.detail = this.createDom('div', { className: 'specDetail' },
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
+        title: this.spec.getFullName()
+      }, this.spec.getFullName())
+  );
+};
+
+jasmine.HtmlReporter.SpecView.prototype.status = function() {
+  return this.getSpecStatus(this.spec);
+};
+
+jasmine.HtmlReporter.SpecView.prototype.refresh = function() {
+  this.symbol.className = this.status();
+
+  switch (this.status()) {
+    case 'skipped':
+      break;
+
+    case 'passed':
+      this.appendSummaryToSuiteDiv();
+      break;
+
+    case 'failed':
+      this.appendSummaryToSuiteDiv();
+      this.appendFailureDetail();
+      break;
+  }
+};
+
+jasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() {
+  this.summary.className += ' ' + this.status();
+  this.appendToSummary(this.spec, this.summary);
+};
+
+jasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() {
+  this.detail.className += ' ' + this.status();
+
+  var resultItems = this.spec.results().getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    this.detail.appendChild(messagesDiv);
+    this.dom.details.appendChild(this.detail);
+  }
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);jasmine.HtmlReporter.SuiteView = function(suite, dom, views) {
+  this.suite = suite;
+  this.dom = dom;
+  this.views = views;
+
+  this.element = this.createDom('div', { className: 'suite' },
+    this.createDom('a', { className: 'description', href: jasmine.HtmlReporter.sectionLink(this.suite.getFullName()) }, this.suite.description)
+  );
+
+  this.appendToSummary(this.suite, this.element);
+};
+
+jasmine.HtmlReporter.SuiteView.prototype.status = function() {
+  return this.getSpecStatus(this.suite);
+};
+
+jasmine.HtmlReporter.SuiteView.prototype.refresh = function() {
+  this.element.className += " " + this.status();
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView);
+
+/* @deprecated Use jasmine.HtmlReporter instead
+ */
+jasmine.TrivialReporter = function(doc) {
+  this.document = doc || document;
+  this.suiteDivs = {};
+  this.logRunningSpecs = false;
+};
+
+jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) { el.appendChild(child); }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
+  var showPassed, showSkipped;
+
+  this.outerDiv = this.createDom('div', { id: 'TrivialReporter', className: 'jasmine_reporter' },
+      this.createDom('div', { className: 'banner' },
+        this.createDom('div', { className: 'logo' },
+            this.createDom('span', { className: 'title' }, "Jasmine"),
+            this.createDom('span', { className: 'version' }, runner.env.versionString())),
+        this.createDom('div', { className: 'options' },
+            "Show ",
+            showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "),
+            showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped")
+            )
+          ),
+
+      this.runnerDiv = this.createDom('div', { className: 'runner running' },
+          this.createDom('a', { className: 'run_spec', href: '?' }, "run all"),
+          this.runnerMessageSpan = this.createDom('span', {}, "Running..."),
+          this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, ""))
+      );
+
+  this.document.body.appendChild(this.outerDiv);
+
+  var suites = runner.suites();
+  for (var i = 0; i < suites.length; i++) {
+    var suite = suites[i];
+    var suiteDiv = this.createDom('div', { className: 'suite' },
+        this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"),
+        this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description));
+    this.suiteDivs[suite.id] = suiteDiv;
+    var parentDiv = this.outerDiv;
+    if (suite.parentSuite) {
+      parentDiv = this.suiteDivs[suite.parentSuite.id];
+    }
+    parentDiv.appendChild(suiteDiv);
+  }
+
+  this.startedAt = new Date();
+
+  var self = this;
+  showPassed.onclick = function(evt) {
+    if (showPassed.checked) {
+      self.outerDiv.className += ' show-passed';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, '');
+    }
+  };
+
+  showSkipped.onclick = function(evt) {
+    if (showSkipped.checked) {
+      self.outerDiv.className += ' show-skipped';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, '');
+    }
+  };
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {
+  var results = runner.results();
+  var className = (results.failedCount > 0) ? "runner failed" : "runner passed";
+  this.runnerDiv.setAttribute("class", className);
+  //do it twice for IE
+  this.runnerDiv.setAttribute("className", className);
+  var specs = runner.specs();
+  var specCount = 0;
+  for (var i = 0; i < specs.length; i++) {
+    if (this.specFilter(specs[i])) {
+      specCount++;
+    }
+  }
+  var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s");
+  message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s";
+  this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild);
+
+  this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString()));
+};
+
+jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {
+  var results = suite.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.totalCount === 0) { // todo: change this to check results.skipped
+    status = 'skipped';
+  }
+  this.suiteDivs[suite.id].className += " " + status;
+};
+
+jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) {
+  if (this.logRunningSpecs) {
+    this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+  }
+};
+
+jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
+  var results = spec.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+  var specDiv = this.createDom('div', { className: 'spec '  + status },
+      this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"),
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(spec.getFullName()),
+        title: spec.getFullName()
+      }, spec.description));
+
+
+  var resultItems = results.getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    specDiv.appendChild(messagesDiv);
+  }
+
+  this.suiteDivs[spec.suite.id].appendChild(specDiv);
+};
+
+jasmine.TrivialReporter.prototype.log = function() {
+  var console = jasmine.getGlobal().console;
+  if (console && console.log) {
+    if (console.log.apply) {
+      console.log.apply(console, arguments);
+    } else {
+      console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+    }
+  }
+};
+
+jasmine.TrivialReporter.prototype.getLocation = function() {
+  return this.document.location;
+};
+
+jasmine.TrivialReporter.prototype.specFilter = function(spec) {
+  var paramMap = {};
+  var params = this.getLocation().search.substring(1).split('&');
+  for (var i = 0; i < params.length; i++) {
+    var p = params[i].split('=');
+    paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+  }
+
+  if (!paramMap.spec) {
+    return true;
+  }
+  return spec.getFullName().indexOf(paramMap.spec) === 0;
+};

Libraries/jasmine-1.3.1/jasmine.css

+body { background-color: #eeeeee; padding: 0; margin: 5px; overflow-y: scroll; }
+
+#HTMLReporter { font-size: 11px; font-family: Monaco, "Lucida Console", monospace; line-height: 14px; color: #333333; }
+#HTMLReporter a { text-decoration: none; }
+#HTMLReporter a:hover { text-decoration: underline; }
+#HTMLReporter p, #HTMLReporter h1, #HTMLReporter h2, #HTMLReporter h3, #HTMLReporter h4, #HTMLReporter h5, #HTMLReporter h6 { margin: 0; line-height: 14px; }
+#HTMLReporter .banner, #HTMLReporter .symbolSummary, #HTMLReporter .summary, #HTMLReporter .resultMessage, #HTMLReporter .specDetail .description, #HTMLReporter .alert .bar, #HTMLReporter .stackTrace { padding-left: 9px; padding-right: 9px; }
+#HTMLReporter #jasmine_content { position: fixed; right: 100%; }
+#HTMLReporter .version { color: #aaaaaa; }
+#HTMLReporter .banner { margin-top: 14px; }
+#HTMLReporter .duration { color: #aaaaaa; float: right; }
+#HTMLReporter .symbolSummary { overflow: hidden; *zoom: 1; margin: 14px 0; }
+#HTMLReporter .symbolSummary li { display: block; float: left; height: 7px; width: 14px; margin-bottom: 7px; font-size: 16px; }
+#HTMLReporter .symbolSummary li.passed { font-size: 14px; }
+#HTMLReporter .symbolSummary li.passed:before { color: #5e7d00; content: "\02022"; }
+#HTMLReporter .symbolSummary li.failed { line-height: 9px; }
+#HTMLReporter .symbolSummary li.failed:before { color: #b03911; content: "x"; font-weight: bold; margin-left: -1px; }
+#HTMLReporter .symbolSummary li.skipped { font-size: 14px; }
+#HTMLReporter .symbolSummary li.skipped:before { color: #bababa; content: "\02022"; }
+#HTMLReporter .symbolSummary li.pending { line-height: 11px; }
+#HTMLReporter .symbolSummary li.pending:before { color: #aaaaaa; content: "-"; }
+#HTMLReporter .exceptions { color: #fff; float: right; margin-top: 5px; margin-right: 5px; }
+#HTMLReporter .bar { line-height: 28px; font-size: 14px; display: block; color: #eee; }
+#HTMLReporter .runningAlert { background-color: #666666; }
+#HTMLReporter .skippedAlert { background-color: #aaaaaa; }
+#HTMLReporter .skippedAlert:first-child { background-color: #333333; }
+#HTMLReporter .skippedAlert:hover { text-decoration: none; color: white; text-decoration: underline; }
+#HTMLReporter .passingAlert { background-color: #a6b779; }
+#HTMLReporter .passingAlert:first-child { background-color: #5e7d00; }
+#HTMLReporter .failingAlert { background-color: #cf867e; }
+#HTMLReporter .failingAlert:first-child { background-color: #b03911; }
+#HTMLReporter .results { margin-top: 14px; }
+#HTMLReporter #details { display: none; }
+#HTMLReporter .resultsMenu, #HTMLReporter .resultsMenu a { background-color: #fff; color: #333333; }
+#HTMLReporter.showDetails .summaryMenuItem { font-weight: normal; text-decoration: inherit; }
+#HTMLReporter.showDetails .summaryMenuItem:hover { text-decoration: underline; }
+#HTMLReporter.showDetails .detailsMenuItem { font-weight: bold; text-decoration: underline; }
+#HTMLReporter.showDetails .summary { display: none; }
+#HTMLReporter.showDetails #details { display: block; }
+#HTMLReporter .summaryMenuItem { font-weight: bold; text-decoration: underline; }
+#HTMLReporter .summary { margin-top: 14px; }
+#HTMLReporter .summary .suite .suite, #HTMLReporter .summary .specSummary { margin-left: 14px; }
+#HTMLReporter .summary .specSummary.passed a { color: #5e7d00; }
+#HTMLReporter .summary .specSummary.failed a { color: #b03911; }
+#HTMLReporter .description + .suite { margin-top: 0; }
+#HTMLReporter .suite { margin-top: 14px; }
+#HTMLReporter .suite a { color: #333333; }
+#HTMLReporter #details .specDetail { margin-bottom: 28px; }
+#HTMLReporter #details .specDetail .description { display: block; color: white; background-color: #b03911; }
+#HTMLReporter .resultMessage { padding-top: 14px; color: #333333; }
+#HTMLReporter .resultMessage span.result { display: block; }
+#HTMLReporter .stackTrace { margin: 5px 0 0 0; max-height: 224px; overflow: auto; line-height: 18px; color: #666666; border: 1px solid #ddd; background: white; white-space: pre; }
+
+#TrivialReporter { padding: 8px 13px; position: absolute; top: 0; bottom: 0; left: 0; right: 0; overflow-y: scroll; background-color: white; font-family: "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif; /*.resultMessage {*/ /*white-space: pre;*/ /*}*/ }
+#TrivialReporter a:visited, #TrivialReporter a { color: #303; }
+#TrivialReporter a:hover, #TrivialReporter a:active { color: blue; }
+#TrivialReporter .run_spec { float: right; padding-right: 5px; font-size: .8em; text-decoration: none; }
+#TrivialReporter .banner { color: #303; background-color: #fef; padding: 5px; }
+#TrivialReporter .logo { float: left; font-size: 1.1em; padding-left: 5px; }
+#TrivialReporter .logo .version { font-size: .6em; padding-left: 1em; }
+#TrivialReporter .runner.running { background-color: yellow; }
+#TrivialReporter .options { text-align: right; font-size: .8em; }
+#TrivialReporter .suite { border: 1px outset gray; margin: 5px 0; padding-left: 1em; }
+#TrivialReporter .suite .suite { margin: 5px; }
+#TrivialReporter .suite.passed { background-color: #dfd; }
+#TrivialReporter .suite.failed { background-color: #fdd; }
+#TrivialReporter .spec { margin: 5px; padding-left: 1em; clear: both; }
+#TrivialReporter .spec.failed, #TrivialReporter .spec.passed, #TrivialReporter .spec.skipped { padding-bottom: 5px; border: 1px solid gray; }
+#TrivialReporter .spec.failed { background-color: #fbb; border-color: red; }
+#TrivialReporter .spec.passed { background-color: #bfb; border-color: green; }
+#TrivialReporter .spec.skipped { background-color: #bbb; }
+#TrivialReporter .messages { border-left: 1px dashed gray; padding-left: 1em; padding-right: 1em; }
+#TrivialReporter .passed { background-color: #cfc; display: none; }
+#TrivialReporter .failed { background-color: #fbb; }
+#TrivialReporter .skipped { color: #777; background-color: #eee; display: none; }
+#TrivialReporter .resultMessage span.result { display: block; line-height: 2em; color: black; }
+#TrivialReporter .resultMessage .mismatch { color: black; }
+#TrivialReporter .stackTrace { white-space: pre; font-size: .8em; margin-left: 10px; max-height: 5em; overflow: auto; border: 1px inset red; padding: 1em; background: #eef; }
+#TrivialReporter .finished-at { padding-left: 1em; font-size: .6em; }
+#TrivialReporter.show-passed .passed, #TrivialReporter.show-skipped .skipped { display: block; }
+#TrivialReporter #jasmine_content { position: fixed; right: 100%; }
+#TrivialReporter .runner { border: 1px solid gray; display: block; margin: 5px 0; padding: 2px 0 2px 10px; }

Libraries/jasmine-1.3.1/jasmine.js

+var isCommonJS = typeof window == "undefined" && typeof exports == "object";
+
+/**
+ * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework.
+ *
+ * @namespace
+ */
+var jasmine = {};
+if (isCommonJS) exports.jasmine = jasmine;
+/**
+ * @private
+ */
+jasmine.unimplementedMethod_ = function() {
+  throw new Error("unimplemented method");
+};
+
+/**
+ * Use <code>jasmine.undefined</code> instead of <code>undefined</code>, since <code>undefined</code> is just
+ * a plain old variable and may be redefined by somebody else.
+ *
+ * @private
+ */
+jasmine.undefined = jasmine.___undefined___;
+
+/**
+ * Show diagnostic messages in the console if set to true
+ *
+ */
+jasmine.VERBOSE = false;
+
+/**
+ * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed.
+ *
+ */
+jasmine.DEFAULT_UPDATE_INTERVAL = 250;
+
+/**
+ * Maximum levels of nesting that will be included when an object is pretty-printed
+ */
+jasmine.MAX_PRETTY_PRINT_DEPTH = 40;
+
+/**
+ * Default timeout interval in milliseconds for waitsFor() blocks.
+ */
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
+
+/**
+ * By default exceptions thrown in the context of a test are caught by jasmine so that it can run the remaining tests in the suite.
+ * Set to false to let the exception bubble up in the browser.
+ *
+ */
+jasmine.CATCH_EXCEPTIONS = true;
+
+jasmine.getGlobal = function() {
+  function getGlobal() {
+    return this;
+  }
+
+  return getGlobal();
+};
+
+/**
+ * Allows for bound functions to be compared.  Internal use only.
+ *
+ * @ignore
+ * @private
+ * @param base {Object} bound 'this' for the function
+ * @param name {Function} function to find
+ */
+jasmine.bindOriginal_ = function(base, name) {
+  var original = base[name];
+  if (original.apply) {
+    return function() {
+      return original.apply(base, arguments);
+    };
+  } else {
+    // IE support
+    return jasmine.getGlobal()[name];
+  }
+};
+
+jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout');
+jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout');
+jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval');
+jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval');
+
+jasmine.MessageResult = function(values) {
+  this.type = 'log';
+  this.values = values;
+  this.trace = new Error(); // todo: test better
+};
+
+jasmine.MessageResult.prototype.toString = function() {
+  var text = "";
+  for (var i = 0; i < this.values.length; i++) {
+    if (i > 0) text += " ";
+    if (jasmine.isString_(this.values[i])) {
+      text += this.values[i];
+    } else {
+      text += jasmine.pp(this.values[i]);
+    }
+  }
+  return text;
+};
+
+jasmine.ExpectationResult = function(params) {
+  this.type = 'expect';
+  this.matcherName = params.matcherName;
+  this.passed_ = params.passed;
+  this.expected = params.expected;
+  this.actual = params.actual;
+  this.message = this.passed_ ? 'Passed.' : params.message;
+
+  var trace = (params.trace || new Error(this.message));
+  this.trace = this.passed_ ? '' : trace;
+};
+
+jasmine.ExpectationResult.prototype.toString = function () {
+  return this.message;
+};
+
+jasmine.ExpectationResult.prototype.passed = function () {
+  return this.passed_;
+};
+
+/**
+ * Getter for the Jasmine environment. Ensures one gets created
+ */
+jasmine.getEnv = function() {
+  var env = jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();
+  return env;
+};
+
+/**
+ * @ignore
+ * @private
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isArray_ = function(value) {
+  return jasmine.isA_("Array", value);
+};
+
+/**
+ * @ignore
+ * @private
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isString_ = function(value) {
+  return jasmine.isA_("String", value);
+};
+
+/**
+ * @ignore
+ * @private
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isNumber_ = function(value) {
+  return jasmine.isA_("Number", value);
+};
+
+/**
+ * @ignore
+ * @private
+ * @param {String} typeName
+ * @param value
+ * @returns {Boolean}
+ */
+jasmine.isA_ = function(typeName, value) {
+  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
+};
+
+/**
+ * Pretty printer for expecations.  Takes any object and turns it into a human-readable string.
+ *
+ * @param value {Object} an object to be outputted
+ * @returns {String}
+ */
+jasmine.pp = function(value) {
+  var stringPrettyPrinter = new jasmine.StringPrettyPrinter();
+  stringPrettyPrinter.format(value);
+  return stringPrettyPrinter.string;
+};
+
+/**
+ * Returns true if the object is a DOM Node.
+ *
+ * @param {Object} obj object to check
+ * @returns {Boolean}
+ */
+jasmine.isDomNode = function(obj) {
+  return obj.nodeType > 0;
+};
+
+/**
+ * Returns a matchable 'generic' object of the class type.  For use in expecations of type when values don't matter.
+ *
+ * @example
+ * // don't care about which function is passed in, as long as it's a function
+ * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));
+ *
+ * @param {Class} clazz
+ * @returns matchable object of the type clazz
+ */
+jasmine.any = function(clazz) {
+  return new jasmine.Matchers.Any(clazz);
+};
+
+/**
+ * Returns a matchable subset of a JSON object. For use in expectations when you don't care about all of the
+ * attributes on the object.
+ *
+ * @example
+ * // don't care about any other attributes than foo.
+ * expect(mySpy).toHaveBeenCalledWith(jasmine.objectContaining({foo: "bar"});
+ *
+ * @param sample {Object} sample
+ * @returns matchable object for the sample
+ */
+jasmine.objectContaining = function (sample) {
+    return new jasmine.Matchers.ObjectContaining(sample);
+};
+
+/**
+ * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.
+ *
+ * Spies should be created in test setup, before expectations.  They can then be checked, using the standard Jasmine
+ * expectation syntax. Spies can be checked if they were called or not and what the calling params were.
+ *
+ * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).
+ *
+ * Spies are torn down at the end of every spec.
+ *
+ * Note: Do <b>not</b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
+ *
+ * @example
+ * // a stub
+ * var myStub = jasmine.createSpy('myStub');  // can be used anywhere
+ *
+ * // spy example
+ * var foo = {
+ *   not: function(bool) { return !bool; }
+ * }
+ *
+ * // actual foo.not will not be called, execution stops
+ * spyOn(foo, 'not');
+
+ // foo.not spied upon, execution will continue to implementation
+ * spyOn(foo, 'not').andCallThrough();
+ *
+ * // fake example
+ * var foo = {
+ *   not: function(bool) { return !bool; }
+ * }
+ *
+ * // foo.not(val) will return val
+ * spyOn(foo, 'not').andCallFake(function(value) {return value;});
+ *
+ * // mock example
+ * foo.not(7 == 7);
+ * expect(foo.not).toHaveBeenCalled();
+ * expect(foo.not).toHaveBeenCalledWith(true);
+ *
+ * @constructor
+ * @see spyOn, jasmine.createSpy, jasmine.createSpyObj
+ * @param {String} name
+ */
+jasmine.Spy = function(name) {
+  /**
+   * The name of the spy, if provided.
+   */
+  this.identity = name || 'unknown';
+  /**
+   *  Is this Object a spy?
+   */
+  this.isSpy = true;
+  /**
+   * The actual function this spy stubs.
+   */
+  this.plan = function() {
+  };
+  /**
+   * Tracking of the most recent call to the spy.
+   * @example
+   * var mySpy = jasmine.createSpy('foo');
+   * mySpy(1, 2);
+   * mySpy.mostRecentCall.args = [1, 2];
+   */
+  this.mostRecentCall = {};
+
+  /**
+   * Holds arguments for each call to the spy, indexed by call count
+   * @example
+   * var mySpy = jasmine.createSpy('foo');
+   * mySpy(1, 2);
+   * mySpy(7, 8);
+   * mySpy.mostRecentCall.args = [7, 8];
+   * mySpy.argsForCall[0] = [1, 2];
+   * mySpy.argsForCall[1] = [7, 8];
+   */
+  this.argsForCall = [];
+  this.calls = [];
+};
+
+/**
+ * Tells a spy to call through to the actual implemenatation.
+ *
+ * @example
+ * var foo = {
+ *   bar: function() { // do some stuff }
+ * }
+ *
+ * // defining a spy on an existing property: foo.bar
+ * spyOn(foo, 'bar').andCallThrough();
+ */
+jasmine.Spy.prototype.andCallThrough = function() {
+  this.plan = this.originalValue;
+  return this;
+};
+
+/**
+ * For setting the return value of a spy.
+ *
+ * @example
+ * // defining a spy from scratch: foo() returns 'baz'
+ * var foo = jasmine.createSpy('spy on foo').andReturn('baz');
+ *
+ * // defining a spy on an existing property: foo.bar() returns 'baz'
+ * spyOn(foo, 'bar').andReturn('baz');
+ *
+ * @param {Object} value
+ */
+jasmine.Spy.prototype.andReturn = function(value) {
+  this.plan = function() {
+    return value;
+  };
+  return this;
+};
+
+/**
+ * For throwing an exception when a spy is called.
+ *
+ * @example
+ * // defining a spy from scratch: foo() throws an exception w/ message 'ouch'
+ * var foo = jasmine.createSpy('spy on foo').andThrow('baz');
+ *
+ * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch'
+ * spyOn(foo, 'bar').andThrow('baz');
+ *
+ * @param {String} exceptionMsg
+ */
+jasmine.Spy.prototype.andThrow = function(exceptionMsg) {
+  this.plan = function() {
+    throw exceptionMsg;
+  };
+  return this;
+};
+
+/**
+ * Calls an alternate implementation when a spy is called.
+ *
+ * @example
+ * var baz = function() {
+ *   // do some stuff, return something
+ * }
+ * // defining a spy from scratch: foo() calls the function baz
+ * var foo = jasmine.createSpy('spy on foo').andCall(baz);
+ *
+ * // defining a spy on an existing property: foo.bar() calls an anonymnous function
+ * spyOn(foo, 'bar').andCall(function() { return 'baz';} );
+ *
+ * @param {Function} fakeFunc
+ */
+jasmine.Spy.prototype.andCallFake = function(fakeFunc) {
+  this.plan = fakeFunc;
+  return this;
+};
+
+/**
+ * Resets all of a spy's the tracking variables so that it can be used again.
+ *
+ * @example
+ * spyOn(foo, 'bar');
+ *
+ * foo.bar();
+ *
+ * expect(foo.bar.callCount).toEqual(1);
+ *
+ * foo.bar.reset();
+ *
+ * expect(foo.bar.callCount).toEqual(0);
+ */
+jasmine.Spy.prototype.reset = function() {
+  this.wasCalled = false;
+  this.callCount = 0;
+  this.argsForCall = [];
+  this.calls = [];
+  this.mostRecentCall = {};
+};
+
+jasmine.createSpy = function(name) {
+
+  var spyObj = function() {
+    spyObj.wasCalled = true;
+    spyObj.callCount++;
+    var args = jasmine.util.argsToArray(arguments);
+    spyObj.mostRecentCall.object = this;
+    spyObj.mostRecentCall.args = args;
+    spyObj.argsForCall.push(args);
+    spyObj.calls.push({object: this, args: args});
+    return spyObj.plan.apply(this, arguments);
+  };
+
+  var spy = new jasmine.Spy(name);
+
+  for (var prop in spy) {
+    spyObj[prop] = spy[prop];
+  }
+
+  spyObj.reset();
+
+  return spyObj;
+};
+
+/**
+ * Determines whether an object is a spy.
+ *
+ * @param {jasmine.Spy|Object} putativeSpy
+ * @returns {Boolean}
+ */
+jasmine.isSpy = function(putativeSpy) {
+  return putativeSpy && putativeSpy.isSpy;
+};
+
+/**
+ * Creates a more complicated spy: an Object that has every property a function that is a spy.  Used for stubbing something
+ * large in one call.
+ *
+ * @param {String} baseName name of spy class
+ * @param {Array} methodNames array of names of methods to make spies
+ */
+jasmine.createSpyObj = function(baseName, methodNames) {
+  if (!jasmine.isArray_(methodNames) || methodNames.length === 0) {
+    throw new Error('createSpyObj requires a non-empty array of method names to create spies for');
+  }
+  var obj = {};
+  for (var i = 0; i < methodNames.length; i++) {
+    obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);
+  }
+  return obj;
+};
+
+/**
+ * All parameters are pretty-printed and concatenated together, then written to the current spec's output.
+ *
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
+ */
+jasmine.log = function() {
+  var spec = jasmine.getEnv().currentSpec;
+  spec.log.apply(spec, arguments);
+};
+
+/**
+ * Function that installs a spy on an existing object's method name.  Used within a Spec to create a spy.
+ *
+ * @example
+ * // spy example
+ * var foo = {
+ *   not: function(bool) { return !bool; }
+ * }
+ * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops
+ *
+ * @see jasmine.createSpy
+ * @param obj
+ * @param methodName
+ * @return {jasmine.Spy} a Jasmine spy that can be chained with all spy methods
+ */
+var spyOn = function(obj, methodName) {
+  return jasmine.getEnv().currentSpec.spyOn(obj, methodName);
+};
+if (isCommonJS) exports.spyOn = spyOn;
+
+/**
+ * Creates a Jasmine spec that will be added to the current suite.
+ *
+ * // TODO: pending tests
+ *
+ * @example
+ * it('should be true', function() {
+ *   expect(true).toEqual(true);
+ * });
+ *
+ * @param {String} desc description of this specification
+ * @param {Function} func defines the preconditions and expectations of the spec
+ */
+var it = function(desc, func) {
+  return jasmine.getEnv().it(desc, func);
+};
+if (isCommonJS) exports.it = it;
+
+/**
+ * Creates a <em>disabled</em> Jasmine spec.
+ *
+ * A convenience method that allows existing specs to be disabled temporarily during development.
+ *
+ * @param {String} desc description of this specification
+ * @param {Function} func defines the preconditions and expectations of the spec
+ */
+var xit = function(desc, func) {
+  return jasmine.getEnv().xit(desc, func);
+};
+if (isCommonJS) exports.xit = xit;
+
+/**
+ * Starts a chain for a Jasmine expectation.
+ *
+ * It is passed an Object that is the actual value and should chain to one of the many
+ * jasmine.Matchers functions.
+ *
+ * @param {Object} actual Actual value to test against and expected value
+ * @return {jasmine.Matchers}
+ */
+var expect = function(actual) {
+  return jasmine.getEnv().currentSpec.expect(actual);
+};
+if (isCommonJS) exports.expect = expect;
+
+/**
+ * Defines part of a jasmine spec.  Used in cominbination with waits or waitsFor in asynchrnous specs.
+ *
+ * @param {Function} func Function that defines part of a jasmine spec.
+ */
+var runs = function(func) {
+  jasmine.getEnv().currentSpec.runs(func);
+};
+if (isCommonJS) exports.runs = runs;
+
+/**
+ * Waits a fixed time period before moving to the next block.
+ *
+ * @deprecated Use waitsFor() instead
+ * @param {Number} timeout milliseconds to wait
+ */
+var waits = function(timeout) {
+  jasmine.getEnv().currentSpec.waits(timeout);
+};
+if (isCommonJS) exports.waits = waits;
+
+/**
+ * Waits for the latchFunction to return true before proceeding to the next block.
+ *
+ * @param {Function} latchFunction
+ * @param {String} optional_timeoutMessage
+ * @param {Number} optional_timeout
+ */
+var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
+  jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments);
+};
+if (isCommonJS) exports.waitsFor = waitsFor;
+
+/**
+ * A function that is called before each spec in a suite.
+ *
+ * Used for spec setup, including validating assumptions.
+ *
+ * @param {Function} beforeEachFunction
+ */
+var beforeEach = function(beforeEachFunction) {
+  jasmine.getEnv().beforeEach(beforeEachFunction);
+};
+if (isCommonJS) exports.beforeEach = beforeEach;
+
+/**
+ * A function that is called after each spec in a suite.
+ *
+ * Used for restoring any state that is hijacked during spec execution.
+ *
+ * @param {Function} afterEachFunction
+ */
+var afterEach = function(afterEachFunction) {
+  jasmine.getEnv().afterEach(afterEachFunction);
+};
+if (isCommonJS) exports.afterEach = afterEach;
+
+/**
+ * Defines a suite of specifications.
+ *
+ * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared
+ * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization
+ * of setup in some tests.
+ *
+ * @example
+ * // TODO: a simple suite
+ *
+ * // TODO: a simple suite with a nested describe block
+ *
+ * @param {String} description A string, usually the class under test.
+ * @param {Function} specDefinitions function that defines several specs.
+ */
+var describe = function(description, specDefinitions) {
+  return jasmine.getEnv().describe(description, specDefinitions);
+};
+if (isCommonJS) exports.describe = describe;
+
+/**
+ * Disables a suite of specifications.  Used to disable some suites in a file, or files, temporarily during development.
+ *
+ * @param {String} description A string, usually the class under test.
+ * @param {Function} specDefinitions function that defines several specs.
+ */
+var xdescribe = function(description, specDefinitions) {
+  return jasmine.getEnv().xdescribe(description, specDefinitions);
+};
+if (isCommonJS) exports.xdescribe = xdescribe;
+
+
+// Provide the XMLHttpRequest class for IE 5.x-6.x:
+jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() {
+  function tryIt(f) {
+    try {
+      return f();
+    } catch(e) {
+    }
+    return null;
+  }
+
+  var xhr = tryIt(function() {
+    return new ActiveXObject("Msxml2.XMLHTTP.6.0");
+  }) ||
+    tryIt(function() {
+      return new ActiveXObject("Msxml2.XMLHTTP.3.0");
+    }) ||
+    tryIt(function() {
+      return new ActiveXObject("Msxml2.XMLHTTP");
+    }) ||
+    tryIt(function() {
+      return new ActiveXObject("Microsoft.XMLHTTP");
+    });
+
+  if (!xhr) throw new Error("This browser does not support XMLHttpRequest.");
+
+  return xhr;
+} : XMLHttpRequest;
+/**
+ * @namespace
+ */
+jasmine.util = {};
+
+/**
+ * Declare that a child class inherit it's prototype from the parent class.
+ *
+ * @private
+ * @param {Function} childClass
+ * @param {Function} parentClass
+ */
+jasmine.util.inherit = function(childClass, parentClass) {
+  /**
+   * @private
+   */
+  var subclass = function() {
+  };
+  subclass.prototype = parentClass.prototype;
+  childClass.prototype = new subclass();
+};
+
+jasmine.util.formatException = function(e) {
+  var lineNumber;
+  if (e.line) {
+    lineNumber = e.line;
+  }
+  else if (e.lineNumber) {
+    lineNumber = e.lineNumber;
+  }
+
+  var file;
+
+  if (e.sourceURL) {
+    file = e.sourceURL;
+  }
+  else if (e.fileName) {
+    file = e.fileName;
+  }
+
+  var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString();
+
+  if (file && lineNumber) {
+    message += ' in ' + file + ' (line ' + lineNumber + ')';
+  }
+
+  return message;
+};
+
+jasmine.util.htmlEscape = function(str) {
+  if (!str) return str;
+  return str.replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+};
+
+jasmine.util.argsToArray = function(args) {
+  var arrayOfArgs = [];
+  for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]);
+  return arrayOfArgs;
+};
+
+jasmine.util.extend = function(destination, source) {
+  for (var property in source) destination[property] = source[property];
+  return destination;
+};
+
+/**
+ * Environment for Jasmine
+ *
+ * @constructor
+ */
+jasmine.Env = function() {
+  this.currentSpec = null;
+  this.currentSuite = null;
+  this.currentRunner_ = new jasmine.Runner(this);
+
+  this.reporter = new jasmine.MultiReporter();
+
+  this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL;
+  this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+  this.lastUpdate = 0;
+  this.specFilter = function() {
+    return true;
+  };
+
+  this.nextSpecId_ = 0;
+  this.nextSuiteId_ = 0;
+  this.equalityTesters_ = [];
+
+  // wrap matchers
+  this.matchersClass = function() {
+    jasmine.Matchers.apply(this, arguments);
+  };
+  jasmine.util.inherit(this.matchersClass, jasmine.Matchers);
+
+  jasmine.Matchers.wrapInto_(jasmine.Matchers.prototype, this.matchersClass);
+};
+
+
+jasmine.Env.prototype.setTimeout = jasmine.setTimeout;
+jasmine.Env.prototype.clearTimeout = jasmine.clearTimeout;
+jasmine.Env.prototype.setInterval = jasmine.setInterval;
+jasmine.Env.prototype.clearInterval = jasmine.clearInterval;
+
+/**
+ * @returns an object containing jasmine version build info, if set.
+ */
+jasmine.Env.prototype.version = function () {
+  if (jasmine.version_) {
+    return jasmine.version_;
+  } else {
+    throw new Error('Version not set');
+  }
+};
+
+/**
+ * @returns string containing jasmine version build info, if set.
+ */
+jasmine.Env.prototype.versionString = function() {
+  if (!jasmine.version_) {
+    return "version unknown";
+  }
+
+  var version = this.version();
+  var versionString = version.major + "." + version.minor + "." + version.build;
+  if (version.release_candidate) {
+    versionString += ".rc" + version.release_candidate;
+  }
+  versionString += " revision " + version.revision;
+  return versionString;
+};
+
+/**
+ * @returns a sequential integer starting at 0
+ */
+jasmine.Env.prototype.nextSpecId = function () {
+  return this.nextSpecId_++;
+};
+
+/**
+ * @returns a sequential integer starting at 0
+ */
+jasmine.Env.prototype.nextSuiteId = function () {
+  return this.nextSuiteId_++;
+};
+
+/**
+ * Register a reporter to receive status updates from Jasmine.
+ * @param {jasmine.Reporter} reporter An object which will receive status updates.
+ */
+jasmine.Env.prototype.addReporter = function(reporter) {
+  this.reporter.addReporter(reporter);
+};
+
+jasmine.Env.prototype.execute = function() {
+  this.currentRunner_.execute();
+};
+
+jasmine.Env.prototype.describe = function(description, specDefinitions) {
+  var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite);
+
+  var parentSuite = this.currentSuite;
+  if (parentSuite) {
+    parentSuite.add(suite);
+  } else {
+    this.currentRunner_.add(suite);
+  }
+
+  this.currentSuite = suite;
+
+  var declarationError = null;
+  try {
+    specDefinitions.call(suite);
+  } catch(e) {
+    declarationError = e;
+  }
+
+  if (declarationError) {
+    this.it("encountered a declaration exception", function() {
+      throw declarationError;
+    });
+  }
+
+  this.currentSuite = parentSuite;
+
+  return suite;
+};
+
+jasmine.Env.prototype.beforeEach = function(beforeEachFunction) {
+  if (this.currentSuite) {
+    this.currentSuite.beforeEach(beforeEachFunction);
+  } else {
+    this.currentRunner_.beforeEach(beforeEachFunction);
+  }
+};
+
+jasmine.Env.prototype.currentRunner = function () {
+  return this.currentRunner_;
+};
+
+jasmine.Env.prototype.afterEach = function(afterEachFunction) {
+  if (this.currentSuite) {
+    this.currentSuite.afterEach(afterEachFunction);
+  } else {
+    this.currentRunner_.afterEach(afterEachFunction);
+  }
+
+};
+
+jasmine.Env.prototype.xdescribe = function(desc, specDefinitions) {
+  return {
+    execute: function() {
+    }
+  };
+};
+
+jasmine.Env.prototype.it = function(description, func) {
+  var spec = new jasmine.Spec(this, this.currentSuite, description);
+  this.currentSuite.add(spec);
+  this.currentSpec = spec;
+
+  if (func) {
+    spec.runs(func);
+  }
+
+  return spec;
+};
+
+jasmine.Env.prototype.xit = function(desc, func) {
+  return {
+    id: this.nextSpecId(),
+    runs: function() {
+    }
+  };
+};
+
+jasmine.Env.prototype.compareRegExps_ = function(a, b, mismatchKeys, mismatchValues) {
+  if (a.source != b.source)
+    mismatchValues.push("expected pattern /" + b.source + "/ is not equal to the pattern /" + a.source + "/");
+
+  if (a.ignoreCase != b.ignoreCase)
+    mismatchValues.push("expected modifier i was" + (b.ignoreCase ? " " : " not ") + "set and does not equal the origin modifier");
+
+  if (a.global != b.global)
+    mismatchValues.push("expected modifier g was" + (b.global ? " " : " not ") + "set and does not equal the origin modifier");
+
+  if (a.multiline != b.multiline)
+    mismatchValues.push("expected modifier m was" + (b.multiline ? " " : " not ") + "set and does not equal the origin modifier");
+
+  if (a.sticky != b.sticky)
+    mismatchValues.push("expected modifier y was" + (b.sticky ? " " : " not ") + "set and does not equal the origin modifier");
+
+  return (mismatchValues.length === 0);
+};
+
+jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) {
+  if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) {
+    return true;
+  }
+
+  a.__Jasmine_been_here_before__ = b;
+  b.__Jasmine_been_here_before__ = a;
+
+  var hasKey = function(obj, keyName) {
+    return obj !== null && obj[keyName] !== jasmine.undefined;
+  };
+
+  for (var property in b) {
+    if (!hasKey(a, property) && hasKey(b, property)) {
+      mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
+    }
+  }
+  for (property in a) {
+    if (!hasKey(b, property) && hasKey(a, property)) {
+      mismatchKeys.push("expected missing key '" + property + "', but present in actual.");
+    }
+  }
+  for (property in b) {
+    if (property == '__Jasmine_been_here_before__') continue;
+    if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) {
+      mismatchValues.push("'" + property + "' was '" + (b[property] ? jasmine.util.htmlEscape(b[property].toString()) : b[property]) + "' in expected, but was '" + (a[property] ? jasmine.util.htmlEscape(a[property].toString()) : a[property]) + "' in actual.");
+    }
+  }
+
+  if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) {
+    mismatchValues.push("arrays were not the same length");
+  }
+
+  delete a.__Jasmine_been_here_before__;
+  delete b.__Jasmine_been_here_before__;
+  return (mismatchKeys.length === 0 && mismatchValues.length === 0);
+};
+
+jasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) {
+  mismatchKeys = mismatchKeys || [];
+  mismatchValues = mismatchValues || [];
+
+  for (var i = 0; i < this.equalityTesters_.length; i++) {
+    var equalityTester = this.equalityTesters_[i];
+    var result = equalityTester(a, b, this, mismatchKeys, mismatchValues);
+    if (result !== jasmine.undefined) return result;
+  }
+
+  if (a === b) return true;
+
+  if (a === jasmine.undefined || a === null || b === jasmine.undefined || b === null) {
+    return (a == jasmine.undefined && b == jasmine.undefined);
+  }
+
+  if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) {
+    return a === b;
+  }
+
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() == b.getTime();
+  }
+
+  if (a.jasmineMatches) {
+    return a.jasmineMatches(b);
+  }
+
+  if (b.jasmineMatches) {
+    return b.jasmineMatches(a);
+  }
+
+  if (a instanceof jasmine.Matchers.ObjectContaining) {
+    return a.matches(b);
+  }
+
+  if (b instanceof jasmine.Matchers.ObjectContaining) {
+    return b.matches(a);
+  }
+
+  if (jasmine.isString_(a) && jasmine.isString_(b)) {
+    return (a == b);
+  }
+
+  if (jasmine.isNumber_(a) && jasmine.isNumber_(b)) {
+    return (a == b);
+  }
+
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return this.compareRegExps_(a, b, mismatchKeys, mismatchValues);
+  }
+
+  if (typeof a === "object" && typeof b === "object") {
+    return this.compareObjects_(a, b, mismatchKeys, mismatchValues);
+  }
+
+  //Straight check
+  return (a === b);
+};
+
+jasmine.Env.prototype.contains_ = function(haystack, needle) {
+  if (jasmine.isArray_(haystack)) {
+    for (var i = 0; i < haystack.length; i++) {
+      if (this.equals_(haystack[i], needle)) return true;
+    }
+    return false;
+  }
+  return haystack.indexOf(needle) >= 0;
+};
+
+jasmine.Env.prototype.addEqualityTester = function(equalityTester) {
+  this.equalityTesters_.push(equalityTester);
+};
+/** No-op base class for Jasmine reporters.
+ *
+ * @constructor
+ */
+jasmine.Reporter = function() {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportRunnerStarting = function(runner) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportRunnerResults = function(runner) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSuiteResults = function(suite) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSpecStarting = function(spec) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSpecResults = function(spec) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.log = function(str) {
+};
+
+/**
+ * Blocks are functions with executable code that make up a spec.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {Function} func
+ * @param {jasmine.Spec} spec
+ */
+jasmine.Block = function(env, func, spec) {
+  this.env = env;
+  this.func = func;
+  this.spec = spec;
+};
+
+jasmine.Block.prototype.execute = function(onComplete) {
+  if (!jasmine.CATCH_EXCEPTIONS) {
+    this.func.apply(this.spec);
+  }
+  else {
+    try {
+      this.func.apply(this.spec);
+    } catch (e) {
+      this.spec.fail(e);
+    }
+  }
+  onComplete();
+};
+/** JavaScript API reporter.
+ *
+ * @constructor
+ */
+jasmine.JsApiReporter = function() {
+  this.started = false;
+  this.finished = false;
+  this.suites_ = [];
+  this.results_ = {};
+};
+
+jasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) {
+  this.started = true;
+  var suites = runner.topLevelSuites();
+  for (var i = 0; i < suites.length; i++) {
+    var suite = suites[i];
+    this.suites_.push(this.summarize_(suite));
+  }
+};
+
+jasmine.JsApiReporter.prototype.suites = function() {
+  return this.suites_;
+};
+
+jasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) {
+  var isSuite = suiteOrSpec instanceof jasmine.Suite;
+  var summary = {
+    id: suiteOrSpec.id,
+    name: suiteOrSpec.description,
+    type: isSuite ? 'suite' : 'spec',
+    children: []
+  };
+  
+  if (isSuite) {
+    var children = suiteOrSpec.children();
+    for (var i = 0; i < children.length; i++) {
+      summary.children.push(this.summarize_(children[i]));
+    }
+  }
+  return summary;
+};
+
+jasmine.JsApiReporter.prototype.results = function() {
+  return this.results_;
+};
+
+jasmine.JsApiReporter.prototype.resultsForSpec = function(specId) {
+  return this.results_[specId];
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) {
+  this.finished = true;
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) {
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) {
+  this.results_[spec.id] = {
+    messages: spec.results().getItems(),
+    result: spec.results().failedCount > 0 ? "failed" : "passed"
+  };
+};
+
+//noinspection JSUnusedLocalSymbols
+jasmine.JsApiReporter.prototype.log = function(str) {
+};
+
+jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){
+  var results = {};
+  for (var i = 0; i < specIds.length; i++) {
+    var specId = specIds[i];
+    results[specId] = this.summarizeResult_(this.results_[specId]);
+  }
+  return results;
+};
+
+jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){
+  var summaryMessages = [];
+  var messagesLength = result.messages.length;
+  for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) {
+    var resultMessage = result.messages[messageIndex];
+    summaryMessages.push({
+      text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined,
+      passed: resultMessage.passed ? resultMessage.passed() : true,
+      type: resultMessage.type,
+      message: resultMessage.message,
+      trace: {
+        stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined
+      }
+    });
+  }
+
+  return {
+    result : result.result,
+    messages : summaryMessages
+  };
+};
+
+/**
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param actual
+ * @param {jasmine.Spec} spec
+ */
+jasmine.Matchers = function(env, actual, spec, opt_isNot) {
+  this.env = env;
+  this.actual = actual;
+  this.spec = spec;
+  this.isNot = opt_isNot || false;
+  this.reportWasCalled_ = false;
+};
+
+// todo: @deprecated as of Jasmine 0.11, remove soon [xw]
+jasmine.Matchers.pp = function(str) {
+  throw new Error("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!");
+};
+
+// todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw]
+jasmine.Matchers.prototype.report = function(result, failing_message, details) {
+  throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs");
+};
+
+jasmine.Matchers.wrapInto_ = function(prototype, matchersClass) {
+  for (var methodName in prototype) {
+    if (methodName == 'report') continue;
+    var orig = prototype[methodName];
+    matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig);
+  }
+};
+
+jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) {
+  return function() {
+    var matcherArgs = jasmine.util.argsToArray(arguments);
+    var result = matcherFunction.apply(this, arguments);
+
+    if (this.isNot) {
+      result = !result;
+    }
+
+    if (this.reportWasCalled_) return result;
+
+    var message;
+    if (!result) {
+      if (this.message) {
+        message = this.message.apply(this, arguments);
+        if (jasmine.isArray_(message)) {
+          message = message[this.isNot ? 1 : 0];
+        }
+      } else {
+        var englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
+        message = "Expected " + jasmine.pp(this.actual) + (this.isNot ? " not " : " ") + englishyPredicate;
+        if (matcherArgs.length > 0) {
+          for (var i = 0; i < matcherArgs.length; i++) {
+            if (i > 0) message += ",";
+            message += " " + jasmine.pp(matcherArgs[i]);
+          }
+        }
+        message += ".";
+      }
+    }
+    var expectationResult = new jasmine.ExpectationResult({
+      matcherName: matcherName,
+      passed: result,
+      expected: matcherArgs.length > 1 ? matcherArgs : matcherArgs[0],
+      actual: this.actual,
+      message: message
+    });
+    this.spec.addMatcherResult(expectationResult);
+    return jasmine.undefined;
+  };
+};
+
+
+
+
+/**
+ * toBe: compares the actual to the expected using ===
+ * @param expected
+ */
+jasmine.Matchers.prototype.toBe = function(expected) {
+  return this.actual === expected;
+};
+
+/**
+ * toNotBe: compares the actual to the expected using !==
+ * @param expected
+ * @deprecated as of 1.0. Use not.toBe() instead.
+ */
+jasmine.Matchers.prototype.toNotBe = function(expected) {
+  return this.actual !== expected;
+};
+
+/**
+ * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.
+ *
+ * @param expected
+ */
+jasmine.Matchers.prototype.toEqual = function(expected) {
+  return this.env.equals_(this.actual, expected);
+};
+
+/**
+ * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual
+ * @param expected
+ * @deprecated as of 1.0. Use not.toEqual() instead.
+ */
+jasmine.Matchers.prototype.toNotEqual = function(expected) {
+  return !this.env.equals_(this.actual, expected);
+};
+
+/**
+ * Matcher that compares the actual to the expected using a regular expression.  Constructs a RegExp, so takes
+ * a pattern or a String.
+ *
+ * @param expected
+ */
+jasmine.Matchers.prototype.toMatch = function(expected) {
+  return new RegExp(expected).test(this.actual);
+};
+
+/**
+ * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch
+ * @param expected
+ * @deprecated as of 1.0. Use not.toMatch() instead.
+ */
+jasmine.Matchers.prototype.toNotMatch = function(expected) {
+  return !(new RegExp(expected).test(this.actual));
+};
+
+/**
+ * Matcher that compares the actual to jasmine.undefined.
+ */
+jasmine.Matchers.prototype.toBeDefined = function() {
+  return (this.actual !== jasmine.undefined);
+};
+
+/**
+ * Matcher that compares the actual to jasmine.undefined.
+ */
+jasmine.Matchers.prototype.toBeUndefined = function() {
+  return (this.actual === jasmine.undefined);
+};
+
+/**
+ * Matcher that compares the actual to null.
+ */
+jasmine.Matchers.prototype.toBeNull = function() {
+  return (this.actual === null);
+};
+
+/**
+ * Matcher that compares the actual to NaN.
+ */
+jasmine.Matchers.prototype.toBeNaN = function() {
+	this.message = function() {
+		return [ "Expected " + jasmine.pp(this.actual) + " to be NaN." ];
+	};
+
+	return (this.actual !== this.actual);
+};
+
+/**
+ * Matcher that boolean not-nots the actual.
+ */
+jasmine.Matchers.prototype.toBeTruthy = function() {
+  return !!this.actual;
+};
+
+
+/**
+ * Matcher that boolean nots the actual.
+ */
+jasmine.Matchers.prototype.toBeFalsy = function() {
+  return !this.actual;
+};
+
+
+/**
+ * Matcher that checks to see if the actual, a Jasmine spy, was called.
+ */
+jasmine.Matchers.prototype.toHaveBeenCalled = function() {
+  if (arguments.length > 0) {
+    throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
+  }
+
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+
+  this.message = function() {
+    return [
+      "Expected spy " + this.actual.identity + " to have been called.",
+      "Expected spy " + this.actual.identity + " not to have been called."
+    ];
+  };
+
+  return this.actual.wasCalled;
+};
+
+/** @deprecated Use expect(xxx).toHaveBeenCalled() instead */
+jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled;
+
+/**
+ * Matcher that checks to see if the actual, a Jasmine spy, was not called.
+ *
+ * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead
+ */
+jasmine.Matchers.prototype.wasNotCalled = function() {
+  if (arguments.length > 0) {
+    throw new Error('wasNotCalled does not take arguments');
+  }
+
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+
+  this.message = function() {
+    return [
+      "Expected spy " + this.actual.identity + " to not have been called.",
+      "Expected spy " + this.actual.identity + " to have been called."
+    ];
+  };
+
+  return !this.actual.wasCalled;
+};
+
+/**
+ * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
+ *
+ * @example
+ *
+ */
+jasmine.Matchers.prototype.toHaveBeenCalledWith = function() {
+  var expectedArgs = jasmine.util.argsToArray(arguments);
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+  this.message = function() {
+    var invertedMessage = "Expected spy " + this.actual.identity + " not to have been called with " + jasmine.pp(expectedArgs) + " but it was.";
+    var positiveMessage = "";
+    if (this.actual.callCount === 0) {
+      positiveMessage = "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but it was never called.";
+    } else {
+      positiveMessage = "Expected spy " + this.actual.identity + " to have been called with " + jasmine.pp(expectedArgs) + " but actual calls were " + jasmine.pp(this.actual.argsForCall).replace(/^\[ | \]$/g, '')
+    }
+    return [positiveMessage, invertedMessage];
+  };
+
+  return this.env.contains_(this.actual.argsForCall, expectedArgs);
+};
+
+/** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */
+jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith;
+
+/** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */
+jasmine.Matchers.prototype.wasNotCalledWith = function() {
+  var expectedArgs = jasmine.util.argsToArray(arguments);
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
+  }
+
+  this.message = function() {
+    return [
+      "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was",
+      "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was"
+    ];
+  };
+
+  return !this.env.contains_(this.actual.argsForCall, expectedArgs);
+};
+
+/**
+ * Matcher that checks that the expected item is an element in the actual Array.
+ *
+ * @param {Object} expected
+ */
+jasmine.Matchers.prototype.toContain = function(expected) {
+  return this.env.contains_(this.actual, expected);
+};
+
+/**
+ * Matcher that checks that the expected item is NOT an element in the actual Array.
+ *
+ * @param {Object} expected
+ * @deprecated as of 1.0. Use not.toContain() instead.
+ */
+jasmine.Matchers.prototype.toNotContain = function(expected) {
+  return !this.env.contains_(this.actual, expected);
+};
+
+jasmine.Matchers.prototype.toBeLessThan = function(expected) {
+  return this.actual < expected;
+};
+
+jasmine.Matchers.prototype.toBeGreaterThan = function(expected) {
+  return this.actual > expected;
+};
+
+/**
+ * Matcher that checks that the expected item is equal to the actual item
+ * up to a given level of decimal precision (default 2).
+ *
+ * @param {Number} expected
+ * @param {Number} precision, as number of decimal places
+ */
+jasmine.Matchers.prototype.toBeCloseTo = function(expected, precision) {
+  if (!(precision === 0)) {
+    precision = precision || 2;
+  }
+  return Math.abs(expected - this.actual) < (Math.pow(10, -precision) / 2);
+};
+
+/**
+ * Matcher that checks that the expected exception was thrown by the actual.
+ *
+ * @param {String} [expected]
+ */
+jasmine.Matchers.prototype.toThrow = function(expected) {
+  var result = false;
+  var exception;
+  if (typeof this.actual != 'function') {
+    throw new Error('Actual is not a function');
+  }
+  try {
+    this.actual();
+  } catch (e) {
+    exception = e;
+  }
+  if (exception) {
+    result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected));
+  }
+
+  var not = this.isNot ? "not " : "";
+
+  this.message = function() {
+    if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
+      return ["Expected function " + not + "to throw", expected ? expected.message || expected : "an exception", ", but it threw", exception.message || exception].join(' ');
+    } else {
+      return "Expected function to throw an exception.";
+    }
+  };
+
+  return result;
+};
+
+jasmine.Matchers.Any = function(expectedClass) {
+  this.expectedClass = expectedClass;
+};
+
+jasmine.Matchers.Any.prototype.jasmineMatches = function(other) {
+  if (this.expectedClass == String) {
+    return typeof other == 'string' || other instanceof String;
+  }
+
+  if (this.expectedClass == Number) {
+    return typeof other == 'number' || other instanceof Number;
+  }
+
+  if (this.expectedClass == Function) {
+    return typeof other == 'function' || other instanceof Function;
+  }
+
+  if (this.expectedClass == Object) {
+    return typeof other == 'object';
+  }
+
+  return other instanceof this.expectedClass;
+};
+
+jasmine.Matchers.Any.prototype.jasmineToString = function() {
+  return '<jasmine.any(' + this.expectedClass + ')>';
+};
+
+jasmine.Matchers.ObjectContaining = function (sample) {
+  this.sample = sample;
+};
+
+jasmine.Matchers.ObjectContaining.prototype.jasmineMatches = function(other, mismatchKeys, mismatchValues) {
+  mismatchKeys = mismatchKeys || [];
+  mismatchValues = mismatchValues || [];
+
+  var env = jasmine.getEnv();
+
+  var hasKey = function(obj, keyName) {
+    return obj != null && obj[keyName] !== jasmine.undefined;
+  };
+
+  for (var property in this.sample) {
+    if (!hasKey(other, property) && hasKey(this.sample, property)) {
+      mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
+    }
+    else if (!env.equals_(this.sample[property], other[property], mismatchKeys, mismatchValues)) {
+      mismatchValues.push("'" + property + "' was '" + (other[property] ? jasmine.util.htmlEscape(other[property].toString()) : other[property]) + "' in expected, but was '" + (this.sample[property] ? jasmine.util.htmlEscape(this.sample[property].toString()) : this.sample[property]) + "' in actual.");
+    }
+  }
+
+  return (mismatchKeys.length === 0 && mismatchValues.length === 0);
+};
+
+jasmine.Matchers.ObjectContaining.prototype.jasmineToString = function () {
+  return "<jasmine.objectContaining(" + jasmine.pp(this.sample) + ")>";
+};
+// Mock setTimeout, clearTimeout
+// Contributed by Pivotal Computer Systems, www.pivotalsf.com
+
+jasmine.FakeTimer = function() {
+  this.reset();
+
+  var self = this;
+  self.setTimeout = function(funcToCall, millis) {
+    self.timeoutsMade++;
+    self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false);
+    return self.timeoutsMade;
+  };
+
+  self.setInterval = function(funcToCall, millis) {
+    self.timeoutsMade++;
+    self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true);
+    return self.timeoutsMade;
+  };
+
+  self.clearTimeout = function(timeoutKey) {
+    self.scheduledFunctions[timeoutKey] = jasmine.undefined;
+  };
+
+  self.clearInterval = function(timeoutKey) {
+    self.scheduledFunctions[timeoutKey] = jasmine.undefined;
+  };
+
+};
+
+jasmine.FakeTimer.prototype.reset = function() {
+  this.timeoutsMade = 0;
+  this.scheduledFunctions = {};
+  this.nowMillis = 0;
+};
+
+jasmine.FakeTimer.prototype.tick = function(millis) {
+  var oldMillis = this.nowMillis;
+  var newMillis = oldMillis + millis;
+  this.runFunctionsWithinRange(oldMillis, newMillis);
+  this.nowMillis = newMillis;
+};
+
+jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) {
+  var scheduledFunc;
+  var funcsToRun = [];
+  for (var timeoutKey in this.scheduledFunctions) {
+    scheduledFunc = this.scheduledFunctions[timeoutKey];
+    if (scheduledFunc != jasmine.undefined &&
+        scheduledFunc.runAtMillis >= oldMillis &&
+        scheduledFunc.runAtMillis <= nowMillis) {
+      funcsToRun.push(scheduledFunc);
+      this.scheduledFunctions[timeoutKey] = jasmine.undefined;
+    }
+  }
+
+  if (funcsToRun.length > 0) {
+    funcsToRun.sort(function(a, b) {
+      return a.runAtMillis - b.runAtMillis;
+    });
+    for (var i = 0; i < funcsToRun.length; ++i) {
+      try {
+        var funcToRun = funcsToRun[i];
+        this.nowMillis = funcToRun.runAtMillis;
+        funcToRun.funcToCall();
+        if (funcToRun.recurring) {
+          this.scheduleFunction(funcToRun.timeoutKey,
+              funcToRun.funcToCall,
+              funcToRun.millis,
+              true);
+        }
+      } catch(e) {
+      }
+    }
+    this.runFunctionsWithinRange(oldMillis, nowMillis);
+  }
+};
+
+jasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) {
+  this.scheduledFunctions[timeoutKey] = {
+    runAtMillis: this.nowMillis + millis,
+    funcToCall: funcToCall,
+    recurring: recurring,
+    timeoutKey: timeoutKey,
+    millis: millis
+  };
+};
+
+/**
+ * @namespace
+ */
+jasmine.Clock = {
+  defaultFakeTimer: new jasmine.FakeTimer(),
+
+  reset: function() {
+    jasmine.Clock.assertInstalled();
+    jasmine.Clock.defaultFakeTimer.reset();
+  },
+
+  tick: function(millis) {
+    jasmine.Clock.assertInstalled();
+    jasmine.Clock.defaultFakeTimer.tick(millis);
+  },
+
+  runFunctionsWithinRange: function(oldMillis, nowMillis) {
+    jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis);
+  },
+
+  scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {
+    jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring);
+  },
+
+  useMock: function() {
+    if (!jasmine.Clock.isInstalled()) {
+      var spec = jasmine.getEnv().currentSpec;
+      spec.after(jasmine.Clock.uninstallMock);
+
+      jasmine.Clock.installMock();
+    }
+  },
+
+  installMock: function() {
+    jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer;
+  },
+
+  uninstallMock: function() {
+    jasmine.Clock.assertInstalled();
+    jasmine.Clock.installed = jasmine.Clock.real;
+  },
+
+  real: {
+    setTimeout: jasmine.getGlobal().setTimeout,
+    clearTimeout: jasmine.getGlobal().clearTimeout,
+    setInterval: jasmine.getGlobal().setInterval,
+    clearInterval: jasmine.getGlobal().clearInterval
+  },
+
+  assertInstalled: function() {
+    if (!jasmine.Clock.isInstalled()) {
+      throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
+    }
+  },
+
+  isInstalled: function() {
+    return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer;
+  },
+
+  installed: null
+};
+jasmine.Clock.installed = jasmine.Clock.real;
+
+//else for IE support
+jasmine.getGlobal().setTimeout = function(funcToCall, millis) {
+  if (jasmine.Clock.installed.setTimeout.apply) {
+    return jasmine.Clock.installed.setTimeout.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.setTimeout(funcToCall, millis);
+  }
+};
+
+jasmine.getGlobal().setInterval = function(funcToCall, millis) {
+  if (jasmine.Clock.installed.setInterval.apply) {
+    return jasmine.Clock.installed.setInterval.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.setInterval(funcToCall, millis);
+  }
+};
+
+jasmine.getGlobal().clearTimeout = function(timeoutKey) {
+  if (jasmine.Clock.installed.clearTimeout.apply) {
+    return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.clearTimeout(timeoutKey);
+  }
+};
+
+jasmine.getGlobal().clearInterval = function(timeoutKey) {
+  if (jasmine.Clock.installed.clearTimeout.apply) {
+    return jasmine.Clock.installed.clearInterval.apply(this, arguments);
+  } else {
+    return jasmine.Clock.installed.clearInterval(timeoutKey);
+  }
+};
+
+/**
+ * @constructor
+ */
+jasmine.MultiReporter = function() {
+  this.subReporters_ = [];
+};
+jasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter);
+
+jasmine.MultiReporter.prototype.addReporter = function(reporter) {
+  this.subReporters_.push(reporter);
+};
+
+(function() {
+  var functionNames = [
+    "reportRunnerStarting",
+    "reportRunnerResults",
+    "reportSuiteResults",
+    "reportSpecStarting",
+    "reportSpecResults",
+    "log"
+  ];
+  for (var i = 0; i < functionNames.length; i++) {
+    var functionName = functionNames[i];
+    jasmine.MultiReporter.prototype[functionName] = (function(functionName) {
+      return function() {
+        for (var j = 0; j < this.subReporters_.length; j++) {
+          var subReporter = this.subReporters_[j];
+          if (subReporter[functionName]) {
+            subReporter[functionName].apply(subReporter, arguments);
+          }
+        }
+      };
+    })(functionName);
+  }
+})();
+/**
+ * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults
+ *
+ * @constructor
+ */
+jasmine.NestedResults = function() {
+  /**
+   * The total count of results
+   */
+  this.totalCount = 0;
+  /**
+   * Number of passed results
+   */
+  this.passedCount = 0;
+  /**
+   * Number of failed results
+   */
+  this.failedCount = 0;
+  /**
+   * Was this suite/spec skipped?
+   */
+  this.skipped = false;
+  /**
+   * @ignore
+   */
+  this.items_ = [];
+};
+
+/**
+ * Roll up the result counts.
+ *
+ * @param result
+ */
+jasmine.NestedResults.prototype.rollupCounts = function(result) {
+  this.totalCount += result.totalCount;
+  this.passedCount += result.passedCount;
+  this.failedCount += result.failedCount;
+};
+
+/**
+ * Adds a log message.
+ * @param values Array of message parts which will be concatenated later.
+ */
+jasmine.NestedResults.prototype.log = function(values) {
+  this.items_.push(new jasmine.MessageResult(values));
+};
+
+/**
+ * Getter for the results: message & results.
+ */
+jasmine.NestedResults.prototype.getItems = function() {
+  return this.items_;
+};
+
+/**
+ * Adds a result, tracking counts (total, passed, & failed)
+ * @param {jasmine.ExpectationResult|jasmine.NestedResults} result
+ */
+jasmine.NestedResults.prototype.addResult = function(result) {
+  if (result.type != 'log') {
+    if (result.items_) {
+      this.rollupCounts(result);
+    } else {
+      this.totalCount++;
+      if (result.passed()) {
+        this.passedCount++;
+      } else {
+        this.failedCount++;
+      }
+    }
+  }
+  this.items_.push(result);
+};
+
+/**
+ * @returns {Boolean} True if <b>everything</b> below passed
+ */
+jasmine.NestedResults.prototype.passed = function() {
+  return this.passedCount === this.totalCount;
+};
+/**
+ * Base class for pretty printing for expectation results.
+ */
+jasmine.PrettyPrinter = function() {
+  this.ppNestLevel_ = 0;
+};
+
+/**
+ * Formats a value in a nice, human-readable string.
+ *
+ * @param value
+ */
+jasmine.PrettyPrinter.prototype.format = function(value) {
+  this.ppNestLevel_++;
+  try {
+    if (value === jasmine.undefined) {
+      this.emitScalar('undefined');
+    } else if (value === null) {
+      this.emitScalar('null');
+    } else if (value === jasmine.getGlobal()) {
+      this.emitScalar('<global>');
+    } else if (value.jasmineToString) {
+      this.emitScalar(value.jasmineToString());
+    } else if (typeof value === 'string') {
+      this.emitString(value);
+    } else if (jasmine.isSpy(value)) {
+      this.emitScalar("spy on " + value.identity);
+    } else if (value instanceof RegExp) {
+      this.emitScalar(value.toString());
+    } else if (typeof value === 'function') {
+      this.emitScalar('Function');
+    } else if (typeof value.nodeType === 'number') {
+      this.emitScalar('HTMLNode');
+    } else if (value instanceof Date) {
+      this.emitScalar('Date(' + value + ')');
+    } else if (value.__Jasmine_been_here_before__) {
+      this.emitScalar('<circular reference: ' + (jasmine.isArray_(value) ? 'Array' : 'Object') + '>');
+    } else if (jasmine.isArray_(value) || typeof value == 'object') {
+      value.__Jasmine_been_here_before__ = true;
+      if (jasmine.isArray_(value)) {
+        this.emitArray(value);
+      } else {
+        this.emitObject(value);
+      }
+      delete value.__Jasmine_been_here_before__;
+    } else {
+      this.emitScalar(value.toString());
+    }
+  } finally {
+    this.ppNestLevel_--;
+  }
+};
+
+jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) {
+  for (var property in obj) {
+    if (!obj.hasOwnProperty(property)) continue;
+    if (property == '__Jasmine_been_here_before__') continue;
+    fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) !== jasmine.undefined && 
+                                         obj.__lookupGetter__(property) !== null) : false);
+  }
+};
+
+jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_;
+jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_;
+
+jasmine.StringPrettyPrinter = function() {
+  jasmine.PrettyPrinter.call(this);
+
+  this.string = '';
+};
+jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter);
+
+jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) {
+  this.append(value);
+};
+
+jasmine.StringPrettyPrinter.prototype.emitString = function(value) {
+  this.append("'" + value + "'");
+};
+
+jasmine.StringPrettyPrinter.prototype.emitArray = function(array) {
+  if (this.ppNestLevel_ > jasmine.MAX_PRETTY_PRINT_DEPTH) {
+    this.append("Array");
+    return;
+  }
+
+  this.append('[ ');
+  for (var i = 0; i < array.length; i++) {
+    if (i > 0) {
+      this.append(', ');
+    }
+    this.format(array[i]);
+  }
+  this.append(' ]');
+};
+
+jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {
+  if (this.ppNestLevel_ > jasmine.MAX_PRETTY_PRINT_DEPTH) {
+    this.append("Object");
+    return;
+  }
+
+  var self = this;
+  this.append('{ ');
+  var first = true;
+
+  this.iterateObject(obj, function(property, isGetter) {
+    if (first) {
+      first = false;
+    } else {
+      self.append(', ');
+    }
+
+    self.append(property);
+    self.append(' : ');
+    if (isGetter) {
+      self.append('<getter>');
+    } else {
+      self.format(obj[property]);
+    }
+  });
+
+  this.append(' }');
+};
+
+jasmine.StringPrettyPrinter.prototype.append = function(value) {
+  this.string += value;
+};
+jasmine.Queue = function(env) {
+  this.env = env;
+
+  // parallel to blocks. each true value in this array means the block will
+  // get executed even if we abort
+  this.ensured = [];
+  this.blocks = [];
+  this.running = false;
+  this.index = 0;
+  this.offset = 0;
+  this.abort = false;
+};
+
+jasmine.Queue.prototype.addBefore = function(block, ensure) {
+  if (ensure === jasmine.undefined) {
+    ensure = false;
+  }
+
+  this.blocks.unshift(block);
+  this.ensured.unshift(ensure);
+};
+
+jasmine.Queue.prototype.add = function(block, ensure) {
+  if (ensure === jasmine.undefined) {
+    ensure = false;
+  }
+
+  this.blocks.push(block);
+  this.ensured.push(ensure);
+};
+
+jasmine.Queue.prototype.insertNext = function(block, ensure) {
+  if (ensure === jasmine.undefined) {
+    ensure = false;
+  }
+
+  this.ensured.splice((this.index + this.offset + 1), 0, ensure);
+  this.blocks.splice((this.index + this.offset + 1), 0, block);
+  this.offset++;
+};
+
+jasmine.Queue.prototype.start = function(onComplete) {
+  this.running = true;
+  this.onComplete = onComplete;
+  this.next_();
+};
+
+jasmine.Queue.prototype.isRunning = function() {
+  return this.running;
+};
+
+jasmine.Queue.LOOP_DONT_RECURSE = true;
+
+jasmine.Queue.prototype.next_ = function() {
+  var self = this;
+  var goAgain = true;
+
+  while (goAgain) {
+    goAgain = false;
+    
+    if (self.index < self.blocks.length && !(this.abort && !this.ensured[self.index])) {
+      var calledSynchronously = true;
+      var completedSynchronously = false;
+
+      var onComplete = function () {
+        if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) {
+          completedSynchronously = true;
+          return;
+        }
+
+        if (self.blocks[self.index].abort) {
+          self.abort = true;
+        }
+
+        self.offset = 0;
+        self.index++;
+
+        var now = new Date().getTime();
+        if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) {
+          self.env.lastUpdate = now;
+          self.env.setTimeout(function() {
+            self.next_();
+          }, 0);
+        } else {
+          if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) {
+            goAgain = true;
+          } else {
+            self.next_();
+          }
+        }
+      };
+      self.blocks[self.index].execute(onComplete);
+
+      calledSynchronously = false;
+      if (completedSynchronously) {
+        onComplete();
+      }
+      
+    } else {
+      self.running = false;
+      if (self.onComplete) {
+        self.onComplete();
+      }
+    }
+  }
+};
+
+jasmine.Queue.prototype.results = function() {
+  var results = new jasmine.NestedResults();
+  for (var i = 0; i < this.blocks.length; i++) {
+    if (this.blocks[i].results) {
+      results.addResult(this.blocks[i].results());
+    }
+  }
+  return results;
+};
+
+
+/**
+ * Runner
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ */
+jasmine.Runner = function(env) {
+  var self = this;
+  self.env = env;
+  self.queue = new jasmine.Queue(env);
+  self.before_ = [];
+  self.after_ = [];
+  self.suites_ = [];
+};
+
+jasmine.Runner.prototype.execute = function() {
+  var self = this;
+  if (self.env.reporter.reportRunnerStarting) {
+    self.env.reporter.reportRunnerStarting(this);
+  }
+  self.queue.start(function () {
+    self.finishCallback();
+  });
+};
+
+jasmine.Runner.prototype.beforeEach = function(beforeEachFunction) {
+  beforeEachFunction.typeName = 'beforeEach';
+  this.before_.splice(0,0,beforeEachFunction);
+};
+
+jasmine.Runner.prototype.afterEach = function(afterEachFunction) {
+  afterEachFunction.typeName = 'afterEach';
+  this.after_.splice(0,0,afterEachFunction);
+};
+
+
+jasmine.Runner.prototype.finishCallback = function() {
+  this.env.reporter.reportRunnerResults(this);
+};
+
+jasmine.Runner.prototype.addSuite = function(suite) {
+  this.suites_.push(suite);
+};
+
+jasmine.Runner.prototype.add = function(block) {
+  if (block instanceof jasmine.Suite) {
+    this.addSuite(block);
+  }
+  this.queue.add(block);
+};
+
+jasmine.Runner.prototype.specs = function () {
+  var suites = this.suites();
+  var specs = [];
+  for (var i = 0; i < suites.length; i++) {
+    specs = specs.concat(suites[i].specs());
+  }
+  return specs;
+};
+
+jasmine.Runner.prototype.suites = function() {
+  return this.suites_;
+};
+
+jasmine.Runner.prototype.topLevelSuites = function() {
+  var topLevelSuites = [];
+  for (var i = 0; i < this.suites_.length; i++) {
+    if (!this.suites_[i].parentSuite) {
+      topLevelSuites.push(this.suites_[i]);
+    }
+  }
+  return topLevelSuites;
+};
+
+jasmine.Runner.prototype.results = function() {
+  return this.queue.results();
+};
+/**
+ * Internal representation of a Jasmine specification, or test.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {jasmine.Suite} suite
+ * @param {String} description
+ */
+jasmine.Spec = function(env, suite, description) {
+  if (!env) {
+    throw new Error('jasmine.Env() required');
+  }
+  if (!suite) {
+    throw new Error('jasmine.Suite() required');
+  }
+  var spec = this;
+  spec.id = env.nextSpecId ? env.nextSpecId() : null;
+  spec.env = env;
+  spec.suite = suite;
+  spec.description = description;
+  spec.queue = new jasmine.Queue(env);
+
+  spec.afterCallbacks = [];
+  spec.spies_ = [];
+
+  spec.results_ = new jasmine.NestedResults();
+  spec.results_.description = description;
+  spec.matchersClass = null;
+};
+
+jasmine.Spec.prototype.getFullName = function() {
+  return this.suite.getFullName() + ' ' + this.description + '.';
+};
+
+
+jasmine.Spec.prototype.results = function() {
+  return this.results_;
+};
+
+/**
+ * All parameters are pretty-printed and concatenated together, then written to the spec's output.
+ *
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
+ */
+jasmine.Spec.prototype.log = function() {
+  return this.results_.log(arguments);
+};
+
+jasmine.Spec.prototype.runs = function (func) {
+  var block = new jasmine.Block(this.env, func, this);
+  this.addToQueue(block);
+  return this;
+};
+
+jasmine.Spec.prototype.addToQueue = function (block) {
+  if (this.queue.isRunning()) {
+    this.queue.insertNext(block);
+  } else {
+    this.queue.add(block);
+  }
+};
+
+/**
+ * @param {jasmine.ExpectationResult} result
+ */
+jasmine.Spec.prototype.addMatcherResult = function(result) {
+  this.results_.addResult(result);
+};
+
+jasmine.Spec.prototype.expect = function(actual) {
+  var positive = new (this.getMatchersClass_())(this.env, actual, this);
+  positive.not = new (this.getMatchersClass_())(this.env, actual, this, true);
+  return positive;
+};
+
+/**
+ * Waits a fixed time period before moving to the next block.
+ *
+ * @deprecated Use waitsFor() instead
+ * @param {Number} timeout milliseconds to wait
+ */
+jasmine.Spec.prototype.waits = function(timeout) {
+  var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this);
+  this.addToQueue(waitsFunc);
+  return this;
+};
+
+/**
+ * Waits for the latchFunction to return true before proceeding to the next block.
+ *
+ * @param {Function} latchFunction
+ * @param {String} optional_timeoutMessage
+ * @param {Number} optional_timeout
+ */
+jasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
+  var latchFunction_ = null;
+  var optional_timeoutMessage_ = null;
+  var optional_timeout_ = null;
+
+  for (var i = 0; i < arguments.length; i++) {
+    var arg = arguments[i];
+    switch (typeof arg) {
+      case 'function':
+        latchFunction_ = arg;
+        break;
+      case 'string':
+        optional_timeoutMessage_ = arg;
+        break;
+      case 'number':
+        optional_timeout_ = arg;
+        break;
+    }
+  }
+
+  var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this);
+  this.addToQueue(waitsForFunc);
+  return this;
+};
+
+jasmine.Spec.prototype.fail = function (e) {
+  var expectationResult = new jasmine.ExpectationResult({
+    passed: false,
+    message: e ? jasmine.util.formatException(e) : 'Exception',
+    trace: { stack: e.stack }
+  });
+  this.results_.addResult(expectationResult);
+};
+
+jasmine.Spec.prototype.getMatchersClass_ = function() {
+  return this.matchersClass || this.env.matchersClass;
+};
+
+jasmine.Spec.prototype.addMatchers = function(matchersPrototype) {
+  var parent = this.getMatchersClass_();
+  var newMatchersClass = function() {
+    parent.apply(this, arguments);
+  };
+  jasmine.util.inherit(newMatchersClass, parent);
+  jasmine.Matchers.wrapInto_(matchersPrototype, newMatchersClass);
+  this.matchersClass = newMatchersClass;
+};
+
+jasmine.Spec.prototype.finishCallback = function() {
+  this.env.reporter.reportSpecResults(this);
+};
+
+jasmine.Spec.prototype.finish = function(onComplete) {
+  this.removeAllSpies();
+  this.finishCallback();
+  if (onComplete) {
+    onComplete();
+  }
+};
+
+jasmine.Spec.prototype.after = function(doAfter) {
+  if (this.queue.isRunning()) {
+    this.queue.add(new jasmine.Block(this.env, doAfter, this), true);
+  } else {
+    this.afterCallbacks.unshift(doAfter);
+  }
+};
+
+jasmine.Spec.prototype.execute = function(onComplete) {
+  var spec = this;
+  if (!spec.env.specFilter(spec)) {
+    spec.results_.skipped = true;
+    spec.finish(onComplete);
+    return;
+  }
+
+  this.env.reporter.reportSpecStarting(this);
+
+  spec.env.currentSpec = spec;
+
+  spec.addBeforesAndAftersToQueue();
+
+  spec.queue.start(function () {
+    spec.finish(onComplete);
+  });
+};
+
+jasmine.Spec.prototype.addBeforesAndAftersToQueue = function() {
+  var runner = this.env.currentRunner();
+  var i;
+
+  for (var suite = this.suite; suite; suite = suite.parentSuite) {
+    for (i = 0; i < suite.before_.length; i++) {
+      this.queue.addBefore(new jasmine.Block(this.env, suite.before_[i], this));
+    }
+  }
+  for (i = 0; i < runner.before_.length; i++) {
+    this.queue.addBefore(new jasmine.Block(this.env, runner.before_[i], this));
+  }
+  for (i = 0; i < this.afterCallbacks.length; i++) {
+    this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this), true);
+  }
+  for (suite = this.suite; suite; suite = suite.parentSuite) {
+    for (i = 0; i < suite.after_.length; i++) {
+      this.queue.add(new jasmine.Block(this.env, suite.after_[i], this), true);
+    }
+  }
+  for (i = 0; i < runner.after_.length; i++) {
+    this.queue.add(new jasmine.Block(this.env, runner.after_[i], this), true);
+  }
+};
+
+jasmine.Spec.prototype.explodes = function() {
+  throw 'explodes function should not have been called';
+};
+
+jasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) {
+  if (obj == jasmine.undefined) {
+    throw "spyOn could not find an object to spy upon for " + methodName + "()";
+  }
+
+  if (!ignoreMethodDoesntExist && obj[methodName] === jasmine.undefined) {
+    throw methodName + '() method does not exist';
+  }
+
+  if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) {
+    throw new Error(methodName + ' has already been spied upon');
+  }
+
+  var spyObj = jasmine.createSpy(methodName);
+
+  this.spies_.push(spyObj);
+  spyObj.baseObj = obj;
+  spyObj.methodName = methodName;
+  spyObj.originalValue = obj[methodName];
+
+  obj[methodName] = spyObj;
+
+  return spyObj;
+};
+
+jasmine.Spec.prototype.removeAllSpies = function() {
+  for (var i = 0; i < this.spies_.length; i++) {
+    var spy = this.spies_[i];
+    spy.baseObj[spy.methodName] = spy.originalValue;
+  }
+  this.spies_ = [];
+};
+
+/**
+ * Internal representation of a Jasmine suite.
+ *
+ * @constructor
+ * @param {jasmine.Env} env
+ * @param {String} description
+ * @param {Function} specDefinitions
+ * @param {jasmine.Suite} parentSuite
+ */
+jasmine.Suite = function(env, description, specDefinitions, parentSuite) {
+  var self = this;
+  self.id = env.nextSuiteId ? env.nextSuiteId() : null;
+  self.description = description;
+  self.queue = new jasmine.Queue(env);
+  self.parentSuite = parentSuite;
+  self.env = env;
+  self.before_ = [];
+  self.after_ = [];
+  self.children_ = [];
+  self.suites_ = [];
+  self.specs_ = [];
+};
+
+jasmine.Suite.prototype.getFullName = function() {
+  var fullName = this.description;
+  for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
+    fullName = parentSuite.description + ' ' + fullName;
+  }
+  return fullName;
+};
+
+jasmine.Suite.prototype.finish = function(onComplete) {
+  this.env.reporter.reportSuiteResults(this);
+  this.finished = true;
+  if (typeof(onComplete) == 'function') {
+    onComplete();
+  }
+};
+
+jasmine.Suite.prototype.beforeEach = function(beforeEachFunction) {
+  beforeEachFunction.typeName = 'beforeEach';
+  this.before_.unshift(beforeEachFunction);
+};
+
+jasmine.Suite.prototype.afterEach = function(afterEachFunction) {
+  afterEachFunction.typeName = 'afterEach';
+  this.after_.unshift(afterEachFunction);
+};
+
+jasmine.Suite.prototype.results = function() {
+  return this.queue.results();
+};
+
+jasmine.Suite.prototype.add = function(suiteOrSpec) {
+  this.children_.push(suiteOrSpec);
+  if (suiteOrSpec instanceof jasmine.Suite) {
+    this.suites_.push(suiteOrSpec);
+    this.env.currentRunner().addSuite(suiteOrSpec);
+  } else {
+    this.specs_.push(suiteOrSpec);
+  }
+  this.queue.add(suiteOrSpec);
+};
+
+jasmine.Suite.prototype.specs = function() {
+  return this.specs_;
+};
+
+jasmine.Suite.prototype.suites = function() {
+  return this.suites_;
+};
+
+jasmine.Suite.prototype.children = function() {
+  return this.children_;
+};
+
+jasmine.Suite.prototype.execute = function(onComplete) {
+  var self = this;
+  this.queue.start(function () {
+    self.finish(onComplete);
+  });
+};
+jasmine.WaitsBlock = function(env, timeout, spec) {
+  this.timeout = timeout;
+  jasmine.Block.call(this, env, null, spec);
+};
+
+jasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block);
+
+jasmine.WaitsBlock.prototype.execute = function (onComplete) {
+  if (jasmine.VERBOSE) {
+    this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...');
+  }
+  this.env.setTimeout(function () {
+    onComplete();
+  }, this.timeout);
+};
+/**
+ * A block which waits for some condition to become true, with timeout.
+ *
+ * @constructor
+ * @extends jasmine.Block
+ * @param {jasmine.Env} env The Jasmine environment.
+ * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true.
+ * @param {Function} latchFunction A function which returns true when the desired condition has been met.
+ * @param {String} message The message to display if the desired condition hasn't been met within the given time period.
+ * @param {jasmine.Spec} spec The Jasmine spec.
+ */
+jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) {
+  this.timeout = timeout || env.defaultTimeoutInterval;
+  this.latchFunction = latchFunction;
+  this.message = message;
+  this.totalTimeSpentWaitingForLatch = 0;
+  jasmine.Block.call(this, env, null, spec);
+};
+jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block);
+
+jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10;
+
+jasmine.WaitsForBlock.prototype.execute = function(onComplete) {
+  if (jasmine.VERBOSE) {
+    this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen'));
+  }
+  var latchFunctionResult;
+  try {
+    latchFunctionResult = this.latchFunction.apply(this.spec);
+  } catch (e) {
+    this.spec.fail(e);
+    onComplete();
+    return;
+  }
+
+  if (latchFunctionResult) {
+    onComplete();
+  } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) {
+    var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen');
+    this.spec.fail({
+      name: 'timeout',
+      message: message
+    });
+
+    this.abort = true;
+    onComplete();
+  } else {
+    this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
+    var self = this;
+    this.env.setTimeout(function() {
+      self.execute(onComplete);
+    }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
+  }
+};
+
+jasmine.version_= {
+  "major": 1,
+  "minor": 3,
+  "build": 1,
+  "revision": 1354556913
+};

Libraries/jquery-GPL-LICENSE.txt

+        GNU GENERAL PUBLIC LICENSE
+           Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+          Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+        GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+          NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.

Libraries/jquery-MIT-LICENSE.txt

+Copyright (c) 2009 John Resig, http://jquery.com/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Libraries/jquery.tinysort.js

+/*! TinySort 1.4.29
+* Copyright (c) 2008-2012 Ron Valstar http://www.sjeiti.com/
+*
+* Dual licensed under the MIT and GPL licenses:
+*   http://www.opensource.org/licenses/mit-license.php
+*   http://www.gnu.org/licenses/gpl.html
+*//*
+* Description:
+*   A jQuery plugin to sort child nodes by (sub) contents or attributes.
+*
+* Contributors:
+*	brian.gibson@gmail.com
+*	michael.thornberry@gmail.com
+*
+* Usage:
+*   $("ul#people>li").tsort();
+*   $("ul#people>li").tsort("span.surname");
+*   $("ul#people>li").tsort("span.surname",{order:"desc"});
+*   $("ul#people>li").tsort({place:"end"});
+*
+* Change default like so:
+*   $.tinysort.defaults.order = "desc";
+*
+* in this update:
+* 	- added plugin hook
+*   - stripped non-latin character ordering and turned it into a plugin
+*
+* in last update:
+*   - header comment no longer stripped in minified version
+*	- revision number no longer corresponds to svn revision since it's now git
+*
+* Todos:
+* 	- todo: uppercase vs lowercase
+* 	- todo: 'foobar' != 'foobars' in non-latin
+*
+*/
+;(function($) {
+	// private vars
+	var fls = !1							// minify placeholder
+		,nll = null							// minify placeholder
+		,prsflt = parseFloat				// minify placeholder
+		,mathmn = Math.min					// minify placeholder
+		,rxLastNr = /(-?\d+\.?\d*)$/g		// regex for testing strings ending on numbers
+		,aPluginPrepare = []
+		,aPluginSort = []
+	;
+	//
+	// init plugin
+	$.tinysort = {
+		 id: 'TinySort'
+		,version: '1.4.29'
+		,copyright: 'Copyright (c) 2008-2012 Ron Valstar'
+		,uri: 'http://tinysort.sjeiti.com/'
+		,licensed: {
+			MIT: 'http://www.opensource.org/licenses/mit-license.php'
+			,GPL: 'http://www.gnu.org/licenses/gpl.html'
+		}
+		,plugin: function(prepare,sort){
+			aPluginPrepare.push(prepare);	// function(settings){doStuff();}
+			aPluginSort.push(sort);			// function(valuesAreNumeric,sA,sB,iReturn){doStuff();return iReturn;}
+		}
+		,defaults: { // default settings
+
+			 order: 'asc'			// order: asc, desc or rand
+
+			,attr: nll				// order by attribute value
+			,data: nll				// use the data attribute for sorting
+			,useVal: fls			// use element value instead of text
+
+			,place: 'start'			// place ordered elements at position: start, end, org (original position), first
+			,returns: fls			// return all elements or only the sorted ones (true/false)
+
+			,cases: fls				// a case sensitive sort orders [aB,aa,ab,bb]
+			,forceStrings:fls		// if false the string '2' will sort with the value 2, not the string '2'
+
+			,sortFunction: nll		// override the default sort function
+		}
+	};
+	$.fn.extend({
+		tinysort: function(_find,_settings) {
+			if (_find&&typeof(_find)!='string') {
+				_settings = _find;
+				_find = nll;
+			}
+
+			var oSettings = $.extend({}, $.tinysort.defaults, _settings)
+				,sParent
+				,oThis = this
+				,iLen = $(this).length
+				,oElements = {} // contains sortable- and non-sortable list per parent
+				,bFind = !(!_find||_find=='')
+				,bAttr = !(oSettings.attr===nll||oSettings.attr=="")
+				,bData = oSettings.data!==nll
+				// since jQuery's filter within each works on array index and not actual index we have to create the filter in advance
+				,bFilter = bFind&&_find[0]==':'
+				,$Filter = bFilter?oThis.filter(_find):oThis
+				,fnSort = oSettings.sortFunction
+				,iAsc = oSettings.order=='asc'?1:-1
+				,aNewOrder = []
+			;
+
+			$.each(aPluginPrepare,function(i,fn){
+				fn.call(fn,oSettings);
+			});
+
+
+			if (!fnSort) fnSort = oSettings.order=='rand'?function() {
+				return Math.random()<.5?1:-1;
+			}:function(a,b) {
+				var bNumeric = fls
+				// maybe toLower
+					,sA = !oSettings.cases?toLowerCase(a.s):a.s
+					,sB = !oSettings.cases?toLowerCase(b.s):b.s;
+				// maybe force Strings
+//				var bAString = typeof(sA)=='string';
+//				var bBString = typeof(sB)=='string';
+//				if (!oSettings.forceStrings&&(bAString||bBString)) {
+//					if (!bAString) sA = ''+sA;
+//					if (!bBString) sB = ''+sB;
+				if (!oSettings.forceStrings) {
+					// maybe mixed
+					var  aAnum = sA&&sA.match(rxLastNr)
+						,aBnum = sB&&sB.match(rxLastNr);
+					if (aAnum&&aBnum) {
+						var  sAprv = sA.substr(0,sA.length-aAnum[0].length)
+							,sBprv = sB.substr(0,sB.length-aBnum[0].length);
+						if (sAprv==sBprv) {
+							bNumeric = !fls;
+							sA = prsflt(aAnum[0]);
+							sB = prsflt(aBnum[0]);
+						}
+					}
+				}
+				// return sort-integer
+				var iReturn = iAsc*(sA<sB?-1:(sA>sB?1:0));
+
+				$.each(aPluginSort,function(i,fn){
+					iReturn = fn.call(fn,bNumeric,sA,sB,iReturn);
+				});
+
+				return iReturn;
+			};
+
+			oThis.each(function(i,el) {
+				var $Elm = $(el)
+					// element or sub selection
+					,mElmOrSub = bFind?(bFilter?$Filter.filter(el):$Elm.find(_find)):$Elm
+					// text or attribute value
+					,sSort = bData?''+mElmOrSub.data(oSettings.data):(bAttr?mElmOrSub.attr(oSettings.attr):(oSettings.useVal?mElmOrSub.val():mElmOrSub.text()))
+ 					// to sort or not to sort
+					,mParent = $Elm.parent();
+				if (!oElements[mParent])	oElements[mParent] = {s:[],n:[]};	// s: sort, n: not sort
+				if (mElmOrSub.length>0)		oElements[mParent].s.push({s:sSort,e:$Elm,n:i}); // s:string, e:element, n:number
+				else						oElements[mParent].n.push({e:$Elm,n:i});
+			});
+			//
+			// sort
+			for (sParent in oElements) oElements[sParent].s.sort(fnSort);
+			//
+			// order elements and fill new order
+			for (sParent in oElements) {
+				var oParent = oElements[sParent]
+					,aOrg = [] // list for original position
+					,iLow = iLen
+					,aCnt = [0,0] // count how much we've sorted for retreival from either the sort list or the non-sort list (oParent.s/oParent.n)
+					,i;
+				switch (oSettings.place) {
+					case 'first':	$.each(oParent.s,function(i,obj) { iLow = mathmn(iLow,obj.n) }); break;
+					case 'org':		$.each(oParent.s,function(i,obj) { aOrg.push(obj.n) }); break;
+					case 'end':		iLow = oParent.n.length; break;
+					default:		iLow = 0;
+				}
+				for (i = 0;i<iLen;i++) {
+					var bSList = contains(aOrg,i)?!fls:i>=iLow&&i<iLow+oParent.s.length
+						,mEl = (bSList?oParent.s:oParent.n)[aCnt[bSList?0:1]].e;
+					mEl.parent().append(mEl);
+					if (bSList||!oSettings.returns) aNewOrder.push(mEl.get(0));
+					aCnt[bSList?0:1]++;
+				}
+			}
+			oThis.length = 0;
+			Array.prototype.push.apply(oThis,aNewOrder);
+			return oThis;
+		}
+	});
+	// toLowerCase
+	function toLowerCase(s) {
+		return s&&s.toLowerCase?s.toLowerCase():s;
+	}
+	// array contains
+	function contains(a,n) {
+		for (var i=0,l=a.length;i<l;i++) if (a[i]==n) return !fls;
+		return fls;
+	}
+	// set functions
+	$.fn.TinySort = $.fn.Tinysort = $.fn.tsort = $.fn.tinysort;
+})(jQuery);
+
+/*! Array.prototype.indexOf for IE (issue #26) */
+if (!Array.prototype.indexOf) {
+	Array.prototype.indexOf = function(elt /*, from*/) {
+		var len = this.length
+			,from = Number(arguments[1])||0;
+		from = from<0?Math.ceil(from):Math.floor(from);
+		if (from<0) from += len;
+		for (;from<len;from++){
+			if (from in this && this[from]===elt) return from;
+		}
+		return -1;
+	};
+}

logging @ 1dbed4ac

+Subproject commit 1dbed4ac2d34276e7e2b438118214c417ebe5691

Libraries/sjcl.js

+"use strict";var sjcl={cipher:{},hash:{},keyexchange:{},mode:{},misc:{},codec:{},exception:{corrupt:function(a){this.toString=function(){return"CORRUPT: "+this.message};this.message=a},invalid:function(a){this.toString=function(){return"INVALID: "+this.message};this.message=a},bug:function(a){this.toString=function(){return"BUG: "+this.message};this.message=a},notReady:function(a){this.toString=function(){return"NOT READY: "+this.message};this.message=a}}};
+if(typeof module!="undefined"&&module.exports)module.exports=sjcl;
+sjcl.cipher.aes=function(a){this.h[0][0][0]||this.z();var b,c,d,e,f=this.h[0][4],g=this.h[1];b=a.length;var h=1;if(b!==4&&b!==6&&b!==8)throw new sjcl.exception.invalid("invalid aes key size");this.a=[d=a.slice(0),e=[]];for(a=b;a<4*b+28;a++){c=d[a-1];if(a%b===0||b===8&&a%b===4){c=f[c>>>24]<<24^f[c>>16&255]<<16^f[c>>8&255]<<8^f[c&255];if(a%b===0){c=c<<8^c>>>24^h<<24;h=h<<1^(h>>7)*283}}d[a]=d[a-b]^c}for(b=0;a;b++,a--){c=d[b&3?a:a-4];e[b]=a<=4||b<4?c:g[0][f[c>>>24]]^g[1][f[c>>16&255]]^g[2][f[c>>8&255]]^
+g[3][f[c&255]]}};
+sjcl.cipher.aes.prototype={encrypt:function(a){return this.I(a,0)},decrypt:function(a){return this.I(a,1)},h:[[[],[],[],[],[]],[[],[],[],[],[]]],z:function(){var a=this.h[0],b=this.h[1],c=a[4],d=b[4],e,f,g,h=[],i=[],k,j,l,m;for(e=0;e<0x100;e++)i[(h[e]=e<<1^(e>>7)*283)^e]=e;for(f=g=0;!c[f];f^=k||1,g=i[g]||1){l=g^g<<1^g<<2^g<<3^g<<4;l=l>>8^l&255^99;c[f]=l;d[l]=f;j=h[e=h[k=h[f]]];m=j*0x1010101^e*0x10001^k*0x101^f*0x1010100;j=h[l]*0x101^l*0x1010100;for(e=0;e<4;e++){a[e][f]=j=j<<24^j>>>8;b[e][l]=m=m<<24^m>>>8}}for(e=
+0;e<5;e++){a[e]=a[e].slice(0);b[e]=b[e].slice(0)}},I:function(a,b){if(a.length!==4)throw new sjcl.exception.invalid("invalid aes block size");var c=this.a[b],d=a[0]^c[0],e=a[b?3:1]^c[1],f=a[2]^c[2];a=a[b?1:3]^c[3];var g,h,i,k=c.length/4-2,j,l=4,m=[0,0,0,0];g=this.h[b];var n=g[0],o=g[1],p=g[2],q=g[3],r=g[4];for(j=0;j<k;j++){g=n[d>>>24]^o[e>>16&255]^p[f>>8&255]^q[a&255]^c[l];h=n[e>>>24]^o[f>>16&255]^p[a>>8&255]^q[d&255]^c[l+1];i=n[f>>>24]^o[a>>16&255]^p[d>>8&255]^q[e&255]^c[l+2];a=n[a>>>24]^o[d>>16&
+255]^p[e>>8&255]^q[f&255]^c[l+3];l+=4;d=g;e=h;f=i}for(j=0;j<4;j++){m[b?3&-j:j]=r[d>>>24]<<24^r[e>>16&255]<<16^r[f>>8&255]<<8^r[a&255]^c[l++];g=d;d=e;e=f;f=a;a=g}return m}};
+sjcl.bitArray={bitSlice:function(a,b,c){a=sjcl.bitArray.P(a.slice(b/32),32-(b&31)).slice(1);return c===undefined?a:sjcl.bitArray.clamp(a,c-b)},extract:function(a,b,c){var d=Math.floor(-b-c&31);return((b+c-1^b)&-32?a[b/32|0]<<32-d^a[b/32+1|0]>>>d:a[b/32|0]>>>d)&(1<<c)-1},concat:function(a,b){if(a.length===0||b.length===0)return a.concat(b);var c=a[a.length-1],d=sjcl.bitArray.getPartial(c);return d===32?a.concat(b):sjcl.bitArray.P(b,d,c|0,a.slice(0,a.length-1))},bitLength:function(a){var b=a.length;
+if(b===0)return 0;return(b-1)*32+sjcl.bitArray.getPartial(a[b-1])},clamp:function(a,b){if(a.length*32<b)return a;a=a.slice(0,Math.ceil(b/32));var c=a.length;b&=31;if(c>0&&b)a[c-1]=sjcl.bitArray.partial(b,a[c-1]&2147483648>>b-1,1);return a},partial:function(a,b,c){if(a===32)return b;return(c?b|0:b<<32-a)+a*0x10000000000},getPartial:function(a){return Math.round(a/0x10000000000)||32},equal:function(a,b){if(sjcl.bitArray.bitLength(a)!==sjcl.bitArray.bitLength(b))return false;var c=0,d;for(d=0;d<a.length;d++)c|=
+a[d]^b[d];return c===0},P:function(a,b,c,d){var e;e=0;if(d===undefined)d=[];for(;b>=32;b-=32){d.push(c);c=0}if(b===0)return d.concat(a);for(e=0;e<a.length;e++){d.push(c|a[e]>>>b);c=a[e]<<32-b}e=a.length?a[a.length-1]:0;a=sjcl.bitArray.getPartial(e);d.push(sjcl.bitArray.partial(b+a&31,b+a>32?c:d.pop(),1));return d},k:function(a,b){return[a[0]^b[0],a[1]^b[1],a[2]^b[2],a[3]^b[3]]}};
+sjcl.codec.utf8String={fromBits:function(a){var b="",c=sjcl.bitArray.bitLength(a),d,e;for(d=0;d<c/8;d++){if((d&3)===0)e=a[d/4];b+=String.fromCharCode(e>>>24);e<<=8}return decodeURIComponent(escape(b))},toBits:function(a){a=unescape(encodeURIComponent(a));var b=[],c,d=0;for(c=0;c<a.length;c++){d=d<<8|a.charCodeAt(c);if((c&3)===3){b.push(d);d=0}}c&3&&b.push(sjcl.bitArray.partial(8*(c&3),d));return b}};
+sjcl.codec.hex={fromBits:function(a){var b="",c;for(c=0;c<a.length;c++)b+=((a[c]|0)+0xf00000000000).toString(16).substr(4);return b.substr(0,sjcl.bitArray.bitLength(a)/4)},toBits:function(a){var b,c=[],d;a=a.replace(/\s|0x/g,"");d=a.length;a+="00000000";for(b=0;b<a.length;b+=8)c.push(parseInt(a.substr(b,8),16)^0);return sjcl.bitArray.clamp(c,d*4)}};
+sjcl.codec.base64={F:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",fromBits:function(a,b,c){var d="",e=0,f=sjcl.codec.base64.F,g=0,h=sjcl.bitArray.bitLength(a);if(c)f=f.substr(0,62)+"-_";for(c=0;d.length*6<h;){d+=f.charAt((g^a[c]>>>e)>>>26);if(e<6){g=a[c]<<6-e;e+=26;c++}else{g<<=6;e-=6}}for(;d.length&3&&!b;)d+="=";return d},toBits:function(a,b){a=a.replace(/\s|=/g,"");var c=[],d=0,e=sjcl.codec.base64.F,f=0,g;if(b)e=e.substr(0,62)+"-_";for(b=0;b<a.length;b++){g=e.indexOf(a.charAt(b));
+if(g<0)throw new sjcl.exception.invalid("this isn't base64!");if(d>26){d-=26;c.push(f^g>>>d);f=g<<32-d}else{d+=6;f^=g<<32-d}}d&56&&c.push(sjcl.bitArray.partial(d&56,f,1));return c}};sjcl.codec.base64url={fromBits:function(a){return sjcl.codec.base64.fromBits(a,1,1)},toBits:function(a){return sjcl.codec.base64.toBits(a,1)}};sjcl.hash.sha256=function(a){this.a[0]||this.z();if(a){this.n=a.n.slice(0);this.i=a.i.slice(0);this.e=a.e}else this.reset()};sjcl.hash.sha256.hash=function(a){return(new sjcl.hash.sha256).update(a).finalize()};
+sjcl.hash.sha256.prototype={blockSize:512,reset:function(){this.n=this.N.slice(0);this.i=[];this.e=0;return this},update:function(a){if(typeof a==="string")a=sjcl.codec.utf8String.toBits(a);var b,c=this.i=sjcl.bitArray.concat(this.i,a);b=this.e;a=this.e=b+sjcl.bitArray.bitLength(a);for(b=512+b&-512;b<=a;b+=512)this.D(c.splice(0,16));return this},finalize:function(){var a,b=this.i,c=this.n;b=sjcl.bitArray.concat(b,[sjcl.bitArray.partial(1,1)]);for(a=b.length+2;a&15;a++)b.push(0);b.push(Math.floor(this.e/
+4294967296));for(b.push(this.e|0);b.length;)this.D(b.splice(0,16));this.reset();return c},N:[],a:[],z:function(){function a(e){return(e-Math.floor(e))*0x100000000|0}var b=0,c=2,d;a:for(;b<64;c++){for(d=2;d*d<=c;d++)if(c%d===0)continue a;if(b<8)this.N[b]=a(Math.pow(c,0.5));this.a[b]=a(Math.pow(c,1/3));b++}},D:function(a){var b,c,d=a.slice(0),e=this.n,f=this.a,g=e[0],h=e[1],i=e[2],k=e[3],j=e[4],l=e[5],m=e[6],n=e[7];for(a=0;a<64;a++){if(a<16)b=d[a];else{b=d[a+1&15];c=d[a+14&15];b=d[a&15]=(b>>>7^b>>>18^
+b>>>3^b<<25^b<<14)+(c>>>17^c>>>19^c>>>10^c<<15^c<<13)+d[a&15]+d[a+9&15]|0}b=b+n+(j>>>6^j>>>11^j>>>25^j<<26^j<<21^j<<7)+(m^j&(l^m))+f[a];n=m;m=l;l=j;j=k+b|0;k=i;i=h;h=g;g=b+(h&i^k&(h^i))+(h>>>2^h>>>13^h>>>22^h<<30^h<<19^h<<10)|0}e[0]=e[0]+g|0;e[1]=e[1]+h|0;e[2]=e[2]+i|0;e[3]=e[3]+k|0;e[4]=e[4]+j|0;e[5]=e[5]+l|0;e[6]=e[6]+m|0;e[7]=e[7]+n|0}};
+sjcl.mode.ccm={name:"ccm",encrypt:function(a,b,c,d,e){var f,g=b.slice(0),h=sjcl.bitArray,i=h.bitLength(c)/8,k=h.bitLength(g)/8;e=e||64;d=d||[];if(i<7)throw new sjcl.exception.invalid("ccm: iv must be at least 7 bytes");for(f=2;f<4&&k>>>8*f;f++);if(f<15-i)f=15-i;c=h.clamp(c,8*(15-f));b=sjcl.mode.ccm.H(a,b,c,d,e,f);g=sjcl.mode.ccm.J(a,g,c,b,e,f);return h.concat(g.data,g.tag)},decrypt:function(a,b,c,d,e){e=e||64;d=d||[];var f=sjcl.bitArray,g=f.bitLength(c)/8,h=f.bitLength(b),i=f.clamp(b,h-e),k=f.bitSlice(b,
+h-e);h=(h-e)/8;if(g<7)throw new sjcl.exception.invalid("ccm: iv must be at least 7 bytes");for(b=2;b<4&&h>>>8*b;b++);if(b<15-g)b=15-g;c=f.clamp(c,8*(15-b));i=sjcl.mode.ccm.J(a,i,c,k,e,b);a=sjcl.mode.ccm.H(a,i.data,c,d,e,b);if(!f.equal(i.tag,a))throw new sjcl.exception.corrupt("ccm: tag doesn't match");return i.data},H:function(a,b,c,d,e,f){var g=[],h=sjcl.bitArray,i=h.k;e/=8;if(e%2||e<4||e>16)throw new sjcl.exception.invalid("ccm: invalid tag length");if(d.length>0xffffffff||b.length>0xffffffff)throw new sjcl.exception.bug("ccm: can't deal with 4GiB or more data");
+f=[h.partial(8,(d.length?64:0)|e-2<<2|f-1)];f=h.concat(f,c);f[3]|=h.bitLength(b)/8;f=a.encrypt(f);if(d.length){c=h.bitLength(d)/8;if(c<=65279)g=[h.partial(16,c)];else if(c<=0xffffffff)g=h.concat([h.partial(16,65534)],[c]);g=h.concat(g,d);for(d=0;d<g.length;d+=4)f=a.encrypt(i(f,g.slice(d,d+4).concat([0,0,0])))}for(d=0;d<b.length;d+=4)f=a.encrypt(i(f,b.slice(d,d+4).concat([0,0,0])));return h.clamp(f,e*8)},J:function(a,b,c,d,e,f){var g,h=sjcl.bitArray;g=h.k;var i=b.length,k=h.bitLength(b);c=h.concat([h.partial(8,
+f-1)],c).concat([0,0,0]).slice(0,4);d=h.bitSlice(g(d,a.encrypt(c)),0,e);if(!i)return{tag:d,data:[]};for(g=0;g<i;g+=4){c[3]++;e=a.encrypt(c);b[g]^=e[0];b[g+1]^=e[1];b[g+2]^=e[2];b[g+3]^=e[3]}return{tag:d,data:h.clamp(b,k)}}};
+sjcl.mode.ocb2={name:"ocb2",encrypt:function(a,b,c,d,e,f){if(sjcl.bitArray.bitLength(c)!==128)throw new sjcl.exception.invalid("ocb iv must be 128 bits");var g,h=sjcl.mode.ocb2.B,i=sjcl.bitArray,k=i.k,j=[0,0,0,0];c=h(a.encrypt(c));var l,m=[];d=d||[];e=e||64;for(g=0;g+4<b.length;g+=4){l=b.slice(g,g+4);j=k(j,l);m=m.concat(k(c,a.encrypt(k(c,l))));c=h(c)}l=b.slice(g);b=i.bitLength(l);g=a.encrypt(k(c,[0,0,0,b]));l=i.clamp(k(l.concat([0,0,0]),g),b);j=k(j,k(l.concat([0,0,0]),g));j=a.encrypt(k(j,k(c,h(c))));
+if(d.length)j=k(j,f?d:sjcl.mode.ocb2.pmac(a,d));return m.concat(i.concat(l,i.clamp(j,e)))},decrypt:function(a,b,c,d,e,f){if(sjcl.bitArray.bitLength(c)!==128)throw new sjcl.exception.invalid("ocb iv must be 128 bits");e=e||64;var g=sjcl.mode.ocb2.B,h=sjcl.bitArray,i=h.k,k=[0,0,0,0],j=g(a.encrypt(c)),l,m,n=sjcl.bitArray.bitLength(b)-e,o=[];d=d||[];for(c=0;c+4<n/32;c+=4){l=i(j,a.decrypt(i(j,b.slice(c,c+4))));k=i(k,l);o=o.concat(l);j=g(j)}m=n-c*32;l=a.encrypt(i(j,[0,0,0,m]));l=i(l,h.clamp(b.slice(c),
+m).concat([0,0,0]));k=i(k,l);k=a.encrypt(i(k,i(j,g(j))));if(d.length)k=i(k,f?d:sjcl.mode.ocb2.pmac(a,d));if(!h.equal(h.clamp(k,e),h.bitSlice(b,n)))throw new sjcl.exception.corrupt("ocb: tag doesn't match");return o.concat(h.clamp(l,m))},pmac:function(a,b){var c,d=sjcl.mode.ocb2.B,e=sjcl.bitArray,f=e.k,g=[0,0,0,0],h=a.encrypt([0,0,0,0]);h=f(h,d(d(h)));for(c=0;c+4<b.length;c+=4){h=d(h);g=f(g,a.encrypt(f(h,b.slice(c,c+4))))}b=b.slice(c);if(e.bitLength(b)<128){h=f(h,d(h));b=e.concat(b,[2147483648|0,0,
+0,0])}g=f(g,b);return a.encrypt(f(d(f(h,d(h))),g))},B:function(a){return[a[0]<<1^a[1]>>>31,a[1]<<1^a[2]>>>31,a[2]<<1^a[3]>>>31,a[3]<<1^(a[0]>>>31)*135]}};sjcl.misc.hmac=function(a,b){this.M=b=b||sjcl.hash.sha256;var c=[[],[]],d=b.prototype.blockSize/32;this.l=[new b,new b];if(a.length>d)a=b.hash(a);for(b=0;b<d;b++){c[0][b]=a[b]^909522486;c[1][b]=a[b]^1549556828}this.l[0].update(c[0]);this.l[1].update(c[1])};
+sjcl.misc.hmac.prototype.encrypt=sjcl.misc.hmac.prototype.mac=function(a,b){a=(new this.M(this.l[0])).update(a,b).finalize();return(new this.M(this.l[1])).update(a).finalize()};
+sjcl.misc.pbkdf2=function(a,b,c,d,e){c=c||1E3;if(d<0||c<0)throw sjcl.exception.invalid("invalid params to pbkdf2");if(typeof a==="string")a=sjcl.codec.utf8String.toBits(a);e=e||sjcl.misc.hmac;a=new e(a);var f,g,h,i,k=[],j=sjcl.bitArray;for(i=1;32*k.length<(d||1);i++){e=f=a.encrypt(j.concat(b,[i]));for(g=1;g<c;g++){f=a.encrypt(f);for(h=0;h<f.length;h++)e[h]^=f[h]}k=k.concat(e)}if(d)k=j.clamp(k,d);return k};
+sjcl.random={randomWords:function(a,b){var c=[];b=this.isReady(b);var d;if(b===0)throw new sjcl.exception.notReady("generator isn't seeded");else b&2&&this.U(!(b&1));for(b=0;b<a;b+=4){(b+1)%0x10000===0&&this.L();d=this.w();c.push(d[0],d[1],d[2],d[3])}this.L();return c.slice(0,a)},setDefaultParanoia:function(a){this.t=a},addEntropy:function(a,b,c){c=c||"user";var d,e,f=(new Date).valueOf(),g=this.q[c],h=this.isReady(),i=0;d=this.G[c];if(d===undefined)d=this.G[c]=this.R++;if(g===undefined)g=this.q[c]=
+0;this.q[c]=(this.q[c]+1)%this.b.length;switch(typeof a){case "number":if(b===undefined)b=1;this.b[g].update([d,this.u++,1,b,f,1,a|0]);break;case "object":c=Object.prototype.toString.call(a);if(c==="[object Uint32Array]"){e=[];for(c=0;c<a.length;c++)e.push(a[c]);a=e}else{if(c!=="[object Array]")i=1;for(c=0;c<a.length&&!i;c++)if(typeof a[c]!="number")i=1}if(!i){if(b===undefined)for(c=b=0;c<a.length;c++)for(e=a[c];e>0;){b++;e>>>=1}this.b[g].update([d,this.u++,2,b,f,a.length].concat(a))}break;case "string":if(b===
+undefined)b=a.length;this.b[g].update([d,this.u++,3,b,f,a.length]);this.b[g].update(a);break;default:i=1}if(i)throw new sjcl.exception.bug("random: addEntropy only supports number, array of numbers or string");this.j[g]+=b;this.f+=b;if(h===0){this.isReady()!==0&&this.K("seeded",Math.max(this.g,this.f));this.K("progress",this.getProgress())}},isReady:function(a){a=this.C[a!==undefined?a:this.t];return this.g&&this.g>=a?this.j[0]>80&&(new Date).valueOf()>this.O?3:1:this.f>=a?2:0},getProgress:function(a){a=
+this.C[a?a:this.t];return this.g>=a?1:this.f>a?1:this.f/a},startCollectors:function(){if(!this.m){if(window.addEventListener){window.addEventListener("load",this.o,false);window.addEventListener("mousemove",this.p,false)}else if(document.attachEvent){document.attachEvent("onload",this.o);document.attachEvent("onmousemove",this.p)}else throw new sjcl.exception.bug("can't attach event");this.m=true}},stopCollectors:function(){if(this.m){if(window.removeEventListener){window.removeEventListener("load",
+this.o,false);window.removeEventListener("mousemove",this.p,false)}else if(window.detachEvent){window.detachEvent("onload",this.o);window.detachEvent("onmousemove",this.p)}this.m=false}},addEventListener:function(a,b){this.r[a][this.Q++]=b},removeEventListener:function(a,b){var c;a=this.r[a];var d=[];for(c in a)a.hasOwnProperty(c)&&a[c]===b&&d.push(c);for(b=0;b<d.length;b++){c=d[b];delete a[c]}},b:[new sjcl.hash.sha256],j:[0],A:0,q:{},u:0,G:{},R:0,g:0,f:0,O:0,a:[0,0,0,0,0,0,0,0],d:[0,0,0,0],s:undefined,
+t:6,m:false,r:{progress:{},seeded:{}},Q:0,C:[0,48,64,96,128,192,0x100,384,512,768,1024],w:function(){for(var a=0;a<4;a++){this.d[a]=this.d[a]+1|0;if(this.d[a])break}return this.s.encrypt(this.d)},L:function(){this.a=this.w().concat(this.w());this.s=new sjcl.cipher.aes(this.a)},T:function(a){this.a=sjcl.hash.sha256.hash(this.a.concat(a));this.s=new sjcl.cipher.aes(this.a);for(a=0;a<4;a++){this.d[a]=this.d[a]+1|0;if(this.d[a])break}},U:function(a){var b=[],c=0,d;this.O=b[0]=(new Date).valueOf()+3E4;for(d=
+0;d<16;d++)b.push(Math.random()*0x100000000|0);for(d=0;d<this.b.length;d++){b=b.concat(this.b[d].finalize());c+=this.j[d];this.j[d]=0;if(!a&&this.A&1<<d)break}if(this.A>=1<<this.b.length){this.b.push(new sjcl.hash.sha256);this.j.push(0)}this.f-=c;if(c>this.g)this.g=c;this.A++;this.T(b)},p:function(a){sjcl.random.addEntropy([a.x||a.clientX||a.offsetX||0,a.y||a.clientY||a.offsetY||0],2,"mouse")},o:function(){sjcl.random.addEntropy((new Date).valueOf(),2,"loadtime")},K:function(a,b){var c;a=sjcl.random.r[a];
+var d=[];for(c in a)a.hasOwnProperty(c)&&d.push(a[c]);for(c=0;c<d.length;c++)d[c](b)}};try{var s=new Uint32Array(32);crypto.getRandomValues(s);sjcl.random.addEntropy(s,1024,"crypto['getRandomValues']")}catch(t){}
+sjcl.json={defaults:{v:1,iter:1E3,ks:128,ts:64,mode:"ccm",adata:"",cipher:"aes"},encrypt:function(a,b,c,d){c=c||{};d=d||{};var e=sjcl.json,f=e.c({iv:sjcl.random.randomWords(4,0)},e.defaults),g;e.c(f,c);c=f.adata;if(typeof f.salt==="string")f.salt=sjcl.codec.base64.toBits(f.salt);if(typeof f.iv==="string")f.iv=sjcl.codec.base64.toBits(f.iv);if(!sjcl.mode[f.mode]||!sjcl.cipher[f.cipher]||typeof a==="string"&&f.iter<=100||f.ts!==64&&f.ts!==96&&f.ts!==128||f.ks!==128&&f.ks!==192&&f.ks!==0x100||f.iv.length<
+2||f.iv.length>4)throw new sjcl.exception.invalid("json encrypt: invalid parameters");if(typeof a==="string"){g=sjcl.misc.cachedPbkdf2(a,f);a=g.key.slice(0,f.ks/32);f.salt=g.salt}if(typeof b==="string")b=sjcl.codec.utf8String.toBits(b);if(typeof c==="string")c=sjcl.codec.utf8String.toBits(c);g=new sjcl.cipher[f.cipher](a);e.c(d,f);d.key=a;f.ct=sjcl.mode[f.mode].encrypt(g,b,f.iv,c,f.ts);return e.encode(f)},decrypt:function(a,b,c,d){c=c||{};d=d||{};var e=sjcl.json;b=e.c(e.c(e.c({},e.defaults),e.decode(b)),
+c,true);var f;c=b.adata;if(typeof b.salt==="string")b.salt=sjcl.codec.base64.toBits(b.salt);if(typeof b.iv==="string")b.iv=sjcl.codec.base64.toBits(b.iv);if(!sjcl.mode[b.mode]||!sjcl.cipher[b.cipher]||typeof a==="string"&&b.iter<=100||b.ts!==64&&b.ts!==96&&b.ts!==128||b.ks!==128&&b.ks!==192&&b.ks!==0x100||!b.iv||b.iv.length<2||b.iv.length>4)throw new sjcl.exception.invalid("json decrypt: invalid parameters");if(typeof a==="string"){f=sjcl.misc.cachedPbkdf2(a,b);a=f.key.slice(0,b.ks/32);b.salt=f.salt}if(typeof c===
+"string")c=sjcl.codec.utf8String.toBits(c);f=new sjcl.cipher[b.cipher](a);c=sjcl.mode[b.mode].decrypt(f,b.ct,b.iv,c,b.ts);e.c(d,b);d.key=a;return sjcl.codec.utf8String.fromBits(c)},encode:function(a){var b,c="{",d="";for(b in a)if(a.hasOwnProperty(b)){if(!b.match(/^[a-z0-9]+$/i))throw new sjcl.exception.invalid("json encode: invalid property name");c+=d+'"'+b+'":';d=",";switch(typeof a[b]){case "number":case "boolean":c+=a[b];break;case "string":c+='"'+escape(a[b])+'"';break;case "object":c+='"'+
+sjcl.codec.base64.fromBits(a[b],1)+'"';break;default:throw new sjcl.exception.bug("json encode: unsupported type");}}return c+"}"},decode:function(a){a=a.replace(/\s/g,"");if(!a.match(/^\{.*\}$/))throw new sjcl.exception.invalid("json decode: this isn't json!");a=a.replace(/^\{|\}$/g,"").split(/,/);var b={},c,d;for(c=0;c<a.length;c++){if(!(d=a[c].match(/^(?:(["']?)([a-z][a-z0-9]*)\1):(?:(\d+)|"([a-z0-9+\/%*_.@=\-]*)")$/i)))throw new sjcl.exception.invalid("json decode: this isn't json!");b[d[2]]=
+d[3]?parseInt(d[3],10):d[2].match(/^(ct|salt|iv)$/)?sjcl.codec.base64.toBits(d[4]):unescape(d[4])}return b},c:function(a,b,c){if(a===undefined)a={};if(b===undefined)return a;var d;for(d in b)if(b.hasOwnProperty(d)){if(c&&a[d]!==undefined&&a[d]!==b[d])throw new sjcl.exception.invalid("required parameter overridden");a[d]=b[d]}return a},W:function(a,b){var c={},d;for(d in a)if(a.hasOwnProperty(d)&&a[d]!==b[d])c[d]=a[d];return c},V:function(a,b){var c={},d;for(d=0;d<b.length;d++)if(a[b[d]]!==undefined)c[b[d]]=
+a[b[d]];return c}};sjcl.encrypt=sjcl.json.encrypt;sjcl.decrypt=sjcl.json.decrypt;sjcl.misc.S={};sjcl.misc.cachedPbkdf2=function(a,b){var c=sjcl.misc.S,d;b=b||{};d=b.iter||1E3;c=c[a]=c[a]||{};d=c[d]=c[d]||{firstSalt:b.salt&&b.salt.length?b.salt.slice(0):sjcl.random.randomWords(2,0)};c=b.salt===undefined?d.firstSalt:b.salt;d[c]=d[c]||sjcl.misc.pbkdf2(a,c,b.iter);return{key:d[c].slice(0),salt:c.slice(0)}};

Libraries/strophe.muc.js

+/*
+ *Plugin to implement the MUC extension.
+   http://xmpp.org/extensions/xep-0045.html
+
+ *Previous Author:
+    Nathan Zorn <nathan.zorn@gmail.com>
+ *Complete CoffeeScript rewrite:
+    Andreas Guth <guth@dbis.rwth-aachen.de>
+ *Cleanup, AMD/global registrations and bugfixes:
+    JC Brand <jc@opkode.com>
+*/
+
+// AMD/global registrations
+(function (root, factory) {
+    if (typeof console === undefined || typeof console.log === undefined) {
+        console = { log: function () {}, error: function () {} };
+    }
+    if (typeof define === 'function' && define.amd) { 
+        define([
+            "strophe"
+            ], function () {
+                if (console===undefined || console.log===undefined) {
+                    console = { log: function () {}, error: function () {} };
+                }
+                return factory(jQuery, console);
+            }
+        );
+    } else { 
+        return factory(jQuery, console);
+    }
+}(this, function ($, console) {
+
+    (function() {
+    var Occupant, RoomConfig, XmppRoom,
+        __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+    Strophe.addConnectionPlugin('muc', {
+        _connection: null,
+        rooms: [],
+        init: function(conn) {
+            /* Initialize the MUC plugin. Sets the correct connection object and
+             * extends the namesace.
+             */
+            this._connection = conn;
+            this._muc_handler = null;
+            Strophe.addNamespace('MUC_OWNER', Strophe.NS.MUC + "#owner");
+            Strophe.addNamespace('MUC_ADMIN', Strophe.NS.MUC + "#admin");
+            Strophe.addNamespace('MUC_USER', Strophe.NS.MUC + "#user");
+            return Strophe.addNamespace('MUC_ROOMCONF', Strophe.NS.MUC + "#roomconfig");
+        },
+
+        join: function(room, nick, msg_handler_cb, pres_handler_cb, roster_cb, password) {
+            /* Join a multi-user chat room
+             *
+             *  Parameters:
+             *  (String) room - The multi-user chat room to join.
+             *  (String) nick - Optional nickname to use in the chat room.
+             *  (Function) msg_handler_cb - The function call to handle messages from the specified chat room.
+             *  (Function) pres_handler_cb - The function call back to handle presence in the chat room.
+             *  (String) password - The optional password to use. (password protected rooms only)
+            */
+            var msg, room_nick, _this = this;
+
+            room_nick = this.test_append_nick(room, nick);
+            msg = $pres({
+                from: this._connection.jid,
+                to: room_nick
+            }).c("x", {
+                xmlns: Strophe.NS.MUC
+            });
+            if (password !== null) {
+                msg.cnode(Strophe.xmlElement("password", [], password));
+            }
+            if (this._muc_handler === null) {
+                this._muc_handler = this._connection.addHandler(function(stanza) {
+                    var from, handler, handlers, id, roomname, x, xmlns, xquery, _i, _len;
+                    from = stanza.getAttribute('from');
+                    roomname = from.split("/")[0];
+                    if (!_this.rooms[roomname]) { return true; }
+                    room = _this.rooms[roomname];
+                    handlers = {};
+                    if (stanza.nodeName === "message") {
+                        handlers = room._message_handlers;
+                    } else if (stanza.nodeName === "presence") {
+                        xquery = stanza.getElementsByTagName("x");
+                        if (xquery.length > 0) {
+                            for (_i = 0, _len = xquery.length; _i < _len; _i++) {
+                                x = xquery[_i];
+                                xmlns = x.getAttribute("xmlns");
+                                if (xmlns && xmlns.match(Strophe.NS.MUC)) {
+                                handlers = room._presence_handlers;
+                                break;
+                                }
+                            }
+                        }
+                    }
+                    _.each(handlers, function (handler, id, handlers) {
+                        if (!handler(stanza, room)) { delete handlers[id]; }
+                    });
+                    return true;
+                });
+            }
+            if (!_.has(this.rooms, room)) {
+                this.rooms[room] = new XmppRoom(this, room, nick, password);
+            }
+            if (pres_handler_cb) {
+                this.rooms[room].addHandler('presence', pres_handler_cb);
+            }
+            if (msg_handler_cb) {
+                this.rooms[room].addHandler('message', msg_handler_cb);
+            }
+            if (roster_cb) {
+                this.rooms[room].addHandler('roster', roster_cb);
+            }
+            return this._connection.send(msg);
+        },
+
+        leave: function(room, nick, handler_cb, exit_msg) {
+            /*  Leave a multi-user chat room
+             *
+             *  Parameters:
+             *  (String) room - The multi-user chat room to leave.
+             *  (String) nick - The nick name used in the room.
+             *  (Function) handler_cb - Optional function to handle the successful leave.
+             *  (String) exit_msg - optional exit message.
+             *  Returns:
+             *  iqid - The unique id for the room leave.
+             */
+            var presence, presenceid, room_nick;
+            delete this.rooms[room];
+            if (this.rooms.length === 0) {
+                this._connection.deleteHandler(this._muc_handler);
+                this._muc_handler = null;
+            }
+            room_nick = this.test_append_nick(room, nick);
+            presenceid = this._connection.getUniqueId();
+            presence = $pres({
+                type: "unavailable",
+                id: presenceid,
+                from: this._connection.jid,
+                to: room_nick
+            });
+            if (exit_msg !== null) {
+                presence.c("status", exit_msg);
+            }
+            if (handler_cb !== null) {
+                this._connection.addHandler(handler_cb, null, "presence", null, presenceid);
+            }
+            this._connection.send(presence);
+            return presenceid;
+        },
+
+        message: function(room, nick, message, html_message, type) {
+            /*  Parameters:
+             *  (String) room - The multi-user chat room name.
+             *  (String) nick - The nick name used in the chat room.
+             *  (String) message - The plaintext message to send to the room.
+             *  (String) html_message - The message to send to the room with html markup.
+             *  (String) type - "groupchat" for group chat messages o
+             *                  "chat" for private chat messages
+             *  Returns:
+             *  msgiq - the unique id used to send the message
+            */
+            var msg, msgid, parent, room_nick;
+            room_nick = this.test_append_nick(room, nick);
+            type = type || (nick !== null ? "chat" : "groupchat");
+            msgid = this._connection.getUniqueId();
+            msg = $msg({
+                to: room_nick,
+                from: this._connection.jid,
+                type: type,
+                id: msgid
+            }).c("body", {
+                xmlns: Strophe.NS.CLIENT
+            }).t(message);
+            msg.up();
+            if (html_message !== null) {
+                msg.c("html", {xmlns: Strophe.NS.XHTML_IM}).c("body", {xmlns: Strophe.NS.XHTML}).h(html_message);
+
+                if (msg.node.childNodes.length === 0) {
+                    parent = msg.node.parentNode;
+                    msg.up().up();
+                    msg.node.removeChild(parent);
+                } else {
+                    msg.up().up();
+                }
+            }
+            msg.c("x", {
+                xmlns: "jabber:x:event"
+            }).c("composing");
+            this._connection.send(msg);
+            return msgid;
+        },
+
+        groupchat: function(room, message, html_message) {
+            /* Convenience Function to send a Message to all Occupants
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (String) message - The plaintext message to send to the room.
+             * (String) html_message - The message to send to the room with html markup.
+             * Returns:
+             * msgiq - the unique id used to send the message
+            */
+            return this.message(room, null, message, html_message);
+        },
+
+        invite: function(room, receiver, reason) {
+            /* Send a mediated invitation.
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (String) receiver - The invitation's receiver.
+             * (String) reason - Optional reason for joining the room.
+             * Returns:
+             * msgiq - the unique id used to send the invitation
+            */
+            var invitation, msgid;
+            msgid = this._connection.getUniqueId();
+            invitation = $msg({
+                from: this._connection.jid,
+                to: room,
+                id: msgid
+            }).c('x', {
+                xmlns: Strophe.NS.MUC_USER
+            }).c('invite', {
+                to: receiver
+            });
+            if (reason !== null) {
+                invitation.c('reason', reason);
+            }
+            this._connection.send(invitation);
+            return msgid;
+        },
+
+        directInvite: function(room, receiver, reason, password) {
+            /* Send a direct invitation.
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (String) receiver - The invitation's receiver.
+             * (String) reason - Optional reason for joining the room.
+             * (String) password - Optional password for the room.
+             * Returns:
+             * msgiq - the unique id used to send the invitation
+            */
+
+            var attrs, invitation, msgid;
+            msgid = this._connection.getUniqueId();
+            attrs = {
+                xmlns: 'jabber:x:conference',
+                jid: room
+            };
+            if (reason !== null) { attrs.reason = reason; }
+            if (password !== null) { attrs.password = password; }
+            invitation = $msg({
+                from: this._connection.jid,
+                to: receiver,
+                id: msgid
+            }).c('x', attrs);
+            this._connection.send(invitation);
+            return msgid;
+        },
+
+        queryOccupants: function(room, success_cb, error_cb) {
+            /* Queries a room for a list of occupants
+             * (String) room - The multi-user chat room name.
+             * (Function) success_cb - Optional function to handle the info.
+             * (Function) error_cb - Optional function to handle an error.
+             * Returns:
+             * id - the unique id used to send the info request
+            */
+            var attrs, info;
+            attrs = {
+                xmlns: Strophe.NS.DISCO_ITEMS
+            };
+            info = $iq({
+                from: this._connection.jid,
+                to: room,
+                type: 'get'
+            }).c('query', attrs);
+            return this._connection.sendIQ(info, success_cb, error_cb);
+        },
+
+        configure: function(room, handler_cb) {
+            /* Start a room configuration.
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (Function) handler_cb - Optional function to handle the config form.
+             * Returns:
+             * id - the unique id used to send the configuration request
+            */
+
+            var config, id, stanza;
+            config = $iq({
+                to: room,
+                type: "get"
+            }).c("query", {
+                xmlns: Strophe.NS.MUC_OWNER
+            });
+            stanza = config.tree();
+            id = this._connection.sendIQ(stanza);
+            if (handler_cb !== null) {
+                this._connection.addHandler(function(stanza) { handler_cb(stanza);
+                return false;
+                }, Strophe.NS.MUC_OWNER, "iq", null, id);
+            }
+        return id;
+        },
+
+        cancelConfigure: function(room) {
+            /* Cancel the room configuration
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * Returns:
+             * id - the unique id used to cancel the configuration.
+            */
+            var config, stanza;
+            config = $iq({
+                to: room,
+                type: "set"
+            }).c("query", {
+                xmlns: Strophe.NS.MUC_OWNER
+            }).c("x", {
+                xmlns: "jabber:x:data",
+                type: "cancel"
+            });
+            stanza = config.tree();
+            return this._connection.sendIQ(stanza);
+        },
+
+        saveConfiguration: function(room, configarray) {
+            /* Save a room configuration.
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (Array) configarray - an array of form elements used to configure the room.
+             * Returns:
+             * id - the unique id used to save the configuration.
+            */
+            var conf, config, stanza, _i, _len;
+            config = $iq({
+                to: room,
+                type: "set"
+            }).c("query", {
+                xmlns: Strophe.NS.MUC_OWNER
+            }).c("x", {
+                xmlns: "jabber:x:data",
+                type: "submit"
+            });
+            for (_i = 0, _len = configarray.length; _i < _len; _i++) {
+                conf = configarray[_i];
+                config.cnode(conf).up();
+            }
+            stanza = config.tree();
+            return this._connection.sendIQ(stanza);
+        },
+
+        createInstantRoom: function(room) {
+            /* Parameters:
+             * (String) room - The multi-user chat room name.
+             * Returns:
+             * id - the unique id used to create the chat room.
+            */
+            var roomiq;
+            roomiq = $iq({
+                to: room,
+                type: "set"
+            }).c("query", {
+                xmlns: Strophe.NS.MUC_OWNER
+            }).c("x", {
+                xmlns: "jabber:x:data",
+                type: "submit"
+            });
+            return this._connection.sendIQ(roomiq.tree());
+        },
+
+        setTopic: function(room, topic) {
+            /* Set the topic of the chat room.
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (String) topic - Topic message.
+            */
+            var msg;
+            msg = $msg({
+                to: room,
+                from: this._connection.jid,
+                type: "groupchat"
+            }).c("subject", {
+                xmlns: "jabber:client"
+            }).t(topic);
+            return this._connection.send(msg.tree());
+        },
+
+        _modifyPrivilege: function(room, item, reason, handler_cb, error_cb) {
+            /* Internal Function that Changes the role or affiliation of a member
+             * of a MUC room. This function is used by modifyRole and modifyAffiliation.
+             * The modification can only be done by a room moderator. An error will be
+             * returned if the user doesn't have permission.
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (Object) item - Object with nick and role or jid and affiliation attribute
+             * (String) reason - Optional reason for the change.
+             * (Function) handler_cb - Optional callback for success
+             * (Function) errer_cb - Optional callback for error
+             * Returns:
+             * iq - the id of the mode change request.
+            */
+            var iq;
+            iq = $iq({
+                to: room,
+                type: "set"
+            }).c("query", {
+                xmlns: Strophe.NS.MUC_ADMIN
+            }).cnode(item.node);
+            if (reason !== null) { iq.c("reason", reason); }
+            return this._connection.sendIQ(iq.tree(), handler_cb, error_cb);
+        },
+
+        modifyRole: function(room, nick, role, reason, handler_cb, error_cb) {
+            /* Changes the role of a member of a MUC room.
+             * The modification can only be done by a room moderator. An error will be
+             * returned if the user doesn't have permission.
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (String) nick - The nick name of the user to modify.
+             * (String) role - The new role of the user.
+             * (String) affiliation - The new affiliation of the user.
+             * (String) reason - Optional reason for the change.
+             * (Function) handler_cb - Optional callback for success
+             * (Function) errer_cb - Optional callback for error
+             * Returns:
+             * iq - the id of the mode change request.
+            */
+            var item;
+            item = $build("item", {
+                nick: nick,
+                role: role
+            });
+            return this._modifyPrivilege(room, item, reason, handler_cb, error_cb);
+        },
+
+        kick: function(room, nick, reason, handler_cb, error_cb) {
+            return this.modifyRole(room, nick, 'none', reason, handler_cb, error_cb);
+        },
+        voice: function(room, nick, reason, handler_cb, error_cb) {
+            return this.modifyRole(room, nick, 'participant', reason, handler_cb, error_cb);
+        },
+        mute: function(room, nick, reason, handler_cb, error_cb) {
+            return this.modifyRole(room, nick, 'visitor', reason, handler_cb, error_cb);
+        },
+        op: function(room, nick, reason, handler_cb, error_cb) {
+            return this.modifyRole(room, nick, 'moderator', reason, handler_cb, error_cb);
+        },
+        deop: function(room, nick, reason, handler_cb, error_cb) {
+            return this.modifyRole(room, nick, 'participant', reason, handler_cb, error_cb);
+        },
+
+        modifyAffiliation: function(room, jid, affiliation, reason, handler_cb, error_cb) {
+            /* Changes the affiliation of a member of a MUC room.
+             * The modification can only be done by a room moderator. An error will be
+             * returned if the user doesn't have permission.
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (String) jid  - The jid of the user to modify.
+             * (String) affiliation - The new affiliation of the user.
+             * (String) reason - Optional reason for the change.
+             * (Function) handler_cb - Optional callback for success
+             * (Function) errer_cb - Optional callback for error
+             * Returns:
+             *  iq - the id of the mode change request.
+            */
+            var item;
+            item = $build("item", {
+                jid: jid,
+                affiliation: affiliation
+            });
+            return this._modifyPrivilege(room, item, reason, handler_cb, error_cb);
+            },
+            ban: function(room, jid, reason, handler_cb, error_cb) {
+            return this.modifyAffiliation(room, jid, 'outcast', reason, handler_cb, error_cb);
+            },
+            member: function(room, jid, reason, handler_cb, error_cb) {
+            return this.modifyAffiliation(room, jid, 'member', reason, handler_cb, error_cb);
+            },
+            revoke: function(room, jid, reason, handler_cb, error_cb) {
+            return this.modifyAffiliation(room, jid, 'none', reason, handler_cb, error_cb);
+            },
+            owner: function(room, jid, reason, handler_cb, error_cb) {
+            return this.modifyAffiliation(room, jid, 'owner', reason, handler_cb, error_cb);
+            },
+            admin: function(room, jid, reason, handler_cb, error_cb) {
+            return this.modifyAffiliation(room, jid, 'admin', reason, handler_cb, error_cb);
+            },
+
+        changeNick: function(room, user) {
+            /* Change the current users nick name.
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (String) user - The new nick name.
+            */
+            var presence, room_nick;
+            room_nick = this.test_append_nick(room, user);
+            presence = $pres({
+                from: this._connection.jid,
+                to: room_nick,
+                id: this._connection.getUniqueId()
+            });
+            return this._connection.send(presence.tree());
+        },
+
+        setStatus: function(room, user, show, status) {
+            /* Change the current users status.
+             * Parameters:
+             * (String) room - The multi-user chat room name.
+             * (String) user - The current nick.
+             * (String) show - The new show-text.
+             * (String) status - The new status-text.
+            */
+            var presence, room_nick;
+            room_nick = this.test_append_nick(room, user);
+            presence = $pres({
+                from: this._connection.jid,
+                to: room_nick
+            });
+            if (show !== null) { presence.c('show', show).up(); }
+            if (status !== null) { presence.c('status', status); }
+            return this._connection.send(presence.tree());
+        },
+
+        listRooms: function(server, handle_cb) {
+            /* List all chat room available on a server.
+             * Parameters:
+             * (String) server - name of chat server.
+             * (String) handle_cb - Function to call for room list return.
+            */
+            var iq;
+            iq = $iq({
+                to: server,
+                from: this._connection.jid,
+                type: "get"
+            }).c("query", {
+                xmlns: Strophe.NS.DISCO_ITEMS
+            });
+            return this._connection.sendIQ(iq, handle_cb);
+            },
+            test_append_nick: function(room, nick) {
+            return room + (nick !== null ? "/" + (Strophe.escapeNode(nick)) : "");
+        }
+    });
+
+    XmppRoom = (function() {
+        function XmppRoom(client, name, nick, password) {
+        this.roster = {};
+        this._message_handlers = {};
+        this._presence_handlers = {};
+        this._roster_handlers = {};
+        this._handler_ids = 0;
+
+        this.client = client;
+        this.name = name;
+        this.nick = nick;
+        this.password = password;
+        this._roomRosterHandler = __bind(this._roomRosterHandler, this);
+        this._addOccupant = __bind(this._addOccupant, this);
+        if (client.muc) { this.client = client.muc; }
+        this.name = Strophe.getBareJidFromJid(name);
+        this.client.rooms[this.name] = this;
+        this.addHandler('presence', this._roomRosterHandler);
+        }
+
+        XmppRoom.prototype.join = function(msg_handler_cb, pres_handler_cb) {
+        if (!this.client.rooms[this.name]) {
+            return this.client.join(this.name, this.nick, msg_handler_cb, pres_handler_cb, this.password);
+        }
+        };
+
+        XmppRoom.prototype.leave = function(handler_cb, message) {
+            this.client.leave(this.name, this.nick, handler_cb, message);
+            return delete this.client.rooms[this.name];
+        };
+
+        XmppRoom.prototype.message = function(nick, message, html_message, type) {
+            return this.client.message(this.name, nick, message, html_message, type);
+        };
+
+        XmppRoom.prototype.groupchat = function(message, html_message) {
+            return this.client.groupchat(this.name, message, html_message);
+        };
+
+        XmppRoom.prototype.invite = function(receiver, reason) {
+            return this.client.invite(this.name, receiver, reason);
+        };
+
+        XmppRoom.prototype.directInvite = function(receiver, reason) {
+            return this.client.directInvite(this.name, receiver, reason, this.password);
+        };
+
+        XmppRoom.prototype.configure = function(handler_cb) {
+            return this.client.configure(this.name, handler_cb);
+        };
+
+        XmppRoom.prototype.cancelConfigure = function() {
+            return this.client.cancelConfigure(this.name);
+        };
+
+        XmppRoom.prototype.saveConfiguration = function(configarray) {
+            return this.client.saveConfiguration(this.name, configarray);
+        };
+
+        XmppRoom.prototype.queryOccupants = function(success_cb, error_cb) {
+            return this.client.queryOccupants(this.name, success_cb, error_cb);
+        };
+
+        XmppRoom.prototype.setTopic = function(topic) {
+            return this.client.setTopic(this.name, topic);
+        };
+
+        XmppRoom.prototype.modifyRole = function(nick, role, reason, success_cb, error_cb) {
+            return this.client.modifyRole(this.name, nick, role, reason, success_cb, error_cb);
+        };
+
+        XmppRoom.prototype.kick = function(nick, reason, handler_cb, error_cb) {
+            return this.client.kick(this.name, nick, reason, handler_cb, error_cb);
+        };
+
+        XmppRoom.prototype.voice = function(nick, reason, handler_cb, error_cb) {
+            return this.client.voice(this.name, nick, reason, handler_cb, error_cb);
+        };
+
+        XmppRoom.prototype.mute = function(nick, reason, handler_cb, error_cb) {
+            return this.client.mute(this.name, nick, reason, handler_cb, error_cb);
+        };
+
+        XmppRoom.prototype.op = function(nick, reason, handler_cb, error_cb) {
+            return this.client.op(this.name, nick, reason, handler_cb, error_cb);
+        };
+
+        XmppRoom.prototype.deop = function(nick, reason, handler_cb, error_cb) {
+            return this.client.deop(this.name, nick, reason, handler_cb, error_cb);
+        };
+
+        XmppRoom.prototype.modifyAffiliation = function(jid, affiliation, reason, success_cb, error_cb) {
+            return this.client.modifyAffiliation(this.name, jid, affiliation, reason, success_cb, error_cb);
+        };
+
+        XmppRoom.prototype.ban = function(jid, reason, handler_cb, error_cb) {
+            return this.client.ban(this.name, jid, reason, handler_cb, error_cb);
+        };
+
+        XmppRoom.prototype.member = function(jid, reason, handler_cb, error_cb) {
+            return this.client.member(this.name, jid, reason, handler_cb, error_cb);
+        };
+
+        XmppRoom.prototype.revoke = function(jid, reason, handler_cb, error_cb) {
+            return this.client.revoke(this.name, jid, reason, handler_cb, error_cb);
+        };
+
+        XmppRoom.prototype.owner = function(jid, reason, handler_cb, error_cb) {
+            return this.client.owner(this.name, jid, reason, handler_cb, error_cb);
+        };
+
+        XmppRoom.prototype.admin = function(jid, reason, handler_cb, error_cb) {
+            return this.client.admin(this.name, jid, reason, handler_cb, error_cb);
+        };
+
+        XmppRoom.prototype.changeNick = function(nick) {
+            this.nick = nick;
+            return this.client.changeNick(this.name, nick);
+        };
+
+        XmppRoom.prototype.setStatus = function(show, status) {
+            return this.client.setStatus(this.name, this.nick, show, status);
+        };
+
+        XmppRoom.prototype.addHandler = function(handler_type, handler) {
+            /* Adds a handler to the MUC room.
+             * Parameters:
+             * (String) handler_type - 'message', 'presence' or 'roster'.
+             * (Function) handler - The handler function.
+             * Returns:
+             * id - the id of handler.
+            */
+            var id;
+            id = this._handler_ids++;
+            switch (handler_type) {
+                case 'presence':
+                this._presence_handlers[id] = handler;
+                break;
+                case 'message':
+                this._message_handlers[id] = handler;
+                break;
+                case 'roster':
+                this._roster_handlers[id] = handler;
+                break;
+                default:
+                this._handler_ids--;
+                return null;
+            }
+            return id;
+        };
+
+        XmppRoom.prototype.removeHandler = function(id) {
+            /* Removes a handler from the MUC room.
+            * This function takes ONLY ids returned by the addHandler function
+            * of this room. passing handler ids returned by connection.addHandler
+            * may brake things!
+            * Parameters:
+            * (number) id - the id of the handler
+            */
+            delete this._presence_handlers[id];
+            delete this._message_handlers[id];
+            return delete this._roster_handlers[id];
+        };
+
+        XmppRoom.prototype._addOccupant = function(data) {
+            /* Creates and adds an Occupant to the Room Roster.
+            * Parameters:
+            * (Object) data - the data the Occupant is filled with
+            * Returns:
+            * occ - the created Occupant.
+            */
+            var occ;
+            occ = new Occupant(data, this);
+            this.roster[occ.nick] = occ;
+            return occ;
+        };
+
+        XmppRoom.prototype._roomRosterHandler = function(pres) {
+            /* The standard handler that managed the Room Roster.
+             * Parameters:
+             * (Object) pres - the presence stanza containing user information
+            */
+            var data, handler, id, newnick, nick, _ref;
+            data = XmppRoom._parsePresence(pres);
+            nick = data.nick;
+            newnick = data.newnick || null;
+            switch (data.type) {
+                case 'error':
+                    return;
+                case 'unavailable':
+                    if (newnick) {
+                        data.nick = newnick;
+                        if (this.roster[nick] && this.roster[newnick]) {
+                            this.roster[nick].update(this.roster[newnick]);
+                            this.roster[newnick] = this.roster[nick];
+                        }
+                        if (this.roster[nick] && !this.roster[newnick]) {
+                            this.roster[newnick] = this.roster[nick].update(data);
+                        }
+                    }
+                    delete this.roster[nick];
+                    break;
+                default:
+                    if (this.roster[nick]) {
+                        this.roster[nick].update(data);
+                    } else {
+                        this._addOccupant(data);
+                    }
+            }
+            _ref = this._roster_handlers;
+            for (id in _ref) {
+                handler = _ref[id];
+                if (!handler(this.roster, this)) { delete this._roster_handlers[id]; }
+            }
+            return true;
+        };
+
+        XmppRoom._parsePresence = function(pres) {
+            /* Parses a presence stanza into a map
+             * Parameters:
+             * (Object) pres -  the presence stanza
+             * Returns:
+             * (Object) data - the data extracted from the presence stanza
+            */
+            var $pres, data, i, j, children, item;
+            $pres = $(pres);
+            data = {};
+            data.nick = Strophe.getResourceFromJid($pres.attr('from'));
+            data.type = $pres.attr('type');
+            data.states = [];
+            for (i=0; i < $pres.children().length; i++) {
+                child = $pres.children()[0];
+                switch (child.nodeName) {
+                    case 'status':
+                        data.status = child.textContent || null;
+                        break;
+                    case 'show':
+                        data.show = child.textContent || null;
+                        break;
+                    case 'x':
+                        if ($(child).attr('xmlns') === Strophe.NS.MUC_USER) {
+                            children = $(child).children();
+                            for (j=0; j < children.length; j++) {
+                                item = children[0];
+                                switch (item.nodeName) {
+                                    case "item":
+                                        a = item.attributes;
+                                        data.affiliation = $(item).attr('affiliation') || null;
+                                        data.role = $(item).attr('role') || null;
+                                        data.jid = $(item).attr('jid') || null;
+                                        data.newnick = $(item).attr('nick') || null;
+                                        break;
+                                    case "status":
+                                        if ($(item).attr('code')) {
+                                            data.states.push($(item).attr('code'));
+                                        }
+                                        break;
+                                }
+                            }
+                        }
+                        break;
+                }
+            }
+            return data;
+        };
+
+        return XmppRoom;
+
+    })();
+
+    RoomConfig = (function() {
+
+        function RoomConfig(info) {
+            this.parse = __bind(this.parse, this);      
+            if (info !== null) { this.parse(info); }
+        }
+
+        RoomConfig.prototype.parse = function(result) {
+            var attr, attrs, child, field, identity, query, _i, _j, _k, _len, _len2, _len3, _ref;
+            query = result.getElementsByTagName("query")[0].childNodes;
+            this.identities = [];
+            this.features = [];
+            this.x = [];
+            for (_i = 0, _len = query.length; _i < _len; _i++) {
+                child = query[_i];
+                attrs = child.attributes;
+                switch (child.nodeName) {
+                    case "identity":
+                        identity = {};
+                        for (_j = 0, _len2 = attrs.length; _j < _len2; _j++) {
+                            attr = attrs[_j];
+                            identity[attr.name] = attr.textContent;
+                        }
+                        this.identities.push(identity);
+                        break;
+                    case "feature":
+                        this.features.push(attrs["var"].textContent);
+                        break;
+                    case "x":
+                        attrs = child.childNodes[0].attributes;
+                        if ((!attrs["var"].textContent === 'FORM_TYPE') || (!attrs.type.textContent === 'hidden')) {
+                            break;
+                        }
+                        _ref = child.childNodes;
+                        for (_k = 0, _len3 = _ref.length; _k < _len3; _k++) {
+                            field = _ref[_k];
+                            if (!(!field.attributes.type)) continue;
+
+                            attrs = field.attributes;
+                            this.x.push({
+                                "var": attrs["var"].textContent,
+                                label: attrs.label.textContent || "",
+                                value: field.firstChild.textContent || ""
+                            });
+                        }
+                }
+            }
+            return {
+                "identities": this.identities,
+                "features": this.features,
+                "x": this.x
+            };
+        };
+
+        return RoomConfig;
+    })();
+
+    Occupant = (function() {
+
+        function Occupant(data, room) {
+            this.room = room;
+            this.update = __bind(this.update, this);
+            this.admin = __bind(this.admin, this);
+            this.owner = __bind(this.owner, this);
+            this.revoke = __bind(this.revoke, this);
+            this.member = __bind(this.member, this);
+            this.ban = __bind(this.ban, this);
+            this.modifyAffiliation = __bind(this.modifyAffiliation, this);
+            this.deop = __bind(this.deop, this);
+            this.op = __bind(this.op, this);
+            this.mute = __bind(this.mute, this);
+            this.voice = __bind(this.voice, this);
+            this.kick = __bind(this.kick, this);
+            this.modifyRole = __bind(this.modifyRole, this);
+            this.update(data);
+        }
+
+        Occupant.prototype.modifyRole = function(role, reason, success_cb, error_cb) {
+            return this.room.modifyRole(this.nick, role, reason, success_cb, error_cb);
+        };
+
+        Occupant.prototype.kick = function(reason, handler_cb, error_cb) {
+            return this.room.kick(this.nick, reason, handler_cb, error_cb);
+        };
+
+        Occupant.prototype.voice = function(reason, handler_cb, error_cb) {
+            return this.room.voice(this.nick, reason, handler_cb, error_cb);
+        };
+
+        Occupant.prototype.mute = function(reason, handler_cb, error_cb) {
+            return this.room.mute(this.nick, reason, handler_cb, error_cb);
+        };
+
+        Occupant.prototype.op = function(reason, handler_cb, error_cb) {
+            return this.room.op(this.nick, reason, handler_cb, error_cb);
+        };
+
+        Occupant.prototype.deop = function(reason, handler_cb, error_cb) {
+            return this.room.deop(this.nick, reason, handler_cb, error_cb);
+        };
+
+        Occupant.prototype.modifyAffiliation = function(affiliation, reason, success_cb, error_cb) {
+            return this.room.modifyAffiliation(this.jid, affiliation, reason, success_cb, error_cb);
+        };
+
+        Occupant.prototype.ban = function(reason, handler_cb, error_cb) {
+            return this.room.ban(this.jid, reason, handler_cb, error_cb);
+        };
+
+        Occupant.prototype.member = function(reason, handler_cb, error_cb) {
+            return this.room.member(this.jid, reason, handler_cb, error_cb);
+        };
+
+        Occupant.prototype.revoke = function(reason, handler_cb, error_cb) {
+            return this.room.revoke(this.jid, reason, handler_cb, error_cb);
+        };
+
+        Occupant.prototype.owner = function(reason, handler_cb, error_cb) {
+            return this.room.owner(this.jid, reason, handler_cb, error_cb);
+        };
+
+        Occupant.prototype.admin = function(reason, handler_cb, error_cb) {
+            return this.room.admin(this.jid, reason, handler_cb, error_cb);
+        };
+
+        Occupant.prototype.update = function(data) {
+            this.nick = data.nick || null;
+            this.affiliation = data.affiliation || null;
+            this.role = data.role || null;
+            this.jid = data.jid || null;
+            this.status = data.status || null;
+            this.show = data.show || null;
+            return this;
+        };
+        return Occupant;
+
+    })();
+
+    }).call(this);
+}));

Libraries/strophe.roster.js

+/*
+  Copyright 2010, François de Metz <francois@2metz.fr>
+*/
+/**
+ * Roster Plugin
+ * Allow easily roster management
+ *
+ *  Features
+ *  * Get roster from server
+ *  * handle presence
+ *  * handle roster iq
+ *  * subscribe/unsubscribe
+ *  * authorize/unauthorize
+ *  * roster versioning (xep 237)
+ */
+Strophe.addConnectionPlugin('roster',
+{
+    _connection: null,
+
+    _callbacks : [],
+    /** Property: items
+     * Roster items
+     * [
+     *    {
+     *        name         : "",
+     *        jid          : "",
+     *        subscription : "",
+     *        ask          : "",
+     *        groups       : ["", ""],
+     *        resources    : {
+     *            myresource : {
+     *                show   : "",
+     *                status : "",
+     *                priority : ""
+     *            }
+     *        }
+     *    }
+     * ]
+     */
+    items : [],
+    /** Property: ver
+     * current roster revision
+     * always null if server doesn't support xep 237
+     */
+    ver : null,
+    /** Function: init
+     * Plugin init
+     *
+     * Parameters:
+     *   (Strophe.Connection) conn - Strophe connection
+     */
+    init: function(conn)
+    {
+    this._connection = conn;
+        this.items = [];
+        // Override the connect and attach methods to always add presence and roster handlers.
+        // They are removed when the connection disconnects, so must be added on connection.
+        var oldCallback, roster = this, _connect = conn.connect, _attach = conn.attach;
+        var newCallback = function(status)
+        {
+            if (status == Strophe.Status.ATTACHED || status == Strophe.Status.CONNECTED)
+            {
+                try
+                {
+                    // Presence subscription
+                    conn.addHandler(roster._onReceivePresence.bind(roster), null, 'presence', null, null, null);
+                    conn.addHandler(roster._onReceiveIQ.bind(roster), Strophe.NS.ROSTER, 'iq', "set", null, null);
+                }
+                catch (e)
+                {
+                    Strophe.error(e);
+                }
+            }
+            if (oldCallback !== null)
+                oldCallback.apply(this, arguments);
+        };
+        conn.connect = function(jid, pass, callback, wait, hold)
+        {
+            oldCallback = callback;
+            if (typeof arguments[0] == "undefined")
+                arguments[0] = null;
+            if (typeof arguments[1] == "undefined")
+                arguments[1] = null;
+            arguments[2] = newCallback;
+            _connect.apply(conn, arguments);
+        };
+        conn.attach = function(jid, sid, rid, callback, wait, hold, wind)
+        {
+            oldCallback = callback;
+            if (typeof arguments[0] == "undefined")
+                arguments[0] = null;
+            if (typeof arguments[1] == "undefined")
+                arguments[1] = null;
+            if (typeof arguments[2] == "undefined")
+                arguments[2] = null;
+            arguments[3] = newCallback;
+            _attach.apply(conn, arguments);
+        };
+
+        Strophe.addNamespace('ROSTER_VER', 'urn:xmpp:features:rosterver');
+        Strophe.addNamespace('NICK', 'http://jabber.org/protocol/nick');
+    },
+    /** Function: supportVersioning
+     * return true if roster versioning is enabled on server
+     */
+    supportVersioning: function()
+    {
+        return (this._connection.features && this._connection.features.getElementsByTagName('ver').length > 0);
+    },
+    /** Function: get
+     * Get Roster on server
+     *
+     * Parameters:
+     *   (Function) userCallback - callback on roster result
+     *   (String) ver - current rev of roster
+     *      (only used if roster versioning is enabled)
+     *   (Array) items - initial items of ver
+     *      (only used if roster versioning is enabled)
+     *     In browser context you can use sessionStorage
+     *     to store your roster in json (JSON.stringify())
+     */
+    get: function(userCallback, ver, items)
+    {
+        var attrs = {xmlns: Strophe.NS.ROSTER};
+        this.items = [];
+        if (this.supportVersioning())
+        {
+            // empty rev because i want an rev attribute in the result
+            attrs.ver = ver || '';
+            this.items = items || [];
+        }
+        var iq = $iq({type: 'get',  'id' : this._connection.getUniqueId('roster')}).c('query', attrs);
+        return this._connection.sendIQ(iq,
+                                this._onReceiveRosterSuccess.bind(this, userCallback),
+                                this._onReceiveRosterError.bind(this, userCallback));
+    },
+    /** Function: registerCallback
+     * register callback on roster (presence and iq)
+     *
+     * Parameters:
+     *   (Function) call_back
+     */
+    registerCallback: function(call_back)
+    {
+        this._callbacks.push(call_back);
+    },
+    /** Function: findItem
+     * Find item by JID
+     *
+     * Parameters:
+     *     (String) jid
+     */
+    findItem : function(jid)
+    {
+        for (var i = 0; i < this.items.length; i++)
+        {
+            if (this.items[i] && this.items[i].jid == jid)
+            {
+                return this.items[i];
+            }
+        }
+        return false;
+    },
+    /** Function: removeItem
+     * Remove item by JID
+     *
+     * Parameters:
+     *     (String) jid
+     */
+    removeItem : function(jid)
+    {
+        for (var i = 0; i < this.items.length; i++)
+        {
+            if (this.items[i] && this.items[i].jid == jid)
+            {
+                this.items.splice(i, 1);
+                return true;
+            }
+        }
+        return false;
+    },
+    /** Function: subscribe
+     * Subscribe presence
+     *
+     * Parameters:
+     *     (String) jid
+     *     (String) message (optional)
+     *     (String) nick  (optional)
+     */
+    subscribe: function(jid, message, nick) {
+        var pres = $pres({to: jid, type: "subscribe"});
+        if (message && message !== "") {
+            pres.c("status").t(message);
+        } 
+        if (nick && nick !== "") {
+            pres.c('nick', {'xmlns': Strophe.NS.NICK}).t(nick);
+        }
+        this._connection.send(pres);
+    },
+    /** Function: unsubscribe
+     * Unsubscribe presence
+     *
+     * Parameters:
+     *     (String) jid
+     *     (String) message
+     */
+    unsubscribe: function(jid, message)
+    {
+        var pres = $pres({to: jid, type: "unsubscribe"});
+        if (message && message != "")
+            pres.c("status").t(message);
+        this._connection.send(pres);
+    },
+    /** Function: authorize
+     * Authorize presence subscription
+     *
+     * Parameters:
+     *     (String) jid
+     *     (String) message
+     */
+    authorize: function(jid, message)
+    {
+        var pres = $pres({to: jid, type: "subscribed"});
+        if (message && message != "")
+            pres.c("status").t(message);
+        this._connection.send(pres);
+    },
+    /** Function: unauthorize
+     * Unauthorize presence subscription
+     *
+     * Parameters:
+     *     (String) jid
+     *     (String) message
+     */
+    unauthorize: function(jid, message)
+    {
+        var pres = $pres({to: jid, type: "unsubscribed"});
+        if (message && message != "")
+            pres.c("status").t(message);
+        this._connection.send(pres);
+    },
+    /** Function: add
+     * Add roster item
+     *
+     * Parameters:
+     *   (String) jid - item jid
+     *   (String) name - name
+     *   (Array) groups
+     *   (Function) call_back
+     */
+    add: function(jid, name, groups, call_back)
+    {
+        var iq = $iq({type: 'set'}).c('query', {xmlns: Strophe.NS.ROSTER}).c('item', {jid: jid,
+                                                                                      name: name});
+        for (var i = 0; i < groups.length; i++)
+        {
+            iq.c('group').t(groups[i]).up();
+        }
+        this._connection.sendIQ(iq, call_back, call_back);
+    },
+    /** Function: update
+     * Update roster item
+     *
+     * Parameters:
+     *   (String) jid - item jid
+     *   (String) name - name
+     *   (Array) groups
+     *   (Function) call_back
+     */
+    update: function(jid, name, groups, call_back)
+    {
+        var item = this.findItem(jid);
+        if (!item)
+        {
+            throw "item not found";
+        }
+        var newName = name || item.name;
+        var newGroups = groups || item.groups;
+        var iq = $iq({type: 'set'}).c('query', {xmlns: Strophe.NS.ROSTER}).c('item', {jid: item.jid,
+                                                                                      name: newName});
+        for (var i = 0; i < newGroups.length; i++)
+        {
+            iq.c('group').t(newGroups[i]).up();
+        }
+        return this._connection.sendIQ(iq, call_back, call_back);
+    },
+    /** Function: remove
+     * Remove roster item
+     *
+     * Parameters:
+     *   (String) jid - item jid
+     *   (Function) call_back
+     */
+    remove: function(jid, call_back)
+    {
+        var item = this.findItem(jid);
+        if (!item)
+        {
+            throw "item not found";
+        }
+        var iq = $iq({type: 'set'}).c('query', {xmlns: Strophe.NS.ROSTER}).c('item', {jid: item.jid,
+                                                                                      subscription: "remove"});
+        this._connection.sendIQ(iq, call_back, call_back);
+    },
+    /** PrivateFunction: _onReceiveRosterSuccess
+     *
+     */
+    _onReceiveRosterSuccess: function(userCallback, stanza)
+    {
+        this._updateItems(stanza);
+        userCallback(this.items);
+    },
+    /** PrivateFunction: _onReceiveRosterError
+     *
+     */
+    _onReceiveRosterError: function(userCallback, stanza)
+    {
+        userCallback(this.items);
+    },
+    /** PrivateFunction: _onReceivePresence
+     * Handle presence
+     */
+    _onReceivePresence : function(presence)
+    {
+        // TODO: from is optional
+        var jid = presence.getAttribute('from');
+        var from = Strophe.getBareJidFromJid(jid);
+        var item = this.findItem(from);
+        // not in roster
+        if (!item)
+        {
+            return true;
+        }
+        var type = presence.getAttribute('type');
+        if (type == 'unavailable')
+        {
+            delete item.resources[Strophe.getResourceFromJid(jid)];
+        }
+        else if (!type)
+        {
+            // TODO: add timestamp
+            item.resources[Strophe.getResourceFromJid(jid)] = {
+                show     : (presence.getElementsByTagName('show').length != 0) ? Strophe.getText(presence.getElementsByTagName('show')[0]) : "",
+                status   : (presence.getElementsByTagName('status').length != 0) ? Strophe.getText(presence.getElementsByTagName('status')[0]) : "",
+                priority : (presence.getElementsByTagName('priority').length != 0) ? Strophe.getText(presence.getElementsByTagName('priority')[0]) : ""
+            };
+        }
+        else
+        {
+            // Stanza is not a presence notification. (It's probably a subscription type stanza.)
+            return true;
+        }
+        this._call_backs(this.items, item);
+        return true;
+    },
+    /** PrivateFunction: _call_backs
+     *
+     */
+    _call_backs : function(items, item)
+    {
+        for (var i = 0; i < this._callbacks.length; i++) // [].forEach my love ...
+        {
+            this._callbacks[i](items, item);
+        }
+    },
+    /** PrivateFunction: _onReceiveIQ
+     * Handle roster push.
+     */
+    _onReceiveIQ : function(iq)
+    {
+        var id = iq.getAttribute('id');
+        var from = iq.getAttribute('from');
+        // Receiving client MUST ignore stanza unless it has no from or from = user's JID.
+        if (from && from != "" && from != this._connection.jid && from != Strophe.getBareJidFromJid(this._connection.jid))
+            return true;
+        var iqresult = $iq({type: 'result', id: id, from: this._connection.jid});
+        this._connection.send(iqresult);
+        this._updateItems(iq);
+        return true;
+    },
+    /** PrivateFunction: _updateItems
+     * Update items from iq
+     */
+    _updateItems : function(iq)
+    {
+        var query = iq.getElementsByTagName('query');
+        if (query.length != 0)
+        {
+            this.ver = query.item(0).getAttribute('ver');
+            var self = this;
+            Strophe.forEachChild(query.item(0), 'item',
+                function (item)
+                {
+                    self._updateItem(item);
+                }
+           );
+        }
+        this._call_backs(this.items);
+    },
+    /** PrivateFunction: _updateItem
+     * Update internal representation of roster item
+     */
+    _updateItem : function(item)
+    {
+        var jid           = item.getAttribute("jid");
+        var name          = item.getAttribute("name");
+        var subscription  = item.getAttribute("subscription");
+        var ask           = item.getAttribute("ask");
+        var groups        = [];
+        Strophe.forEachChild(item, 'group',
+            function(group)
+            {
+                groups.push(Strophe.getText(group));
+            }
+        );
+
+        if (subscription == "remove")
+        {
+            this.removeItem(jid);
+            return;
+        }
+
+        var item = this.findItem(jid);
+        if (!item)
+        {
+            this.items.push({
+                name         : name,
+                jid          : jid,
+                subscription : subscription,
+                ask          : ask,
+                groups       : groups,
+                resources    : {}
+            });
+        }
+        else
+        {
+            item.name = name;
+            item.subscription = subscription;
+            item.ask = ask;
+            item.groups = groups;
+        }
+    }
+});

Libraries/strophe.vcard.js

+// Generated by CoffeeScript 1.3.3
+/*
+Plugin to implement the vCard extension.
+http://xmpp.org/extensions/xep-0054.html
+
+Author: Nathan Zorn (nathan.zorn@gmail.com)
+CoffeeScript port: Andreas Guth (guth@dbis.rwth-aachen.de)
+*/
+
+/* jslint configuration:
+*/
+
+/* global document, window, setTimeout, clearTimeout, console,
+    XMLHttpRequest, ActiveXObject,
+    Base64, MD5,
+    Strophe, $build, $msg, $iq, $pres
+*/
+
+var buildIq;
+
+buildIq = function(type, jid, vCardEl) {
+  var iq;
+  iq = $iq(jid ? {
+    type: type,
+    to: jid
+  } : {
+    type: type
+  });
+  iq.c("vCard", {
+    xmlns: Strophe.NS.VCARD
+  });
+  if (vCardEl) {
+    iq.cnode(vCardEl);
+  }
+  return iq;
+};
+
+Strophe.addConnectionPlugin('vcard', {
+  _connection: null,
+  init: function(conn) {
+    this._connection = conn;
+    return Strophe.addNamespace('VCARD', 'vcard-temp');
+  },
+  /*Function
+    Retrieve a vCard for a JID/Entity
+    Parameters:
+    (Function) handler_cb - The callback function used to handle the request.
+    (String) jid - optional - The name of the entity to request the vCard
+       If no jid is given, this function retrieves the current user's vcard.
+  */
+
+  get: function(handler_cb, jid, error_cb) {
+    var iq;
+    iq = buildIq("get", jid);
+    return this._connection.sendIQ(iq, handler_cb, error_cb);
+  },
+  /* Function
+      Set an entity's vCard.
+  */
+
+  set: function(handler_cb, vCardEl, jid, error_cb) {
+    var iq;
+    iq = buildIq("set", jid, vCardEl);
+    return this._connection.sendIQ(iq, handler_cb, error_rb);
+  }
+});

Libraries/underscore.js

+//     Underscore.js 1.4.4
+//     http://underscorejs.org
+//     (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
+//     Underscore may be freely distributed under the MIT license.
+
+(function() {
+
+  // Baseline setup
+  // --------------
+
+  // Establish the root object, `window` in the browser, or `global` on the server.
+  var root = this;
+
+  // Save the previous value of the `_` variable.
+  var previousUnderscore = root._;
+
+  // Establish the object that gets returned to break out of a loop iteration.
+  var breaker = {};
+
+  // Save bytes in the minified (but not gzipped) version:
+  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
+
+  // Create quick reference variables for speed access to core prototypes.
+  var push             = ArrayProto.push,
+      slice            = ArrayProto.slice,
+      concat           = ArrayProto.concat,
+      toString         = ObjProto.toString,
+      hasOwnProperty   = ObjProto.hasOwnProperty;
+
+  // All **ECMAScript 5** native function implementations that we hope to use
+  // are declared here.
+  var
+    nativeForEach      = ArrayProto.forEach,
+    nativeMap          = ArrayProto.map,
+    nativeReduce       = ArrayProto.reduce,
+    nativeReduceRight  = ArrayProto.reduceRight,
+    nativeFilter       = ArrayProto.filter,
+    nativeEvery        = ArrayProto.every,
+    nativeSome         = ArrayProto.some,
+    nativeIndexOf      = ArrayProto.indexOf,
+    nativeLastIndexOf  = ArrayProto.lastIndexOf,
+    nativeIsArray      = Array.isArray,
+    nativeKeys         = Object.keys,
+    nativeBind         = FuncProto.bind;
+
+  // Create a safe reference to the Underscore object for use below.
+  var _ = function(obj) {
+    if (obj instanceof _) return obj;
+    if (!(this instanceof _)) return new _(obj);
+    this._wrapped = obj;
+  };
+
+  // Export the Underscore object for **Node.js**, with
+  // backwards-compatibility for the old `require()` API. If we're in
+  // the browser, add `_` as a global object via a string identifier,
+  // for Closure Compiler "advanced" mode.
+  if (typeof exports !== 'undefined') {
+    if (typeof module !== 'undefined' && module.exports) {
+      exports = module.exports = _;
+    }
+    exports._ = _;
+  } else {
+    root._ = _;
+  }
+
+  // Current version.
+  _.VERSION = '1.4.4';
+
+  // Collection Functions
+  // --------------------
+
+  // The cornerstone, an `each` implementation, aka `forEach`.
+  // Handles objects with the built-in `forEach`, arrays, and raw objects.
+  // Delegates to **ECMAScript 5**'s native `forEach` if available.
+  var each = _.each = _.forEach = function(obj, iterator, context) {
+    if (obj == null) return;
+    if (nativeForEach && obj.forEach === nativeForEach) {
+      obj.forEach(iterator, context);
+    } else if (obj.length === +obj.length) {
+      for (var i = 0, l = obj.length; i < l; i++) {
+        if (iterator.call(context, obj[i], i, obj) === breaker) return;
+      }
+    } else {
+      for (var key in obj) {
+        if (_.has(obj, key)) {
+          if (iterator.call(context, obj[key], key, obj) === breaker) return;
+        }
+      }
+    }
+  };
+
+  // Return the results of applying the iterator to each element.
+  // Delegates to **ECMAScript 5**'s native `map` if available.
+  _.map = _.collect = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
+    each(obj, function(value, index, list) {
+      results[results.length] = iterator.call(context, value, index, list);
+    });
+    return results;
+  };
+
+  var reduceError = 'Reduce of empty array with no initial value';
+
+  // **Reduce** builds up a single result from a list of values, aka `inject`,
+  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
+  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
+    var initial = arguments.length > 2;
+    if (obj == null) obj = [];
+    if (nativeReduce && obj.reduce === nativeReduce) {
+      if (context) iterator = _.bind(iterator, context);
+      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
+    }
+    each(obj, function(value, index, list) {
+      if (!initial) {
+        memo = value;
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, value, index, list);
+      }
+    });
+    if (!initial) throw new TypeError(reduceError);
+    return memo;
+  };
+
+  // The right-associative version of reduce, also known as `foldr`.
+  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
+  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
+    var initial = arguments.length > 2;
+    if (obj == null) obj = [];
+    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
+      if (context) iterator = _.bind(iterator, context);
+      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
+    }
+    var length = obj.length;
+    if (length !== +length) {
+      var keys = _.keys(obj);
+      length = keys.length;
+    }
+    each(obj, function(value, index, list) {
+      index = keys ? keys[--length] : --length;
+      if (!initial) {
+        memo = obj[index];
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, obj[index], index, list);
+      }
+    });
+    if (!initial) throw new TypeError(reduceError);
+    return memo;
+  };
+
+  // Return the first value which passes a truth test. Aliased as `detect`.
+  _.find = _.detect = function(obj, iterator, context) {
+    var result;
+    any(obj, function(value, index, list) {
+      if (iterator.call(context, value, index, list)) {
+        result = value;
+        return true;
+      }
+    });
+    return result;
+  };
+
+  // Return all the elements that pass a truth test.
+  // Delegates to **ECMAScript 5**'s native `filter` if available.
+  // Aliased as `select`.
+  _.filter = _.select = function(obj, iterator, context) {
+    var results = [];
+    if (obj == null) return results;
+    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
+    each(obj, function(value, index, list) {
+      if (iterator.call(context, value, index, list)) results[results.length] = value;
+    });
+    return results;
+  };
+
+  // Return all the elements for which a truth test fails.
+  _.reject = function(obj, iterator, context) {
+    return _.filter(obj, function(value, index, list) {
+      return !iterator.call(context, value, index, list);
+    }, context);
+  };
+
+  // Determine whether all of the elements match a truth test.
+  // Delegates to **ECMAScript 5**'s native `every` if available.
+  // Aliased as `all`.
+  _.every = _.all = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
+    var result = true;
+    if (obj == null) return result;
+    if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
+    each(obj, function(value, index, list) {
+      if (!(result = result && iterator.call(context, value, index, list))) return breaker;
+    });
+    return !!result;
+  };
+
+  // Determine if at least one element in the object matches a truth test.
+  // Delegates to **ECMAScript 5**'s native `some` if available.
+  // Aliased as `any`.
+  var any = _.some = _.any = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
+    var result = false;
+    if (obj == null) return result;
+    if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
+    each(obj, function(value, index, list) {
+      if (result || (result = iterator.call(context, value, index, list))) return breaker;
+    });
+    return !!result;
+  };
+
+  // Determine if the array or object contains a given value (using `===`).
+  // Aliased as `include`.
+  _.contains = _.include = function(obj, target) {
+    if (obj == null) return false;
+    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
+    return any(obj, function(value) {
+      return value === target;
+    });
+  };
+
+  // Invoke a method (with arguments) on every item in a collection.
+  _.invoke = function(obj, method) {
+    var args = slice.call(arguments, 2);
+    var isFunc = _.isFunction(method);
+    return _.map(obj, function(value) {
+      return (isFunc ? method : value[method]).apply(value, args);
+    });
+  };
+
+  // Convenience version of a common use case of `map`: fetching a property.
+  _.pluck = function(obj, key) {
+    return _.map(obj, function(value){ return value[key]; });
+  };
+
+  // Convenience version of a common use case of `filter`: selecting only objects
+  // containing specific `key:value` pairs.
+  _.where = function(obj, attrs, first) {
+    if (_.isEmpty(attrs)) return first ? null : [];
+    return _[first ? 'find' : 'filter'](obj, function(value) {
+      for (var key in attrs) {
+        if (attrs[key] !== value[key]) return false;
+      }
+      return true;
+    });
+  };
+
+  // Convenience version of a common use case of `find`: getting the first object
+  // containing specific `key:value` pairs.
+  _.findWhere = function(obj, attrs) {
+    return _.where(obj, attrs, true);
+  };
+
+  // Return the maximum element or (element-based computation).
+  // Can't optimize arrays of integers longer than 65,535 elements.
+  // See: https://bugs.webkit.org/show_bug.cgi?id=80797
+  _.max = function(obj, iterator, context) {
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.max.apply(Math, obj);
+    }
+    if (!iterator && _.isEmpty(obj)) return -Infinity;
+    var result = {computed : -Infinity, value: -Infinity};
+    each(obj, function(value, index, list) {
+      var computed = iterator ? iterator.call(context, value, index, list) : value;
+      computed >= result.computed && (result = {value : value, computed : computed});
+    });
+    return result.value;
+  };
+
+  // Return the minimum element (or element-based computation).
+  _.min = function(obj, iterator, context) {
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.min.apply(Math, obj);
+    }
+    if (!iterator && _.isEmpty(obj)) return Infinity;
+    var result = {computed : Infinity, value: Infinity};
+    each(obj, function(value, index, list) {
+      var computed = iterator ? iterator.call(context, value, index, list) : value;
+      computed < result.computed && (result = {value : value, computed : computed});
+    });
+    return result.value;
+  };
+
+  // Shuffle an array.
+  _.shuffle = function(obj) {
+    var rand;
+    var index = 0;
+    var shuffled = [];
+    each(obj, function(value) {
+      rand = _.random(index++);
+      shuffled[index - 1] = shuffled[rand];
+      shuffled[rand] = value;
+    });
+    return shuffled;
+  };
+
+  // An internal function to generate lookup iterators.
+  var lookupIterator = function(value) {
+    return _.isFunction(value) ? value : function(obj){ return obj[value]; };
+  };
+
+  // Sort the object's values by a criterion produced by an iterator.
+  _.sortBy = function(obj, value, context) {
+    var iterator = lookupIterator(value);
+    return _.pluck(_.map(obj, function(value, index, list) {
+      return {
+        value : value,
+        index : index,
+        criteria : iterator.call(context, value, index, list)
+      };
+    }).sort(function(left, right) {
+      var a = left.criteria;
+      var b = right.criteria;
+      if (a !== b) {
+        if (a > b || a === void 0) return 1;
+        if (a < b || b === void 0) return -1;
+      }
+      return left.index < right.index ? -1 : 1;
+    }), 'value');
+  };
+
+  // An internal function used for aggregate "group by" operations.
+  var group = function(obj, value, context, behavior) {
+    var result = {};
+    var iterator = lookupIterator(value || _.identity);
+    each(obj, function(value, index) {
+      var key = iterator.call(context, value, index, obj);
+      behavior(result, key, value);
+    });
+    return result;
+  };
+
+  // Groups the object's values by a criterion. Pass either a string attribute
+  // to group by, or a function that returns the criterion.
+  _.groupBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key, value) {
+      (_.has(result, key) ? result[key] : (result[key] = [])).push(value);
+    });
+  };
+
+  // Counts instances of an object that group by a certain criterion. Pass
+  // either a string attribute to count by, or a function that returns the
+  // criterion.
+  _.countBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key) {
+      if (!_.has(result, key)) result[key] = 0;
+      result[key]++;
+    });
+  };
+
+  // Use a comparator function to figure out the smallest index at which
+  // an object should be inserted so as to maintain order. Uses binary search.
+  _.sortedIndex = function(array, obj, iterator, context) {
+    iterator = iterator == null ? _.identity : lookupIterator(iterator);
+    var value = iterator.call(context, obj);
+    var low = 0, high = array.length;
+    while (low < high) {
+      var mid = (low + high) >>> 1;
+      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
+    }
+    return low;
+  };
+
+  // Safely convert anything iterable into a real, live array.
+  _.toArray = function(obj) {
+    if (!obj) return [];
+    if (_.isArray(obj)) return slice.call(obj);
+    if (obj.length === +obj.length) return _.map(obj, _.identity);
+    return _.values(obj);
+  };
+
+  // Return the number of elements in an object.
+  _.size = function(obj) {
+    if (obj == null) return 0;
+    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
+  };
+
+  // Array Functions
+  // ---------------
+
+  // Get the first element of an array. Passing **n** will return the first N
+  // values in the array. Aliased as `head` and `take`. The **guard** check
+  // allows it to work with `_.map`.
+  _.first = _.head = _.take = function(array, n, guard) {
+    if (array == null) return void 0;
+    return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
+  };
+
+  // Returns everything but the last entry of the array. Especially useful on
+  // the arguments object. Passing **n** will return all the values in
+  // the array, excluding the last N. The **guard** check allows it to work with
+  // `_.map`.
+  _.initial = function(array, n, guard) {
+    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
+  };
+
+  // Get the last element of an array. Passing **n** will return the last N
+  // values in the array. The **guard** check allows it to work with `_.map`.
+  _.last = function(array, n, guard) {
+    if (array == null) return void 0;
+    if ((n != null) && !guard) {
+      return slice.call(array, Math.max(array.length - n, 0));
+    } else {
+      return array[array.length - 1];
+    }
+  };
+
+  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
+  // Especially useful on the arguments object. Passing an **n** will return
+  // the rest N values in the array. The **guard**
+  // check allows it to work with `_.map`.
+  _.rest = _.tail = _.drop = function(array, n, guard) {
+    return slice.call(array, (n == null) || guard ? 1 : n);
+  };
+
+  // Trim out all falsy values from an array.
+  _.compact = function(array) {
+    return _.filter(array, _.identity);
+  };
+
+  // Internal implementation of a recursive `flatten` function.
+  var flatten = function(input, shallow, output) {
+    each(input, function(value) {
+      if (_.isArray(value)) {
+        shallow ? push.apply(output, value) : flatten(value, shallow, output);
+      } else {
+        output.push(value);
+      }
+    });
+    return output;
+  };
+
+  // Return a completely flattened version of an array.
+  _.flatten = function(array, shallow) {
+    return flatten(array, shallow, []);
+  };
+
+  // Return a version of the array that does not contain the specified value(s).
+  _.without = function(array) {
+    return _.difference(array, slice.call(arguments, 1));
+  };
+
+  // Produce a duplicate-free version of the array. If the array has already
+  // been sorted, you have the option of using a faster algorithm.
+  // Aliased as `unique`.
+  _.uniq = _.unique = function(array, isSorted, iterator, context) {
+    if (_.isFunction(isSorted)) {
+      context = iterator;
+      iterator = isSorted;
+      isSorted = false;
+    }
+    var initial = iterator ? _.map(array, iterator, context) : array;
+    var results = [];
+    var seen = [];
+    each(initial, function(value, index) {
+      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
+        seen.push(value);
+        results.push(array[index]);
+      }
+    });
+    return results;
+  };
+
+  // Produce an array that contains the union: each distinct element from all of
+  // the passed-in arrays.
+  _.union = function() {
+    return _.uniq(concat.apply(ArrayProto, arguments));
+  };
+
+  // Produce an array that contains every item shared between all the
+  // passed-in arrays.
+  _.intersection = function(array) {
+    var rest = slice.call(arguments, 1);
+    return _.filter(_.uniq(array), function(item) {
+      return _.every(rest, function(other) {
+        return _.indexOf(other, item) >= 0;
+      });
+    });
+  };
+
+  // Take the difference between one array and a number of other arrays.
+  // Only the elements present in just the first array will remain.
+  _.difference = function(array) {
+    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
+    return _.filter(array, function(value){ return !_.contains(rest, value); });
+  };
+
+  // Zip together multiple lists into a single array -- elements that share
+  // an index go together.
+  _.zip = function() {
+    var args = slice.call(arguments);
+    var length = _.max(_.pluck(args, 'length'));
+    var results = new Array(length);
+    for (var i = 0; i < length; i++) {
+      results[i] = _.pluck(args, "" + i);
+    }
+    return results;
+  };
+
+  // Converts lists into objects. Pass either a single array of `[key, value]`
+  // pairs, or two parallel arrays of the same length -- one of keys, and one of
+  // the corresponding values.
+  _.object = function(list, values) {
+    if (list == null) return {};
+    var result = {};
+    for (var i = 0, l = list.length; i < l; i++) {
+      if (values) {
+        result[list[i]] = values[i];
+      } else {
+        result[list[i][0]] = list[i][1];
+      }
+    }
+    return result;
+  };
+
+  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
+  // we need this function. Return the position of the first occurrence of an
+  // item in an array, or -1 if the item is not included in the array.
+  // Delegates to **ECMAScript 5**'s native `indexOf` if available.
+  // If the array is large and already in sort order, pass `true`
+  // for **isSorted** to use binary search.
+  _.indexOf = function(array, item, isSorted) {
+    if (array == null) return -1;
+    var i = 0, l = array.length;
+    if (isSorted) {
+      if (typeof isSorted == 'number') {
+        i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
+      } else {
+        i = _.sortedIndex(array, item);
+        return array[i] === item ? i : -1;
+      }
+    }
+    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
+    for (; i < l; i++) if (array[i] === item) return i;
+    return -1;
+  };
+
+  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
+  _.lastIndexOf = function(array, item, from) {
+    if (array == null) return -1;
+    var hasIndex = from != null;
+    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
+      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
+    }
+    var i = (hasIndex ? from : array.length);
+    while (i--) if (array[i] === item) return i;
+    return -1;
+  };
+
+  // Generate an integer Array containing an arithmetic progression. A port of
+  // the native Python `range()` function. See
+  // [the Python documentation](http://docs.python.org/library/functions.html#range).
+  _.range = function(start, stop, step) {
+    if (arguments.length <= 1) {
+      stop = start || 0;
+      start = 0;
+    }
+    step = arguments[2] || 1;
+
+    var len = Math.max(Math.ceil((stop - start) / step), 0);
+    var idx = 0;
+    var range = new Array(len);
+
+    while(idx < len) {
+      range[idx++] = start;
+      start += step;
+    }
+
+    return range;
+  };
+
+  // Function (ahem) Functions
+  // ------------------
+
+  // Create a function bound to a given object (assigning `this`, and arguments,
+  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
+  // available.
+  _.bind = function(func, context) {
+    if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
+    var args = slice.call(arguments, 2);
+    return function() {
+      return func.apply(context, args.concat(slice.call(arguments)));
+    };
+  };
+
+  // Partially apply a function by creating a version that has had some of its
+  // arguments pre-filled, without changing its dynamic `this` context.
+  _.partial = function(func) {
+    var args = slice.call(arguments, 1);
+    return function() {
+      return func.apply(this, args.concat(slice.call(arguments)));
+    };
+  };
+
+  // Bind all of an object's methods to that object. Useful for ensuring that
+  // all callbacks defined on an object belong to it.
+  _.bindAll = function(obj) {
+    var funcs = slice.call(arguments, 1);
+    if (funcs.length === 0) funcs = _.functions(obj);
+    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
+    return obj;
+  };
+
+  // Memoize an expensive function by storing its results.
+  _.memoize = function(func, hasher) {
+    var memo = {};
+    hasher || (hasher = _.identity);
+    return function() {
+      var key = hasher.apply(this, arguments);
+      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+    };
+  };
+
+  // Delays a function for the given number of milliseconds, and then calls
+  // it with the arguments supplied.
+  _.delay = function(func, wait) {
+    var args = slice.call(arguments, 2);
+    return setTimeout(function(){ return func.apply(null, args); }, wait);
+  };
+
+  // Defers a function, scheduling it to run after the current call stack has
+  // cleared.
+  _.defer = function(func) {
+    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
+  };
+
+  // Returns a function, that, when invoked, will only be triggered at most once
+  // during a given window of time.
+  _.throttle = function(func, wait) {
+    var context, args, timeout, result;
+    var previous = 0;
+    var later = function() {
+      previous = new Date;
+      timeout = null;
+      result = func.apply(context, args);
+    };
+    return function() {
+      var now = new Date;
+      var remaining = wait - (now - previous);
+      context = this;
+      args = arguments;
+      if (remaining <= 0) {
+        clearTimeout(timeout);
+        timeout = null;
+        previous = now;
+        result = func.apply(context, args);
+      } else if (!timeout) {
+        timeout = setTimeout(later, remaining);
+      }
+      return result;
+    };
+  };
+
+  // Returns a function, that, as long as it continues to be invoked, will not
+  // be triggered. The function will be called after it stops being called for
+  // N milliseconds. If `immediate` is passed, trigger the function on the
+  // leading edge, instead of the trailing.
+  _.debounce = function(func, wait, immediate) {
+    var timeout, result;
+    return function() {
+      var context = this, args = arguments;
+      var later = function() {
+        timeout = null;
+        if (!immediate) result = func.apply(context, args);
+      };
+      var callNow = immediate && !timeout;
+      clearTimeout(timeout);
+      timeout = setTimeout(later, wait);
+      if (callNow) result = func.apply(context, args);
+      return result;
+    };
+  };
+
+  // Returns a function that will be executed at most one time, no matter how
+  // often you call it. Useful for lazy initialization.
+  _.once = function(func) {
+    var ran = false, memo;
+    return function() {
+      if (ran) return memo;
+      ran = true;
+      memo = func.apply(this, arguments);
+      func = null;
+      return memo;
+    };
+  };
+
+  // Returns the first function passed as an argument to the second,
+  // allowing you to adjust arguments, run code before and after, and
+  // conditionally execute the original function.
+  _.wrap = function(func, wrapper) {
+    return function() {
+      var args = [func];
+      push.apply(args, arguments);
+      return wrapper.apply(this, args);
+    };
+  };
+
+  // Returns a function that is the composition of a list of functions, each
+  // consuming the return value of the function that follows.
+  _.compose = function() {
+    var funcs = arguments;
+    return function() {
+      var args = arguments;
+      for (var i = funcs.length - 1; i >= 0; i--) {
+        args = [funcs[i].apply(this, args)];
+      }
+      return args[0];
+    };
+  };
+
+  // Returns a function that will only be executed after being called N times.
+  _.after = function(times, func) {
+    if (times <= 0) return func();
+    return function() {
+      if (--times < 1) {
+        return func.apply(this, arguments);
+      }
+    };
+  };
+
+  // Object Functions
+  // ----------------
+
+  // Retrieve the names of an object's properties.
+  // Delegates to **ECMAScript 5**'s native `Object.keys`
+  _.keys = nativeKeys || function(obj) {
+    if (obj !== Object(obj)) throw new TypeError('Invalid object');
+    var keys = [];
+    for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
+    return keys;
+  };
+
+  // Retrieve the values of an object's properties.
+  _.values = function(obj) {
+    var values = [];
+    for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
+    return values;
+  };
+
+  // Convert an object into a list of `[key, value]` pairs.
+  _.pairs = function(obj) {
+    var pairs = [];
+    for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
+    return pairs;
+  };
+
+  // Invert the keys and values of an object. The values must be serializable.
+  _.invert = function(obj) {
+    var result = {};
+    for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
+    return result;
+  };
+
+  // Return a sorted list of the function names available on the object.
+  // Aliased as `methods`
+  _.functions = _.methods = function(obj) {
+    var names = [];
+    for (var key in obj) {
+      if (_.isFunction(obj[key])) names.push(key);
+    }
+    return names.sort();
+  };
+
+  // Extend a given object with all the properties in passed-in object(s).
+  _.extend = function(obj) {
+    each(slice.call(arguments, 1), function(source) {
+      if (source) {
+        for (var prop in source) {
+          obj[prop] = source[prop];
+        }
+      }
+    });
+    return obj;
+  };
+
+  // Return a copy of the object only containing the whitelisted properties.
+  _.pick = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    each(keys, function(key) {
+      if (key in obj) copy[key] = obj[key];
+    });
+    return copy;
+  };
+
+   // Return a copy of the object without the blacklisted properties.
+  _.omit = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    for (var key in obj) {
+      if (!_.contains(keys, key)) copy[key] = obj[key];
+    }
+    return copy;
+  };
+
+  // Fill in a given object with default properties.
+  _.defaults = function(obj) {
+    each(slice.call(arguments, 1), function(source) {
+      if (source) {
+        for (var prop in source) {
+          if (obj[prop] == null) obj[prop] = source[prop];
+        }
+      }
+    });
+    return obj;
+  };
+
+  // Create a (shallow-cloned) duplicate of an object.
+  _.clone = function(obj) {
+    if (!_.isObject(obj)) return obj;
+    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+  };
+
+  // Invokes interceptor with the obj, and then returns obj.
+  // The primary purpose of this method is to "tap into" a method chain, in
+  // order to perform operations on intermediate results within the chain.
+  _.tap = function(obj, interceptor) {
+    interceptor(obj);
+    return obj;
+  };
+
+  // Internal recursive comparison function for `isEqual`.
+  var eq = function(a, b, aStack, bStack) {
+    // Identical objects are equal. `0 === -0`, but they aren't identical.
+    // See the Harmony `egal` proposal: http://wiki.ecmascript.org/doku.php?id=harmony:egal.
+    if (a === b) return a !== 0 || 1 / a == 1 / b;
+    // A strict comparison is necessary because `null == undefined`.
+    if (a == null || b == null) return a === b;
+    // Unwrap any wrapped objects.
+    if (a instanceof _) a = a._wrapped;
+    if (b instanceof _) b = b._wrapped;
+    // Compare `[[Class]]` names.
+    var className = toString.call(a);
+    if (className != toString.call(b)) return false;
+    switch (className) {
+      // Strings, numbers, dates, and booleans are compared by value.
+      case '[object String]':
+        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
+        // equivalent to `new String("5")`.
+        return a == String(b);
+      case '[object Number]':
+        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
+        // other numeric values.
+        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
+      case '[object Date]':
+      case '[object Boolean]':
+        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
+        // millisecond representations. Note that invalid dates with millisecond representations
+        // of `NaN` are not equivalent.
+        return +a == +b;
+      // RegExps are compared by their source patterns and flags.
+      case '[object RegExp]':
+        return a.source == b.source &&
+               a.global == b.global &&
+               a.multiline == b.multiline &&
+               a.ignoreCase == b.ignoreCase;
+    }
+    if (typeof a != 'object' || typeof b != 'object') return false;
+    // Assume equality for cyclic structures. The algorithm for detecting cyclic
+    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
+    var length = aStack.length;
+    while (length--) {
+      // Linear search. Performance is inversely proportional to the number of
+      // unique nested structures.
+      if (aStack[length] == a) return bStack[length] == b;
+    }
+    // Add the first object to the stack of traversed objects.
+    aStack.push(a);
+    bStack.push(b);
+    var size = 0, result = true;
+    // Recursively compare objects and arrays.
+    if (className == '[object Array]') {
+      // Compare array lengths to determine if a deep comparison is necessary.
+      size = a.length;
+      result = size == b.length;
+      if (result) {
+        // Deep compare the contents, ignoring non-numeric properties.
+        while (size--) {
+          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
+        }
+      }
+    } else {
+      // Objects with different constructors are not equivalent, but `Object`s
+      // from different frames are.
+      var aCtor = a.constructor, bCtor = b.constructor;
+      if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
+                               _.isFunction(bCtor) && (bCtor instanceof bCtor))) {
+        return false;
+      }
+      // Deep compare objects.
+      for (var key in a) {
+        if (_.has(a, key)) {
+          // Count the expected number of properties.
+          size++;
+          // Deep compare each member.
+          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
+        }
+      }
+      // Ensure that both objects contain the same number of properties.
+      if (result) {
+        for (key in b) {
+          if (_.has(b, key) && !(size--)) break;
+        }
+        result = !size;
+      }
+    }
+    // Remove the first object from the stack of traversed objects.
+    aStack.pop();
+    bStack.pop();
+    return result;
+  };
+
+  // Perform a deep comparison to check if two objects are equal.
+  _.isEqual = function(a, b) {
+    return eq(a, b, [], []);
+  };
+
+  // Is a given array, string, or object empty?
+  // An "empty" object has no enumerable own-properties.
+  _.isEmpty = function(obj) {
+    if (obj == null) return true;
+    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
+    for (var key in obj) if (_.has(obj, key)) return false;
+    return true;
+  };
+
+  // Is a given value a DOM element?
+  _.isElement = function(obj) {
+    return !!(obj && obj.nodeType === 1);
+  };
+
+  // Is a given value an array?
+  // Delegates to ECMA5's native Array.isArray
+  _.isArray = nativeIsArray || function(obj) {
+    return toString.call(obj) == '[object Array]';
+  };
+
+  // Is a given variable an object?
+  _.isObject = function(obj) {
+    return obj === Object(obj);
+  };
+
+  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
+  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+    _['is' + name] = function(obj) {
+      return toString.call(obj) == '[object ' + name + ']';
+    };
+  });
+
+  // Define a fallback version of the method in browsers (ahem, IE), where
+  // there isn't any inspectable "Arguments" type.
+  if (!_.isArguments(arguments)) {
+    _.isArguments = function(obj) {
+      return !!(obj && _.has(obj, 'callee'));
+    };
+  }
+
+  // Optimize `isFunction` if appropriate.
+  if (typeof (/./) !== 'function') {
+    _.isFunction = function(obj) {
+      return typeof obj === 'function';
+    };
+  }
+
+  // Is a given object a finite number?
+  _.isFinite = function(obj) {
+    return isFinite(obj) && !isNaN(parseFloat(obj));
+  };
+
+  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
+  _.isNaN = function(obj) {
+    return _.isNumber(obj) && obj != +obj;
+  };
+
+  // Is a given value a boolean?
+  _.isBoolean = function(obj) {
+    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
+  };
+
+  // Is a given value equal to null?
+  _.isNull = function(obj) {
+    return obj === null;
+  };
+
+  // Is a given variable undefined?
+  _.isUndefined = function(obj) {
+    return obj === void 0;
+  };
+
+  // Shortcut function for checking if an object has a given property directly
+  // on itself (in other words, not on a prototype).
+  _.has = function(obj, key) {
+    return hasOwnProperty.call(obj, key);
+  };
+
+  // Utility Functions
+  // -----------------
+
+  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
+  // previous owner. Returns a reference to the Underscore object.
+  _.noConflict = function() {
+    root._ = previousUnderscore;
+    return this;
+  };
+
+  // Keep the identity function around for default iterators.
+  _.identity = function(value) {
+    return value;
+  };
+
+  // Run a function **n** times.
+  _.times = function(n, iterator, context) {
+    var accum = Array(n);
+    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
+    return accum;
+  };
+
+  // Return a random integer between min and max (inclusive).
+  _.random = function(min, max) {
+    if (max == null) {
+      max = min;
+      min = 0;
+    }
+    return min + Math.floor(Math.random() * (max - min + 1));
+  };
+
+  // List of HTML entities for escaping.
+  var entityMap = {
+    escape: {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#x27;',
+      '/': '&#x2F;'
+    }
+  };
+  entityMap.unescape = _.invert(entityMap.escape);
+
+  // Regexes containing the keys and values listed immediately above.
+  var entityRegexes = {
+    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
+    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
+  };
+
+  // Functions for escaping and unescaping strings to/from HTML interpolation.
+  _.each(['escape', 'unescape'], function(method) {
+    _[method] = function(string) {
+      if (string == null) return '';
+      return ('' + string).replace(entityRegexes[method], function(match) {
+        return entityMap[method][match];
+      });
+    };
+  });
+
+  // If the value of the named property is a function then invoke it;
+  // otherwise, return it.
+  _.result = function(object, property) {
+    if (object == null) return null;
+    var value = object[property];
+    return _.isFunction(value) ? value.call(object) : value;
+  };
+
+  // Add your own custom functions to the Underscore object.
+  _.mixin = function(obj) {
+    each(_.functions(obj), function(name){
+      var func = _[name] = obj[name];
+      _.prototype[name] = function() {
+        var args = [this._wrapped];
+        push.apply(args, arguments);
+        return result.call(this, func.apply(_, args));
+      };
+    });
+  };
+
+  // Generate a unique integer id (unique within the entire client session).
+  // Useful for temporary DOM ids.
+  var idCounter = 0;
+  _.uniqueId = function(prefix) {
+    var id = ++idCounter + '';
+    return prefix ? prefix + id : id;
+  };
+
+  // By default, Underscore uses ERB-style template delimiters, change the
+  // following template settings to use alternative delimiters.
+  _.templateSettings = {
+    evaluate    : /<%([\s\S]+?)%>/g,
+    interpolate : /<%=([\s\S]+?)%>/g,
+    escape      : /<%-([\s\S]+?)%>/g
+  };
+
+  // When customizing `templateSettings`, if you don't want to define an
+  // interpolation, evaluation or escaping regex, we need one that is
+  // guaranteed not to match.
+  var noMatch = /(.)^/;
+
+  // Certain characters need to be escaped so that they can be put into a
+  // string literal.
+  var escapes = {
+    "'":      "'",
+    '\\':     '\\',
+    '\r':     'r',
+    '\n':     'n',
+    '\t':     't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029'
+  };
+
+  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
+
+  // JavaScript micro-templating, similar to John Resig's implementation.
+  // Underscore templating handles arbitrary delimiters, preserves whitespace,
+  // and correctly escapes quotes within interpolated code.
+  _.template = function(text, data, settings) {
+    var render;
+    settings = _.defaults({}, settings, _.templateSettings);
+
+    // Combine delimiters into one regular expression via alternation.
+    var matcher = new RegExp([
+      (settings.escape || noMatch).source,
+      (settings.interpolate || noMatch).source,
+      (settings.evaluate || noMatch).source
+    ].join('|') + '|$', 'g');
+
+    // Compile the template source, escaping string literals appropriately.
+    var index = 0;
+    var source = "__p+='";
+    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+      source += text.slice(index, offset)
+        .replace(escaper, function(match) { return '\\' + escapes[match]; });
+
+      if (escape) {
+        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+      }
+      if (interpolate) {
+        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+      }
+      if (evaluate) {
+        source += "';\n" + evaluate + "\n__p+='";
+      }
+      index = offset + match.length;
+      return match;
+    });
+    source += "';\n";
+
+    // If a variable is not specified, place data values in local scope.
+    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+    source = "var __t,__p='',__j=Array.prototype.join," +
+      "print=function(){__p+=__j.call(arguments,'');};\n" +
+      source + "return __p;\n";
+
+    try {
+      render = new Function(settings.variable || 'obj', '_', source);
+    } catch (e) {
+      e.source = source;
+      throw e;
+    }
+
+    if (data) return render(data, _);
+    var template = function(data) {
+      return render.call(this, data, _);
+    };
+
+    // Provide the compiled function source as a convenience for precompilation.
+    template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
+
+    return template;
+  };
+
+  // Add a "chain" function, which will delegate to the wrapper.
+  _.chain = function(obj) {
+    return _(obj).chain();
+  };
+
+  // OOP
+  // ---------------
+  // If Underscore is called as a function, it returns a wrapped object that
+  // can be used OO-style. This wrapper holds altered versions of all the
+  // underscore functions. Wrapped objects may be chained.
+
+  // Helper function to continue chaining intermediate results.
+  var result = function(obj) {
+    return this._chain ? _(obj).chain() : obj;
+  };
+
+  // Add all of the Underscore functions to the wrapper object.
+  _.mixin(_);
+
+  // Add all mutator Array functions to the wrapper.
+  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
+    var method = ArrayProto[name];
+    _.prototype[name] = function() {
+      var obj = this._wrapped;
+      method.apply(obj, arguments);
+      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
+      return result.call(this, obj);
+    };
+  });
+
+  // Add all accessor Array functions to the wrapper.
+  each(['concat', 'join', 'slice'], function(name) {
+    var method = ArrayProto[name];
+    _.prototype[name] = function() {
+      return result.call(this, method.apply(this._wrapped, arguments));
+    };
+  });
+
+  _.extend(_.prototype, {
+
+    // Start chaining a wrapped Underscore object.
+    chain: function() {
+      this._chain = true;
+      return this;
+    },
+
+    // Extracts the result from a wrapped and chained object.
+    value: function() {
+      return this._wrapped;
+    }
+
+  });
+
+}).call(this);

Libraries/xml2json.js

+/*	This work is licensed under Creative Commons GNU LGPL License.
+
+	License: http://creativecommons.org/licenses/LGPL/2.1/
+   Version: 0.9
+	Author:  Stefan Goessner/2006
+	Web:     http://goessner.net/ 
+*/
+function xml2json(xml, tab) {
+   var X = {
+      toObj: function(xml) {
+         var o = {};
+         if (xml.nodeType==1) {   // element node ..
+            if (xml.attributes.length)   // element with attributes  ..
+               for (var i=0; i<xml.attributes.length; i++)
+                  o["@"+xml.attributes[i].nodeName] = (xml.attributes[i].nodeValue||"").toString();
+            if (xml.firstChild) { // element has child nodes ..
+               var textChild=0, cdataChild=0, hasElementChild=false;
+               for (var n=xml.firstChild; n; n=n.nextSibling) {
+                  if (n.nodeType==1) hasElementChild = true;
+                  else if (n.nodeType==3 && n.nodeValue.match(/[^ \f\n\r\t\v]/)) textChild++; // non-whitespace text
+                  else if (n.nodeType==4) cdataChild++; // cdata section node
+               }
+               if (hasElementChild) {
+                  if (textChild < 2 && cdataChild < 2) { // structured element with evtl. a single text or/and cdata node ..
+                     X.removeWhite(xml);
+                     for (var n=xml.firstChild; n; n=n.nextSibling) {
+                        if (n.nodeType == 3)  // text node
+                           o["#text"] = X.escape(n.nodeValue);
+                        else if (n.nodeType == 4)  // cdata node
+                           o["#cdata"] = X.escape(n.nodeValue);
+                        else if (o[n.nodeName]) {  // multiple occurence of element ..
+                           if (o[n.nodeName] instanceof Array)
+                              o[n.nodeName][o[n.nodeName].length] = X.toObj(n);
+                           else
+                              o[n.nodeName] = [o[n.nodeName], X.toObj(n)];
+                        }
+                        else  // first occurence of element..
+                           o[n.nodeName] = X.toObj(n);
+                     }
+                  }
+                  else { // mixed content
+                     if (!xml.attributes.length)
+                        o = X.escape(X.innerXml(xml));
+                     else
+                        o["#text"] = X.escape(X.innerXml(xml));
+                  }
+               }
+               else if (textChild) { // pure text
+                  if (!xml.attributes.length)
+                     o = X.escape(X.innerXml(xml));
+                  else
+                     o["#text"] = X.escape(X.innerXml(xml));
+               }
+               else if (cdataChild) { // cdata
+                  if (cdataChild > 1)
+                     o = X.escape(X.innerXml(xml));
+                  else
+                     for (var n=xml.firstChild; n; n=n.nextSibling)
+                        o["#cdata"] = X.escape(n.nodeValue);
+               }
+            }
+            if (!xml.attributes.length && !xml.firstChild) o = null;
+         }
+         else if (xml.nodeType==9) { // document.node
+            o = X.toObj(xml.documentElement);
+         }
+         else
+            alert("unhandled node type: " + xml.nodeType);
+         return o;
+      },
+      toJson: function(o, name, ind) {
+         var json = name ? ("\""+name+"\"") : "";
+         if (o instanceof Array) {
+            for (var i=0,n=o.length; i<n; i++)
+               o[i] = X.toJson(o[i], "", ind+"\t");
+            json += (name?":[":"[") + (o.length > 1 ? ("\n"+ind+"\t"+o.join(",\n"+ind+"\t")+"\n"+ind) : o.join("")) + "]";
+         }
+         else if (o == null)
+            json += (name&&":") + "null";
+         else if (typeof(o) == "object") {
+            var arr = [];
+            for (var m in o)
+               arr[arr.length] = X.toJson(o[m], m, ind+"\t");
+            json += (name?":{":"{") + (arr.length > 1 ? ("\n"+ind+"\t"+arr.join(",\n"+ind+"\t")+"\n"+ind) : arr.join("")) + "}";
+         }
+         else if (typeof(o) == "string")
+            json += (name&&":") + "\"" + o.toString() + "\"";
+         else
+            json += (name&&":") + o.toString();
+         return json;
+      },
+      innerXml: function(node) {
+         var s = ""
+         if ("innerHTML" in node)
+            s = node.innerHTML;
+         else {
+            var asXml = function(n) {
+               var s = "";
+               if (n.nodeType == 1) {
+                  s += "<" + n.nodeName;
+                  for (var i=0; i<n.attributes.length;i++)
+                     s += " " + n.attributes[i].nodeName + "=\"" + (n.attributes[i].nodeValue||"").toString() + "\"";
+                  if (n.firstChild) {
+                     s += ">";
+                     for (var c=n.firstChild; c; c=c.nextSibling)
+                        s += asXml(c);
+                     s += "</"+n.nodeName+">";
+                  }
+                  else
+                     s += "/>";
+               }
+               else if (n.nodeType == 3)
+                  s += n.nodeValue;
+               else if (n.nodeType == 4)
+                  s += "<![CDATA[" + n.nodeValue + "]]>";
+               return s;
+            };
+            for (var c=node.firstChild; c; c=c.nextSibling)
+               s += asXml(c);
+         }
+         return s;
+      },
+      escape: function(txt) {
+         return txt.replace(/[\\]/g, "\\\\")
+                   .replace(/[\"]/g, '\\"')
+                   .replace(/[\n]/g, '\\n')
+                   .replace(/[\r]/g, '\\r');
+      },
+      removeWhite: function(e) {
+         e.normalize();
+         for (var n = e.firstChild; n; ) {
+            if (n.nodeType == 3) {  // text node
+               if (!n.nodeValue.match(/[^ \f\n\r\t\v]/)) { // pure whitespace text node
+                  var nxt = n.nextSibling;
+                  e.removeChild(n);
+                  n = nxt;
+               }
+               else
+                  n = n.nextSibling;
+            }
+            else if (n.nodeType == 1) {  // element node
+               X.removeWhite(n);
+               n = n.nextSibling;
+            }
+            else                      // any other node
+               n = n.nextSibling;
+         }
+         return e;
+      }
+   };
+   if (xml.nodeType == 9) // document node
+      xml = xml.documentElement;
+   var json = X.toJson(X.toObj(X.removeWhite(xml)), xml.nodeName, "\t");
+   return "{\n" + tab + (tab ? json.replace(/\t/g, tab) : json.replace(/\t|\n/g, "")) + "\n}";
+}

README.rst

+===========
+converse.js
+===========
+
+Converse.js_ implements an XMPP_ based instant messaging client in the browser.
+
+It is used by collective.xmpp.chat_, which is a Plone_ instant messaging add-on.
+
+The ultimate goal is to enable anyone to add chat functionality to their websites, regardless of the backend.
+This is currently possible, except for adding new contacts, which still makes an XHR call to the (Plone) backend to fetch user info.
+
+--------
+Features
+--------
+
+It has the following features:
+
+* Manually or automically subscribe to other users.
+* Accept or decline contact requests
+* Chat status (online, busy, away, offline)
+* Custom status messages
+* Typing notifications
+* Third person messages (/me )
+* Multi-user chat in chatrooms
+* Chatroom Topics
+* vCard support
+
+-----------
+Screencasts
+-----------
+
+* `In a static HTML page`_. Here we chat to external XMPP accounts on Jabber.org and Gmail.
+* `Integrated into a Plone site`_ via collective.xmpp.chat.
+
+------------
+Dependencies
+------------
+
+It depends on quite a few third party libraries, including:
+
+* strophe.js_
+* backbone.js_ 
+* require.js_
+
+-------
+Licence
+-------
+
+``Converse.js`` is released under both the MIT_ and GPL_ licenses.
+
+.. _Converse.js: http://conversejs.org
+.. _strophe.js: http://strophe.im/strophejs
+.. _backbone.js: http:/backbonejs.org
+.. _require.js: http:/requirejs.org
+.. _collective.xmpp.chat: http://github.com/collective/collective.xmpp.chat
+.. _Plone: http://plone.org
+.. _XMPP: http://xmpp.org
+.. _MIT: http://opensource.org/licenses/mit-license.php
+.. _GPL: http://opensource.org/licenses/gpl-license.php
+.. _here: http://opkode.com/media/blog/instant-messaging-for-plone-with-javascript-and-xmpp
+.. _Screencast2: http://opkode.com/media/blog/2013/04/02/converse.js-xmpp-instant-messaging-with-javascript
+.. _`Integrated into a Plone site`: http://opkode.com/media/blog/instant-messaging-for-plone-with-javascript-and-xmpp
+.. _`In a static HTML page`: http://opkode.com/media/blog/2013/04/02/converse.js-xmpp-instant-messaging-with-javascript

TODO

+TODO:
+=====
+
+* Refresh Rooms panel every time the user goes to it
+* Add /leave command
+* Inform users of /help via placeholder in textarea
+* Create a single sprite image from the current images
+* Add "keep me logged in" feature when logging in manually
+* Add support for XMPP server feature detection
+* Implement "Fetch user vCard" feature.

converse.css

+.hidden {
+    display: none
+}
+
+#chatpanel {
+    z-index: 99; /*--Keeps the panel on top of all other elements--*/
+    position: fixed;
+    bottom: 0; right: 0;
+    height: 332px;
+    width: auto;
+}
+
+#toggle-controlbox {
+    position: fixed;
+    font-size: 80%;
+    bottom: 0;
+    right: 0;
+    border-top-right-radius: 4px;
+    border-top-left-radius: 4px;
+    background: #e3e2e2;
+    border: 1px solid #c3c3c3;
+    border-bottom: none;
+    padding: 0.25em 0.5em;
+    margin-right: 1em;
+    height: 1.1em;
+}
+
+#connecting-to-chat {
+    background: url(images/spinner.gif) no-repeat left;
+    padding-left: 1.4em;
+}
+
+.chat-head {
+    color: #ffffff;
+    margin: 0;
+    font-size: 100%;
+    border-top-right-radius: 4px;
+    border-top-left-radius: 4px;
+    padding: 3px 0 3px 7px;
+}
+
+.chat-head-chatbox {
+    background-color: rgb(89, 106, 114);
+    background-color: rgba(89, 106, 114, 1);
+}
+
+.chat-head-chatroom {
+    background-color: #2D617A;
+}
+
+.chatroom .chat-area {
+    float: left;
+    width: 200px;
+}
+
+.chatroom .chat {
+    overflow: auto;
+    height: 400px;
+    border: solid 1px #ccc;
+}
+
+.chatroom .participants {
+    float: left;
+    width: 99px;
+    height: 272px;
+    background-color: white;
+    overflow: auto;
+    border-right: 1px solid #999;
+    border-bottom: 1px solid #999;
+    border-bottom-right-radius: 4px;
+}
+
+.participants ul.participant-list li {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    display: block;
+    font-size: 12px;
+    padding: 0.5em 0 0 0.5em;
+
+}
+
+.chatroom form.sendXMPPMessage {
+    -webkit-border-bottom-right-radius: 0;
+    border-bottom-right-radius: 0;
+}
+
+.chatroom .participant-list {
+    list-style: none;
+}
+
+input.new-chatroom-name {
+    width: 10em;
+}
+
+.chat-blink {
+    background-color: #176689;
+    border-right:1px solid #176689;
+    border-left:1px solid #176689;
+}
+
+.chat-content {
+    padding: 0.3em;
+    font-size: 13px;
+    color: #333333;
+    height:193px;
+    overflow-y:auto;
+    border:1px solid #999;
+    border-bottom: 0;
+    border-top: 0;
+    background-color: #ffffff;
+    line-height: 1.3em;
+}
+
+.chat-textarea {
+    border: 0;
+    height: 50px;
+}
+
+.chat-textarea-chatbox-selected {
+    border: 1px solid #578308;
+    margin:0;
+}
+
+.chat-textarea-chatroom-selected {
+    border: 2px solid #2D617A;
+    margin:0;
+}
+
+.chat-info {
+    color:#666666;
+
+}
+
+.chat-message-me {
+    font-weight: bold;
+    color: #436976;
+}
+
+.chat-message-room {
+    font-weight: bold;
+    color: #4B7003;
+    white-space: nowrap;
+}
+
+.chat-message-them {
+    font-weight: bold;
+    color: #F62817;
+    white-space: nowrap;
+    max-width: 100px;
+    text-overflow: ellipsis;
+    overflow: hidden;
+    display: inline-block;
+}
+
+.chat-event, .chat-date, .chat-help {
+    color: #808080;
+}
+
+.chat-date {
+    display: inline-block;
+    padding-top: 10px;
+}
+
+div#settings,
+div#chatrooms,
+div#login-dialog {
+    height: 272px;
+}
+
+p.not-implemented {
+    margin-top: 3em;
+    margin-left: 0.3em;
+    color: #808080;
+}
+
+div.delayed .chat-message-them {
+    color: #FB5D50;
+}
+
+div.delayed .chat-message-me {
+    color: #7EABBB;
+}
+
+.chat-message-error {
+    color:#76797C;
+    font-size:90%;
+    font-weight:normal;
+}
+
+.chat-head .avatar {
+    float: left;
+    margin-right: 6px;
+}
+
+div.chat-title {
+    height: 1.1em;
+    color: white;
+    font-weight: bold;
+    line-height: 15px;
+    display: block;
+    margin-top: 2px;
+    margin-right: 20px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    text-shadow: rgba(0,0,0,0.51) 0 -1px 0;
+}
+
+.chat-head-chatbox,
+.chat-head-chatroom {
+    background: linear-gradient(top, rgba(206,220,231,1) 0%,rgba(89,106,114,1) 100%);
+    height: 33px;
+    position: relative;
+}
+
+p.user-custom-message,
+p.chatroom-topic {
+    font-size: 80%;
+    font-style: italic;
+    height: 1.3em;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    margin: 0;
+}
+
+.activated{
+    display: block !important;
+}
+
+a.subscribe-to-user {
+    padding-left: 2em;
+    font-weight: bold;
+}
+
+dl.add-xmpp-contact {
+    margin: 0 0 0 0.5em;
+    padding-top: 3px;
+    z-index: 21;
+    background: url('images/add_icon.png') no-repeat 3px;
+}
+
+dt#xmpp-contact-search {
+    padding-top: 3px;
+}
+
+.fancy-dropdown a.choose-xmpp-status,
+.fancy-dropdown a.add-xmpp-contact {
+    text-shadow: 0 1px 0 rgba(250, 250, 250, 1);
+    padding-left: 1.5em;
+    width: 140px;
+    display: block;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    float: left;
+}
+
+#fancy-xmpp-status-select {
+    padding-bottom: 3px;
+}
+
+#fancy-xmpp-status-select a.change-xmpp-status-message {
+    text-shadow: 0 1px 0 rgba(250, 250, 250, 1);
+    background: url('images/pencil_icon.png') no-repeat right top;
+    float: right;
+    clear: right;
+    width: 1em;
+    height: 1em;
+}
+
+ul#found-users {
+    padding: 10px 0 5px 5px;
+    border: 0; 
+}
+
+form.search-xmpp-contact {
+    margin: 0;
+    padding-left: 5px;
+    padding: 1em 0 0 5px;
+    background: white;
+}
+
+form.search-xmpp-contact input {
+    width: 9em;
+}
+
+.oc-chat-head {
+    margin: 0;
+    color: #FFF;
+    border-top-right-radius: 4px;
+    border-top-left-radius: 4px;
+    height: 35px;
+    clear: right;
+    background-color: #5390C8;
+    padding: 3px 0 0 0;
+}
+
+.close-chatbox-button {
+    cursor: pointer;
+    float: right;
+    margin-top: 0.2em;
+    margin-right: 0.5em;
+    -moz-box-shadow:inset 0 1px 0 0 #ffffff;
+    -webkit-box-shadow:inset 0 1px 0 0 #ffffff;
+    box-shadow:inset 0 1px 0 0 #ffffff;
+    background:-webkit-gradient( linear, left top, left bottom, color-stop(0.05, #ffffff), color-stop(1, #f6f6f6) );
+    background:-moz-linear-gradient( center top, #ffffff 5%, #f6f6f6 100% );
+    filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffff', endColorstr='#f6f6f6');
+    background-color:#ffffff;
+    -moz-border-radius:6px;
+    -webkit-border-radius:6px;
+    border-radius:6px;
+    border:1px solid #888;
+    display:inline-block;
+    color: #666 !important;
+    font-family:arial;
+    font-size:12px;
+    font-weight:bold;
+    padding:0 4px;
+    text-decoration:none;
+    text-shadow:1px 1px 0 #ffffff;
+}
+
+.close-chatbox-button:hover {
+    background:-webkit-gradient( linear, left top, left bottom, color-stop(0.05, #f6f6f6), color-stop(1, #ffffff) );
+    background:-moz-linear-gradient( center top, #f6f6f6 5%, #ffffff 100% );
+    filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#f6f6f6', endColorstr='#ffffff');
+    background-color:#f6f6f6;
+}
+
+.close-chatbox-button:active {
+    position:relative;
+    top:1px;
+}
+
+.oc-chat-content dt {
+    margin: 0;
+    padding-top: 0.5em;
+}
+
+#xmppchat-roster dd.odd {
+    background-color: #DCEAC5; /* Make this difference */
+}
+
+#xmppchat-roster dd.current-xmpp-contact {
+    clear: both;
+}
+
+#xmppchat-roster dd.current-xmpp-contact,
+#xmppchat-roster dd.current-xmpp-contact:hover {
+    background: url(images/user_online_panel.png) no-repeat 5px 2px;
+}
+
+#xmppchat-roster dd.current-xmpp-contact.offline:hover,
+#xmppchat-roster dd.current-xmpp-contact.unavailable:hover,
+#xmppchat-roster dd.current-xmpp-contact.offline,
+#xmppchat-roster dd.current-xmpp-contact.unavailable {
+    background: url(images/user_offline_panel.png) no-repeat 5px 2px;
+}
+
+#xmppchat-roster dd.current-xmpp-contact.dnd,
+#xmppchat-roster dd.current-xmpp-contact.dnd:hover {
+    background: url(images/user_busy_panel.png) no-repeat 5px 2px;
+}
+
+#xmppchat-roster dd.current-xmpp-contact.away,
+#xmppchat-roster dd.current-xmpp-contact.away:hover {
+    background: url(images/user_away_panel.png) no-repeat 5px 2px;
+}
+
+#xmppchat-roster dd.requesting-xmpp-contact button{
+    margin-left: 0.5em;
+}
+
+#xmppchat-roster dd a {
+    margin-left: 1.5em;
+    text-shadow: 0 1px 0 rgba(250, 250, 250, 1);
+    display: inline-block;
+    width: 113px;
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+}
+
+.remove-xmpp-contact-dialog .ui-dialog-buttonpane {
+    border: none;
+}
+
+#xmppchat-roster {
+    height: 200px;
+    overflow-y: scroll;
+    width: 100%;
+    margin: 0;
+    position: relative;
+    top: 0;
+    border: none;
+    margin-top: 0.5em;
+}
+
+#available-chatrooms dt,
+#xmppchat-roster dt {
+    font-weight: normal;
+    display: none;
+    font-size: 13px;
+    color: #666;
+    border: none;
+    padding: 0.3em 0.5em 0.3em 0.5em;
+    text-shadow: 0 1px 0 rgba(250, 250, 250, 1);
+}
+
+#available-chatrooms dt {
+    padding-top: 1em;
+}
+
+#available-chatrooms li {
+    display: block;
+}
+
+
+dd.available-chatroom,
+#xmppchat-roster dd {
+    font-weight: bold;
+    border: none;
+    display: block;
+    padding: 0 0.5em 0 0.5em;
+    color: #3f3f3f;
+    text-shadow: 0 1px 0 rgba(250, 250, 250, 1);
+}
+
+#xmppchat-roster dd a.remove-xmpp-contact {
+    background: url('images/delete_icon.png') no-repeat right top;
+    padding: 0 1em 1em 0;
+    float: right;
+    width: 22px;
+    margin: 0;
+}
+
+.chatbox,
+.chatroom {
+    box-shadow: 1px 1px 5px 1px rgba(0,0,0,0.4);
+    display:none;
+    float: right;
+    margin-right: 15px;
+    z-index: 20; /* So that it's higher than the content actions */
+    border-radius: 4px;
+}
+
+.chatbox {
+    width: 201px;
+}
+
+.chatroom {
+    width: 300px;
+    height: 311px;
+}
+
+.oc-chat-content {
+    height:272px;
+    width: 199px;
+    padding: 0;
+}
+
+.oc-chat-content dd {
+    margin-left: 0;
+    margin-bottom: 0;
+    padding: 1em;
+}
+
+.oc-chat-content dd.odd {
+    background-color: #DCEAC5;
+}
+
+div#controlbox-panes {
+    background: -moz-linear-gradient(top, rgba(255,255,255,1) 0%, rgba(240,240,240,1) 100%); /* FF3.6+ */
+    background: -ms-linear-gradient(top, rgba(255,255,255,1) 0%,rgba(240,240,240,1) 100%); /* IE10+ */
+    background: -o-linear-gradient(top, rgba(255,255,255,1) 0%,rgba(240,240,240,1) 100%); /* Opera 11.10+ */
+    background: -webkit-gradient(linear, left top, left bottom, color-stop(0%,rgba(255,255,255,1)), color-stop(100%,rgba(240,240,240,1))); /* Chrome,Safari4+ */
+    background: -webkit-linear-gradient(top, rgba(255,255,255,1) 0%,rgba(240,240,240,1) 100%); /* Chrome10+,Safari5.1+ */
+    background: linear-gradient(top, rgba(255,255,255,1) 0%,rgba(240,240,240,1) 100%); /* W3C */
+    background-color: white;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border: 1px solid #999;
+    width: 199px;
+}
+
+form#xmppchat-login {
+    background: white;
+    padding: 2em 0 0.3em 0.5em;
+}
+
+form#xmppchat-login input {
+    display: block;
+}
+
+form.set-xmpp-status,
+form.add-chatroom {
+    padding: 0.5em 0 0.3em 0.5em;
+    background: white;
+}
+
+.set-xmpp-status li {
+    list-style: none;
+    padding-left: 5px;
+}
+
+select#select-xmpp-status {
+    float: right;
+    margin-right: 0.5em;
+}
+
+/* @group Tabs */
+
+.chat-head #controlbox-tabs {
+    text-align: center;
+    display: inline;
+    overflow: hidden;
+    font-size: 12px;
+    list-style-type: none;
+}
+
+/* single tab */
+.chat-head #controlbox-tabs li {
+    float:left;
+    list-style: none;
+    padding-left: 0;
+    text-shadow: white 0 1px 0;
+    width: 40%;
+}
+
+ul#controlbox-tabs li a {
+    display:block;
+    font-size:12px;
+    height: 34px;
+    line-height:34px;
+    margin: 0;
+    text-align:center;
+    text-decoration:none;
+    border: 1px solid #999;
+    border-top-right-radius: 4px;
+    border-top-left-radius: 4px;
+    color:#666;
+    text-shadow: 0 1px 0 rgba(250, 250, 250, 1);
+}
+
+.chat-head #controlbox-tabs li a:hover {
+    color: black;
+}
+
+.chat-head #controlbox-tabs li a {
+    background-color: white;
+    box-shadow: inset 0 0 8px rgba(0,0,0,0.2);
+}
+
+ul#controlbox-tabs a.current, ul#controlbox-tabs a.current:hover {
+    box-shadow: none;
+    color: #000;
+    border-bottom: 0;
+    height: 35px;
+}
+
+div#users,
+div#chatrooms,
+div#login-dialog,
+div#settings {
+    border: 0;
+    font-size: 14px;
+    width: 199px;
+    background-color: white;
+}
+
+form.sendXMPPMessage {
+    background: white;
+    border: 1px solid #999;
+    padding:0.5em;
+    margin: 0;
+    position: relative;
+    -webkit-border-radius: 4px;
+    -moz-border-radius: 4px;
+    border-radius: 4px;
+    -moz-background-clip: padding;
+    -webkit-background-clip: padding-box;
+    background-clip: padding-box;
+    border-top-left-radius: 0;
+    border-top-right-radius: 0;
+    height: 54px;
+}
+
+#set-custom-xmpp-status {
+    float: left;
+}
+
+#set-custom-xmpp-status button {
+    padding: 1px 2px 1px 1px;
+}
+
+/* status dropdown styles */
+dl.dropdown {
+    margin-right: 0.5em;
+    margin-bottom: 0;
+}
+.dropdown dd, .dropdown dt, .dropdown ul { margin:0px; padding:0px; }
+.dropdown dd { position:relative; }
+
+div.xmpp-status {
+    padding: 3px;
+}
+
+input.custom-xmpp-status {
+    height: 18px;
+}
+
+.fancy-dropdown {
+    border:1px solid #ddd;
+    height: 22px;
+}
+
+.dropdown dt a span {
+    cursor:pointer; display:block; padding:5px;
+}
+
+.dropdown dd ul {
+    list-style:none;
+    position:absolute; left:0; top:0;
+    border:1px solid #ddd;
+    border-top: 0;
+    width: 99%;
+    background-color: #FFF;
+    z-index: 21;
+}
+
+.dropdown dd ul li a:hover {
+    background-color: #bed6e5;
+}
+
+.dropdown span.value {
+    display:none;
+}
+
+.dropdown dd ul li a {
+    padding:5px 5px 5px 30px;
+    display:block;
+}
+
+.dropdown a.online {
+    background: url(images/user_online_panel.png) no-repeat left 3px;
+}
+
+.dropdown a.offline {
+    background: url(images/user_offline_panel.png) no-repeat left 3px;
+}
+
+.dropdown a.dnd {
+    background: url(images/user_busy_panel.png) no-repeat left 3px;
+}
+
+.dropdown a.away {
+    background: url(images/user_away_panel.png) no-repeat left 3px;
+}
+

converse.js

+/*!
+ * Converse.js (XMPP-based instant messaging with Strophe.js and backbone.js)
+ * http://opkode.com
+ *
+ * Copyright (c) 2012 Jan-Carel Brand (jc@opkode.com)
+ * Dual licensed under the MIT and GPL Licenses
+ */
+
+/* The following line defines global variables defined elsewhere. */
+/*globals jQuery, portal_url*/
+
+// AMD/global registrations
+(function (root, factory) {
+    if (console===undefined || console.log===undefined) {
+        console = { log: function () {}, error: function () {} };
+    }
+    if (typeof define === 'function' && define.amd) {
+        require.config({
+            paths: {
+                "sjcl": "Libraries/sjcl",
+                "tinysort": "Libraries/jquery.tinysort",
+                "underscore": "Libraries/underscore",
+                "backbone": "Libraries/backbone",
+                "localstorage": "Libraries/backbone.localStorage",
+                "strophe": "Libraries/strophe",
+                "strophe.muc": "Libraries/strophe.muc",
+                "strophe.roster": "Libraries/strophe.roster",
+                "strophe.vcard": "Libraries/strophe.vcard"
+            },
+
+            // define module dependencies for modules not using define
+            shim: {
+                'backbone': {
+                    //These script dependencies should be loaded before loading
+                    //backbone.js
+                    deps: [
+                        'underscore',
+                        'jquery'
+                        ],
+                    //Once loaded, use the global 'Backbone' as the
+                    //module value.
+                    exports: 'Backbone'
+                },
+
+                'underscore': {
+                    exports: '_'
+                },
+
+                'strophe.muc': {
+                    deps: ['strophe', 'jquery']
+                },
+
+                'strophe.roster': {
+                    deps: ['strophe', 'jquery']
+                },
+
+                'strophe.vcard': {
+                    deps: ['strophe', 'jquery']
+                }
+            }
+        });
+
+        define("converse", [
+            "localstorage",
+            "tinysort",
+            "sjcl",
+            "strophe.muc",
+            "strophe.roster",
+            "strophe.vcard"
+            ], function() {
+                // Use Mustache style syntax for variable interpolation
+                _.templateSettings = {
+                    evaluate : /\{\[([\s\S]+?)\]\}/g,
+                    interpolate : /\{\{([\s\S]+?)\}\}/g
+                };
+                return factory(jQuery, _, console);
+            }
+        );
+    } else {
+        // Browser globals
+        _.templateSettings = {
+            evaluate : /\{\[([\s\S]+?)\]\}/g,
+            interpolate : /\{\{([\s\S]+?)\}\}/g
+        };
+        root.xmppchat = factory(jQuery, _, console || {log: function(){}});
+    }
+}(this, function ($, _, console) {
+
+    var xmppchat = {};
+    xmppchat.msg_counter = 0;
+
+    var strinclude = function(str, needle){
+      if (needle === '') { return true; }
+      if (str === null) { return false; }
+      return String(str).indexOf(needle) !== -1;
+    };
+
+    xmppchat.autoLink = function (text) {
+        // Convert URLs into hyperlinks
+        var re = /((http|https|ftp):\/\/[\w?=&.\/\-;#~%\-]+(?![\w\s?&.\/;#~%"=\-]*>))/g;
+        return text.replace(re, '<a target="_blank" href="$1">$1</a>');
+    };
+
+    xmppchat.toISOString = function (date) {
+        var pad;
+        if (typeof date.toISOString !== 'undefined') {
+            return date.toISOString();
+        } else {
+            // IE <= 8 Doesn't have toISOStringMethod
+            pad = function (num) {
+                return (num < 10) ? '0' + num : '' + num;
+            };
+            return date.getUTCFullYear() + '-' +
+                pad(date.getUTCMonth() + 1) + '-' +
+                pad(date.getUTCDate()) + 'T' +
+                pad(date.getUTCHours()) + ':' +
+                pad(date.getUTCMinutes()) + ':' +
+                pad(date.getUTCSeconds()) + '.000Z';
+        }
+    };
+
+    xmppchat.parseISO8601 = function (datestr) {
+        /* Parses string formatted as 2013-02-14T11:27:08.268Z to a Date obj.
+        */
+        var numericKeys = [1, 4, 5, 6, 7, 10, 11],
+            struct = /^\s*(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}\.?\d*)Z\s*$/.exec(datestr),
+            minutesOffset = 0,
+            i, k;
+
+        for (i = 0; (k = numericKeys[i]); ++i) {
+            struct[k] = +struct[k] || 0;
+        }
+        // allow undefined days and months
+        struct[2] = (+struct[2] || 1) - 1;
+        struct[3] = +struct[3] || 1;
+        if (struct[8] !== 'Z' && struct[9] !== undefined) {
+            minutesOffset = struct[10] * 60 + struct[11];
+
+            if (struct[9] === '+') {
+                minutesOffset = 0 - minutesOffset;
+            }
+        }
+        return new Date(Date.UTC(struct[1], struct[2], struct[3], struct[4], struct[5] + minutesOffset, struct[6], struct[7]));
+    };
+
+    xmppchat.updateMsgCounter = function () {
+        if (this.msg_counter > 0) {
+            if (document.title.search(/^Messages \(\d+\) /) == -1) {
+                document.title = "Messages (" + this.msg_counter + ") " + document.title;
+            } else {
+                document.title = document.title.replace(/^Messages \(\d+\) /, "Messages (" + this.msg_counter + ") ");
+            }
+            window.blur();
+            window.focus();
+        } else if (document.title.search(/^Messages \(\d+\) /) != -1) {
+            document.title = document.title.replace(/^Messages \(\d+\) /, "");
+        }
+    };
+
+    xmppchat.incrementMsgCounter = function () {
+        this.msg_counter += 1;
+        this.updateMsgCounter();
+    };
+
+    xmppchat.clearMsgCounter = function () {
+        this.msg_counter = 0;
+        this.updateMsgCounter();
+    };
+
+    xmppchat.collections = {
+        /* FIXME: XEP-0136 specifies 'urn:xmpp:archive' but the mod_archive_odbc
+        *  add-on for ejabberd wants the URL below. This might break for other
+        *  Jabber servers.
+        */
+        'URI': 'http://www.xmpp.org/extensions/xep-0136.html#ns'
+    };
+
+    xmppchat.collections.getLastCollection = function (jid, callback) {
+        var bare_jid = Strophe.getBareJidFromJid(jid),
+            iq = $iq({'type':'get'})
+                    .c('list', {'xmlns': this.URI,
+                                'with': bare_jid
+                                })
+                    .c('set', {'xmlns': 'http://jabber.org/protocol/rsm'})
+                    .c('before').up()
+                    .c('max')
+                    .t('1');
+
+        xmppchat.connection.sendIQ(iq,
+                    callback,
+                    function () {
+                        console.log('Error while retrieving collections');
+                    });
+    };
+
+    xmppchat.collections.getLastMessages = function (jid, callback) {
+        var that = this;
+        this.getLastCollection(jid, function (result) {
+            // Retrieve the last page of a collection (max 30 elements).
+            var $collection = $(result).find('chat'),
+                jid = $collection.attr('with'),
+                start = $collection.attr('start'),
+                iq = $iq({'type':'get'})
+                        .c('retrieve', {'start': start,
+                                    'xmlns': that.URI,
+                                    'with': jid
+                                    })
+                        .c('set', {'xmlns': 'http://jabber.org/protocol/rsm'})
+                        .c('max')
+                        .t('30');
+            xmppchat.connection.sendIQ(iq, callback);
+        });
+    };
+
+    xmppchat.Message = Backbone.Model.extend();
+
+    xmppchat.Messages = Backbone.Collection.extend({
+        model: xmppchat.Message
+    });
+
+    xmppchat.ChatBox = Backbone.Model.extend({
+        initialize: function () {
+            if (this.get('box_id') !== 'controlbox') {
+                this.messages = new xmppchat.Messages();
+                this.messages.localStorage = new Backbone.LocalStorage(
+                    hex_sha1('converse.messages'+this.get('jid')));
+                this.set({
+                    'user_id' : Strophe.getNodeFromJid(this.get('jid')),
+                    'box_id' : hex_sha1(this.get('jid')),
+                    'fullname' : this.get('fullname'),
+                    'url': this.get('url'),
+                    'image_type': this.get('image_type'),
+                    'image_src': this.get('image_src')
+                });
+            }
+        },
+
+        messageReceived: function (message) {
+            var $message = $(message),
+                body = xmppchat.autoLink($message.children('body').text()),
+                from = Strophe.getBareJidFromJid($message.attr('from')),
+                composing = $message.find('composing'),
+                delayed = $message.find('delay').length > 0,
+                fullname = this.get('fullname').split(' ')[0],
+                stamp, time, sender;
+
+            if (!body) {
+                if (composing.length) {
+                    this.messages.add({
+                        fullname: fullname,
+                        sender: 'them',
+                        delayed: delayed,
+                        time: xmppchat.toISOString(new Date()),
+                        composing: composing.length
+                    });
+                }
+            } else {
+                if (delayed) {
+                    stamp = $message.find('delay').attr('stamp');
+                    time = stamp;
+                } else {
+                    time = xmppchat.toISOString(new Date());
+                }
+                if (from == xmppchat.bare_jid) {
+                    fullname = 'me';
+                    sender = 'me';
+                } else {
+                    sender = 'them';
+                }
+                this.messages.create({
+                    fullname: fullname,
+                    sender: sender,
+                    delayed: delayed,
+                    time: time,
+                    message: body
+                });
+            }
+        }
+    });
+
+    xmppchat.ChatBoxView = Backbone.View.extend({
+        length: 200,
+        tagName: 'div',
+        className: 'chatbox',
+
+        events: {
+            'click .close-chatbox-button': 'closeChat',
+            'keypress textarea.chat-textarea': 'keyPressed'
+        },
+
+        message_template: _.template(
+                            '<div class="chat-message {{extra_classes}}">' +
+                                '<span class="chat-message-{{sender}}">{{time}} {{username}}:&nbsp;</span>' +
+                                '<span class="chat-message-content">{{message}}</span>' +
+                            '</div>'),
+
+        action_template: _.template(
+                            '<div class="chat-message {{extra_classes}}">' +
+                                '<span class="chat-message-{{sender}}">{{time}}:&nbsp;</span>' +
+                                '<span class="chat-message-content">{{message}}</span>' +
+                            '</div>'),
+
+        new_day_template: _.template(
+                            '<time class="chat-date" datetime="{{isodate}}">{{datestring}}</time>'
+                            ),
+
+        insertStatusNotification: function (message, replace) {
+            var $chat_content = this.$el.find('.chat-content');
+            $chat_content.find('div.chat-event').remove().end()
+                .append($('<div class="chat-event"></div>').text(message));
+            this.scrollDown();
+        },
+
+        showMessage: function (message) {
+            var time = message.get('time'),
+                times = this.model.messages.pluck('time'),
+                this_date = xmppchat.parseISO8601(time),
+                $chat_content = this.$el.find('.chat-content'),
+                previous_message, idx, prev_date, isodate;
+
+            // If this message is on a different day than the one received
+            // prior, then indicate it on the chatbox.
+            idx = _.indexOf(times, time)-1;
+            if (idx >= 0) {
+                previous_message = this.model.messages.at(idx);
+                prev_date = xmppchat.parseISO8601(previous_message.get('time'));
+                isodate = new Date(this_date.getTime());
+                isodate.setUTCHours(0,0,0,0);
+                isodate = xmppchat.toISOString(isodate);
+                if (this.isDifferentDay(prev_date, this_date)) {
+                    $chat_content.append(this.new_day_template({
+                        isodate: isodate,
+                        datestring: this_date.toString().substring(0,15)
+                    }));
+                }
+            }
+            if (xmppchat.xmppstatus.get('status') === 'offline') {
+                // only update the UI if the user is not offline
+                return;
+            }
+            if (message.get('composing')) {
+                this.insertStatusNotification(message.get('fullname')+' '+'is typing');
+                return;
+            } else {
+                $chat_content.find('div.chat-event').remove();
+                $chat_content.append(
+                        this.message_template({
+                            'sender': message.get('sender'),
+                            'time': this_date.toLocaleTimeString().substring(0,5),
+                            'message': message.get('message'),
+                            'username': message.get('fullname'),
+                            'extra_classes': message.get('delayed') && 'delayed' || ''
+                        }));
+            }
+            if (message.get('sender') != 'me') {
+                xmppchat.incrementMsgCounter();
+            }
+            this.scrollDown();
+        },
+
+        isDifferentDay: function (prev_date, next_date) {
+            return (
+                (next_date.getDate() != prev_date.getDate()) || 
+                (next_date.getFullYear() != prev_date.getFullYear()) || 
+                (next_date.getMonth() != prev_date.getMonth()));
+        },
+
+        addHelpMessages: function (msgs) {
+            var $chat_content = this.$el.find('.chat-content'), i,
+                msgs_length = msgs.length;
+            for (i=0; i<msgs_length; i++) {
+                $chat_content.append($('<div class="chat-help">'+msgs[i]+'</div>'));
+            }
+            this.scrollDown();
+        },
+
+        sendMessage: function (text) {
+            // TODO: Look in ChatPartners to see what resources we have for the recipient.
+            // if we have one resource, we sent to only that resources, if we have multiple
+            // we send to the bare jid.
+            var timestamp = (new Date()).getTime(),
+                bare_jid = this.model.get('jid'),
+                match = text.replace(/^\s*/, "").match(/^\/(.*)\s*$/),
+                msgs;
+
+            if (match) {
+                if (match[1] === "clear") {
+                    this.$el.find('.chat-content').empty();
+                    this.model.messages.reset();
+                    return;
+                }
+                else if (match[1] === "help") {
+                    msgs =  [
+                        '<strong>/help</strong>: Show this menu',
+                        '<strong>/clear</strong>: Remove messages'
+                        ];
+                    this.addHelpMessages(msgs);
+                    return;
+                }
+            }
+
+            var message = $msg({from: xmppchat.bare_jid, to: bare_jid, type: 'chat', id: timestamp})
+                .c('body').t(text).up()
+                .c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'});
+            // Forward the message, so that other connected resources are also aware of it.
+            // TODO: Forward the message only to other connected resources (inside the browser)
+            var forwarded = $msg({to:xmppchat.bare_jid, type:'chat', id:timestamp})
+                            .c('forwarded', {xmlns:'urn:xmpp:forward:0'})
+                            .c('delay', {xmns:'urn:xmpp:delay',stamp:timestamp}).up()
+                            .cnode(message.tree());
+            xmppchat.connection.send(message);
+            xmppchat.connection.send(forwarded);
+            // Add the new message
+            this.model.messages.create({
+                fullname: 'me',
+                sender: 'me',
+                time: xmppchat.toISOString(new Date()),
+                message: text 
+            });
+        },
+
+        keyPressed: function (ev) {
+            var $textarea = $(ev.target),
+                message,
+                notify,
+                composing;
+
+            if(ev.keyCode == 13) {
+                ev.preventDefault();
+                message = $textarea.val();
+                $textarea.val('').focus();
+                if (message !== '') {
+                    if (this.model.get('chatroom')) {
+                        this.sendChatRoomMessage(message);
+                    } else {
+                        this.sendMessage(message);
+                    }
+                }
+                this.$el.data('composing', false);
+
+            } else if (!this.model.get('chatroom')) {
+                // composing data is only for single user chat
+                composing = this.$el.data('composing');
+                if (!composing) {
+                    if (ev.keyCode != 47) {
+                        // We don't send composing messages if the message
+                        // starts with forward-slash.
+                        notify = $msg({'to':this.model.get('jid'), 'type': 'chat'})
+                                        .c('composing', {'xmlns':'http://jabber.org/protocol/chatstates'});
+                        xmppchat.connection.send(notify);
+                    }
+                    this.$el.data('composing', true);
+                }
+            }
+        },
+
+        onChange: function (item, changed) {
+            if (_.has(item.changed, 'chat_status')) {
+                var chat_status = item.get('chat_status'),
+                    fullname = item.get('fullname');
+                if (this.$el.is(':visible')) {
+                    if (chat_status === 'offline') {
+                        this.insertStatusNotification(fullname+' '+'has gone offline');
+                    } else if (chat_status === 'away') {
+                        this.insertStatusNotification(fullname+' '+'has gone away');
+                    } else if ((chat_status === 'dnd')) {
+                        this.insertStatusNotification(fullname+' '+'is busy');
+                    } else if (chat_status === 'online') {
+                        this.$el.find('div.chat-event').remove();
+                    }
+                }
+            } if (_.has(item.changed, 'status')) {
+                this.showStatusMessage(item.get('status'));
+            }
+        },
+
+        showStatusMessage: function (msg) {
+            this.$el.find('p.user-custom-message').text(msg).attr('title', msg);
+        },
+
+        closeChat: function () {
+            if (xmppchat.connection) {
+                this.model.destroy();
+            } else {
+                this.model.trigger('hide');
+            }
+        },
+
+        initialize: function (){
+            this.model.messages.on('add', this.showMessage, this);
+            this.model.on('show', this.show, this);
+            this.model.on('destroy', function (model, response, options) { this.$el.hide('fast'); }, this);
+            this.model.on('change', this.onChange, this);
+
+            this.$el.appendTo(xmppchat.chatboxesview.$el);
+            this.render().show().model.messages.fetch({add: true});
+            if (this.model.get('status')) {
+                this.showStatusMessage(this.model.get('status'));
+            }
+            xmppchat.clearMsgCounter();
+        },
+
+        template: _.template(
+                    '<div class="chat-head chat-head-chatbox">' +
+                        '<a class="close-chatbox-button">X</a>' +
+                        '<a href="{{url}}" target="_blank" class="user">' +
+                            '<div class="chat-title"> {{ fullname }} </div>' +
+                        '</a>' +
+                        '<p class="user-custom-message"><p/>' +
+                    '</div>' +
+                    '<div class="chat-content"></div>' +
+                    '<form class="sendXMPPMessage" action="" method="post">' +
+                    '<textarea ' +
+                        'type="text" ' +
+                        'class="chat-textarea" ' +
+                        'placeholder="Personal message"/>'+
+                    '</form>'),
+
+        render: function () {
+            this.$el.attr('id', this.model.get('box_id'))
+                    .html(this.template(this.model.toJSON()));
+            if (this.model.get('image')) {
+                var img_src = 'data:'+this.model.get('image_type')+';base64,'+this.model.get('image'),
+                    canvas = $('<canvas height="35px" width="35px" class="avatar"></canvas>'),
+                    ctx = canvas.get(0).getContext('2d'),
+                    img = new Image();   // Create new Image object
+                img.onload = function() {
+                    var ratio = img.width/img.height;
+                    ctx.drawImage(img,0,0, 35*ratio, 35);
+                };
+                img.src = img_src;
+                this.$el.find('.chat-title').before(canvas);
+            }
+            return this;
+        },
+
+        focus: function () {
+            this.$el.find('.chat-textarea').focus();
+            return this;
+        },
+
+        show: function () {
+            if (this.$el.is(':visible') && this.$el.css('opacity') == "1") {
+                return this.focus();
+            }
+            if (xmppchat.animate) {
+                this.$el.css({'opacity': 0, 'display': 'inline'}).animate({opacity: '1'}, 200);
+            } else {
+                this.$el.css({'opacity': 1, 'display': 'inline'});
+            }
+            if (xmppchat.connection) {
+                // Without a connection, we haven't yet initialized
+                // localstorage
+                this.model.save();
+            }
+            return this;
+        },
+
+        scrollDown: function () {
+            var $content = this.$el.find('.chat-content');
+            $content.scrollTop($content[0].scrollHeight);
+            return this;
+        }
+    });
+
+    xmppchat.ContactsPanel = Backbone.View.extend({
+        tagName: 'div',
+        className: 'oc-chat-content',
+        id: 'users',
+        events: {
+            'click a.add-xmpp-contact': 'toggleContactForm',
+            'submit form.search-xmpp-contact': 'searchContacts',
+            'click a.subscribe-to-user': 'subscribeToContact'
+        },
+
+        tab_template: _.template('<li><a class="s current" href="#users">Contacts</a></li>'),
+        template: _.template(
+            '<form class="set-xmpp-status" action="" method="post">'+
+                '<span id="xmpp-status-holder">'+
+                    '<select id="select-xmpp-status">'+
+                        '<option value="online">Online</option>'+
+                        '<option value="dnd">Busy</option>'+
+                        '<option value="away">Away</option>'+
+                        '<option value="offline">Offline</option>'+
+                    '</select>'+
+                '</span>'+
+            '</form>'+
+            '<dl class="add-xmpp-contact dropdown">' +
+                '<dt id="xmpp-contact-search" class="fancy-dropdown">' +
+                    '<a class="add-xmpp-contact" href="#" title="Click to search for new users to add as chat contacts">Add a contact</a>' +
+                '</dt>' +
+                '<dd class="search-xmpp" style="display:none"><ul>' +
+                '<form class="search-xmpp-contact">' +
+                    '<input type="text" name="identifier" class="username" placeholder="Contact name"/>' +
+                    '<button type="submit">Search</button>' +
+                    '<ul id="found-users"></ul>' +
+                '</form>' +
+                '</ul></dd>' +
+            '</dl>'
+        ),
+
+        render: function () {
+            this.$parent.find('#controlbox-tabs').append(this.tab_template());
+            this.$parent.find('#controlbox-panes').append(this.$el.html(this.template()));
+            return this;
+        },
+
+        toggleContactForm: function (ev) {
+            ev.preventDefault();
+            this.$el.find('.search-xmpp').toggle().find('input.username').focus();
+        },
+
+        searchContacts: function (ev) {
+            ev.preventDefault();
+            $.getJSON(portal_url + "/search-users?q=" + $(ev.target).find('input.username').val(), function (data) {
+                    var $results_el = $('#found-users');
+                    $(data).each(function (idx, obj) {
+                        if ($results_el.children().length) {
+                        $results_el.empty();
+                        }
+                        $results_el.append(
+                            $('<li></li>')
+                            .attr('id', 'found-users-'+obj.id)
+                            .append(
+                                $('<a class="subscribe-to-user" href="#" title="Click to add as a chat contact"></a>')
+                                .attr('data-recipient', Strophe.escapeNode(obj.id)+'@'+xmppchat.domain)
+                                .text(obj.fullname)
+                                )
+                            );
+                        });
+                    });
+            },
+
+        subscribeToContact: function (ev) {
+            ev.preventDefault();
+            var $target = $(ev.target),
+                jid = $target.attr('data-recipient'),
+                name = $target.text();
+            xmppchat.connection.roster.add(jid, name, [], function (iq) {
+                    xmppchat.connection.roster.subscribe(jid, null, xmppchat.fullname);
+                    });
+            $target.parent().remove();
+            $('.search-xmpp').hide();
+        }
+    });
+
+    xmppchat.RoomsPanel = Backbone.View.extend({
+        tagName: 'div',
+        id: 'chatrooms',
+        events: {
+            'submit form.add-chatroom': 'createChatRoom',
+            'click a.open-room': 'createChatRoom'
+        },
+        room_template: _.template(
+            '<dd class="available-chatroom">' +
+            '<a class="open-room" data-room-jid="{{jid}}"' +
+                ' title="Click to open this chatroom"' +
+                ' href="#">' +
+            '{{name}}</a></dd>'),
+
+        tab_template: _.template('<li><a class="s" href="#chatrooms">Rooms</a></li>'),
+
+        template: _.template(
+            '<form class="add-chatroom" action="" method="post">'+
+                '<input type="text" name="chatroom" class="new-chatroom-name" placeholder="Chat room name"/>'+
+                '<button type="submit">Join</button>'+
+            '</form>'+
+            '<dl id="available-chatrooms">'+
+                '<dt>Available chatrooms</dt>'+
+            '</dl>'),
+
+        render: function () {
+            this.$parent.find('#controlbox-tabs').append(this.tab_template());
+            this.$parent.find('#controlbox-panes').append(this.$el.html(this.template()).hide());
+            return this;
+        },
+
+        initialize: function () {
+            this.on('update-rooms-list', function (ev) {
+                this.updateRoomsList();
+            });
+            this.trigger('update-rooms-list');
+        },
+
+        updateRoomsList: function () {
+            xmppchat.connection.muc.listRooms(xmppchat.muc_domain, $.proxy(function (iq) {
+                var name, jid, i,
+                    rooms = $(iq).find('query').find('item'),
+                    rooms_length = rooms.length,
+                    $available_chatrooms = this.$el.find('#available-chatrooms');
+                $available_chatrooms.find('dd.available-chatroom').remove();
+                if (rooms.length) {
+                    $available_chatrooms.find('dt').show();
+                } else {
+                    $available_chatrooms.find('dt').hide();
+                }
+                for (i=0; i<rooms_length; i++) {
+                    name = Strophe.unescapeNode($(rooms[i]).attr('name'));
+                    jid = $(rooms[i]).attr('jid');
+                    $available_chatrooms.append(this.room_template({'name':name, 'jid':jid}));
+                }
+                return true;
+            }, this));
+        },
+
+        createChatRoom: function (ev) {
+            ev.preventDefault();
+            var name, jid;
+            if (ev.type === 'click') {
+                jid = $(ev.target).attr('data-room-jid');
+            } else {
+                name = $(ev.target).find('input.new-chatroom-name').val().trim().toLowerCase();
+                if (name) {
+                    jid = Strophe.escapeNode(name) + '@' + xmppchat.muc_domain;
+                } else {
+                    return;
+                }
+            }
+            xmppchat.chatboxes.create({
+                'id': jid,
+                'jid': jid,
+                'name': Strophe.unescapeNode(Strophe.getNodeFromJid(jid)),
+                'nick': xmppchat.xmppstatus.get('fullname')||xmppchat.bare_jid,
+                'chatroom': true,
+                'box_id' : hex_sha1(jid)
+            });
+        }
+    });
+
+    xmppchat.ControlBoxView = xmppchat.ChatBoxView.extend({
+        tagName: 'div',
+        className: 'chatbox',
+        id: 'controlbox',
+        events: {
+            'click a.close-chatbox-button': 'closeChat',
+            'click ul#controlbox-tabs li a': 'switchTab'
+        },
+
+        initialize: function () {
+            this.$el.appendTo(xmppchat.chatboxesview.$el);
+            this.model.on('change', $.proxy(function (item, changed) {
+                if (_.has(item.changed, 'connected')) {
+                    this.render();
+                }
+                if (_.has(item.changed, 'visible')) {
+                    if (item.changed.visible === true) {
+                        this.show();
+                    } 
+                }
+            }, this));
+
+            this.model.on('show', this.show, this);
+            this.model.on('destroy', $.proxy(function (model, response, options) {
+                this.$el.hide('fast');
+            }, this));
+            this.model.on('hide', $.proxy(function (model, response, options) {
+                this.$el.hide('fast');
+            }, this));
+
+            if (this.model.get('visible')) {
+                this.show();
+            } 
+        },
+
+        template: _.template(
+            '<div class="chat-head oc-chat-head">'+
+                '<ul id="controlbox-tabs"></ul>'+
+                '<a class="close-chatbox-button">X</a>'+
+            '</div>'+
+            '<div id="controlbox-panes"></div>'
+        ),
+
+        switchTab: function (ev) {
+            ev.preventDefault();
+            var $tab = $(ev.target),
+                $sibling = $tab.parent().siblings('li').children('a'),
+                $tab_panel = $($tab.attr('href')),
+                $sibling_panel = $($sibling.attr('href'));
+
+            $sibling_panel.fadeOut('fast', function () {
+                $sibling.removeClass('current');
+                $tab.addClass('current');
+                $tab_panel.fadeIn('fast', function () {
+                });
+            });
+        },
+
+        addHelpMessages: function (msgs) {
+            // Override addHelpMessages in ChatBoxView, for now do nothing.
+            return;
+        },
+
+        render: function () {
+            this.$el.html(this.template(this.model.toJSON()));
+            if ((!xmppchat.prebind) && (!xmppchat.connection)) {
+                // Add login panel if the user still has to authenticate
+                this.loginpanel = new xmppchat.LoginPanel();
+                this.loginpanel.$parent = this.$el;
+                this.loginpanel.render();
+            } else {
+                this.contactspanel = new xmppchat.ContactsPanel();
+                this.contactspanel.$parent = this.$el;
+                this.contactspanel.render();
+                // TODO: Only add the rooms panel if the server supports MUC
+                this.roomspanel = new xmppchat.RoomsPanel(); 
+                this.roomspanel.$parent = this.$el;
+                this.roomspanel.render();
+            }
+            return this;
+        }
+    });
+
+    xmppchat.ChatRoomView = xmppchat.ChatBoxView.extend({
+        length: 300,
+        tagName: 'div',
+        className: 'chatroom',
+        events: {
+            'click a.close-chatbox-button': 'closeChat',
+            'keypress textarea.chat-textarea': 'keyPressed'
+        },
+
+        sendChatRoomMessage: function (body) {
+            var match = body.replace(/^\s*/, "").match(/^\/(.*?)(?: (.*))?$/) || [false],
+                $chat_content;
+            switch (match[1]) {
+                case 'msg':
+                    // TODO: Private messages
+                    break;
+                case 'topic':
+                    xmppchat.connection.muc.setTopic(this.model.get('jid'), match[2]);
+                    break;
+                case 'kick':
+                    xmppchat.connection.muc.kick(this.model.get('jid'), match[2]);
+                    break;
+                case 'ban':
+                    xmppchat.connection.muc.ban(this.model.get('jid'), match[2]);
+                    break;
+                case 'op':
+                    xmppchat.connection.muc.op(this.model.get('jid'), match[2]);
+                    break;
+                case 'deop':
+                    xmppchat.connection.muc.deop(this.model.get('jid'), match[2]);
+                    break;
+                case 'help':
+                    $chat_content = this.$el.find('.chat-content');
+                    $chat_content.append('<div class="chat-help"><strong>/help</strong>: Show this menu</div>' +
+                                         '<div class="chat-help"><strong>/topic</strong>: Set chatroom topic</div>');
+                    /* TODO:
+                    $chat_content.append($('<div class="chat-help"><strong>/kick</strong>: Kick out user</div>'));
+                    $chat_content.append($('<div class="chat-help"><strong>/ban</strong>: Ban user</div>'));
+                    $chat_content.append($('<div class="chat-help"><strong>/op $user</strong>: Remove messages</div>'));
+                    $chat_content.append($('<div class="chat-help"><strong>/deop $user</strong>: Remove messages</div>'));
+                    */
+                    this.scrollDown();
+                    break;
+                default:
+                    this.last_msgid = xmppchat.connection.muc.groupchat(this.model.get('jid'), body);
+                break;
+            }
+        },
+
+        template: _.template(
+                '<div class="chat-head chat-head-chatroom">' +
+                    '<a class="close-chatbox-button">X</a>' +
+                    '<div class="chat-title"> {{ name }} </div>' +
+                    '<p class="chatroom-topic"><p/>' +
+                '</div>' +
+                '<div>' +
+                '<div class="chat-area">' +
+                    '<div class="chat-content"></div>' +
+                    '<form class="sendXMPPMessage" action="" method="post">' +
+                        '<textarea ' +
+                            'type="text" ' +
+                            'class="chat-textarea" ' +
+                            'placeholder="Message"/>' +
+                    '</form>' +
+                '</div>' +
+                '<div class="participants">' +
+                    '<ul class="participant-list"></ul>' +
+                '</div>' +
+                '</div>'),
+
+        initialize: function () {
+            xmppchat.connection.muc.join(
+                            this.model.get('jid'),
+                            this.model.get('nick'),
+                            $.proxy(this.onChatRoomMessage, this),
+                            $.proxy(this.onChatRoomPresence, this),
+                            $.proxy(this.onChatRoomRoster, this));
+
+
+            this.model.messages.on('add', this.showMessage, this);
+            this.model.on('destroy', function (model, response, options) { 
+                this.$el.hide('fast'); 
+                xmppchat.connection.muc.leave(
+                    this.model.get('jid'),
+                    this.model.get('nick'),
+                    this.onLeave,
+                    undefined);
+            }, 
+            this);
+            this.$el.appendTo(xmppchat.chatboxesview.$el);
+            this.render().show().model.messages.fetch({add: true});
+            xmppchat.clearMsgCounter();
+        },
+
+        onLeave: function () {
+            var controlboxview = xmppchat.chatboxesview.views.controlbox;
+            if (controlboxview) {
+                controlboxview.roomspanel.trigger('update-rooms-list');
+            }
+        },
+
+        onChatRoomPresence: function (presence, room) {
+            var nick = room.nick,
+                $presence = $(presence),
+                from = $presence.attr('from');
+            if ($presence.attr('type') !== 'error') {
+                // check for status 110 to see if it's our own presence
+                if ($presence.find("status[code='110']").length) {
+                    // check if server changed our nick
+                    if ($presence.find("status[code='210']").length) {
+                        this.model.set({'nick': Strophe.getResourceFromJid(from)});
+                    }
+                }
+            }
+            return true;
+        },
+
+        onChatRoomMessage: function (message) {
+            var $message = $(message),
+                body = $message.children('body').text(),
+                jid = $message.attr('from'),
+                $chat_content = this.$el.find('.chat-content'),
+                sender = Strophe.unescapeNode(Strophe.getResourceFromJid(jid)),
+                delayed = $message.find('delay').length > 0,
+                subject = $message.children('subject').text(),
+                match, template, message_datetime, message_date, dates, isodate;
+            if (!body) { return true; } // XXX: Necessary?
+            if (subject) {
+                this.$el.find('.chatroom-topic').text(subject).attr('title', subject);
+            }
+            if (delayed) {
+                stamp = $message.find('delay').attr('stamp');
+                message_datetime = xmppchat.parseISO8601(stamp);
+            } else {
+                message_datetime = new Date();
+            }
+            // If this message is on a different day than the one received
+            // prior, then indicate it on the chatbox.
+            dates = $chat_content.find("time").map(function(){return $(this).attr("datetime");}).get();
+            message_date = message_datetime;
+            message_date.setUTCHours(0,0,0,0);
+            isodate = xmppchat.toISOString(message_date);
+            if (_.indexOf(dates, isodate) == -1) {
+                $chat_content.append(this.new_day_template({
+                    isodate: isodate,
+                    datestring: message_date.toString().substring(0,15)
+                }));
+            }
+
+            match = body.match(/^\/(.*?)(?: (.*))?$/);
+            if ((match) && (match[1] === 'me')) {
+                body = body.replace(/^\/me/, '*'+sender);
+                template = this.action_template;
+            } else  {
+                template = this.message_template;
+            }
+            if (sender === this.model.get('nick')) {
+                sender = 'me';
+            }
+            $chat_content.append(
+                template({
+                    'sender': sender == 'me' && sender || 'room',
+                    'time': message_date.toLocaleTimeString().substring(0,5),
+                    'message': body,
+                    'username': sender,
+                    'extra_classes': delayed && 'delayed' || ''
+                })
+            );
+            this.scrollDown();
+            return true;
+        },
+
+        onChatRoomRoster: function (roster, room) {
+            // underscore size is needed because roster is on object
+            var controlboxview = xmppchat.chatboxesview.views.controlbox,
+                roster_size = _.size(roster),
+                $participant_list = this.$el.find('.participant-list'),
+                participants = [],
+                i;
+
+            if (controlboxview) {
+                controlboxview.roomspanel.trigger('update-rooms-list');
+            }
+            this.$el.find('.participant-list').empty();
+            for (i=0; i<roster_size; i++) {
+                participants.push('<li>' + Strophe.unescapeNode(_.keys(roster)[i]) + '</li>');
+            }
+            $participant_list.append(participants.join(""));
+            return true;
+        },
+
+        render: function () {
+            this.$el.attr('id', this.model.get('box_id'))
+                    .html(this.template(this.model.toJSON()));
+            return this;
+        }
+    });
+
+    xmppchat.ChatBoxes = Backbone.Collection.extend({
+        model: xmppchat.ChatBox,
+
+        onConnected: function () {
+            this.localStorage = new Backbone.LocalStorage(
+                hex_sha1('converse.chatboxes-'+xmppchat.bare_jid));
+            if (!this.get('controlbox')) {
+                this.add({
+                    id: 'controlbox',
+                    box_id: 'controlbox'
+                });
+            } else {
+                this.get('controlbox').save();
+            }
+            // This will make sure the Roster is set up
+            this.get('controlbox').set({connected:true});
+            // Get cached chatboxes from localstorage
+            this.fetch({
+                add: true,
+                success: $.proxy(function (collection, resp) {
+                    if (_.include(_.pluck(resp, 'id'), 'controlbox')) {
+                        // If the controlbox was saved in localstorage, it must be visible
+                        this.get('controlbox').set({visible:true}).save();
+                    }
+                }, this)
+            }); 
+        },
+
+        messageReceived: function (message) {
+            var  partner_jid, $message = $(message),
+                 message_from = $message.attr('from');
+            if (message_from == xmppchat.connection.jid) {
+                // FIXME: Forwarded messages should be sent to specific resources, 
+                // not broadcasted
+                return true;
+            }
+            var $forwarded = $message.children('forwarded');
+            if ($forwarded.length) {
+                $message = $forwarded.children('message');
+            }
+            var from = Strophe.getBareJidFromJid(message_from),
+                to = Strophe.getBareJidFromJid($message.attr('to')),
+                resource, chatbox;
+            if (from == xmppchat.bare_jid) {
+                // I am the sender, so this must be a forwarded message...
+                partner_jid = to;
+                resource = Strophe.getResourceFromJid($message.attr('to'));
+            } else {
+                partner_jid = from;
+                resource = Strophe.getResourceFromJid(message_from);
+            }
+            chatbox = this.get(partner_jid);
+            if (!chatbox) {
+                xmppchat.getVCard(
+                    partner_jid, 
+                    $.proxy(function (jid, fullname, image, image_type, url) {
+                        chatbox = this.create({
+                            'id': jid,
+                            'jid': jid,
+                            'fullname': fullname,
+                            'image_type': image_type,
+                            'image': image,
+                            'url': url
+                        });
+                        chatbox.messageReceived(message);
+                        xmppchat.roster.addResource(partner_jid, resource);
+                    }, this),
+                    $.proxy(function () {
+                        // # FIXME
+                        console.log("An error occured while fetching vcard");
+                    }, this));
+                return true;
+            }
+            chatbox.messageReceived(message);
+            xmppchat.roster.addResource(partner_jid, resource);
+            return true;
+        }
+    });
+
+    xmppchat.ChatBoxesView = Backbone.View.extend({
+        el: '#collective-xmpp-chat-data',
+
+        initialize: function () {
+            // boxesviewinit
+            this.views = {};
+            this.options.model.on("add", function (item) {
+                var view = this.views[item.get('id')];
+                if (!view) {
+                    if (item.get('chatroom')) {
+                        view = new xmppchat.ChatRoomView({'model': item});
+                    } else if (item.get('box_id') === 'controlbox') {
+                        view = new xmppchat.ControlBoxView({model: item});
+                        view.render();
+                    } else {
+                        view = new xmppchat.ChatBoxView({model: item});
+                    }
+                    this.views[item.get('id')] = view;
+                } else {
+                    view.model = item;
+                    view.initialize();
+                    if (item.get('id') !== 'controlbox') {
+                        // FIXME: Why is it necessary to again append chatboxes?
+                        view.$el.appendTo(this.$el);
+                    }
+                }
+            }, this);
+        }
+    });
+
+    xmppchat.RosterItem = Backbone.Model.extend({
+        initialize: function (attributes, options) {
+            var jid = attributes.jid;
+            if (!attributes.fullname) {
+                attributes.fullname = jid;
+            }
+            _.extend(attributes, {
+                'id': jid,
+                'user_id': Strophe.getNodeFromJid(jid),
+                'resources': [],
+                'chat_status': 'offline',
+                'status': 'offline',
+                'sorted': false
+            });
+            this.set(attributes);
+        }
+    });
+
+    xmppchat.RosterItemView = Backbone.View.extend({
+        tagName: 'dd',
+
+        events: {
+            "click .accept-xmpp-request": "acceptRequest",
+            "click .decline-xmpp-request": "declineRequest",
+            "click .open-chat": "openChat",
+            "click .remove-xmpp-contact": "removeContact"
+        },
+
+        openChat: function (ev) {
+            ev.preventDefault();
+            var jid = Strophe.getBareJidFromJid(this.model.get('jid')),
+                chatbox  = xmppchat.chatboxes.get(jid);
+            if (chatbox) {
+                chatbox.trigger('show');
+            } else {
+                xmppchat.chatboxes.create({
+                    'id': this.model.get('jid'),
+                    'jid': this.model.get('jid'),
+                    'fullname': this.model.get('fullname'),
+                    'image_type': this.model.get('image_type'),
+                    'image': this.model.get('image'),
+                    'url': this.model.get('url')
+                });
+            }
+        },
+
+        removeContact: function (ev) {
+            ev.preventDefault();
+            var result = confirm("Are you sure you want to remove this contact?");
+            if (result === true) {
+                var bare_jid = this.model.get('jid');
+                xmppchat.connection.roster.remove(bare_jid, function (iq) {
+                    xmppchat.connection.roster.unauthorize(bare_jid);
+                    xmppchat.rosterview.model.remove(bare_jid);
+                });
+            }
+        },
+
+        acceptRequest: function (ev) {
+            var jid = this.model.get('jid');
+            xmppchat.connection.roster.authorize(jid);
+            xmppchat.connection.roster.add(jid, this.model.get('fullname'), [], function (iq) {
+                xmppchat.connection.roster.subscribe(jid, null, xmppchat.fullname);
+            });
+            ev.preventDefault();
+        },
+
+        declineRequest: function (ev) {
+            ev.preventDefault();
+            xmppchat.connection.roster.unauthorize(this.model.get('jid'));
+            this.model.destroy();
+        },
+
+        template: _.template(
+                    '<a class="open-chat" title="Click to chat with this contact" href="#">{{ fullname }}</a>' +
+                    '<a class="remove-xmpp-contact" title="Click to remove this contact" href="#"></a>'),
+
+        pending_template: _.template(
+                    '{{ fullname }}' +
+                    '<a class="remove-xmpp-contact" title="Click to remove this contact" href="#"></a>'),
+
+        request_template: _.template('{{ fullname }}' +
+                    '<button type="button" class="accept-xmpp-request">' +
+                    'Accept</button>' +
+                    '<button type="button" class="decline-xmpp-request">' +
+                    'Decline</button>' +
+                    ''),
+
+        render: function () {
+            var item = this.model,
+                ask = item.get('ask'),
+                subscription = item.get('subscription');
+            this.$el.addClass(item.get('chat_status'));
+
+            if (ask === 'subscribe') {
+                this.$el.addClass('pending-xmpp-contact');
+                this.$el.html(this.pending_template(item.toJSON()));
+            } else if (ask === 'request') {
+                this.$el.addClass('requesting-xmpp-contact');
+                this.$el.html(this.request_template(item.toJSON()));
+                xmppchat.showControlBox();
+            } else if (subscription === 'both' || subscription === 'to') {
+                this.$el.addClass('current-xmpp-contact');
+                this.$el.html(this.template(item.toJSON()));
+            }
+
+            return this;
+        },
+
+        initialize: function () {
+            this.options.model.on('change', function (item, changed) {
+                if (_.has(item.changed, 'chat_status')) {
+                    this.$el.attr('class', item.changed.chat_status);
+                }
+            }, this);
+        }
+    });
+
+    xmppchat.getVCard = function (jid, callback, errback) {
+        xmppchat.connection.vcard.get($.proxy(function (iq) {
+            $vcard = $(iq).find('vCard');
+            var fullname = $vcard.find('FN').text(),
+                img = $vcard.find('BINVAL').text(),
+                img_type = $vcard.find('TYPE').text(),
+                url = $vcard.find('URL').text();
+            callback(jid, fullname, img, img_type, url);
+        }, this), jid, errback);
+    }
+
+    xmppchat.RosterItems = Backbone.Collection.extend({
+        model: xmppchat.RosterItem,
+        comparator : function (rosteritem) {
+            var chat_status = rosteritem.get('chat_status'),
+                rank = 4;
+            switch(chat_status) {
+                case 'offline':
+                    rank = 0;
+                    break;
+                case 'unavailable':
+                    rank = 1;
+                    break;
+                case 'xa':
+                    rank = 2;
+                    break;
+                case 'away':
+                    rank = 3;
+                    break;
+                case 'dnd':
+                    rank = 4;
+                    break;
+                case 'online':
+                    rank = 5;
+                    break;
+            }
+            return rank;
+        },
+
+        subscribeToSuggestedItems: function (msg) {
+            $(msg).find('item').each(function () {
+                var $this = $(this),
+                    jid = $this.attr('jid'),
+                    action = $this.attr('action'),
+                    fullname = $this.attr('name');
+                if (action === 'add') {
+                    xmppchat.connection.roster.add(jid, fullname, [], function (iq) {
+                        xmppchat.connection.roster.subscribe(jid, null, xmppchat.fullname);
+                    });
+                }
+            });
+            return true;
+        },
+
+        isSelf: function (jid) {
+            return (Strophe.getBareJidFromJid(jid) === Strophe.getBareJidFromJid(xmppchat.connection.jid));
+        },
+
+        getItem: function (id) {
+            return Backbone.Collection.prototype.get.call(this, id);
+        },
+
+        addResource: function (bare_jid, resource) {
+            var item = this.getItem(bare_jid),
+                resources;
+            if (item) {
+                resources = item.get('resources');
+                if (resources) {
+                    if (_.indexOf(resources, resource) == -1) {
+                        resources.push(resource);
+                        item.set({'resources': resources});
+                    }
+                } else  {
+                    item.set({'resources': [resource]});
+                }
+            }
+        },
+
+        removeResource: function (bare_jid, resource) {
+            var item = this.getItem(bare_jid),
+                resources,
+                idx;
+            if (item) {
+                resources = item.get('resources');
+                idx = _.indexOf(resources, resource);
+                if (idx !== -1) {
+                    resources.splice(idx, 1);
+                    item.set({'resources': resources});
+                    return resources.length;
+                }
+            }
+            return 0;
+        },
+
+        subscribeBack: function (jid) {
+            var bare_jid = Strophe.getBareJidFromJid(jid);
+            if (xmppchat.connection.roster.findItem(bare_jid)) {
+                xmppchat.connection.roster.authorize(bare_jid);
+                xmppchat.connection.roster.subscribe(jid, null, xmppchat.fullname);
+            } else {
+                xmppchat.connection.roster.add(jid, '', [], function (iq) {
+                    xmppchat.connection.roster.authorize(bare_jid);
+                    xmppchat.connection.roster.subscribe(jid, null, xmppchat.fullname);
+                });
+            }
+        },
+
+        unsubscribe: function (jid) {
+            /* Upon receiving the presence stanza of type "unsubscribed",
+            * the user SHOULD acknowledge receipt of that subscription state
+            * notification by sending a presence stanza of type "unsubscribe"
+            * this step lets the user's server know that it MUST no longer
+            * send notification of the subscription state change to the user.
+            */
+            xmppchat.xmppstatus.sendPresence('unsubscribe');
+            if (xmppchat.connection.roster.findItem(jid)) {
+                xmppchat.connection.roster.remove(jid, function (iq) {
+                    xmppchat.rosterview.model.remove(jid);
+                });
+            }
+        },
+
+        getNumOnlineContacts: function () {
+            var count = 0,
+                models = this.models,
+                models_length = models.length,
+                i;
+            for (i=0; i<models_length; i++) {
+                if (_.indexOf(['offline', 'unavailable'], models[i].get('chat_status')) === -1) {
+                    count++;
+                }
+            }
+            return count;
+        },
+
+        cleanCache: function (items) {
+            /* The localstorage cache containing roster contacts might contain
+             * some contacts that aren't actually in our roster anymore. We
+             * therefore need to remove them now.
+             */
+            var id, i,
+                roster_ids = [];
+            for (i=0; i < items.length; ++i) {
+                roster_ids.push(items[i].jid);
+            }
+            for (i=0; i < this.models.length; ++i) {
+                id = this.models[i].get('id');
+                if (_.indexOf(roster_ids, id) === -1) {
+                    this.getItem(id).destroy();
+                }
+            }
+        },
+
+        rosterHandler: function (items) {
+            this.cleanCache(items);
+            _.each(items, function (item, index, items) {
+                if (this.isSelf(item.jid)) { return; }
+                var model = this.getItem(item.jid);
+                if (!model) {
+                    is_last = false;
+                    if (index === (items.length-1)) { is_last = true; }
+                    this.create({
+                        jid: item.jid, 
+                        subscription: item.subscription,
+                        ask: item.ask,
+                        fullname: item.name,
+                        is_last: is_last
+                    });
+                } else {
+                    if ((item.subscription === 'none') && (item.ask === null)) {
+                        // This user is no longer in our roster
+                        model.destroy();
+                    } else if (model.get('subscription') !== item.subscription || model.get('ask') !== item.ask) {
+                        // only modify model attributes if they are different from the
+                        // ones that were already set when the rosterItem was added
+                        model.set({'subscription': item.subscription, 'ask': item.ask});
+                        model.save();
+                    }
+                }
+            }, this);
+        },
+
+        presenceHandler: function (presence) {
+            var $presence = $(presence),
+                jid = $presence.attr('from'),
+                bare_jid = Strophe.getBareJidFromJid(jid),
+                resource = Strophe.getResourceFromJid(jid),
+                presence_type = $presence.attr('type'),
+                show = $presence.find('show'),
+                chat_status = show.text() || 'online',
+                status_message = $presence.find('status'),
+                item;
+
+            if (this.isSelf(bare_jid)) {
+                if ((xmppchat.connection.jid !== jid)&&(presence_type !== 'unavailabe')) {
+                    // Another resource has changed it's status, we'll update ours as well.
+                    // FIXME: We should ideally differentiate between converse.js using
+                    // resources and other resources (i.e Pidgin etc.)
+                    xmppchat.xmppstatus.set({'status': chat_status});
+                }
+                return true;
+            } else if (($presence.find('x').attr('xmlns') || '').indexOf(Strophe.NS.MUC) === 0) {
+                return true; // Ignore MUC
+            }
+
+            item = this.getItem(bare_jid);
+            if (item && (status_message.text() != item.get('status'))) {
+                item.set({'status': status_message.text()});
+            }
+
+            if ((presence_type === 'error') || (presence_type === 'subscribed') || (presence_type === 'unsubscribe')) {
+                return true;
+            } else if (presence_type === 'subscribe') {
+                if (xmppchat.auto_subscribe) {
+                    if ((!item) || (item.get('subscription') != 'to')) {
+                        this.subscribeBack(jid);
+                    } else {
+                        xmppchat.connection.roster.authorize(bare_jid);
+                    }
+                } else {
+                    if ((item) && (item.get('subscription') != 'none'))  {
+                        xmppchat.connection.roster.authorize(bare_jid);
+                    } else {
+                        xmppchat.getVCard(
+                            bare_jid, 
+                            $.proxy(function (jid, fullname, img, img_type, url) {
+                                this.add({
+                                    jid: bare_jid, 
+                                    subscription: 'none',
+                                    ask: 'request',
+                                    fullname: fullname,
+                                    image: img,
+                                    image_type: img_type,
+                                    url: url,
+                                    is_last: true
+                                });
+                            }, this),
+                            $.proxy(function (jid, fullname, img, img_type, url) {
+                                console.log("Error while retrieving vcard");
+                                this.add({jid: bare_jid, subscription: 'none', ask: 'request', fullname: jid, is_last: true});
+                            }, this)
+                        );
+                    }
+                }
+            } else if (presence_type === 'unsubscribed') {
+                this.unsubscribe(bare_jid);
+            } else if (presence_type === 'unavailable') {
+                if (this.removeResource(bare_jid, resource) === 0) {
+                    if (item) {
+                        item.set({'chat_status': 'offline'});
+                    }
+                }
+            } else if (item) {
+                // presence_type is undefined
+                this.addResource(bare_jid, resource);
+                item.set({'chat_status': chat_status});
+            }
+            return true;
+        }
+    });
+
+    xmppchat.RosterView = Backbone.View.extend({
+        tagName: 'dl',
+        id: 'xmppchat-roster',
+        rosteritemviews: {},
+
+        removeRosterItem: function (item) {
+            var view = this.rosteritemviews[item.id];
+            if (view) {
+                view.$el.remove();
+                delete this.rosteritemviews[item.id];
+                this.render();
+            }
+        },
+
+        initialize: function () {
+            this.model.on("add", function (item) {
+                var view = new xmppchat.RosterItemView({model: item});
+                this.rosteritemviews[item.id] = view;
+                this.render(item);
+            }, this);
+
+            this.model.on('change', function (item, changed) {
+                if ((_.size(item.changed) === 1) && _.contains(_.keys(item.changed), 'sorted')) {
+                    return;
+                }
+                this.updateChatBox(item, changed);
+                this.render(item);
+            }, this);
+
+            this.model.on("destroy", function (item) {
+                this.removeRosterItem(item);
+            }, this);
+
+            this.$el.hide().html(this.template());
+            this.model.fetch({add: true}); // Get the cached roster items from localstorage
+            this.initialSort();
+            this.$el.appendTo(xmppchat.chatboxesview.views.controlbox.contactspanel.$el);
+        },
+
+        updateChatBox: function (item, changed) {
+            var chatbox = xmppchat.chatboxes.get(item.get('jid')),
+                changes = {};
+            if (!chatbox) { return; }
+            if (_.has(item.changed, 'chat_status')) {
+                changes.chat_status = item.get('chat_status');
+            }
+            if (_.has(item.changed, 'status')) {
+                changes.status = item.get('status');
+            }
+            chatbox.save(changes);
+        },
+
+        template: _.template('<dt id="xmpp-contact-requests">Contact requests</dt>' +
+                            '<dt id="xmpp-contacts">My contacts</dt>' +
+                            '<dt id="pending-xmpp-contacts">Pending contacts</dt>'),
+
+        render: function (item) {
+            var $my_contacts = this.$el.find('#xmpp-contacts'),
+                $contact_requests = this.$el.find('#xmpp-contact-requests'),
+                $pending_contacts = this.$el.find('#pending-xmpp-contacts'),
+                $count, presence_change;
+            if (item) {
+                var jid = item.id,
+                    view = this.rosteritemviews[item.id],
+                    ask = item.get('ask'),
+                    subscription = item.get('subscription'),
+                    crit = {order:'asc'};
+
+                if (ask === 'subscribe') {
+                    $pending_contacts.after(view.render().el);
+                    $pending_contacts.after($pending_contacts.siblings('dd.pending-xmpp-contact').tsort(crit));
+                } else if (ask === 'request') {
+                    $contact_requests.after(view.render().el);
+                    $contact_requests.after($contact_requests.siblings('dd.requesting-xmpp-contact').tsort(crit));
+                } else if (subscription === 'both' || subscription === 'to') {
+                    if (!item.get('sorted')) {
+                        // this attribute will be true only after all of the elements have been added on the page
+                        // at this point all offline
+                        $my_contacts.after(view.render().el);
+                    }
+                    else {
+                        // just by calling render will be enough to change the icon of the existing item without
+                        // having to reinsert it and the sort will come from the presence change
+                        view.render();
+                    }
+                }
+                presence_change = view.model.changed.chat_status;
+                if (presence_change) {
+                    // resort all items only if the model has changed it's chat_status as this render
+                    // is also triggered when the resource is changed which always comes before the presence change
+                    // therefore we avoid resorting when the change doesn't affect the position of the item
+                    $my_contacts.after($my_contacts.siblings('dd.current-xmpp-contact.offline').tsort('a', crit));
+                    $my_contacts.after($my_contacts.siblings('dd.current-xmpp-contact.unavailable').tsort('a', crit));
+                    $my_contacts.after($my_contacts.siblings('dd.current-xmpp-contact.away').tsort('a', crit));
+                    $my_contacts.after($my_contacts.siblings('dd.current-xmpp-contact.dnd').tsort('a', crit));
+                    $my_contacts.after($my_contacts.siblings('dd.current-xmpp-contact.online').tsort('a', crit));
+                }
+
+                if (item.get('is_last') && !item.get('sorted')) {
+                    // this will be true after all of the roster items have been added with the default
+                    // options where all of the items are offline and now we can show the rosterView
+                    item.set('sorted', true);
+                    this.initialSort();
+                    this.$el.show();
+                }
+            }
+            // Hide the headings if there are no contacts under them
+            _.each([$my_contacts, $contact_requests, $pending_contacts], function (h) {
+                if (h.nextUntil('dt').length) {
+                    h.show();
+                }
+                else {
+                    h.hide();
+                }
+            });
+            $count = $('#online-count');
+            $count.text('('+this.model.getNumOnlineContacts()+')');
+            if (!$count.is(':visible')) {
+                $count.show();
+            }
+            return this;
+        },
+
+        initialSort: function () {
+            var $my_contacts = this.$el.find('#xmpp-contacts'),
+                crit = {order:'asc'};
+            $my_contacts.after($my_contacts.siblings('dd.current-xmpp-contact.offline').tsort('a', crit));
+            $my_contacts.after($my_contacts.siblings('dd.current-xmpp-contact.unavailable').tsort('a', crit));
+        },
+
+    });
+
+    xmppchat.XMPPStatus = Backbone.Model.extend({
+        initialize: function () {
+            this.set({
+                'status' : this.get('status'),
+                'status_message' : this.get('status_message')
+            });
+        },
+
+        initStatus: function () {
+            var stat = this.get('status');
+            if (stat === undefined) {
+                this.save({status: 'online'});
+            } else {
+                this.sendPresence(stat);
+            }
+        },
+
+        sendPresence: function (type) {
+            var status_message = this.get('status_message'), 
+                presence;
+            // Most of these presence types are actually not explicitly sent,
+            // but I add all of them here fore reference and future proofing.
+            if ((type === 'unavailable') ||
+                    (type === 'probe') ||
+                    (type === 'error') ||
+                    (type === 'unsubscribe') ||
+                    (type === 'unsubscribed') ||
+                    (type === 'subscribe') ||
+                    (type === 'subscribed')) {
+                presence = $pres({'type':type});
+            } else {
+                if (type === 'online') {
+                    presence = $pres();
+                } else {
+                    presence = $pres().c('show').t(type);
+                }
+                if (status_message) {
+                    presence.c('status').t(status_message);
+                }
+            }
+            xmppchat.connection.send(presence);
+        },
+
+        setStatus: function (value) {
+            this.sendPresence(value);
+            this.save({'status': value});
+        },
+
+        setStatusMessage: function (status_message) {
+            xmppchat.connection.send($pres().c('show').t(this.get('status')).up().c('status').t(status_message));
+            this.save({'status_message': status_message});
+        }
+
+    });
+
+    xmppchat.XMPPStatusView = Backbone.View.extend({
+        el: "span#xmpp-status-holder",
+
+        events: {
+            "click a.choose-xmpp-status": "toggleOptions",
+            "click #fancy-xmpp-status-select a.change-xmpp-status-message": "renderStatusChangeForm",
+            "submit #set-custom-xmpp-status": "setStatusMessage",
+            "click .dropdown dd ul li a": "setStatus"
+        },
+
+        toggleOptions: function (ev) {
+            ev.preventDefault();
+            $(ev.target).parent().parent().siblings('dd').find('ul').toggle('fast');
+        },
+
+        change_status_message_template: _.template(
+            '<form id="set-custom-xmpp-status">' +
+                '<input type="text" class="custom-xmpp-status" {{ status_message }}" placeholder="Custom status"/>' +
+                '<button type="submit">Save</button>' +
+            '</form>'),
+
+        status_template: _.template(
+            '<div class="xmpp-status">' +
+                '<a class="choose-xmpp-status {{ chat_status }}" href="#" title="Click to change your chat status">' +
+                    '{{ status_message }} <span class="value">{{ status_message }}</span>' +
+                '</a>' +
+                '<a class="change-xmpp-status-message" href="#" Title="Click here to write a custom status message"></a>' +
+            '</div>'),
+
+
+        renderStatusChangeForm: function (ev) {
+            ev.preventDefault();
+            var status_message = this.model.get('status') || 'offline';
+            var input = this.change_status_message_template({'status_message': status_message});
+            this.$el.find('.xmpp-status').replaceWith(input);
+            this.$el.find('.custom-xmpp-status').focus().focus();
+        },
+
+        setStatusMessage: function (ev) {
+            ev.preventDefault();
+            var status_message = $(ev.target).find('input').attr('value');
+            if (status_message === "") {
+            }
+            this.model.setStatusMessage(status_message);
+        },
+
+        setStatus: function (ev) {
+            ev.preventDefault();
+            var $el = $(ev.target).find('span'),
+                value = $el.text();
+            this.model.setStatus(value);
+            this.$el.find(".dropdown dd ul").hide();
+        },
+
+        getPrettyStatus: function (stat) {
+            if (stat === 'chat') {
+                pretty_status = 'online';
+            } else if (stat === 'dnd') {
+                pretty_status = 'busy';
+            } else if (stat === 'xa') {
+                pretty_status = 'away for long';
+            } else {
+                pretty_status = stat || 'online';
+            }
+            return pretty_status;
+        },
+
+        updateStatusUI: function (model) {
+            if (!(_.has(model.changed, 'status')) && !(_.has(model.changed, 'status_message'))) {
+                return;
+            }
+            var stat = model.get('status'), 
+                status_message = model.get('status_message') || "I am " + this.getPrettyStatus(stat);
+            this.$el.find('#fancy-xmpp-status-select').html(
+                this.status_template({
+                    'chat_status': stat,
+                    'status_message': status_message
+                }));
+        },
+
+        choose_template: _.template(
+            '<dl id="target" class="dropdown">' +
+                '<dt id="fancy-xmpp-status-select" class="fancy-dropdown"></dt>' +
+                '<dd><ul></ul></dd>' +
+            '</dl>'),
+
+        option_template: _.template(
+            '<li>' +
+                '<a href="#" class="{{ value }}">' +
+                    '{{ text }}' +
+                    '<span class="value">{{ value }}</span>' +
+                '</a>' +
+            '</li>'),
+
+        initialize: function () {
+            this.model.on("change", this.updateStatusUI, this);
+        },
+
+        render: function () {
+            // Replace the default dropdown with something nicer
+            var $select = this.$el.find('select#select-xmpp-status'),
+                chat_status = this.model.get('status') || 'offline',
+                options = $('option', $select),
+                $options_target,
+                options_list = [],
+                that = this;
+            this.$el.html(this.choose_template());
+            this.$el.find('#fancy-xmpp-status-select')
+                    .html(this.status_template({
+                            'status_message': "I am " + this.getPrettyStatus(chat_status),
+                            'chat_status': chat_status
+                            }));
+            // iterate through all the <option> elements and add option values
+            options.each(function(){
+                options_list.push(that.option_template({
+                                                        'value': $(this).val(),
+                                                        'text': $(this).text()
+                                                        }));
+            });
+            $options_target = this.$el.find("#target dd ul").hide();
+            $options_target.append(options_list.join(''));
+            $select.remove();
+            return this;
+        }
+    });
+
+    xmppchat.LoginPanel = Backbone.View.extend({
+        tagName: 'div',
+        id: "login-dialog",
+        events: {
+            'submit form#xmppchat-login': 'authenticate'
+        },
+        tab_template: _.template(
+            '<li><a class="current" href="#login">Sign in</a></li>'),
+        template: _.template(
+            '<form id="xmppchat-login">' +
+            '<label>XMPP ID:</label>' +
+            '<input type="text" id="jid">' +
+            '<label>Password:</label>' +
+            '<input type="password" id="password">' +
+            '<label>BOSH Service URL:</label>' +
+            '<input type="text" id="bosh_service_url">' +
+            '<input type="submit" name="submit"/>' +
+            '</form">'),
+
+        authenticate: function (ev) {
+            ev.preventDefault();
+            var $form = $(ev.target),
+                bosh_service_url = $form.find('input#bosh_service_url').val(),
+                jid = $form.find('input#jid').val(),
+                password = $form.find('input#password').val(),
+                connection = new Strophe.Connection(bosh_service_url);
+
+            connection.connect(jid, password, $.proxy(function (status) {
+                if (status === Strophe.Status.CONNECTED) {
+                    $(document).trigger('jarnxmpp.connected', connection);
+                } else if (status === Strophe.Status.DISCONNECTED) {
+                    console.log('Disconnected');
+                    $(document).trigger('jarnxmpp.disconnected');
+                } else if (status === Strophe.Status.Error) {
+                    console.log('Error');
+                } else if (status === Strophe.Status.CONNECTING) {
+                    console.log('Connecting');
+                    $(document).trigger('jarnxmpp.connecting');
+                } else if (status === Strophe.Status.CONNFAIL) {
+                    console.log('Connection Failed');
+                } else if (status === Strophe.Status.AUTHENTICATING) {
+                    console.log('Authenticating');
+                    xmppchat.giveFeedback('Authenticating');
+                } else if (status === Strophe.Status.AUTHFAIL) {
+                    console.log('Authenticating Failed');
+                    xmppchat.giveFeedback('Authentication failed');
+                } else if (status === Strophe.Status.DISCONNECTING) {
+                    console.log('Disconnecting');
+                } else if (status === Strophe.Status.ATTACHED) {
+                    console.log('Attached');
+                }
+            }, this));
+        },
+
+        remove: function () {
+            this.$parent.find('#controlbox-tabs').empty();
+            this.$parent.find('#controlbox-panes').empty();
+        },
+
+        render: function () {
+            this.$parent.find('#controlbox-tabs').append(this.tab_template());
+            this.$parent.find('#controlbox-panes').append(this.$el.html(this.template()));
+            return this;
+        }
+    });
+
+    xmppchat.showControlBox = function () {
+        var controlbox = this.chatboxes.get('controlbox');
+        if (!controlbox) {
+            this.chatboxes.add({
+                id: 'controlbox',
+                box_id: 'controlbox',
+                visible: true
+            });
+            if (this.connection) {
+                this.chatboxes.get('controlbox').save();
+            }
+        } else {
+            controlbox.trigger('show');
+        }
+    }
+
+    xmppchat.toggleControlBox = function () {
+        if ($("div#controlbox").is(':visible')) {
+            var controlbox = this.chatboxes.get('controlbox');
+            if (this.connection) {
+                controlbox.destroy();
+            } else {
+                controlbox.trigger('hide');
+            }
+        } else {
+            this.showControlBox();
+        }
+    };
+
+    xmppchat.giveFeedback = function (message) {
+        $('.conn-feedback').text(message);
+    }
+
+    xmppchat.initialize = function () {
+        var chatdata = $('div#collective-xmpp-chat-data');
+        this.fullname = chatdata.attr('fullname');
+        this.prebind = chatdata.attr('prebind');
+        this.auto_subscribe = chatdata.attr('auto_subscribe') === "True" || false;
+        this.chatboxes = new this.ChatBoxes();
+        this.chatboxesview = new this.ChatBoxesView({model: this.chatboxes});
+        $('a#toggle-online-users').bind(
+            'click', 
+            $.proxy(function (e) { 
+                e.preventDefault(); this.toggleControlBox(); 
+            }, this)
+        );
+    },
+
+    xmppchat.onConnected = function (connection) {
+        this.animate = true; // Use animations
+        this.connection = connection;
+        this.connection.xmlInput = function (body) { console.log(body); };
+        this.connection.xmlOutput = function (body) { console.log(body); };
+        this.bare_jid = Strophe.getBareJidFromJid(this.connection.jid);
+        this.domain = Strophe.getDomainFromJid(this.connection.jid);
+        this.muc_domain = 'conference.' +  this.domain;
+
+        // Set up the roster
+        this.roster = new this.RosterItems();
+        this.roster.localStorage = new Backbone.LocalStorage(
+            hex_sha1('converse.rosteritems-'+this.bare_jid));
+
+        this.xmppstatus = new this.XMPPStatus({id:1});
+        this.xmppstatus.localStorage = new Backbone.LocalStorage(
+            hex_sha1('converse.xmppstatus-'+this.bare_jid));
+
+        this.chatboxes.onConnected();
+        this.rosterview = new this.RosterView({'model':this.roster});
+
+        this.xmppstatusview = new this.XMPPStatusView({'model': this.xmppstatus}).render();
+        this.xmppstatus.fetch();
+
+        this.connection.addHandler(
+            $.proxy(this.roster.subscribeToSuggestedItems, this.roster),
+            'http://jabber.org/protocol/rosterx', 'message', null);
+
+        this.connection.roster.registerCallback(
+            $.proxy(this.roster.rosterHandler, this.roster),
+            null, 'presence', null);
+
+        this.connection.roster.get($.proxy(function () {
+            this.connection.addHandler(
+                    $.proxy(function (presence) {
+                        this.presenceHandler(presence);
+                        return true;
+                    }, this.roster), null, 'presence', null);
+
+            this.connection.addHandler(
+                    $.proxy(function (message) {
+                        this.chatboxes.messageReceived(message);
+                        return true;
+                    }, this), null, 'message', 'chat');
+
+            this.xmppstatus.initStatus();
+        }, this));
+        this.giveFeedback('Online Contacts');
+    };
+
+    // Event handlers
+    // --------------
+    $(document).ready($.proxy(function () {
+        this.initialize();
+        $(document).bind('jarnxmpp.connecting', $.proxy(function (ev, conn) {
+        this.giveFeedback('Connecting to chat...');
+        }, this));
+        $(document).bind('jarnxmpp.disconnected', $.proxy(function (ev, conn) {
+            this.giveFeedback('Unable to communicate with chat server').css('background-image', "url(images/error_icon.png)");
+            console.log("Connection Failed :(");
+        }, this));
+        $(document).unbind('jarnxmpp.connected');
+        $(document).bind('jarnxmpp.connected', $.proxy(function (ev, connection) {
+            this.onConnected(connection);
+        }, this));
+    }, xmppchat));
+
+    return xmppchat;
+}));

main.js

+require(["jquery", "converse"], function($) {});

spec/MainSpec.js

+(function (root, factory) {
+    define([
+        "converse"
+        ], function (xmppchat) {
+            return factory(xmppchat);
+        }
+    );
+} (this, function (xmppchat) {
+
+    return describe("Converse.js", $.proxy(function() {
+        // Names from http://www.fakenamegenerator.com/
+        var req_names = [
+            'Louw Spekman', 'Mohamad Stet', 'Dominik Beyer', 'Dirk Eichel', 'Marco Duerr', 'Ute Schiffer',
+            'Billie Westerhuis', 'Sarah Kuester', 'Sabrina Loewe', 'Laura Duerr', 'Mathias Meyer',
+            'Tijm Keller', 'Lea Gerste', 'Martin Pfeffer', 'Ulrike Abt', 'Zoubida van Rooij',
+            'Maylin Hettema', 'Ruwan Bechan', 'Marco Beich', 'Karin Busch', 'Mathias Müller'
+        ];
+        var pend_names = [
+            'Suleyman van Beusichem', 'Nicole Diederich', 'Nanja van Yperen', 'Delany Bloemendaal',
+            'Jannah Hofmeester', 'Christine Trommler', 'Martin Bumgarner', 'Emil Baeten', 'Farshad Brasser',
+            'Gabriele Fisher', 'Sofiane Schopman', 'Sky Wismans', 'Jeffery Stoelwinder', 'Ganesh Waaijenberg',
+            'Dani Boldewijn', 'Katrin Propst', 'Martina Kaiser', 'Philipp Kappel', 'Meeke Grootendorst'
+        ];
+        var cur_names = [
+            'Max Frankfurter', 'Candice van der Knijff', 'Irini Vlastuin', 'Rinse Sommer', 'Annegreet Gomez',
+            'Robin Schook', 'Marcel Eberhardt', 'Simone Brauer', 'Asmaa Haakman', 'Felix Amsel',
+            'Lena Grunewald', 'Laura Grunewald', 'Mandy Seiler', 'Sven Bosch', 'Nuriye Cuypers', 'Ben Zomer',
+            'Leah Weiss', 'Francesca Disseldorp', 'Sven Bumgarner', 'Benjamin Zweig'
+        ];
+        var num_contacts = req_names.length + pend_names.length + cur_names.length;
+        this.bare_jid = 'dummy@localhost';
+        mock_connection  = {
+            'muc': {
+                'listRooms': function () {}
+            },
+            'jid': this.bare_jid,
+            'addHandler': function (handler, ns, name, type, id, from, options) { 
+                return function () {};
+            },
+            'roster': {
+                'add': function () {},
+                'authorize': function () {},
+                'unauthorize': function () {},
+                'get': function () {},
+                'subscribe': function () {},
+                'registerCallback': function () {}
+            }
+        };
+
+        // Clear localStorage
+        window.localStorage.removeItem(
+            hex_sha1('converse.rosteritems-'+this.bare_jid));
+        window.localStorage.removeItem(
+            hex_sha1('converse.chatboxes-'+this.bare_jid));
+        window.localStorage.removeItem(
+            hex_sha1('converse.xmppstatus-'+this.bare_jid));
+
+        this.prebind = true;
+        this.onConnected(mock_connection);
+        this.animate = false; // don't use animations
+
+        // The timeout is used to slow down the tests so that one can see
+        // visually what is happening in the page.
+        var timeout = 0;
+        var sleep = function (delay) {
+            // Yes this is blocking and stupid, but these are tests and this is
+            // the easiest way to delay execution without having to use
+            // callbacks.
+            var start = new Date().getTime();
+            while (new Date().getTime() < start + delay) {
+                continue;
+            }
+        };
+
+        describe("The Contacts Roster", $.proxy(function () {
+            it("is not shown by default", $.proxy(function () {
+                expect(this.rosterview.$el.is(':visible')).toEqual(false);
+            }, xmppchat));
+
+            it("can be opened by clicking a DOM element with id 'toggle-online-users'", $.proxy(function () {
+                spyOn(this, 'toggleControlBox').andCallThrough();
+                $('#toggle-online-users').click();
+                expect(this.toggleControlBox).toHaveBeenCalled();
+            }, xmppchat));
+
+            describe("Pending Contacts", $.proxy(function () {
+                it("do not have a heading if there aren't any", $.proxy(function () {
+                    expect(this.rosterview.$el.find('dt#pending-xmpp-contacts').css('display')).toEqual('none');
+                }, xmppchat));
+
+                it("can be added to the roster and they will be sorted alphabetically", $.proxy(function () {
+                    var i, t, is_last;
+                    spyOn(this.rosterview, 'render').andCallThrough();
+                    for (i=0; i<pend_names.length; i++) {
+                        is_last = i==(pend_names.length-1);
+                        this.roster.create({
+                            jid: pend_names[i].replace(' ','.').toLowerCase() + '@localhost',
+                            subscription: 'none',
+                            ask: 'subscribe',
+                            fullname: pend_names[i],
+                            is_last: is_last
+                        });
+                        // For performance reasons, the roster should only be shown once 
+                        // the last contact has been added.
+                        if (is_last) {
+                            expect(this.rosterview.$el.is(':visible')).toEqual(true);
+                        } else {
+                            expect(this.rosterview.$el.is(':visible')).toEqual(false);
+                        }
+                        expect(this.rosterview.render).toHaveBeenCalled();
+                        // Check that they are sorted alphabetically
+                        t = this.rosterview.$el.find('dt#pending-xmpp-contacts').siblings('dd.pending-xmpp-contact').text();
+                        expect(t).toEqual(pend_names.slice(0,i+1).sort().join(''));
+                    }
+                    sleep(timeout);
+                }, xmppchat));
+
+                it("will have their own heading once they have been added", $.proxy(function () {
+                    expect(this.rosterview.$el.find('dt#pending-xmpp-contacts').css('display')).toEqual('block');
+                }, xmppchat));
+            }, xmppchat));
+
+            describe("Existing Contacts", $.proxy(function () {
+                it("do not have a heading if there aren't any", $.proxy(function () {
+                    expect(this.rosterview.$el.find('dt#xmpp-contacts').css('display')).toEqual('none');
+                }, xmppchat));
+
+                it("can be added to the roster and they will be sorted alphabetically", $.proxy(function () {
+                    var i, t;
+                    spyOn(this.rosterview, 'render').andCallThrough();
+                    for (i=0; i<cur_names.length; i++) {
+                        this.roster.create({
+                            jid: cur_names[i].replace(' ','.').toLowerCase() + '@localhost',
+                            subscription: 'both',
+                            ask: null,
+                            fullname: cur_names[i],
+                            is_last: i==(cur_names.length-1)
+                        });
+                        expect(this.rosterview.render).toHaveBeenCalled();
+                        // Check that they are sorted alphabetically
+                        t = this.rosterview.$el.find('dt#xmpp-contacts').siblings('dd.current-xmpp-contact.offline').find('a.open-chat').text();
+                        expect(t).toEqual(cur_names.slice(0,i+1).sort().join(''));
+                    }
+                    sleep(timeout);
+                }, xmppchat));
+
+                it("will have their own heading once they have been added", $.proxy(function () {
+                    expect(this.rosterview.$el.find('dt#xmpp-contacts').css('display')).toEqual('block');
+                }, xmppchat));
+
+                it("can change their status to online and be sorted alphabetically", $.proxy(function () {
+                    var item, view, jid, t;
+                    spyOn(this.rosterview, 'render').andCallThrough();
+                    for (i=0; i<5; i++) {
+                        jid = cur_names[i].replace(' ','.').toLowerCase() + '@localhost';
+                        view = this.rosterview.rosteritemviews[jid];
+                        spyOn(view, 'render').andCallThrough();
+                        item = view.model;
+                        item.set('chat_status', 'online');
+                        expect(view.render).toHaveBeenCalled();
+                        expect(this.rosterview.render).toHaveBeenCalled();
+
+                        // Check that they are sorted alphabetically
+                        t = this.rosterview.$el.find('dt#xmpp-contacts').siblings('dd.current-xmpp-contact.online').find('a.open-chat').text();
+                        expect(t).toEqual(cur_names.slice(0,i+1).sort().join(''));
+                        sleep(timeout);
+                    }
+                }, xmppchat));
+
+                it("can change their status to busy and be sorted alphabetically", $.proxy(function () {
+                    var item, view, jid, t;
+                    spyOn(this.rosterview, 'render').andCallThrough();
+                    for (i=5; i<10; i++) {
+                        jid = cur_names[i].replace(' ','.').toLowerCase() + '@localhost';
+                        view = this.rosterview.rosteritemviews[jid];
+                        spyOn(view, 'render').andCallThrough();
+                        item = view.model;
+                        item.set('chat_status', 'dnd');
+                        expect(view.render).toHaveBeenCalled();
+                        expect(this.rosterview.render).toHaveBeenCalled();
+                        // Check that they are sorted alphabetically
+                        t = this.rosterview.$el.find('dt#xmpp-contacts').siblings('dd.current-xmpp-contact.dnd').find('a.open-chat').text();
+                        expect(t).toEqual(cur_names.slice(5,i+1).sort().join(''));
+                        sleep(timeout);
+                    }
+                }, xmppchat));
+
+                it("can change their status to away and be sorted alphabetically", $.proxy(function () {
+                    var item, view, jid, t;
+                    spyOn(this.rosterview, 'render').andCallThrough();
+                    for (i=10; i<15; i++) {
+                        jid = cur_names[i].replace(' ','.').toLowerCase() + '@localhost';
+                        view = this.rosterview.rosteritemviews[jid];
+                        spyOn(view, 'render').andCallThrough();
+                        item = view.model;
+                        item.set('chat_status', 'away');
+                        expect(view.render).toHaveBeenCalled();
+                        expect(this.rosterview.render).toHaveBeenCalled();
+
+                        // Check that they are sorted alphabetically
+                        t = this.rosterview.$el.find('dt#xmpp-contacts').siblings('dd.current-xmpp-contact.away').find('a.open-chat').text();
+                        expect(t).toEqual(cur_names.slice(10,i+1).sort().join(''));
+                        sleep(timeout);
+                    }
+                }, xmppchat));
+
+                it("can change their status to unavailable and be sorted alphabetically", $.proxy(function () {
+                    var item, view, jid, t;
+                    spyOn(this.rosterview, 'render').andCallThrough();
+                    for (i=15; i<20; i++) {
+                        jid = cur_names[i].replace(' ','.').toLowerCase() + '@localhost';
+                        view = this.rosterview.rosteritemviews[jid];
+                        spyOn(view, 'render').andCallThrough();
+                        item = view.model;
+                        item.set('chat_status', 'unavailable');
+                        expect(view.render).toHaveBeenCalled();
+                        expect(this.rosterview.render).toHaveBeenCalled();
+
+                        // Check that they are sorted alphabetically
+                        t = this.rosterview.$el.find('dt#xmpp-contacts').siblings('dd.current-xmpp-contact.unavailable').find('a.open-chat').text();
+                        expect(t).toEqual(cur_names.slice(15, i+1).sort().join(''));
+                        sleep(timeout);
+                    }
+                }, xmppchat));
+
+                it("are ordered according to status: online, busy, away, unavailable, offline", $.proxy(function () {
+                    var contacts = this.rosterview.$el.find('dd.current-xmpp-contact');
+                    var i;
+                    // The first five contacts are online.
+                    for (i=0; i<5; i++) {
+                        expect($(contacts[i]).attr('class').split(' ',1)[0]).toEqual('online');
+                    }
+                    // The next five are busy
+                    for (i=5; i<10; i++) {
+                        expect($(contacts[i]).attr('class').split(' ',1)[0]).toEqual('dnd');
+                    }
+                    // The next five are away
+                    for (i=10; i<15; i++) {
+                        expect($(contacts[i]).attr('class').split(' ',1)[0]).toEqual('away');
+                    }
+                    // The next five are unavailable
+                    for (i=15; i<20; i++) {
+                        expect($(contacts[i]).attr('class').split(' ',1)[0]).toEqual('unavailable');
+                    }
+                    // The next 20 are offline
+                    for (i=20; i<cur_names.length; i++) {
+                        expect($(contacts[i]).attr('class').split(' ',1)[0]).toEqual('offline');
+                    }
+                }, xmppchat));
+
+
+            }, xmppchat));
+
+            describe("Requesting Contacts", $.proxy(function () {
+                // by default the dts are hidden from css class and only later they will be hidden
+                // by jQuery therefore for the first check we will see if visible instead of none
+                it("do not have a heading if there aren't any", $.proxy(function () {
+                    expect(this.rosterview.$el.find('dt#xmpp-contact-requests').is(':visible')).toEqual(false);
+                }, xmppchat));
+
+                it("can be added to the roster and they will be sorted alphabetically", $.proxy(function () {
+                    var i, t;
+                    spyOn(this.rosterview, 'render').andCallThrough();
+                    spyOn(this, 'showControlBox').andCallThrough();
+                    for (i=0; i<req_names.length; i++) {
+                        this.roster.create({
+                            jid: req_names[i].replace(' ','.').toLowerCase() + '@localhost',
+                            subscription: 'none',
+                            ask: 'request',
+                            fullname: req_names[i],
+                            is_last: i==(req_names.length-1)
+                        });
+                        expect(this.rosterview.render).toHaveBeenCalled();
+                        // Check that they are sorted alphabetically
+                        t = this.rosterview.$el.find('dt#xmpp-contact-requests').siblings('dd.requesting-xmpp-contact').text().replace(/AcceptDecline/g, '');
+                        expect(t).toEqual(req_names.slice(0,i+1).sort().join(''));
+                        // When a requesting contact is added, the controlbox must
+                        // be opened.
+                        expect(this.showControlBox).toHaveBeenCalled();
+                    }
+                    sleep(timeout);
+                }, xmppchat));
+
+                it("will have their own heading once they have been added", $.proxy(function () {
+                    expect(this.rosterview.$el.find('dt#xmpp-contact-requests').css('display')).toEqual('block');
+                }, xmppchat));
+
+                it("can have their requests accepted by the user", $.proxy(function () {
+                    // TODO: Testing can be more thorough here, the user is
+                    // actually not accepted/authorized because of
+                    // mock_connection.
+                    var jid = req_names.sort()[0].replace(' ','.').toLowerCase() + '@localhost';
+                    var view = this.rosterview.rosteritemviews[jid];
+                    spyOn(this.connection.roster, 'authorize');
+                    spyOn(view, 'acceptRequest').andCallThrough();
+                    view.delegateEvents(); // We need to rebind all events otherwise our spy won't be called
+                    var accept_button = view.$el.find('.accept-xmpp-request');
+                    accept_button.click();
+                    expect(view.acceptRequest).toHaveBeenCalled();
+                    expect(this.connection.roster.authorize).toHaveBeenCalled();
+                    sleep(timeout);
+                }, xmppchat));
+
+                it("can have their requests denied by the user", $.proxy(function () {
+                    var jid = req_names.sort()[1].replace(' ','.').toLowerCase() + '@localhost';
+                    var view = this.rosterview.rosteritemviews[jid];
+                    spyOn(this.connection.roster, 'unauthorize');
+                    spyOn(this.rosterview, 'removeRosterItem').andCallThrough();
+                    spyOn(view, 'declineRequest').andCallThrough();
+                    view.delegateEvents(); // We need to rebind all events otherwise our spy won't be called
+                    var accept_button = view.$el.find('.decline-xmpp-request');
+                    accept_button.click();
+                    expect(view.declineRequest).toHaveBeenCalled();
+                    expect(this.rosterview.removeRosterItem).toHaveBeenCalled();
+                    expect(this.connection.roster.unauthorize).toHaveBeenCalled();
+                    // There should now be one less contact
+                    expect(this.roster.length).toEqual(num_contacts-1); 
+                    sleep(timeout);
+                }, xmppchat));
+            }, xmppchat));
+
+            describe("All Contacts", $.proxy(function () {
+
+                it("are saved to, and can be retrieved from, localStorage", $.proxy(function () {
+                    var new_attrs, old_attrs, attrs, old_roster;
+                    // One contact was declined, so we have 1 less contact then originally
+                    expect(this.roster.length).toEqual(num_contacts-1); 
+                    old_roster = this.roster;
+                    this.roster = new this.RosterItems();
+                    expect(this.roster.length).toEqual(0);
+
+                    this.roster.localStorage = new Backbone.LocalStorage(
+                        hex_sha1('converse.rosteritems-dummy@localhost'));
+                    this.chatboxes.onConnected();
+
+                    spyOn(this.roster, 'fetch').andCallThrough();
+                    this.rosterview = new this.RosterView({'model':this.roster});
+                    expect(this.roster.fetch).toHaveBeenCalled();
+                    expect(this.roster.length).toEqual(num_contacts-1);
+
+                    // Check that the roster items retrieved from localStorage
+                    // have the same attributes values as the original ones.
+                    attrs = ['jid', 'fullname', 'subscription', 'ask'];
+                    for (i=0; i<attrs.length; i++) {
+                        new_attrs = _.pluck(_.pluck(this.roster.models, 'attributes'), attrs[i]);
+                        old_attrs = _.pluck(_.pluck(old_roster.models, 'attributes'), attrs[i]);
+                        // Roster items in storage are not necessarily sorted,
+                        // so we have to sort them here to do a proper
+                        // comparison
+                        expect(_.isEqual(new_attrs.sort(), old_attrs.sort())).toEqual(true);
+                    }
+                    this.rosterview.render();
+                }, xmppchat));
+
+                afterEach($.proxy(function () {
+                    // Contacts retrieved from localStorage have chat_status of
+                    // "offline". 
+                    // In the next test suite, we need some online contacts, so
+                    // we make some online now
+                    for (i=0; i<5; i++) {
+                        jid = cur_names[i].replace(' ','.').toLowerCase() + '@localhost';
+                        view = this.rosterview.rosteritemviews[jid];
+                        view.model.set('chat_status', 'online');
+                    }
+                }, xmppchat));
+            }, xmppchat));
+        }, xmppchat));
+
+        describe("Chatboxes", $.proxy(function () {
+
+            it("are created when you click on a roster item", $.proxy(function () {
+                var i, $el, click, jid, view;
+                // showControlBox was called earlier, so the controlbox is
+                // visible, but no other chat boxes have been created.
+                expect(this.chatboxes.length).toEqual(1);
+
+                var online_contacts = this.rosterview.$el.find('dt#xmpp-contacts').siblings('dd.current-xmpp-contact.online').find('a.open-chat');
+                for (i=0; i<online_contacts.length; i++) {
+                    $el = $(online_contacts[i]);
+                    jid = $el.text().replace(' ','.').toLowerCase() + '@localhost';
+                    view = this.rosterview.rosteritemviews[jid];
+                    spyOn(view, 'openChat').andCallThrough();
+                    view.delegateEvents(); // We need to rebind all events otherwise our spy won't be called
+                    $el.click();
+                    expect(view.openChat).toHaveBeenCalled();
+                    expect(this.chatboxes.length).toEqual(i+2);
+                    sleep(timeout);
+                }
+            }, xmppchat));
+
+            it("can be saved to, and retrieved from, localStorage", $.proxy(function () {
+                var old_chatboxes = this.chatboxes;
+                expect(this.chatboxes.length).toEqual(6);
+                this.chatboxes = new this.ChatBoxes();
+                expect(this.chatboxes.length).toEqual(0);
+
+                this.chatboxes.onConnected();
+                expect(this.chatboxes.length).toEqual(6);
+
+                // Check that the roster items retrieved from localStorage
+                // have the same attributes values as the original ones.
+                attrs = ['id', 'box_id', 'visible'];
+                for (i=0; i<attrs.length; i++) {
+                    new_attrs = _.pluck(_.pluck(this.chatboxes.models, 'attributes'), attrs[i]);
+                    old_attrs = _.pluck(_.pluck(old_chatboxes.models, 'attributes'), attrs[i]);
+                    expect(_.isEqual(new_attrs, old_attrs)).toEqual(true);
+                }
+                this.rosterview.render();
+            }, xmppchat));
+
+            it("can be closed again by clicking a DOM element with class 'close-chatbox-button'", $.proxy(function () {
+                var chatbox, view, $el;
+                for (i=0; i<this.chatboxes.length; i++) {
+                    chatbox = this.chatboxes.models[i];
+                    view = this.chatboxesview.views[chatbox.get('id')];
+                    spyOn(view, 'closeChat').andCallThrough();
+                    view.delegateEvents(); // We need to rebind all events otherwise our spy won't be called
+                    view.$el.find('.close-chatbox-button').click();
+                    expect(view.closeChat).toHaveBeenCalled();
+                    sleep(timeout);
+                }
+            }, xmppchat));
+
+            it("will be removed from localStorage when closed", $.proxy(function () {
+                var old_chatboxes = this.chatboxes;
+                expect(this.chatboxes.length).toEqual(6);
+                this.chatboxes = new this.ChatBoxes();
+                expect(this.chatboxes.length).toEqual(0);
+
+                this.chatboxes.onConnected();
+                expect(this.chatboxes.length).toEqual(0);
+            }, xmppchat));
+        }, xmppchat));
+
+    }, xmppchat));
+}));

stylesheets/stylesheet.css

@@ -126,12 +126,12 @@ a {
 
 #main_content a:hover {
   color: #0069ba;
-  text-shadow: #0090ff 0px 0px 2px;
+  text-shadow: #5390c8 0px 0px 2px;
 }
 
 footer a:hover {
   color: #43adff;
-  text-shadow: #0090ff 0px 0px 2px;
+  text-shadow: #5390c8 0px 0px 2px;
 }
 
 em {
@@ -284,7 +284,7 @@ Full-Width Styles
   z-index: 10;
   padding: 10px 50px 10px 10px;
   color: #fff;
-  background: url('../images/blacktocat.png') #0090ff no-repeat 95% 50%;
+  background: url('../images/blacktocat.png') #5390c8 no-repeat 95% 50%;
   font-weight: 700;
   box-shadow: 0 0 10px rgba(0,0,0,.5);
   border-bottom-left-radius: 2px;

tests.html

+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+  "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+    <title>Converse.js Tests</title>
+    <meta name="description" content="Converse.js: Open Source Browser-Based Instant Messaging" />
+    <link rel="shortcut icon" type="image/png" href="Libraries/jasmine-1.3.1/jasmine_favicon.png">
+    <link rel="stylesheet" type="text/css" href="Libraries/jasmine-1.3.1/jasmine.css">
+    <script type="text/javascript" src="Libraries/jasmine-1.3.1/jasmine.js"></script>
+    <script type="text/javascript" src="Libraries/jasmine-1.3.1/jasmine-html.js"></script>
+    <link rel="stylesheet" type="text/css" media="screen" href="stylesheets/stylesheet.css">
+    <link rel="stylesheet" type="text/css" media="screen" href="converse.css">
+    <script data-main="tests_main" src="Libraries/require-jquery.js"></script>
+</head>
+
+<body>
+    <div id="header_wrap" class="outer">
+        <header class="inner">
+          <h1 id="project_title">Converse.js</h1>
+          <h2 id="project_tagline">Tests</h2>
+        </header>
+    </div>
+
+    <div id="chatpanel">
+        <div id="collective-xmpp-chat-data"></div>
+        <div id="toggle-controlbox">
+            <a href="#" class="chat" id="toggle-online-users">
+                <span class="conn-feedback">Click here to chat</span> <strong style="display: none" id="online-count">(0)</strong>
+            </a>
+        </div>
+    </div>
+</body>
+</html>

tests_main.js

+require(["jquery", "spec/MainSpec"], function($) {
+
+    $(function($) {
+        var jasmineEnv = jasmine.getEnv();
+        jasmineEnv.updateInterval = 1000;
+
+        var htmlReporter = new jasmine.HtmlReporter();
+
+        jasmineEnv.addReporter(htmlReporter);
+
+        jasmineEnv.specFilter = function(spec) {
+            return htmlReporter.specFilter(spec);
+        };
+        jasmineEnv.execute();
+    });
+});