119   // Backbone.Events
128   //     _.extend(object, Backbone.Events);
132   var Events = Backbone.Events = {};
138   // space-separated events `"change blur", callback` and jQuery-style event
140   var eventsApi = function(iteratee, events, name, callback, opts) {  argument
146         events = eventsApi(iteratee, events, names[i], name[names[i]], opts);
151         events = iteratee(events, names[i], callback, opts);
154       // Finally, standard events.
155       events = iteratee(events, name, callback, opts);
157     return events;
161   // the callback to all events fired.
162   Events.on = function(name, callback, context) {
185   Events.listenTo = function(obj, name, callback) {
191     // This object is not listening to any other events on `obj` yet.
203   // The reducing API that adds a callback to the `events` object.
204   var onApi = function(events, name, callback, options) {  argument
206       var handlers = events[name] || (events[name] = []);
212     return events;
218   // callbacks for all events.
219   Events.off = function(name, callback, context) {
228   // Tell this object to stop listening to either specific events ... or
230   Events.stopListening = function(obj, name, callback) {
249   // The reducing API that removes a callback from the `events` object.
250   var offApi = function(events, name, callback, options) {  argument
251     if (!events) return;
256     // Delete all events listeners and "drop" events.
267     var names = name ? [name] : _.keys(events);
270       var handlers = events[name];
272       // Bail out if there are no events stored.
275       // Replace events if there are any remaining.  Otherwise, clean up.
294       // Update tail event if the list has any events.  Otherwise, clean up.
296         events[name] = remaining;  field
298         delete events[name];
301     return events;
305   // the callback is invoked, its listener will be removed. If multiple events
307   // once for each event, not once for a combination of all events.
308   Events.once = function(name, callback, context) {
310     var events = eventsApi(onceMap, {}, name, callback, _.bind(this.off, this));
312     return this.on(events, callback, context);
316   Events.listenToOnce = function(obj, name, callback) {
318     var events = eventsApi(onceMap, {}, name, callback, _.bind(this.stopListening, this, obj));
319     return this.listenTo(obj, events);
335   // Trigger one or many events, firing all bound callbacks. Callbacks are
339   Events.trigger = function(name) {
353       var events = objEvents[name];
355       if (events && allEvents) allEvents = allEvents.slice();
356       if (events) triggerEvents(events, args);
363   // triggering events. Tries to keep the usual cases speedy (most internal
364   // Backbone events have 3 arguments).
365   var triggerEvents = function(events, args) {  argument
366     var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
368       case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
369       case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
370       case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
371       case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
372       default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;
377   Events.bind   = Events.on;
378   Events.unbind = Events.off;
382   _.extend(Backbone, Events);
410   _.extend(Model.prototype, Events, {
526       // be recursively nested within `"change"` events.
788   _.extend(Collection.prototype, Events, {
931       // Unless silenced, it's time to fire all appropriate add/sort/update events.
955     // any granular `add` or `remove` events. Fires `reset` when finished.
1185     // events simply proxy through. "add" and "remove" events that originate
1227   // UI as a **View** allows you to define your DOM events declaratively, without
1245 … viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
1248   _.extend(View.prototype, Events, {
1275     // applicable Backbone.Events listeners.
1290     // view's events on the new element.
1308     // Set callbacks, where `this.events` is a hash of
1321     delegateEvents: function(events) {  argument
1322       events || (events = _.result(this, 'events'));
1323       if (!events) return this;
1325       for (var key in events) {
1326         var method = events[key];
1336     // using `selector`). This only works for delegate-able events: not `focus`,
1484   // Routers map faux-URLs to actions, and fire events when routes are
1502   _.extend(Router.prototype, Events, {
1619   _.extend(History.prototype, Events, {
1720       // Proxy an iframe to handle location events if the browser doesn't