enmi-conf.org: comparison wp/wp-includes/js/backbone.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-includes/js/backbone.js

changeset 16	a86126ab1dd4
parent 9	177826044cd9
child 19	3d72ae0968f4

equal deleted inserted replaced

-:3d4e9c994f10
+:a86126ab1dd4
-//     Backbone.js 1.3.3
+//     Backbone.js 1.4.0
-//     (c) 2010-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+//     (c) 2010-2019 Jeremy Ashkenas and DocumentCloud
 //     Backbone may be freely distributed under the MIT license.
 //     For all details and documentation:
 //     http://backbonejs.org
 (function(factory) {
 // Establish the root object, `window` (`self`) in the browser, or `global` on the server.
 // We use `self` instead of `window` for `WebWorker` support.
-var root = (typeof self == 'object' && self.self === self && self) ||
+var root = typeof self == 'object' && self.self === self && self ||
-(typeof global == 'object' && global.global === global && global);
+typeof global == 'object' && global.global === global && global;
 // Set up Backbone appropriately for the environment. Start with AMD.
 if (typeof define === 'function' && define.amd) {
 define(['underscore', 'jquery', 'exports'], function(_, $, exports) {
 // Export global even in AMD case in case this script is loaded with
 try { $ = require('jquery'); } catch (e) {}
 factory(root, exports, _, $);
 // Finally, as a browser global.
 } else {
-root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));
+root.Backbone = factory(root, {}, root._, root.jQuery || root.Zepto || root.ender || root.$);
 }
 })(function(root, Backbone, _, $) {
 // Initial Setup
 // Create a local reference to a common array method we'll want to use later.
 var slice = Array.prototype.slice;
 // Current version of the library. Keep in sync with `package.json`.
-Backbone.VERSION = '1.3.3';
+Backbone.VERSION = '1.4.0';
 // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
 // the `$` variable.
 Backbone.$ = $;
 // Turn on `emulateJSON` to support legacy servers that can't deal with direct
 // `application/json` requests ... this 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;
-// Proxy Backbone class methods to Underscore functions, wrapping the model's
-// `attributes` object or collection's `models` array behind the scenes.
-//
-// collection.filter(function(model) { return model.get('age') > 10 });
-// collection.each(this.addView);
-//
-// `Function#apply` can be slow so we use the method's arg count, if we know it.
-var addMethod = function(length, method, attribute) {
-switch (length) {
-case 1: return function() {
-return _[method](this[attribute]);
-};
-case 2: return function(value) {
-return _[method](this[attribute], value);
-};
-case 3: return function(iteratee, context) {
-return _[method](this[attribute], cb(iteratee, this), context);
-};
-case 4: return function(iteratee, defaultVal, context) {
-return _[method](this[attribute], cb(iteratee, this), defaultVal, context);
-};
-default: return function() {
-var args = slice.call(arguments);
-args.unshift(this[attribute]);
-return _[method].apply(_, args);
-};
-}
-};
-var addUnderscoreMethods = function(Class, methods, attribute) {
-_.each(methods, function(length, method) {
-if (_[method]) Class.prototype[method] = addMethod(length, method, attribute);
-});
-};
-// Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.
-var cb = function(iteratee, instance) {
-if (_.isFunction(iteratee)) return iteratee;
-if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee);
-if (_.isString(iteratee)) return function(model) { return model.get(iteratee); };
-return iteratee;
-};
-var modelMatcher = function(attrs) {
-var matcher = _.matches(attrs);
-return function(model) {
-return matcher(model.attributes);
-};
-};
 // Backbone.Events
 // ---------------
 // A module that can be mixed in to *any object* in order to provide it with
 var Events = Backbone.Events = {};
 // Regular expression used to split event strings.
 var eventSplitter = /\s+/;
+// A private global variable to share between listeners and listenees.
+var _listening;
 // Iterates over the standard `event, callback` (as well as the fancy multiple
 // space-separated events `"change blur", callback` and jQuery-style event
 // maps `{event: callback}`).
 var eventsApi = function(iteratee, events, name, callback, opts) {
 var i = 0, names;
 };
 // Bind an event to a `callback` function. Passing `"all"` will bind
 // the callback to all events fired.
 Events.on = function(name, callback, context) {
-return internalOn(this, name, callback, context);
+this._events = eventsApi(onApi, this._events || {}, name, callback, {
-};
-// Guard the `listening` argument from the public API.
-var internalOn = function(obj, name, callback, context, listening) {
-obj._events = eventsApi(onApi, obj._events || {}, name, callback, {
 context: context,
-ctx: obj,
+ctx: this,
-listening: listening
+listening: _listening
 });
-if (listening) {
+if (_listening) {
-var listeners = obj._listeners || (obj._listeners = {});
+var listeners = this._listeners || (this._listeners = {});
-listeners[listening.id] = listening;
+listeners[_listening.id] = _listening;
-}
+// Allow the listening to use a counter, instead of tracking
+// callbacks for library interop
-return obj;
+_listening.interop = false;
+}
+return this;
 };
 // Inversion-of-control versions of `on`. Tell *this* object to listen to
 // an event in another object... keeping track of what it's listening to
 // for easier unbinding later.
 Events.listenTo = function(obj, name, callback) {
 if (!obj) return this;
 var id = obj._listenId || (obj._listenId = _.uniqueId('l'));
 var listeningTo = this._listeningTo || (this._listeningTo = {});
-var listening = listeningTo[id];
+var listening = _listening = listeningTo[id];
 // This object is not listening to any other events on `obj` yet.
 // Setup the necessary references to track the listening callbacks.
 if (!listening) {
-var thisId = this._listenId || (this._listenId = _.uniqueId('l'));
+this._listenId || (this._listenId = _.uniqueId('l'));
-listening = listeningTo[id] = {obj: obj, objId: id, id: thisId, listeningTo: listeningTo, count: 0};
+listening = _listening = listeningTo[id] = new Listening(this, obj);
 }
-// Bind callbacks on obj, and keep track of them on listening.
+// Bind callbacks on obj.
-internalOn(obj, name, callback, this, listening);
+var error = tryCatchOn(obj, name, callback, this);
+_listening = void 0;
+if (error) throw error;
+// If the target obj is not Backbone.Events, track events manually.
+if (listening.interop) listening.on(name, callback);
 return this;
 };
 // The reducing API that adds a callback to the `events` object.
 var onApi = function(events, name, callback, options) {
 if (listening) listening.count++;
 handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening});
 }
 return events;
+};
+// An try-catch guarded #on function, to prevent poisoning the global
+// `_listening` variable.
+var tryCatchOn = function(obj, name, callback, context) {
+try {
+obj.on(name, callback, context);
+} catch (e) {
+return e;
+}
 };
 // 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
 if (!this._events) return this;
 this._events = eventsApi(offApi, this._events, name, callback, {
 context: context,
 listeners: this._listeners
 });
 return this;
 };
 // Tell this object to stop listening to either specific events ... or
 // to every object it's currently listening to.
 Events.stopListening = function(obj, name, callback) {
 var listeningTo = this._listeningTo;
 if (!listeningTo) return this;
 var ids = obj ? [obj._listenId] : _.keys(listeningTo);
 for (var i = 0; i < ids.length; i++) {
 var listening = listeningTo[ids[i]];
 // If listening doesn't exist, this object is not currently
 // listening to obj. Break out early.
 if (!listening) break;
 listening.obj.off(name, callback, this);
-}
+if (listening.interop) listening.off(name, callback);
+}
+if (_.isEmpty(listeningTo)) this._listeningTo = void 0;
 return this;
 };
 // The reducing API that removes a callback from the `events` object.
 var offApi = function(events, name, callback, options) {
 if (!events) return;
-var i = 0, listening;
 var context = options.context, listeners = options.listeners;
+var i = 0, names;
-// Delete all events listeners and "drop" events.
-if (!name && !callback && !context) {
+// Delete all event listeners and "drop" events.
-var ids = _.keys(listeners);
+if (!name && !context && !callback) {
-for (; i < ids.length; i++) {
+for (names = _.keys(listeners); i < names.length; i++) {
-listening = listeners[ids[i]];
+listeners[names[i]].cleanup();
-delete listeners[listening.id];
-delete listening.listeningTo[listening.objId];
 }
 return;
 }
-var names = name ? [name] : _.keys(events);
+names = name ? [name] : _.keys(events);
 for (; i < names.length; i++) {
 name = names[i];
 var handlers = events[name];
 // Bail out if there are no events stored.
 if (!handlers) break;
-// Replace events if there are any remaining.  Otherwise, clean up.
+// Find any remaining events.
 var remaining = [];
 for (var j = 0; j < handlers.length; j++) {
 var handler = handlers[j];
 if (
 callback && callback !== handler.callback &&
 callback !== handler.callback._callback ||
 context && context !== handler.context
 ) {
 remaining.push(handler);
 } else {
-listening = handler.listening;
+var listening = handler.listening;
-if (listening && --listening.count === 0) {
+if (listening) listening.off(name, callback);
-delete listeners[listening.id];
-delete listening.listeningTo[listening.objId];
-}
 }
 }
-// Update tail event if the list has any events.  Otherwise, clean up.
+// Replace events if there are any remaining.  Otherwise, clean up.
 if (remaining.length) {
 events[name] = remaining;
 } else {
 delete events[name];
 }
 }
 return events;
 };
 // Bind an event to only be triggered a single time. After the first time
 // the callback is invoked, its listener will be removed. If multiple events
 // are passed in using the space-separated syntax, the handler will fire
 // once for each event, not once for a combination of all events.
 Events.once = function(name, callback, context) {
 // Map the event into a `{event: once}` object.
-var events = eventsApi(onceMap, {}, name, callback, _.bind(this.off, this));
+var events = eventsApi(onceMap, {}, name, callback, this.off.bind(this));
 if (typeof name === 'string' && context == null) callback = void 0;
 return this.on(events, callback, context);
 };
 // Inversion-of-control versions of `once`.
 Events.listenToOnce = function(obj, name, callback) {
 // Map the event into a `{event: once}` object.
-var events = eventsApi(onceMap, {}, name, callback, _.bind(this.stopListening, this, obj));
+var events = eventsApi(onceMap, {}, name, callback, this.stopListening.bind(this, obj));
 return this.listenTo(obj, events);
 };
 // Reduces the event callbacks into a map of `{event: onceWrapper}`.
 // `offer` unbinds the `onceWrapper` after it has been called.
 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); return;
 }
 };
+// A listening class that tracks and cleans up memory bindings
+// when all callbacks have been offed.
+var Listening = function(listener, obj) {
+this.id = listener._listenId;
+this.listener = listener;
+this.obj = obj;
+this.interop = true;
+this.count = 0;
+this._events = void 0;
+};
+Listening.prototype.on = Events.on;
+// Offs a callback (or several).
+// Uses an optimized counter if the listenee uses Backbone.Events.
+// Otherwise, falls back to manual tracking to support events
+// library interop.
+Listening.prototype.off = function(name, callback) {
+var cleanup;
+if (this.interop) {
+this._events = eventsApi(offApi, this._events, name, callback, {
+context: void 0,
+listeners: void 0
+});
+cleanup = !this._events;
+} else {
+this.count--;
+cleanup = this.count === 0;
+}
+if (cleanup) this.cleanup();
+};
+// Cleans up memory bindings between the listener and the listenee.
+Listening.prototype.cleanup = function() {
+delete this.listener._listeningTo[this.obj._listenId];
+if (!this.interop) delete this.obj._listeners[this.id];
+};
 // 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
 // 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 attrs = attributes || {};
 options || (options = {});
+this.preinitialize.apply(this, arguments);
 this.cid = _.uniqueId(this.cidPrefix);
 this.attributes = {};
 if (options.collection) this.collection = options.collection;
 if (options.parse) attrs = this.parse(attrs, options) || {};
 var defaults = _.result(this, 'defaults');
 idAttribute: 'id',
 // The prefix is used to create the client id which is used to identify models locally.
 // You may want to override this if you're experiencing name clashes with model ids.
 cidPrefix: 'c',
+// preinitialize is an empty function by default. You can override it with a function
+// or object.  preinitialize will run before any instantiation logic is run in the Model.
+preinitialize: function(){},
 // Initialize is an empty function by default. Override it with your own
 // initialization logic.
 initialize: function(){},
 // determining if there *would be* a change.
 changedAttributes: function(diff) {
 if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
 var old = this._changing ? this._previousAttributes : this.attributes;
 var changed = {};
+var hasChanged;
 for (var attr in diff) {
 var val = diff[attr];
 if (_.isEqual(old[attr], val)) continue;
 changed[attr] = val;
-}
+hasChanged = true;
-return _.size(changed) ? changed : false;
+}
+return hasChanged ? changed : false;
 },
 // Get the previous value of an attribute, recorded at the time the last
 // `"change"` event was fired.
 previous: function(attr) {
 wrapError(this, options);
 // Set temporary attributes if `{wait: true}` to properly find new ids.
 if (attrs && wait) this.attributes = _.extend({}, attributes, attrs);
-var method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
+var method = this.isNew() ? 'create' : options.patch ? 'patch' : 'update';
 if (method === 'patch' && !options.attrs) options.attrs = attrs;
 var xhr = this.sync(method, this, options);
 // Restore attributes.
 this.attributes = attributes;
 return false;
 }
 });
-// Underscore methods that we want to implement on the Model, mapped to the
-// number of arguments they take.
-var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,
-omit: 0, chain: 1, isEmpty: 1};
-// Mix in each Underscore method as a proxy to `Model#attributes`.
-addUnderscoreMethods(Model, modelMethods, 'attributes');
 // Backbone.Collection
 // -------------------
 // If models tend to represent a single row of data, a Backbone Collection is
 // more analogous to a table full of data ... or a small slice or page of that
 // 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 = {});
+this.preinitialize.apply(this, arguments);
 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));
 _.extend(Collection.prototype, Events, {
 // The default model for a collection is just a **Backbone.Model**.
 // This should be overridden in most cases.
 model: Model,
+// preinitialize is an empty function by default. You can override it with a function
+// or object.  preinitialize will run before any instantiation logic is run in the Collection.
+preinitialize: function(){},
 // Initialize is an empty function by default. Override it with your own
 // initialization logic.
 initialize: function(){},
 // Get a model from the set by id, cid, model object with id or cid
 // properties, or an attributes object that is transformed through modelId.
 get: function(obj) {
 if (obj == null) return void 0;
 return this._byId[obj] ||
-this._byId[this.modelId(obj.attributes || obj)] ||
+this._byId[this.modelId(this._isModel(obj) ? obj.attributes : obj)] ||
 obj.cid && this._byId[obj.cid];
 },
 // Returns `true` if the model is in the collection.
 has: function(obj) {
 var comparator = this.comparator;
 if (!comparator) throw new Error('Cannot sort a set without a comparator');
 options || (options = {});
 var length = comparator.length;
-if (_.isFunction(comparator)) comparator = _.bind(comparator, this);
+if (_.isFunction(comparator)) comparator = comparator.bind(this);
 // Run sort based on type of `comparator`.
 if (length === 1 || _.isString(comparator)) {
 this.models = this.sortBy(comparator);
 } else {
 // Define how to uniquely identify models in the collection.
 modelId: function(attrs) {
 return attrs[this.model.prototype.idAttribute || 'id'];
 },
+// Get an iterator of all models in this collection.
+values: function() {
+return new CollectionIterator(this, ITERATOR_VALUES);
+},
+// Get an iterator of all model IDs in this collection.
+keys: function() {
+return new CollectionIterator(this, ITERATOR_KEYS);
+},
+// Get an iterator of all [ID, model] tuples in this collection.
+entries: function() {
+return new CollectionIterator(this, ITERATOR_KEYSVALUES);
+},
 // Private method to reset all internal state. Called when the collection
 // is first initialized or reset.
 _reset: function() {
 this.length = 0;
 this.models = [];
 this.trigger.apply(this, arguments);
 }
 });
-// Underscore methods that we want to implement on the Collection.
+// Defining an @@iterator method implements JavaScript's Iterable protocol.
-// 90% of the core usefulness of Backbone Collections is actually implemented
+// In modern ES2015 browsers, this value is found at Symbol.iterator.
-// right here:
+/* global Symbol */
-var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0,
+var $$iterator = typeof Symbol === 'function' && Symbol.iterator;
-foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter: 3,
+if ($$iterator) {
-select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3,
+Collection.prototype[$$iterator] = Collection.prototype.values;
-contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,
+}
-head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,
-without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,
+// CollectionIterator
-isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,
+// ------------------
-sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3};
+// A CollectionIterator implements JavaScript's Iterator protocol, allowing the
-// Mix in each Underscore method as a proxy to `Collection#models`.
+// use of `for of` loops in modern browsers and interoperation between
-addUnderscoreMethods(Collection, collectionMethods, 'models');
+// Backbone.Collection and other JavaScript functions and third-party libraries
+// which can operate on Iterables.
+var CollectionIterator = function(collection, kind) {
+this._collection = collection;
+this._kind = kind;
+this._index = 0;
+};
+// This "enum" defines the three possible kinds of values which can be emitted
+// by a CollectionIterator that correspond to the values(), keys() and entries()
+// methods on Collection, respectively.
+var ITERATOR_VALUES = 1;
+var ITERATOR_KEYS = 2;
+var ITERATOR_KEYSVALUES = 3;
+// All Iterators should themselves be Iterable.
+if ($$iterator) {
+CollectionIterator.prototype[$$iterator] = function() {
+return this;
+};
+}
+CollectionIterator.prototype.next = function() {
+if (this._collection) {
+// Only continue iterating if the iterated collection is long enough.
+if (this._index < this._collection.length) {
+var model = this._collection.at(this._index);
+this._index++;
+// Construct a value depending on what kind of values should be iterated.
+var value;
+if (this._kind === ITERATOR_VALUES) {
+value = model;
+} else {
+var id = this._collection.modelId(model.attributes);
+if (this._kind === ITERATOR_KEYS) {
+value = id;
+} else { // ITERATOR_KEYSVALUES
+value = [id, model];
+}
+}
+return {value: value, done: false};
+}
+// Once exhausted, remove the reference to the collection so future
+// calls to the next method always return done.
+this._collection = void 0;
+}
+return {value: void 0, done: true};
+};
 // Backbone.View
 // -------------
 // Backbone Views are almost more convention than they are actual code. A View
 // 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.preinitialize.apply(this, arguments);
 _.extend(this, _.pick(options, viewOptions));
 this._ensureElement();
 this.initialize.apply(this, arguments);
 };
 // jQuery delegate for element lookup, scoped to DOM elements within the
 // current view. This should be preferred to global lookups where possible.
 $: function(selector) {
 return this.$el.find(selector);
 },
+// preinitialize is an empty function by default. You can override it with a function
+// or object.  preinitialize will run before any instantiation logic is run in the View
+preinitialize: function(){},
 // Initialize is an empty function by default. Override it with your own
 // initialization logic.
 initialize: function(){},
 for (var key in events) {
 var method = events[key];
 if (!_.isFunction(method)) method = this[method];
 if (!method) continue;
 var match = key.match(delegateEventSplitter);
-this.delegate(match[1], match[2], _.bind(method, this));
+this.delegate(match[1], match[2], method.bind(this));
 }
 return this;
 },
 // Add a single event listener to the view's element (or a child element
 // subclasses using an alternative DOM manipulation API.
 _setAttributes: function(attributes) {
 this.$el.attr(attributes);
 }
+});
+// Proxy Backbone class methods to Underscore functions, wrapping the model's
+// `attributes` object or collection's `models` array behind the scenes.
+//
+// collection.filter(function(model) { return model.get('age') > 10 });
+// collection.each(this.addView);
+//
+// `Function#apply` can be slow so we use the method's arg count, if we know it.
+var addMethod = function(base, length, method, attribute) {
+switch (length) {
+case 1: return function() {
+return base[method](this[attribute]);
+};
+case 2: return function(value) {
+return base[method](this[attribute], value);
+};
+case 3: return function(iteratee, context) {
+return base[method](this[attribute], cb(iteratee, this), context);
+};
+case 4: return function(iteratee, defaultVal, context) {
+return base[method](this[attribute], cb(iteratee, this), defaultVal, context);
+};
+default: return function() {
+var args = slice.call(arguments);
+args.unshift(this[attribute]);
+return base[method].apply(base, args);
+};
+}
+};
+var addUnderscoreMethods = function(Class, base, methods, attribute) {
+_.each(methods, function(length, method) {
+if (base[method]) Class.prototype[method] = addMethod(base, length, method, attribute);
+});
+};
+// Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.
+var cb = function(iteratee, instance) {
+if (_.isFunction(iteratee)) return iteratee;
+if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee);
+if (_.isString(iteratee)) return function(model) { return model.get(iteratee); };
+return iteratee;
+};
+var modelMatcher = function(attrs) {
+var matcher = _.matches(attrs);
+return function(model) {
+return matcher(model.attributes);
+};
+};
+// Underscore methods that we want to implement on the Collection.
+// 90% of the core usefulness of Backbone Collections is actually implemented
+// right here:
+var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0,
+foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter: 3,
+select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3,
+contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,
+head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,
+without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,
+isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,
+sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3};
+// Underscore methods that we want to implement on the Model, mapped to the
+// number of arguments they take.
+var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,
+omit: 0, chain: 1, isEmpty: 1};
+// Mix in each Underscore method as a proxy to `Collection#models`.
+_.each([
+[Collection, collectionMethods, 'models'],
+[Model, modelMethods, 'attributes']
+], function(config) {
+var Base = config[0],
+methods = config[1],
+attribute = config[2];
+Base.mixin = function(obj) {
+var mappings = _.reduce(_.functions(obj), function(memo, name) {
+memo[name] = 0;
+return memo;
+}, {});
+addUnderscoreMethods(Base, obj, mappings, attribute);
+};
+addUnderscoreMethods(Base, _, methods, attribute);
 });
 // Backbone.sync
 // -------------
 return xhr;
 };
 // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
 var methodMap = {
-'create': 'POST',
+create: 'POST',
-'update': 'PUT',
+update: 'PUT',
-'patch': 'PATCH',
+patch: 'PATCH',
-'delete': 'DELETE',
+delete: 'DELETE',
-'read': 'GET'
+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() {
 // 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 = {});
+this.preinitialize.apply(this, arguments);
 if (options.routes) this.routes = options.routes;
 this._bindRoutes();
 this.initialize.apply(this, arguments);
 };
 var splatParam    = /\*\w+/g;
 var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
 // Set up all inheritable **Backbone.Router** properties and methods.
 _.extend(Router.prototype, Events, {
+// preinitialize is an empty function by default. You can override it with a function
+// or object.  preinitialize will run before any instantiation logic is run in the Router.
+preinitialize: function(){},
 // Initialize is an empty function by default. Override it with your own
 // initialization logic.
 initialize: function(){},
 // 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 + '(?:\\?([\\s\\S]*))?$');
 },
 // Given a route, and a URL fragment that it matches, return the array of
 // extracted decoded parameters. Empty or unmatched parameters will be
 // [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 = [];
-this.checkUrl = _.bind(this.checkUrl, this);
+this.checkUrl = this.checkUrl.bind(this);
 // Ensure that `History` can be used outside of the browser.
 if (typeof window !== 'undefined') {
 this.location = window.location;
 this.history = window.history;
 if (fragment === '' || fragment.charAt(0) === '?') {
 rootPath = rootPath.slice(0, -1) || '/';
 }
 var url = rootPath + fragment;
-// Strip the hash and decode for matching.
+// Strip the fragment of the query and hash for matching.
-fragment = this.decodeFragment(fragment.replace(pathStripper, ''));
+fragment = fragment.replace(pathStripper, '');
-if (this.fragment === fragment) return;
+// Decode for matching.
-this.fragment = fragment;
+var decodedFragment = this.decodeFragment(fragment);
+if (this.fragment === decodedFragment) return;
+this.fragment = decodedFragment;
 // If pushState is available, we use it to set the fragment as a real URL.
 if (this._usePushState) {
 this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);

enmi-conf.org