/*! messenger 1.5.0 */
/*
 * this file begins the output concatenated into messenger.js
 *
 * it establishes the messenger object while preserving whatever it was before
 * (for noconflict), and making it a callable function.
 */

(function(){
    var _prevmessenger = window.messenger;
    var localmessenger;

    localmessenger = window.messenger = function(){
        return localmessenger._call.apply(this, arguments);
    }

    window.messenger.noconflict = function(){
        window.messenger = _prevmessenger;

        return localmessenger;
    }
})();

/*
 * this file contains shims for when underscore and backbone
 * are not included.
 *
 * portions taken from underscore.js and backbone.js
 * both of which are copyright (c) 2009-2013 jeremy ashkenas, documentcloud
 */
window.messenger._ = (function() {
    if (window._)
        return window._

    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 _ = {};

    // establish the object that gets returned to break out of a loop iteration.
    var breaker = {};
  
    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;
                }
            }
        }
    };

    _.result = function(object, property) {
        if (object == null) return null;
        var value = object[property];
        return _.isfunction(value) ? value.call(object) : value;
    };

    _.once = function(func) {
        var ran = false, memo;
        return function() {
            if (ran) return memo;
            ran = true;
            memo = func.apply(this, arguments);
            func = null;
            return memo;
        };
    };

    var idcounter = 0;
    _.uniqueid = function(prefix) {
        var id = ++idcounter + '';
        return prefix ? prefix + id : id;
    };

    _.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;
    };

    // 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 + ']';
        };
    });

    _.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;
    };

    _.extend = function(obj) {
        each(slice.call(arguments, 1), function(source) {
            if (source) {
                for (var prop in source) {
                    obj[prop] = source[prop];
                }
            }
        });
        return obj;
    };

    _.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;
    };

    _.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)));
        };
    };

    _.isobject = function(obj) {
        return obj === object(obj);
    };

    return _;
})();

window.messenger.events = (function() {
    if (window.backbone && backbone.events) {
        return backbone.events;
    }

    var eventsshim = function() {
        var eventsplitter = /\s+/;

        var eventsapi = function(obj, action, name, rest) {
            if (!name) return true;
            if (typeof name === 'object') {
                for (var key in name) {
                    obj[action].apply(obj, [key, name[key]].concat(rest));
                }
            } else 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));
                }
            } else {
                return true;
            }
        };

        var triggerevents = function(events, args) {
            var ev, i = -1, l = events.length;
            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, args[0]);
            return;
            case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1]);
            return;
            case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1], args[2]);
            return;
            default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
            }
        };

        var events = {

            on: function(name, callback, context) {
                if (!(eventsapi(this, 'on', name, [callback, context]) && callback)) return this;
                this._events || (this._events = {});
                var list = this._events[name] || (this._events[name] = []);
                list.push({callback: callback, context: context, ctx: context || this});
                return this;
            },

            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;
                this.on(name, once, context);
                return this;
            },

            off: function(name, callback, context) {
                var list, 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 (list = this._events[name]) {
                        events = [];
                        if (callback || context) {
                            for (j = 0, k = list.length; j < k; j++) {
                                ev = list[j];
                                if ((callback && callback !== ev.callback &&
                                                                 callback !== ev.callback._callback) ||
                                        (context && context !== ev.context)) {
                                    events.push(ev);
                                }
                            }
                        }
                        this._events[name] = events;
                    }
                }

                return this;
            },

            trigger: function(name) {
                if (!this._events) return this;
                var args = array.prototype.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;
            },

            listento: function(obj, name, callback) {
                var listeners = this._listeners || (this._listeners = {});
                var id = obj._listenerid || (obj._listenerid = _.uniqueid('l'));
                listeners[id] = obj;
                obj.on(name, typeof name === 'object' ? this : callback, this);
                return this;
            },

            stoplistening: function(obj, name, callback) {
                var listeners = this._listeners;
                if (!listeners) return;
                if (obj) {
                    obj.off(name, typeof name === 'object' ? this : callback, this);
                    if (!name && !callback) delete listeners[obj._listenerid];
                } else {
                    if (typeof name === 'object') callback = this;
                    for (var id in listeners) {
                        listeners[id].off(name, callback, this);
                    }
                    this._listeners = {};
                }
                return this;
            }
        };

        events.bind   = events.on;
        events.unbind = events.off;
        return events;
    };
    return eventsshim();
})();

(function() {
  var $, actionmessenger, baseview, events, retryingmessage, _, _message, _messenger, _ref, _ref1, _ref2,
    __hasprop = {}.hasownproperty,
    __extends = function(child, parent) { for (var key in parent) { if (__hasprop.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    __slice = [].slice,
    __indexof = [].indexof || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };

  $ = jquery;

  _ = (_ref = window._) != null ? _ref : window.messenger._;

  events = (_ref1 = typeof backbone !== "undefined" && backbone !== null ? backbone.events : void 0) != null ? _ref1 : window.messenger.events;

  baseview = (function() {

    function baseview(options) {
      $.extend(this, events);
      if (_.isobject(options)) {
        if (options.el) {
          this.setelement(options.el);
        }
        this.model = options.model;
      }
      this.initialize.apply(this, arguments);
    }

    baseview.prototype.setelement = function(el) {
      this.$el = $(el);
      return this.el = this.$el[0];
    };

    baseview.prototype.delegateevents = function(events) {
      var delegateeventsplitter, eventname, key, match, method, selector, _results;
      if (!(events || (events = _.result(this, "events")))) {
        return;
      }
      this.undelegateevents();
      delegateeventsplitter = /^(\s+)\s*(.*)$/;
      _results = [];
      for (key in events) {
        method = events[key];
        if (!_.isfunction(method)) {
          method = this[events[key]];
        }
        if (!method) {
          throw new error("method \"" + events[key] + "\" does not exist");
        }
        match = key.match(delegateeventsplitter);
        eventname = match[1];
        selector = match[2];
        method = _.bind(method, this);
        eventname += ".delegateevents" + this.cid;
        if (selector === '') {
          _results.push(this.jqon(eventname, method));
        } else {
          _results.push(this.jqon(eventname, selector, method));
        }
      }
      return _results;
    };

    baseview.prototype.jqon = function(eventname, selector, method) {
      var _ref2;
      if (this.$el.on != null) {
        return (_ref2 = this.$el).on.apply(_ref2, arguments);
      } else {
        if (!(method != null)) {
          method = selector;
          selector = void 0;
        }
        if (selector != null) {
          return this.$el.delegate(selector, eventname, method);
        } else {
          return this.$el.bind(eventname, method);
        }
      }
    };

    baseview.prototype.jqoff = function(eventname) {
      var _ref2;
      if (this.$el.off != null) {
        return (_ref2 = this.$el).off.apply(_ref2, arguments);
      } else {
        this.$el.undelegate();
        return this.$el.unbind(eventname);
      }
    };

    baseview.prototype.undelegateevents = function() {
      return this.jqoff(".delegateevents" + this.cid);
    };

    baseview.prototype.remove = function() {
      this.undelegateevents();
      return this.$el.remove();
    };

    return baseview;

  })();

  _message = (function(_super) {

    __extends(_message, _super);

    function _message() {
      return _message.__super__.constructor.apply(this, arguments);
    }

    _message.prototype.defaults = {
      hideafter: 10,
      scroll: true,
      closebuttontext: "&times;",
      escapetext: false
    };

    _message.prototype.initialize = function(opts) {
      if (opts == null) {
        opts = {};
      }
      this.shown = false;
      this.rendered = false;
      this.messenger = opts.messenger;
      return this.options = $.extend({}, this.options, opts, this.defaults);
    };

    _message.prototype.show = function() {
      var wasshown;
      if (!this.rendered) {
        this.render();
      }
      this.$message.removeclass('messenger-hidden');
      wasshown = this.shown;
      this.shown = true;
      if (!wasshown) {
        return this.trigger('show');
      }
    };

    _message.prototype.hide = function() {
      var wasshown;
      if (!this.rendered) {
        return;
      }
      this.$message.addclass('messenger-hidden');
      wasshown = this.shown;
      this.shown = false;
      if (wasshown) {
        return this.trigger('hide');
      }
    };

    _message.prototype.cancel = function() {
      return this.hide();
    };

    _message.prototype.update = function(opts) {
      var _ref2,
        _this = this;
      if (_.isstring(opts)) {
        opts = {
          message: opts
        };
      }
      $.extend(this.options, opts);
      this.lastupdate = new date();
      this.rendered = false;
      this.events = (_ref2 = this.options.events) != null ? _ref2 : {};
      this.render();
      this.actionstoevents();
      this.delegateevents();
      this.checkclickable();
      if (this.options.hideafter) {
        this.$message.addclass('messenger-will-hide-after');
        if (this._hidetimeout != null) {
          cleartimeout(this._hidetimeout);
        }
        this._hidetimeout = settimeout(function() {
          return _this.hide();
        }, this.options.hideafter * 1000);
      } else {
        this.$message.removeclass('messenger-will-hide-after');
      }
      if (this.options.hideonnavigate) {
        this.$message.addclass('messenger-will-hide-on-navigate');
        if ((typeof backbone !== "undefined" && backbone !== null ? backbone.history : void 0) != null) {
          backbone.history.on('route', function() {
            return _this.hide();
          });
        }
      } else {
        this.$message.removeclass('messenger-will-hide-on-navigate');
      }
      return this.trigger('update', this);
    };

    _message.prototype.scrollto = function() {
      if (!this.options.scroll) {
        return;
      }
      return $.scrollto(this.$el, {
        duration: 400,
        offset: {
          left: 0,
          top: -20
        }
      });
    };

    _message.prototype.timesinceupdate = function() {
      if (this.lastupdate) {
        return (new date) - this.lastupdate;
      } else {
        return null;
      }
    };

    _message.prototype.actionstoevents = function() {
      var act, name, _ref2, _results,
        _this = this;
      _ref2 = this.options.actions;
      _results = [];
      for (name in _ref2) {
        act = _ref2[name];
        _results.push(this.events["click [data-action=\"" + name + "\"] a"] = (function(act) {
          return function(e) {
            e.preventdefault();
            e.stoppropagation();
            _this.trigger("action:" + name, act, e);
            return act.action.call(_this, e, _this);
          };
        })(act));
      }
      return _results;
    };

    _message.prototype.checkclickable = function() {
      var evt, name, _ref2, _results;
      _ref2 = this.events;
      _results = [];
      for (name in _ref2) {
        evt = _ref2[name];
        if (name === 'click') {
          _results.push(this.$message.addclass('messenger-clickable'));
        } else {
          _results.push(void 0);
        }
      }
      return _results;
    };

    _message.prototype.undelegateevents = function() {
      var _ref2;
      _message.__super__.undelegateevents.apply(this, arguments);
      return (_ref2 = this.$message) != null ? _ref2.removeclass('messenger-clickable') : void 0;
    };

    _message.prototype.parseactions = function() {
      var act, actions, n_act, name, _ref2, _ref3;
      actions = [];
      _ref2 = this.options.actions;
      for (name in _ref2) {
        act = _ref2[name];
        n_act = $.extend({}, act);
        n_act.name = name;
        if ((_ref3 = n_act.label) == null) {
          n_act.label = name;
        }
        actions.push(n_act);
      }
      return actions;
    };

    _message.prototype.template = function(opts) {
      var $action, $actions, $cancel, $link, $message, $text, action, _i, _len, _ref2,
        _this = this;
      $message = $("<div class='messenger-message message alert " + opts.type + " message-" + opts.type + " alert-" + opts.type + "'>");
      if (opts.showclosebutton) {
        $cancel = $('<button type="button" class="messenger-close" data-dismiss="alert">');
        $cancel.html(opts.closebuttontext);
        $cancel.click(function() {
          var _base;
          _this.cancel();
          if (typeof (_base = _this.options).onclickclose === "function") {
            _base.onclickclose();
          }
          return true;
        });
        $message.append($cancel);
      }
      if (opts.escapetext) {
        $text = $('<div class="messenger-message-inner"></div>').text(opts.message);
      } else {
        $text = $("<div class=\"messenger-message-inner\">" + opts.message + "</div>");
      }
      $message.append($text);
      if (opts.actions.length) {
        $actions = $('<div class="messenger-actions">');
      }
      _ref2 = opts.actions;
      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
        action = _ref2[_i];
        $action = $('<span>');
        $action.attr('data-action', "" + action.name);
        $link = $('<a>');
        $link.html(action.label);
        $action.append($('<span class="messenger-phrase">'));
        $action.append($link);
        $actions.append($action);
      }
      $message.append($actions);
      return $message;
    };

    _message.prototype.render = function() {
      var opts;
      if (this.rendered) {
        return;
      }
      if (!this._hasslot) {
        this.setelement(this.messenger._reservemessageslot(this));
        this._hasslot = true;
      }
      opts = $.extend({}, this.options, {
        actions: this.parseactions()
      });
      this.$message = $(this.template(opts));
      this.$el.html(this.$message);
      this.shown = true;
      this.rendered = true;
      return this.trigger('render');
    };

    return _message;

  })(baseview);

  retryingmessage = (function(_super) {

    __extends(retryingmessage, _super);

    function retryingmessage() {
      return retryingmessage.__super__.constructor.apply(this, arguments);
    }

    retryingmessage.prototype.initialize = function() {
      retryingmessage.__super__.initialize.apply(this, arguments);
      return this._timers = {};
    };

    retryingmessage.prototype.cancel = function() {
      this.cleartimers();
      this.hide();
      if ((this._actioninstance != null) && (this._actioninstance.abort != null)) {
        return this._actioninstance.abort();
      }
    };

    retryingmessage.prototype.cleartimers = function() {
      var name, timer, _ref2, _ref3;
      _ref2 = this._timers;
      for (name in _ref2) {
        timer = _ref2[name];
        cleartimeout(timer);
      }
      this._timers = {};
      return (_ref3 = this.$message) != null ? _ref3.removeclass('messenger-retry-soon messenger-retry-later') : void 0;
    };

    retryingmessage.prototype.render = function() {
      var action, name, _ref2, _results;
      retryingmessage.__super__.render.apply(this, arguments);
      this.cleartimers();
      _ref2 = this.options.actions;
      _results = [];
      for (name in _ref2) {
        action = _ref2[name];
        if (action.auto) {
          _results.push(this.startcountdown(name, action));
        } else {
          _results.push(void 0);
        }
      }
      return _results;
    };

    retryingmessage.prototype.renderphrase = function(action, time) {
      var phrase;
      phrase = action.phrase.replace('time', this.formattime(time));
      return phrase;
    };

    retryingmessage.prototype.formattime = function(time) {
      var pluralize;
      pluralize = function(num, str) {
        num = math.floor(num);
        if (num !== 1) {
          str = str + 's';
        }
        return 'in ' + num + ' ' + str;
      };
      if (math.floor(time) === 0) {
        return 'now...';
      }
      if (time < 60) {
        return pluralize(time, 'second');
      }
      time /= 60;
      if (time < 60) {
        return pluralize(time, 'minute');
      }
      time /= 60;
      return pluralize(time, 'hour');
    };

    retryingmessage.prototype.startcountdown = function(name, action) {
      var $phrase, remaining, tick, _ref2,
        _this = this;
      if (this._timers[name] != null) {
        return;
      }
      $phrase = this.$message.find("[data-action='" + name + "'] .messenger-phrase");
      remaining = (_ref2 = action.delay) != null ? _ref2 : 3;
      if (remaining <= 10) {
        this.$message.removeclass('messenger-retry-later');
        this.$message.addclass('messenger-retry-soon');
      } else {
        this.$message.removeclass('messenger-retry-soon');
        this.$message.addclass('messenger-retry-later');
      }
      tick = function() {
        var delta;
        $phrase.text(_this.renderphrase(action, remaining));
        if (remaining > 0) {
          delta = math.min(remaining, 1);
          remaining -= delta;
          return _this._timers[name] = settimeout(tick, delta * 1000);
        } else {
          _this.$message.removeclass('messenger-retry-soon messenger-retry-later');
          delete _this._timers[name];
          return action.action();
        }
      };
      return tick();
    };

    return retryingmessage;

  })(_message);

  _messenger = (function(_super) {

    __extends(_messenger, _super);

    function _messenger() {
      return _messenger.__super__.constructor.apply(this, arguments);
    }

    _messenger.prototype.tagname = 'ul';

    _messenger.prototype.classname = 'messenger';

    _messenger.prototype.messagedefaults = {
      type: 'info'
    };

    _messenger.prototype.initialize = function(options) {
      this.options = options != null ? options : {};
      this.history = [];
      return this.messagedefaults = $.extend({}, this.messagedefaults, this.options.messagedefaults);
    };

    _messenger.prototype.render = function() {
      return this.updatemessageslotclasses();
    };

    _messenger.prototype.findbyid = function(id) {
      return _.filter(this.history, function(rec) {
        return rec.msg.options.id === id;
      });
    };

    _messenger.prototype._reservemessageslot = function(msg) {
      var $slot, dmsg,
        _this = this;
      $slot = $('<li>');
      $slot.addclass('messenger-message-slot');
      this.$el.prepend($slot);
      this.history.push({
        msg: msg,
        $slot: $slot
      });
      this._enforceidconstraint(msg);
      msg.on('update', function() {
        return _this._enforceidconstraint(msg);
      });
      while (this.options.maxmessages && this.history.length > this.options.maxmessages) {
        dmsg = this.history.shift();
        dmsg.msg.remove();
        dmsg.$slot.remove();
      }
      return $slot;
    };

    _messenger.prototype._enforceidconstraint = function(msg) {
      var entry, _i, _len, _msg, _ref2;
      if (msg.options.id == null) {
        return;
      }
      _ref2 = this.history;
      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
        entry = _ref2[_i];
        _msg = entry.msg;
        if ((_msg.options.id != null) && _msg.options.id === msg.options.id && msg !== _msg) {
          if (msg.options.singleton) {
            msg.hide();
            return;
          } else {
            _msg.hide();
          }
        }
      }
    };

    _messenger.prototype.newmessage = function(opts) {
      var msg, _ref2, _ref3, _ref4,
        _this = this;
      if (opts == null) {
        opts = {};
      }
      opts.messenger = this;
      _message = (_ref2 = (_ref3 = messenger.themes[(_ref4 = opts.theme) != null ? _ref4 : this.options.theme]) != null ? _ref3.message : void 0) != null ? _ref2 : retryingmessage;
      msg = new _message(opts);
      msg.on('show', function() {
        if (opts.scrollto && _this.$el.css('position') !== 'fixed') {
          return msg.scrollto();
        }
      });
      msg.on('hide show render', this.updatemessageslotclasses, this);
      return msg;
    };

    _messenger.prototype.updatemessageslotclasses = function() {
      var anyshown, last, rec, willbefirst, _i, _len, _ref2;
      willbefirst = true;
      last = null;
      anyshown = false;
      _ref2 = this.history;
      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
        rec = _ref2[_i];
        rec.$slot.removeclass('messenger-first messenger-last messenger-shown');
        if (rec.msg.shown && rec.msg.rendered) {
          rec.$slot.addclass('messenger-shown');
          anyshown = true;
          last = rec;
          if (willbefirst) {
            willbefirst = false;
            rec.$slot.addclass('messenger-first');
          }
        }
      }
      if (last != null) {
        last.$slot.addclass('messenger-last');
      }
      return this.$el["" + (anyshown ? 'remove' : 'add') + "class"]('messenger-empty');
    };

    _messenger.prototype.hideall = function() {
      var rec, _i, _len, _ref2, _results;
      _ref2 = this.history;
      _results = [];
      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
        rec = _ref2[_i];
        _results.push(rec.msg.hide());
      }
      return _results;
    };

    _messenger.prototype.post = function(opts) {
      var msg;
      if (_.isstring(opts)) {
        opts = {
          message: opts
        };
      }
      opts = $.extend(true, {}, this.messagedefaults, opts);
      msg = this.newmessage(opts);
      msg.update(opts);
      return msg;
    };

    return _messenger;

  })(baseview);

  actionmessenger = (function(_super) {

    __extends(actionmessenger, _super);

    function actionmessenger() {
      return actionmessenger.__super__.constructor.apply(this, arguments);
    }

    actionmessenger.prototype.dodefaults = {
      progressmessage: null,
      successmessage: null,
      errormessage: "error connecting to the server.",
      showsuccesswithouterror: true,
      retry: {
        auto: true,
        allow: true
      },
      action: $.ajax
    };

    actionmessenger.prototype.hookbackboneajax = function(msgr_opts) {
      var _ajax,
        _this = this;
      if (msgr_opts == null) {
        msgr_opts = {};
      }
      if (!(window.backbone != null)) {
        throw 'expected backbone to be defined';
      }
      msgr_opts = _.defaults(msgr_opts, {
        id: 'backbone_action',
        errormessage: false,
        successmessage: "request completed successfully.",
        showsuccesswithouterror: false
      });
      _ajax = function(options) {
        var sync_msgr_opts;
        sync_msgr_opts = _.extend({}, msgr_opts, options.messenger);
        return _this["do"](sync_msgr_opts, options);
      };
      if (backbone.ajax != null) {
        if (backbone.ajax._withoutmessenger) {
          backbone.ajax = backbone.ajax._withoutmessenger;
        }
        if (!(msgr_opts.action != null) || msgr_opts.action === this.dodefaults.action) {
          msgr_opts.action = backbone.ajax;
        }
        _ajax._withoutmessenger = backbone.ajax;
        return backbone.ajax = _ajax;
      } else {
        return backbone.sync = _.wrap(backbone.sync, function() {
          var args, _old_ajax, _old_sync;
          _old_sync = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
          _old_ajax = $.ajax;
          $.ajax = _ajax;
          _old_sync.call.apply(_old_sync, [this].concat(__slice.call(args)));
          return $.ajax = _old_ajax;
        });
      }
    };

    actionmessenger.prototype._gethandlerresponse = function(returnval) {
      if (returnval === false) {
        return false;
      }
      if (returnval === true || !(returnval != null)) {
        return true;
      }
      return returnval;
    };

    actionmessenger.prototype._parseevents = function(events) {
      var desc, firstspace, func, label, out, type, _ref2;
      if (events == null) {
        events = {};
      }
      out = {};
      for (label in events) {
        func = events[label];
        firstspace = label.indexof(' ');
        type = label.substring(0, firstspace);
        desc = label.substring(firstspace + 1);
        if ((_ref2 = out[type]) == null) {
          out[type] = {};
        }
        out[type][desc] = func;
      }
      return out;
    };

    actionmessenger.prototype._normalizeresponse = function() {
      var data, elem, resp, type, xhr, _i, _len;
      resp = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      type = null;
      xhr = null;
      data = null;
      for (_i = 0, _len = resp.length; _i < _len; _i++) {
        elem = resp[_i];
        if (elem === 'success' || elem === 'timeout' || elem === 'abort') {
          type = elem;
        } else if (((elem != null ? elem.readystate : void 0) != null) && ((elem != null ? elem.responsetext : void 0) != null)) {
          xhr = elem;
        } else if (_.isobject(elem)) {
          data = elem;
        }
      }
      return [type, data, xhr];
    };

    actionmessenger.prototype.run = function() {
      var args, events, getmessagetext, handler, handlers, m_opts, msg, old, opts, type, _ref2,
        _this = this;
      m_opts = arguments[0], opts = arguments[1], args = 3 <= arguments.length ? __slice.call(arguments, 2) : [];
      if (opts == null) {
        opts = {};
      }
      m_opts = $.extend(true, {}, this.messagedefaults, this.dodefaults, m_opts != null ? m_opts : {});
      events = this._parseevents(m_opts.events);
      getmessagetext = function(type, xhr) {
        var message;
        message = m_opts[type + 'message'];
        if (_.isfunction(message)) {
          return message.call(_this, type, xhr);
        }
        return message;
      };
      msg = (_ref2 = m_opts.messageinstance) != null ? _ref2 : this.newmessage(m_opts);
      if (m_opts.id != null) {
        msg.options.id = m_opts.id;
      }
      if (m_opts.progressmessage != null) {
        msg.update($.extend({}, m_opts, {
          message: getmessagetext('progress', null),
          type: 'info'
        }));
      }
      handlers = {};
      _.each(['error', 'success'], function(type) {
        var originalhandler;
        originalhandler = opts[type];
        return handlers[type] = function() {
          var data, defaultopts, handlerresp, msgopts, reason, resp, responseopts, xhr, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9;
          resp = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
          _ref3 = _this._normalizeresponse.apply(_this, resp), reason = _ref3[0], data = _ref3[1], xhr = _ref3[2];
          if (type === 'success' && !(msg.errorcount != null) && m_opts.showsuccesswithouterror === false) {
            m_opts['successmessage'] = null;
          }
          if (type === 'error') {
            if ((_ref4 = m_opts.errorcount) == null) {
              m_opts.errorcount = 0;
            }
            m_opts.errorcount += 1;
          }
          handlerresp = m_opts.returnspromise ? resp[0] : typeof originalhandler === "function" ? originalhandler.apply(null, resp) : void 0;
          responseopts = _this._gethandlerresponse(handlerresp);
          if (_.isstring(responseopts)) {
            responseopts = {
              message: responseopts
            };
          }
          if (type === 'error' && ((xhr != null ? xhr.status : void 0) === 0 || reason === 'abort')) {
            msg.hide();
            return;
          }
          if (type === 'error' && ((m_opts.ignorederrorcodes != null) && (_ref5 = xhr != null ? xhr.status : void 0, __indexof.call(m_opts.ignorederrorcodes, _ref5) >= 0))) {
            msg.hide();
            return;
          }
          defaultopts = {
            message: getmessagetext(type, xhr),
            type: type,
            events: (_ref6 = events[type]) != null ? _ref6 : {},
            hideonnavigate: type === 'success'
          };
          msgopts = $.extend({}, m_opts, defaultopts, responseopts);
          if (typeof ((_ref7 = msgopts.retry) != null ? _ref7.allow : void 0) === 'number') {
            msgopts.retry.allow--;
          }
          if (type === 'error' && (xhr != null ? xhr.status : void 0) >= 500 && ((_ref8 = msgopts.retry) != null ? _ref8.allow : void 0)) {
            if (msgopts.retry.delay == null) {
              if (msgopts.errorcount < 4) {
                msgopts.retry.delay = 10;
              } else {
                msgopts.retry.delay = 5 * 60;
              }
            }
            if (msgopts.hideafter) {
              if ((_ref9 = msgopts._hideafter) == null) {
                msgopts._hideafter = msgopts.hideafter;
              }
              msgopts.hideafter = msgopts._hideafter + msgopts.retry.delay;
            }
            msgopts._retryactions = true;
            msgopts.actions = {
              retry: {
                label: 'retry now',
                phrase: 'retrying time',
                auto: msgopts.retry.auto,
                delay: msgopts.retry.delay,
                action: function() {
                  msgopts.messageinstance = msg;
                  return settimeout(function() {
                    return _this["do"].apply(_this, [msgopts, opts].concat(__slice.call(args)));
                  }, 0);
                }
              },
              cancel: {
                action: function() {
                  return msg.cancel();
                }
              }
            };
          } else if (msgopts._retryactions) {
            delete msgopts.actions.retry;
            delete msgopts.actions.cancel;
            delete m_opts._retryactions;
          }
          msg.update(msgopts);
          if (responseopts && msgopts.message) {
            messenger(_.extend({}, _this.options, {
              instance: _this
            }));
            return msg.show();
          } else {
            return msg.hide();
          }
        };
      });
      if (!m_opts.returnspromise) {
        for (type in handlers) {
          handler = handlers[type];
          old = opts[type];
          opts[type] = handler;
        }
      }
      msg._actioninstance = m_opts.action.apply(m_opts, [opts].concat(__slice.call(args)));
      if (m_opts.returnspromise) {
        msg._actioninstance.then(handlers.success, handlers.error);
      }
      return msg;
    };

    actionmessenger.prototype["do"] = actionmessenger.prototype.run;

    actionmessenger.prototype.ajax = function() {
      var args, m_opts;
      m_opts = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
      m_opts.action = $.ajax;
      return this.run.apply(this, [m_opts].concat(__slice.call(args)));
    };

    actionmessenger.prototype.expectpromise = function(action, m_opts) {
      m_opts = _.extend({}, m_opts, {
        action: action,
        returnspromise: true
      });
      return this.run(m_opts);
    };

    actionmessenger.prototype.error = function(m_opts) {
      if (m_opts == null) {
        m_opts = {};
      }
      if (typeof m_opts === 'string') {
        m_opts = {
          message: m_opts
        };
      }
      m_opts.type = 'error';
      return this.post(m_opts);
    };

    actionmessenger.prototype.info = function(m_opts) {
      if (m_opts == null) {
        m_opts = {};
      }
      if (typeof m_opts === 'string') {
        m_opts = {
          message: m_opts
        };
      }
      m_opts.type = 'info';
      return this.post(m_opts);
    };

    actionmessenger.prototype.success = function(m_opts) {
      if (m_opts == null) {
        m_opts = {};
      }
      if (typeof m_opts === 'string') {
        m_opts = {
          message: m_opts
        };
      }
      m_opts.type = 'success';
      return this.post(m_opts);
    };

    return actionmessenger;

  })(_messenger);

  $.fn.messenger = function() {
    var $el, args, func, instance, opts, _ref2, _ref3, _ref4;
    func = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
    if (func == null) {
      func = {};
    }
    $el = this;
    if (!(func != null) || !_.isstring(func)) {
      opts = func;
      if (!($el.data('messenger') != null)) {
        _messenger = (_ref2 = (_ref3 = messenger.themes[opts.theme]) != null ? _ref3.messenger : void 0) != null ? _ref2 : actionmessenger;
        $el.data('messenger', instance = new _messenger($.extend({
          el: $el
        }, opts)));
        instance.render();
      }
      return $el.data('messenger');
    } else {
      return (_ref4 = $el.data('messenger'))[func].apply(_ref4, args);
    }
  };

  window.messenger._call = function(opts) {
    var $el, $parent, choosen_loc, chosen_loc, classes, defaultopts, inst, loc, locations, _i, _len;
    defaultopts = {
      extraclasses: 'messenger-fixed messenger-on-bottom messenger-on-right',
      theme: 'future',
      maxmessages: 9,
      parentlocations: ['body']
    };
    opts = $.extend(defaultopts, $._messengerdefaults, messenger.options, opts);
    if (opts.theme != null) {
      opts.extraclasses += " messenger-theme-" + opts.theme;
    }
    inst = opts.instance || messenger.instance;
    if (opts.instance == null) {
      locations = opts.parentlocations;
      $parent = null;
      choosen_loc = null;
      for (_i = 0, _len = locations.length; _i < _len; _i++) {
        loc = locations[_i];
        $parent = $(loc);
        if ($parent.length) {
          chosen_loc = loc;
          break;
        }
      }
      if (!inst) {
        $el = $('<ul>');
        $parent.prepend($el);
        inst = $el.messenger(opts);
        inst._location = chosen_loc;
        messenger.instance = inst;
      } else if (!$(inst._location).is($(chosen_loc))) {
        inst.$el.detach();
        $parent.prepend(inst.$el);
      }
    }
    if (inst._addedclasses != null) {
      inst.$el.removeclass(inst._addedclasses);
    }
    inst.$el.addclass(classes = "" + inst.classname + " " + opts.extraclasses);
    inst._addedclasses = classes;
    return inst;
  };

  $.extend(messenger, {
    message: retryingmessage,
    messenger: actionmessenger,
    themes: (_ref2 = messenger.themes) != null ? _ref2 : {}
  });

  $.globalmessenger = window.messenger = messenger;

}).call(this);