fanforce-app-factory 0.38.2 → 0.39.0

data/lib/fanforce/app_factory/assets/lib/vendors/knockout/knockout.debug.js

@@ -1,4 +1,4 @@
-// Knockout JavaScript library v2.3.0
+// Knockout JavaScript library v3.1.0
 // (c) Steven Sanderson - http://knockoutjs.com/
 // License: MIT (http://www.opensource.org/licenses/mit-license.php)
 
@@ -44,17 +44,35 @@
             ko.exportProperty = function(owner, publicName, object) {
                 owner[publicName] = object;
             };
-            ko.version = "2.3.0";
+            ko.version = "3.1.0";
 
             ko.exportSymbol('version', ko.version);
             ko.utils = (function () {
-                var objectForEach = function(obj, action) {
+                function objectForEach(obj, action) {
                     for (var prop in obj) {
                         if (obj.hasOwnProperty(prop)) {
                             action(prop, obj[prop]);
                         }
                     }
-                };
+                }
+
+                function extend(target, source) {
+                    if (source) {
+                        for(var prop in source) {
+                            if(source.hasOwnProperty(prop)) {
+                                target[prop] = source[prop];
+                            }
+                        }
+                    }
+                    return target;
+                }
+
+                function setPrototypeOf(obj, proto) {
+                    obj.__proto__ = proto;
+                    return obj;
+                }
+
+                var canSetPrototype = ({ __proto__: [] } instanceof Array);
 
                 // Represent the known event types in a compact way, then at runtime transform it into a hash with event name as key (for fast lookup)
                 var knownEvents = {}, knownEventTypesByEventName = {};
@@ -98,7 +116,7 @@
 
                     arrayForEach: function (array, action) {
                         for (var i = 0, j = array.length; i < j; i++)
-                            action(array[i]);
+                            action(array[i], i);
                     },
 
                     arrayIndexOf: function (array, item) {
@@ -112,15 +130,19 @@
 
                     arrayFirst: function (array, predicate, predicateOwner) {
                         for (var i = 0, j = array.length; i < j; i++)
-                            if (predicate.call(predicateOwner, array[i]))
+                            if (predicate.call(predicateOwner, array[i], i))
                                 return array[i];
                         return null;
                     },
 
                     arrayRemoveItem: function (array, itemToRemove) {
                         var index = ko.utils.arrayIndexOf(array, itemToRemove);
-                        if (index >= 0)
+                        if (index > 0) {
                             array.splice(index, 1);
+                        }
+                        else if (index === 0) {
+                            array.shift();
+                        }
                     },
 
                     arrayGetDistinctValues: function (array) {
@@ -137,7 +159,7 @@
                         array = array || [];
                         var result = [];
                         for (var i = 0, j = array.length; i < j; i++)
-                            result.push(mapping(array[i]));
+                            result.push(mapping(array[i], i));
                         return result;
                     },
 
@@ -145,7 +167,7 @@
                         array = array || [];
                         var result = [];
                         for (var i = 0, j = array.length; i < j; i++)
-                            if (predicate(array[i]))
+                            if (predicate(array[i], i))
                                 result.push(array[i]);
                         return result;
                     },
@@ -160,7 +182,7 @@
                     },
 
                     addOrRemoveItem: function(array, value, included) {
-                        var existingEntryIndex = array.indexOf ? array.indexOf(value) : ko.utils.arrayIndexOf(array, value);
+                        var existingEntryIndex = ko.utils.arrayIndexOf(ko.utils.peekObservable(array), value);
                         if (existingEntryIndex < 0) {
                             if (included)
                                 array.push(value);
@@ -170,19 +192,28 @@
                         }
                     },
 
-                    extend: function (target, source) {
-                        if (source) {
-                            for(var prop in source) {
-                                if(source.hasOwnProperty(prop)) {
-                                    target[prop] = source[prop];
-                                }
+                    canSetPrototype: canSetPrototype,
+
+                    extend: extend,
+
+                    setPrototypeOf: setPrototypeOf,
+
+                    setPrototypeOfOrExtend: canSetPrototype ? setPrototypeOf : extend,
+
+                    objectForEach: objectForEach,
+
+                    objectMap: function(source, mapping) {
+                        if (!source)
+                            return source;
+                        var target = {};
+                        for (var prop in source) {
+                            if (source.hasOwnProperty(prop)) {
+                                target[prop] = mapping(source[prop], prop, source);
                             }
                         }
                         return target;
                     },
 
-                    objectForEach: objectForEach,
-
                     emptyDomNode: function (domNode) {
                         while (domNode.firstChild) {
                             ko.removeNode(domNode.firstChild);
@@ -230,6 +261,45 @@
                         }
                     },
 
+                    fixUpContinuousNodeArray: function(continuousNodeArray, parentNode) {
+                        // Before acting on a set of nodes that were previously outputted by a template function, we have to reconcile
+                        // them against what is in the DOM right now. It may be that some of the nodes have already been removed, or that
+                        // new nodes might have been inserted in the middle, for example by a binding. Also, there may previously have been
+                        // leading comment nodes (created by rewritten string-based templates) that have since been removed during binding.
+                        // So, this function translates the old "map" output array into its best guess of the set of current DOM nodes.
+                        //
+                        // Rules:
+                        //   [A] Any leading nodes that have been removed should be ignored
+                        //       These most likely correspond to memoization nodes that were already removed during binding
+                        //       See https://github.com/SteveSanderson/knockout/pull/440
+                        //   [B] We want to output a continuous series of nodes. So, ignore any nodes that have already been removed,
+                        //       and include any nodes that have been inserted among the previous collection
+
+                        if (continuousNodeArray.length) {
+                            // The parent node can be a virtual element; so get the real parent node
+                            parentNode = (parentNode.nodeType === 8 && parentNode.parentNode) || parentNode;
+
+                            // Rule [A]
+                            while (continuousNodeArray.length && continuousNodeArray[0].parentNode !== parentNode)
+                                continuousNodeArray.shift();
+
+                            // Rule [B]
+                            if (continuousNodeArray.length > 1) {
+                                var current = continuousNodeArray[0], last = continuousNodeArray[continuousNodeArray.length - 1];
+                                // Replace with the actual new continuous node set
+                                continuousNodeArray.length = 0;
+                                while (current !== last) {
+                                    continuousNodeArray.push(current);
+                                    current = current.nextSibling;
+                                    if (!current) // Won't happen, except if the developer has manually removed some DOM elements (then we're in an undefined scenario)
+                                        return;
+                                }
+                                continuousNodeArray.push(last);
+                            }
+                        }
+                        return continuousNodeArray;
+                    },
+
                     setOptionNodeSelectionState: function (optionNode, isSelected) {
                         // IE6 sometimes throws "unknown error" if you try to write to .selected directly, whereas Firefox struggles with setAttribute. Pick one based on browser.
                         if (ieVersion < 7)
@@ -264,18 +334,22 @@
                     },
 
                     domNodeIsContainedBy: function (node, containedByNode) {
+                        if (node === containedByNode)
+                            return true;
+                        if (node.nodeType === 11)
+                            return false; // Fixes issue #1162 - can't use node.contains for document fragments on IE8
+                        if (containedByNode.contains)
+                            return containedByNode.contains(node.nodeType === 3 ? node.parentNode : node);
                         if (containedByNode.compareDocumentPosition)
                             return (containedByNode.compareDocumentPosition(node) & 16) == 16;
-                        while (node != null) {
-                            if (node == containedByNode)
-                                return true;
+                        while (node && node != containedByNode) {
                             node = node.parentNode;
                         }
-                        return false;
+                        return !!node;
                     },
 
                     domNodeIsAttachedToDocument: function (node) {
-                        return ko.utils.domNodeIsContainedBy(node, node.ownerDocument);
+                        return ko.utils.domNodeIsContainedBy(node, node.ownerDocument.documentElement);
                     },
 
                     anyDomNodeIsAttachedToDocument: function(nodes) {
@@ -291,21 +365,7 @@
 
                     registerEventHandler: function (element, eventType, handler) {
                         var mustUseAttachEvent = ieVersion && eventsThatMustBeRegisteredUsingAttachEvent[eventType];
-                        if (!mustUseAttachEvent && typeof jQuery != "undefined") {
-                            if (isClickOnCheckableElement(element, eventType)) {
-                                // For click events on checkboxes, jQuery interferes with the event handling in an awkward way:
-                                // it toggles the element checked state *after* the click event handlers run, whereas native
-                                // click events toggle the checked state *before* the event handler.
-                                // Fix this by intecepting the handler and applying the correct checkedness before it runs.
-                                var originalHandler = handler;
-                                handler = function(event, eventData) {
-                                    var jQuerySuppliedCheckedState = this.checked;
-                                    if (eventData)
-                                        this.checked = eventData.checkedStateBeforeEvent !== true;
-                                    originalHandler.call(this, event);
-                                    this.checked = jQuerySuppliedCheckedState; // Restore the state jQuery applied
-                                };
-                            }
+                        if (!mustUseAttachEvent && jQuery) {
                             jQuery(element)['bind'](eventType, handler);
                         } else if (!mustUseAttachEvent && typeof element.addEventListener == "function")
                             element.addEventListener(eventType, handler, false);
@@ -327,13 +387,14 @@
                         if (!(element && element.nodeType))
                             throw new Error("element must be a DOM node when calling triggerEvent");
 
-                        if (typeof jQuery != "undefined") {
-                            var eventData = [];
-                            if (isClickOnCheckableElement(element, eventType)) {
-                                // Work around the jQuery "click events on checkboxes" issue described above by storing the original checked state before triggering the handler
-                                eventData.push({ checkedStateBeforeEvent: element.checked });
-                            }
-                            jQuery(element)['trigger'](eventType, eventData);
+                        // For click events on checkboxes and radio buttons, jQuery toggles the element checked state *after* the
+                        // event handler runs instead of *before*. (This was fixed in 1.9 for checkboxes but not for radio buttons.)
+                        // IE doesn't change the checked state when you trigger the click event using "fireEvent".
+                        // In both cases, we'll use the click method instead.
+                        var useClickWorkaround = isClickOnCheckableElement(element, eventType);
+
+                        if (jQuery && !useClickWorkaround) {
+                            jQuery(element)['trigger'](eventType);
                         } else if (typeof document.createEvent == "function") {
                             if (typeof element.dispatchEvent == "function") {
                                 var eventCategory = knownEventTypesByEventName[eventType] || "HTMLEvents";
@@ -343,15 +404,13 @@
                             }
                             else
                                 throw new Error("The supplied element doesn't support dispatchEvent");
+                        } else if (useClickWorkaround && element.click) {
+                            element.click();
                         } else if (typeof element.fireEvent != "undefined") {
-                            // Unlike other browsers, IE doesn't change the checked state of checkboxes/radiobuttons when you trigger their "click" event
-                            // so to make it consistent, we'll do it manually here
-                            if (isClickOnCheckableElement(element, eventType))
-                                element.checked = element.checked !== true;
                             element.fireEvent("on" + eventType);
-                        }
-                        else
+                        } else {
                             throw new Error("Browser doesn't support triggering events");
+                        }
                     },
 
                     unwrapObservable: function (value) {
@@ -383,7 +442,7 @@
                         // we'll clear everything and create a single text node.
                         var innerTextNode = ko.virtualElements.firstChild(element);
                         if (!innerTextNode || innerTextNode.nodeType != 3 || ko.virtualElements.nextSibling(innerTextNode)) {
-                            ko.virtualElements.setDomNodeChildren(element, [document.createTextNode(value)]);
+                            ko.virtualElements.setDomNodeChildren(element, [element.ownerDocument.createTextNode(value)]);
                         } else {
                             innerTextNode.data = value;
                         }
@@ -560,31 +619,33 @@
                 var uniqueId = 0;
                 var dataStoreKeyExpandoPropertyName = "__ko__" + (new Date).getTime();
                 var dataStore = {};
+
+                function getAll(node, createIfNotFound) {
+                    var dataStoreKey = node[dataStoreKeyExpandoPropertyName];
+                    var hasExistingDataStore = dataStoreKey && (dataStoreKey !== "null") && dataStore[dataStoreKey];
+                    if (!hasExistingDataStore) {
+                        if (!createIfNotFound)
+                            return undefined;
+                        dataStoreKey = node[dataStoreKeyExpandoPropertyName] = "ko" + uniqueId++;
+                        dataStore[dataStoreKey] = {};
+                    }
+                    return dataStore[dataStoreKey];
+                }
+
                 return {
                     get: function (node, key) {
-                        var allDataForNode = ko.utils.domData.getAll(node, false);
+                        var allDataForNode = getAll(node, false);
                         return allDataForNode === undefined ? undefined : allDataForNode[key];
                     },
                     set: function (node, key, value) {
                         if (value === undefined) {
                             // Make sure we don't actually create a new domData key if we are actually deleting a value
-                            if (ko.utils.domData.getAll(node, false) === undefined)
+                            if (getAll(node, false) === undefined)
                                 return;
                         }
-                        var allDataForNode = ko.utils.domData.getAll(node, true);
+                        var allDataForNode = getAll(node, true);
                         allDataForNode[key] = value;
                     },
-                    getAll: function (node, createIfNotFound) {
-                        var dataStoreKey = node[dataStoreKeyExpandoPropertyName];
-                        var hasExistingDataStore = dataStoreKey && (dataStoreKey !== "null") && dataStore[dataStoreKey];
-                        if (!hasExistingDataStore) {
-                            if (!createIfNotFound)
-                                return undefined;
-                            dataStoreKey = node[dataStoreKeyExpandoPropertyName] = "ko" + uniqueId++;
-                            dataStore[dataStoreKey] = {};
-                        }
-                        return dataStore[dataStoreKey];
-                    },
                     clear: function (node) {
                         var dataStoreKey = node[dataStoreKeyExpandoPropertyName];
                         if (dataStoreKey) {
@@ -593,15 +654,19 @@
                             return true; // Exposing "did clean" flag purely so specs can infer whether things have been cleaned up as intended
                         }
                         return false;
+                    },
+
+                    nextKey: function () {
+                        return (uniqueId++) + dataStoreKeyExpandoPropertyName;
                     }
-                }
+                };
             })();
 
             ko.exportSymbol('utils.domData', ko.utils.domData);
             ko.exportSymbol('utils.domData.clear', ko.utils.domData.clear); // Exporting only so specs can clear up after themselves fully
 
             ko.utils.domNodeDisposal = new (function () {
-                var domDataKey = "__ko_domNodeDisposal__" + (new Date).getTime();
+                var domDataKey = ko.utils.domData.nextKey();
                 var cleanableNodeTypes = { 1: true, 8: true, 9: true };       // Element, Comment, Document
                 var cleanableNodeTypesWithDescendants = { 1: true, 9: true }; // Element, Document
 
@@ -626,16 +691,13 @@
                             callbacks[i](node);
                     }
 
-                    // Also erase the DOM data
+                    // Erase the DOM data
                     ko.utils.domData.clear(node);
 
-                    // Special support for jQuery here because it's so commonly used.
-                    // Many jQuery plugins (including jquery.tmpl) store data using jQuery's equivalent of domData
-                    // so notify it to tear down any resources associated with the node & descendants here.
-                    if ((typeof jQuery == "function") && (typeof jQuery['cleanData'] == "function"))
-                        jQuery['cleanData']([node]);
+                    // Perform cleanup needed by external libraries (currently only jQuery, but can be extended)
+                    ko.utils.domNodeDisposal["cleanExternalData"](node);
 
-                    // Also clear any immediate-child comment nodes, as these wouldn't have been found by
+                    // Clear any immediate-child comment nodes, as these wouldn't have been found by
                     // node.getElementsByTagName("*") in cleanNode() (comment nodes aren't elements)
                     if (cleanableNodeTypesWithDescendants[node.nodeType])
                         cleanImmediateCommentTypeChildren(node);
@@ -687,6 +749,14 @@
                         ko.cleanNode(node);
                         if (node.parentNode)
                             node.parentNode.removeChild(node);
+                    },
+
+                    "cleanExternalData" : function (node) {
+                        // Special support for jQuery here because it's so commonly used.
+                        // Many jQuery plugins (including jquery.tmpl) store data using jQuery's equivalent of domData
+                        // so notify it to tear down any resources associated with the node & descendants here.
+                        if (jQuery && (typeof jQuery['cleanData'] == "function"))
+                            jQuery['cleanData']([node]);
                     }
                 }
             })();
@@ -760,7 +830,7 @@
                 }
 
                 ko.utils.parseHtmlFragment = function(html) {
-                    return typeof jQuery != 'undefined' ? jQueryHtmlParse(html)   // As below, benefit from jQuery's optimisations where possible
+                    return jQuery ? jQueryHtmlParse(html)   // As below, benefit from jQuery's optimisations where possible
                         : simpleHtmlParse(html);  // ... otherwise, this simple logic will do in most common cases.
                 };
 
@@ -777,7 +847,7 @@
                         // jQuery contains a lot of sophisticated code to parse arbitrary HTML fragments,
                         // for example <tr> elements which are not normally allowed to exist on their own.
                         // If you've referenced jQuery we'll use that rather than duplicating its code.
-                        if (typeof jQuery != 'undefined') {
+                        if (jQuery) {
                             jQuery(node)['html'](html);
                         } else {
                             // ... otherwise, use KO's own parsing logic.
@@ -883,21 +953,62 @@
                     });
                 },
 
+                'rateLimit': function(target, options) {
+                    var timeout, method, limitFunction;
+
+                    if (typeof options == 'number') {
+                        timeout = options;
+                    } else {
+                        timeout = options['timeout'];
+                        method = options['method'];
+                    }
+
+                    limitFunction = method == 'notifyWhenChangesStop' ?  debounce : throttle;
+                    target.limit(function(callback) {
+                        return limitFunction(callback, timeout);
+                    });
+                },
+
                 'notify': function(target, notifyWhen) {
-                    target["equalityComparer"] = notifyWhen == "always"
-                        ? function() { return false } // Treat all values as not equal
-                        : ko.observable["fn"]["equalityComparer"];
-                    return target;
+                    target["equalityComparer"] = notifyWhen == "always" ?
+                        null :  // null equalityComparer means to always notify
+                        valuesArePrimitiveAndEqual;
                 }
             };
 
+            var primitiveTypes = { 'undefined':1, 'boolean':1, 'number':1, 'string':1 };
+            function valuesArePrimitiveAndEqual(a, b) {
+                var oldValueIsPrimitive = (a === null) || (typeof(a) in primitiveTypes);
+                return oldValueIsPrimitive ? (a === b) : false;
+            }
+
+            function throttle(callback, timeout) {
+                var timeoutInstance;
+                return function () {
+                    if (!timeoutInstance) {
+                        timeoutInstance = setTimeout(function() {
+                            timeoutInstance = undefined;
+                            callback();
+                        }, timeout);
+                    }
+                };
+            }
+
+            function debounce(callback, timeout) {
+                var timeoutInstance;
+                return function () {
+                    clearTimeout(timeoutInstance);
+                    timeoutInstance = setTimeout(callback, timeout);
+                };
+            }
+
             function applyExtenders(requestedExtenders) {
                 var target = this;
                 if (requestedExtenders) {
                     ko.utils.objectForEach(requestedExtenders, function(key, value) {
                         var extenderHandler = ko.extenders[key];
                         if (typeof extenderHandler == 'function') {
-                            target = extenderHandler(target, value);
+                            target = extenderHandler(target, value) || target;
                         }
                     });
                 }
@@ -910,6 +1021,7 @@
                 this.target = target;
                 this.callback = callback;
                 this.disposeCallback = disposeCallback;
+                this.isDisposed = false;
                 ko.exportProperty(this, 'dispose', this.dispose);
             };
             ko.subscription.prototype.dispose = function () {
@@ -918,45 +1030,98 @@
             };
 
             ko.subscribable = function () {
+                ko.utils.setPrototypeOfOrExtend(this, ko.subscribable['fn']);
                 this._subscriptions = {};
-
-                ko.utils.extend(this, ko.subscribable['fn']);
-                ko.exportProperty(this, 'subscribe', this.subscribe);
-                ko.exportProperty(this, 'extend', this.extend);
-                ko.exportProperty(this, 'getSubscriptionsCount', this.getSubscriptionsCount);
             }
 
             var defaultEvent = "change";
 
-            ko.subscribable['fn'] = {
+            var ko_subscribable_fn = {
                 subscribe: function (callback, callbackTarget, event) {
+                    var self = this;
+
                     event = event || defaultEvent;
                     var boundCallback = callbackTarget ? callback.bind(callbackTarget) : callback;
 
-                    var subscription = new ko.subscription(this, boundCallback, function () {
-                        ko.utils.arrayRemoveItem(this._subscriptions[event], subscription);
-                    }.bind(this));
+                    var subscription = new ko.subscription(self, boundCallback, function () {
+                        ko.utils.arrayRemoveItem(self._subscriptions[event], subscription);
+                    });
+
+                    // This will force a computed with deferEvaluation to evaluate before any subscriptions
+                    // are registered.
+                    if (self.peek) {
+                        self.peek();
+                    }
 
-                    if (!this._subscriptions[event])
-                        this._subscriptions[event] = [];
-                    this._subscriptions[event].push(subscription);
+                    if (!self._subscriptions[event])
+                        self._subscriptions[event] = [];
+                    self._subscriptions[event].push(subscription);
                     return subscription;
                 },
 
                 "notifySubscribers": function (valueToNotify, event) {
                     event = event || defaultEvent;
-                    if (this._subscriptions[event]) {
-                        ko.dependencyDetection.ignore(function() {
-                            ko.utils.arrayForEach(this._subscriptions[event].slice(0), function (subscription) {
+                    if (this.hasSubscriptionsForEvent(event)) {
+                        try {
+                            ko.dependencyDetection.begin(); // Begin suppressing dependency detection (by setting the top frame to undefined)
+                            for (var a = this._subscriptions[event].slice(0), i = 0, subscription; subscription = a[i]; ++i) {
                                 // In case a subscription was disposed during the arrayForEach cycle, check
                                 // for isDisposed on each subscription before invoking its callback
-                                if (subscription && (subscription.isDisposed !== true))
+                                if (!subscription.isDisposed)
                                     subscription.callback(valueToNotify);
-                            });
-                        }, this);
+                            }
+                        } finally {
+                            ko.dependencyDetection.end(); // End suppressing dependency detection
+                        }
                     }
                 },
 
+                limit: function(limitFunction) {
+                    var self = this, selfIsObservable = ko.isObservable(self),
+                        isPending, previousValue, pendingValue, beforeChange = 'beforeChange';
+
+                    if (!self._origNotifySubscribers) {
+                        self._origNotifySubscribers = self["notifySubscribers"];
+                        self["notifySubscribers"] = function(value, event) {
+                            if (!event || event === defaultEvent) {
+                                self._rateLimitedChange(value);
+                            } else if (event === beforeChange) {
+                                self._rateLimitedBeforeChange(value);
+                            } else {
+                                self._origNotifySubscribers(value, event);
+                            }
+                        };
+                    }
+
+                    var finish = limitFunction(function() {
+                        // If an observable provided a reference to itself, access it to get the latest value.
+                        // This allows computed observables to delay calculating their value until needed.
+                        if (selfIsObservable && pendingValue === self) {
+                            pendingValue = self();
+                        }
+                        isPending = false;
+                        if (self.isDifferent(previousValue, pendingValue)) {
+                            self._origNotifySubscribers(previousValue = pendingValue);
+                        }
+                    });
+
+                    self._rateLimitedChange = function(value) {
+                        isPending = true;
+                        pendingValue = value;
+                        finish();
+                    };
+                    self._rateLimitedBeforeChange = function(value) {
+                        if (!isPending) {
+                            previousValue = value;
+                            self._origNotifySubscribers(value, beforeChange);
+                        }
+                    };
+                },
+
+                hasSubscriptionsForEvent: function(event) {
+                    return this._subscriptions[event] && this._subscriptions[event].length;
+                },
+
                 getSubscriptionsCount: function () {
                     var total = 0;
                     ko.utils.objectForEach(this._subscriptions, function(eventName, subscriptions) {
@@ -965,9 +1130,26 @@
                     return total;
                 },
 
+                isDifferent: function(oldValue, newValue) {
+                    return !this['equalityComparer'] || !this['equalityComparer'](oldValue, newValue);
+                },
+
                 extend: applyExtenders
             };
 
+            ko.exportProperty(ko_subscribable_fn, 'subscribe', ko_subscribable_fn.subscribe);
+            ko.exportProperty(ko_subscribable_fn, 'extend', ko_subscribable_fn.extend);
+            ko.exportProperty(ko_subscribable_fn, 'getSubscriptionsCount', ko_subscribable_fn.getSubscriptionsCount);
+
+// For browsers that support proto assignment, we overwrite the prototype of each
+// observable instance. Since observables are functions, we need Function.prototype
+// to still be in the prototype chain.
+            if (ko.utils.canSetPrototype) {
+                ko.utils.setPrototypeOf(ko_subscribable_fn, Function.prototype);
+            }
+
+            ko.subscribable['fn'] = ko_subscribable_fn;
+
 
             ko.isSubscribable = function (instance) {
                 return instance != null && typeof instance.subscribe == "function" && typeof instance["notifySubscribers"] == "function";
@@ -976,42 +1158,67 @@
             ko.exportSymbol('subscribable', ko.subscribable);
             ko.exportSymbol('isSubscribable', ko.isSubscribable);
 
-            ko.dependencyDetection = (function () {
-                var _frames = [];
+            ko.computedContext = ko.dependencyDetection = (function () {
+                var outerFrames = [],
+                    currentFrame,
+                    lastId = 0;
+
+                // Return a unique ID that can be assigned to an observable for dependency tracking.
+                // Theoretically, you could eventually overflow the number storage size, resulting
+                // in duplicate IDs. But in JavaScript, the largest exact integral value is 2^53
+                // or 9,007,199,254,740,992. If you created 1,000,000 IDs per second, it would
+                // take over 285 years to reach that number.
+                // Reference http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html
+                function getId() {
+                    return ++lastId;
+                }
+
+                function begin(options) {
+                    outerFrames.push(currentFrame);
+                    currentFrame = options;
+                }
+
+                function end() {
+                    currentFrame = outerFrames.pop();
+                }
 
                 return {
-                    begin: function (callback) {
-                        _frames.push({ callback: callback, distinctDependencies:[] });
-                    },
+                    begin: begin,
 
-                    end: function () {
-                        _frames.pop();
-                    },
+                    end: end,
 
                     registerDependency: function (subscribable) {
-                        if (!ko.isSubscribable(subscribable))
-                            throw new Error("Only subscribable things can act as dependencies");
-                        if (_frames.length > 0) {
-                            var topFrame = _frames[_frames.length - 1];
-                            if (!topFrame || ko.utils.arrayIndexOf(topFrame.distinctDependencies, subscribable) >= 0)
-                                return;
-                            topFrame.distinctDependencies.push(subscribable);
-                            topFrame.callback(subscribable);
+                        if (currentFrame) {
+                            if (!ko.isSubscribable(subscribable))
+                                throw new Error("Only subscribable things can act as dependencies");
+                            currentFrame.callback(subscribable, subscribable._id || (subscribable._id = getId()));
                         }
                     },
 
-                    ignore: function(callback, callbackTarget, callbackArgs) {
+                    ignore: function (callback, callbackTarget, callbackArgs) {
                         try {
-                            _frames.push(null);
+                            begin();
                             return callback.apply(callbackTarget, callbackArgs || []);
                         } finally {
-                            _frames.pop();
+                            end();
                         }
+                    },
+
+                    getDependenciesCount: function () {
+                        if (currentFrame)
+                            return currentFrame.computed.getDependenciesCount();
+                    },
+
+                    isInitial: function() {
+                        if (currentFrame)
+                            return currentFrame.isInitial;
                     }
                 };
             })();
-            var primitiveTypes = { 'undefined':true, 'boolean':true, 'number':true, 'string':true };
 
+            ko.exportSymbol('computedContext', ko.computedContext);
+            ko.exportSymbol('computedContext.getDependenciesCount', ko.computedContext.getDependenciesCount);
+            ko.exportSymbol('computedContext.isInitial', ko.computedContext.isInitial);
             ko.observable = function (initialValue) {
                 var _latestValue = initialValue;
 
@@ -1020,7 +1227,7 @@
                         // Write
 
                         // Ignore writes if the value hasn't changed
-                        if ((!observable['equalityComparer']) || !observable['equalityComparer'](_latestValue, arguments[0])) {
+                        if (observable.isDifferent(_latestValue, arguments[0])) {
                             observable.valueWillMutate();
                             _latestValue = arguments[0];
                             if (DEBUG) observable._latestValue = _latestValue;
@@ -1034,12 +1241,13 @@
                         return _latestValue;
                     }
                 }
-                if (DEBUG) observable._latestValue = _latestValue;
                 ko.subscribable.call(observable);
+                ko.utils.setPrototypeOfOrExtend(observable, ko.observable['fn']);
+
+                if (DEBUG) observable._latestValue = _latestValue;
                 observable.peek = function() { return _latestValue };
                 observable.valueHasMutated = function () { observable["notifySubscribers"](_latestValue); }
                 observable.valueWillMutate = function () { observable["notifySubscribers"](_latestValue, "beforeChange"); }
-                ko.utils.extend(observable, ko.observable['fn']);
 
                 ko.exportProperty(observable, 'peek', observable.peek);
                 ko.exportProperty(observable, "valueHasMutated", observable.valueHasMutated);
@@ -1049,15 +1257,18 @@
             }
 
             ko.observable['fn'] = {
-                "equalityComparer": function valuesArePrimitiveAndEqual(a, b) {
-                    var oldValueIsPrimitive = (a === null) || (typeof(a) in primitiveTypes);
-                    return oldValueIsPrimitive ? (a === b) : false;
-                }
+                "equalityComparer": valuesArePrimitiveAndEqual
             };
 
             var protoProperty = ko.observable.protoProperty = "__ko_proto__";
             ko.observable['fn'][protoProperty] = ko.observable;
 
+// Note that for browsers that don't support proto assignment, the
+// inheritance chain is created manually in the ko.observable constructor
+            if (ko.utils.canSetPrototype) {
+                ko.utils.setPrototypeOf(ko.observable['fn'], ko.subscribable['fn']);
+            }
+
             ko.hasPrototype = function(instance, prototype) {
                 if ((instance === null) || (instance === undefined) || (instance[protoProperty] === undefined)) return false;
                 if (instance[protoProperty] === prototype) return true;
@@ -1089,15 +1300,15 @@
                     throw new Error("The argument passed when initializing an observable array must be an array, or null, or undefined.");
 
                 var result = ko.observable(initialValues);
-                ko.utils.extend(result, ko.observableArray['fn']);
-                return result;
+                ko.utils.setPrototypeOfOrExtend(result, ko.observableArray['fn']);
+                return result.extend({'trackArrayChanges':true});
             };
 
             ko.observableArray['fn'] = {
                 'remove': function (valueOrPredicate) {
                     var underlyingArray = this.peek();
                     var removedValues = [];
-                    var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) { return value === valueOrPredicate; };
+                    var predicate = typeof valueOrPredicate == "function" && !ko.isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate; };
                     for (var i = 0; i < underlyingArray.length; i++) {
                         var value = underlyingArray[i];
                         if (predicate(value)) {
@@ -1135,7 +1346,7 @@
 
                 'destroy': function (valueOrPredicate) {
                     var underlyingArray = this.peek();
-                    var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) { return value === valueOrPredicate; };
+                    var predicate = typeof valueOrPredicate == "function" && !ko.isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate; };
                     this.valueWillMutate();
                     for (var i = underlyingArray.length - 1; i >= 0; i--) {
                         var value = underlyingArray[i];
@@ -1182,6 +1393,7 @@
                     // (for consistency with mutating regular observables)
                     var underlyingArray = this.peek();
                     this.valueWillMutate();
+                    this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
                     var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
                     this.valueHasMutated();
                     return methodCallResult;
@@ -1196,11 +1408,144 @@
                 };
             });
 
+// Note that for browsers that don't support proto assignment, the
+// inheritance chain is created manually in the ko.observableArray constructor
+            if (ko.utils.canSetPrototype) {
+                ko.utils.setPrototypeOf(ko.observableArray['fn'], ko.observable['fn']);
+            }
+
             ko.exportSymbol('observableArray', ko.observableArray);
-            ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunctionTarget, options) {
+            var arrayChangeEventName = 'arrayChange';
+            ko.extenders['trackArrayChanges'] = function(target) {
+                // Only modify the target observable once
+                if (target.cacheDiffForKnownOperation) {
+                    return;
+                }
+                var trackingChanges = false,
+                    cachedDiff = null,
+                    pendingNotifications = 0,
+                    underlyingSubscribeFunction = target.subscribe;
+
+                // Intercept "subscribe" calls, and for array change events, ensure change tracking is enabled
+                target.subscribe = target['subscribe'] = function(callback, callbackTarget, event) {
+                    if (event === arrayChangeEventName) {
+                        trackChanges();
+                    }
+                    return underlyingSubscribeFunction.apply(this, arguments);
+                };
+
+                function trackChanges() {
+                    // Calling 'trackChanges' multiple times is the same as calling it once
+                    if (trackingChanges) {
+                        return;
+                    }
+
+                    trackingChanges = true;
+
+                    // Intercept "notifySubscribers" to track how many times it was called.
+                    var underlyingNotifySubscribersFunction = target['notifySubscribers'];
+                    target['notifySubscribers'] = function(valueToNotify, event) {
+                        if (!event || event === defaultEvent) {
+                            ++pendingNotifications;
+                        }
+                        return underlyingNotifySubscribersFunction.apply(this, arguments);
+                    };
+
+                    // Each time the array changes value, capture a clone so that on the next
+                    // change it's possible to produce a diff
+                    var previousContents = [].concat(target.peek() || []);
+                    cachedDiff = null;
+                    target.subscribe(function(currentContents) {
+                        // Make a copy of the current contents and ensure it's an array
+                        currentContents = [].concat(currentContents || []);
+
+                        // Compute the diff and issue notifications, but only if someone is listening
+                        if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
+                            var changes = getChanges(previousContents, currentContents);
+                            if (changes.length) {
+                                target['notifySubscribers'](changes, arrayChangeEventName);
+                            }
+                        }
+
+                        // Eliminate references to the old, removed items, so they can be GCed
+                        previousContents = currentContents;
+                        cachedDiff = null;
+                        pendingNotifications = 0;
+                    });
+                }
+
+                function getChanges(previousContents, currentContents) {
+                    // We try to re-use cached diffs.
+                    // The scenarios where pendingNotifications > 1 are when using rate-limiting or the Deferred Updates
+                    // plugin, which without this check would not be compatible with arrayChange notifications. Normally,
+                    // notifications are issued immediately so we wouldn't be queueing up more than one.
+                    if (!cachedDiff || pendingNotifications > 1) {
+                        cachedDiff = ko.utils.compareArrays(previousContents, currentContents, { 'sparse': true });
+                    }
+
+                    return cachedDiff;
+                }
+
+                target.cacheDiffForKnownOperation = function(rawArray, operationName, args) {
+                    // Only run if we're currently tracking changes for this observable array
+                    // and there aren't any pending deferred notifications.
+                    if (!trackingChanges || pendingNotifications) {
+                        return;
+                    }
+                    var diff = [],
+                        arrayLength = rawArray.length,
+                        argsLength = args.length,
+                        offset = 0;
+
+                    function pushDiff(status, value, index) {
+                        return diff[diff.length] = { 'status': status, 'value': value, 'index': index };
+                    }
+                    switch (operationName) {
+                        case 'push':
+                            offset = arrayLength;
+                        case 'unshift':
+                            for (var index = 0; index < argsLength; index++) {
+                                pushDiff('added', args[index], offset + index);
+                            }
+                            break;
+
+                        case 'pop':
+                            offset = arrayLength - 1;
+                        case 'shift':
+                            if (arrayLength) {
+                                pushDiff('deleted', rawArray[offset], offset);
+                            }
+                            break;
+
+                        case 'splice':
+                            // Negative start index means 'from end of array'. After that we clamp to [0...arrayLength].
+                            // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice
+                            var startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength),
+                                endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength),
+                                endAddIndex = startIndex + argsLength - 2,
+                                endIndex = Math.max(endDeleteIndex, endAddIndex),
+                                additions = [], deletions = [];
+                            for (var index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {
+                                if (index < endDeleteIndex)
+                                    deletions.push(pushDiff('deleted', rawArray[index], index));
+                                if (index < endAddIndex)
+                                    additions.push(pushDiff('added', args[argsIndex], index));
+                            }
+                            ko.utils.findMovesInArrayComparison(deletions, additions);
+                            break;
+
+                        default:
+                            return;
+                    }
+                    cachedDiff = diff;
+                };
+            };
+            ko.computed = ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunctionTarget, options) {
                 var _latestValue,
-                    _hasBeenEvaluated = false,
+                    _needsEvaluation = true,
                     _isBeingEvaluated = false,
+                    _suppressDisposalUntilDisposeWhenReturnsFalse = false,
+                    _isDisposed = false,
                     readFunction = evaluatorFunctionOrOptions;
 
                 if (readFunction && typeof readFunction == "object") {
@@ -1216,15 +1561,21 @@
                 if (typeof readFunction != "function")
                     throw new Error("Pass a function that returns the value of the ko.computed");
 
-                function addSubscriptionToDependency(subscribable) {
-                    _subscriptionsToDependencies.push(subscribable.subscribe(evaluatePossiblyAsync));
+                function addSubscriptionToDependency(subscribable, id) {
+                    if (!_subscriptionsToDependencies[id]) {
+                        _subscriptionsToDependencies[id] = subscribable.subscribe(evaluatePossiblyAsync);
+                        ++_dependenciesCount;
+                    }
                 }
 
                 function disposeAllSubscriptionsToDependencies() {
-                    ko.utils.arrayForEach(_subscriptionsToDependencies, function (subscription) {
+                    _isDisposed = true;
+                    ko.utils.objectForEach(_subscriptionsToDependencies, function (id, subscription) {
                         subscription.dispose();
                     });
-                    _subscriptionsToDependencies = [];
+                    _subscriptionsToDependencies = {};
+                    _dependenciesCount = 0;
+                    _needsEvaluation = false;
                 }
 
                 function evaluatePossiblyAsync() {
@@ -1232,8 +1583,11 @@
                     if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {
                         clearTimeout(evaluationTimeoutInstance);
                         evaluationTimeoutInstance = setTimeout(evaluateImmediate, throttleEvaluationTimeout);
-                    } else
+                    } else if (dependentObservable._evalRateLimited) {
+                        dependentObservable._evalRateLimited();
+                    } else {
                         evaluateImmediate();
+                    }
                 }
 
                 function evaluateImmediate() {
@@ -1245,49 +1599,83 @@
                         return;
                     }
 
-                    // Don't dispose on first evaluation, because the "disposeWhen" callback might
-                    // e.g., dispose when the associated DOM element isn't in the doc, and it's not
-                    // going to be in the doc until *after* the first evaluation
-                    if (_hasBeenEvaluated && disposeWhen()) {
-                        dispose();
+                    // Do not evaluate (and possibly capture new dependencies) if disposed
+                    if (_isDisposed) {
                         return;
                     }
 
+                    if (disposeWhen && disposeWhen()) {
+                        // See comment below about _suppressDisposalUntilDisposeWhenReturnsFalse
+                        if (!_suppressDisposalUntilDisposeWhenReturnsFalse) {
+                            dispose();
+                            return;
+                        }
+                    } else {
+                        // It just did return false, so we can stop suppressing now
+                        _suppressDisposalUntilDisposeWhenReturnsFalse = false;
+                    }
+
                     _isBeingEvaluated = true;
                     try {
                         // Initially, we assume that none of the subscriptions are still being used (i.e., all are candidates for disposal).
                         // Then, during evaluation, we cross off any that are in fact still being used.
-                        var disposalCandidates = ko.utils.arrayMap(_subscriptionsToDependencies, function(item) {return item.target;});
-
-                        ko.dependencyDetection.begin(function(subscribable) {
-                            var inOld;
-                            if ((inOld = ko.utils.arrayIndexOf(disposalCandidates, subscribable)) >= 0)
-                                disposalCandidates[inOld] = undefined; // Don't want to dispose this subscription, as it's still being used
-                            else
-                                addSubscriptionToDependency(subscribable); // Brand new subscription - add it
+                        var disposalCandidates = _subscriptionsToDependencies, disposalCount = _dependenciesCount;
+                        ko.dependencyDetection.begin({
+                            callback: function(subscribable, id) {
+                                if (!_isDisposed) {
+                                    if (disposalCount && disposalCandidates[id]) {
+                                        // Don't want to dispose this subscription, as it's still being used
+                                        _subscriptionsToDependencies[id] = disposalCandidates[id];
+                                        ++_dependenciesCount;
+                                        delete disposalCandidates[id];
+                                        --disposalCount;
+                                    } else {
+                                        // Brand new subscription - add it
+                                        addSubscriptionToDependency(subscribable, id);
+                                    }
+                                }
+                            },
+                            computed: dependentObservable,
+                            isInitial: !_dependenciesCount        // If we're evaluating when there are no previous dependencies, it must be the first time
                         });
 
-                        var newValue = readFunction.call(evaluatorFunctionTarget);
+                        _subscriptionsToDependencies = {};
+                        _dependenciesCount = 0;
+
+                        try {
+                            var newValue = evaluatorFunctionTarget ? readFunction.call(evaluatorFunctionTarget) : readFunction();
+
+                        } finally {
+                            ko.dependencyDetection.end();
+
+                            // For each subscription no longer being used, remove it from the active subscriptions list and dispose it
+                            if (disposalCount) {
+                                ko.utils.objectForEach(disposalCandidates, function(id, toDispose) {
+                                    toDispose.dispose();
+                                });
+                            }
 
-                        // For each subscription no longer being used, remove it from the active subscriptions list and dispose it
-                        for (var i = disposalCandidates.length - 1; i >= 0; i--) {
-                            if (disposalCandidates[i])
-                                _subscriptionsToDependencies.splice(i, 1)[0].dispose();
+                            _needsEvaluation = false;
                         }
-                        _hasBeenEvaluated = true;
 
-                        dependentObservable["notifySubscribers"](_latestValue, "beforeChange");
+                        if (dependentObservable.isDifferent(_latestValue, newValue)) {
+                            dependentObservable["notifySubscribers"](_latestValue, "beforeChange");
 
-                        _latestValue = newValue;
-                        if (DEBUG) dependentObservable._latestValue = _latestValue;
-                        dependentObservable["notifySubscribers"](_latestValue);
+                            _latestValue = newValue;
+                            if (DEBUG) dependentObservable._latestValue = _latestValue;
 
+                            // If rate-limited, the notification will happen within the limit function. Otherwise,
+                            // notify as soon as the value changes. Check specifically for the throttle setting since
+                            // it overrides rateLimit.
+                            if (!dependentObservable._evalRateLimited || dependentObservable['throttleEvaluation']) {
+                                dependentObservable["notifySubscribers"](_latestValue);
+                            }
+                        }
                     } finally {
-                        ko.dependencyDetection.end();
                         _isBeingEvaluated = false;
                     }
 
-                    if (!_subscriptionsToDependencies.length)
+                    if (!_dependenciesCount)
                         dispose();
                 }
 
@@ -1302,7 +1690,7 @@
                         return this; // Permits chained assignments
                     } else {
                         // Reading the value
-                        if (!_hasBeenEvaluated)
+                        if (_needsEvaluation)
                             evaluateImmediate();
                         ko.dependencyDetection.registerDependency(dependentObservable);
                         return _latestValue;
@@ -1310,58 +1698,90 @@
                 }
 
                 function peek() {
-                    if (!_hasBeenEvaluated)
+                    // Peek won't re-evaluate, except to get the initial value when "deferEvaluation" is set.
+                    // That's the only time that both of these conditions will be satisfied.
+                    if (_needsEvaluation && !_dependenciesCount)
                         evaluateImmediate();
                     return _latestValue;
                 }
 
                 function isActive() {
-                    return !_hasBeenEvaluated || _subscriptionsToDependencies.length > 0;
+                    return _needsEvaluation || _dependenciesCount > 0;
                 }
 
                 // By here, "options" is always non-null
                 var writeFunction = options["write"],
                     disposeWhenNodeIsRemoved = options["disposeWhenNodeIsRemoved"] || options.disposeWhenNodeIsRemoved || null,
-                    disposeWhen = options["disposeWhen"] || options.disposeWhen || function() { return false; },
+                    disposeWhenOption = options["disposeWhen"] || options.disposeWhen,
+                    disposeWhen = disposeWhenOption,
                     dispose = disposeAllSubscriptionsToDependencies,
-                    _subscriptionsToDependencies = [],
+                    _subscriptionsToDependencies = {},
+                    _dependenciesCount = 0,
                     evaluationTimeoutInstance = null;
 
                 if (!evaluatorFunctionTarget)
                     evaluatorFunctionTarget = options["owner"];
 
+                ko.subscribable.call(dependentObservable);
+                ko.utils.setPrototypeOfOrExtend(dependentObservable, ko.dependentObservable['fn']);
+
                 dependentObservable.peek = peek;
-                dependentObservable.getDependenciesCount = function () { return _subscriptionsToDependencies.length; };
+                dependentObservable.getDependenciesCount = function () { return _dependenciesCount; };
                 dependentObservable.hasWriteFunction = typeof options["write"] === "function";
                 dependentObservable.dispose = function () { dispose(); };
                 dependentObservable.isActive = isActive;
 
-                ko.subscribable.call(dependentObservable);
-                ko.utils.extend(dependentObservable, ko.dependentObservable['fn']);
+                // Replace the limit function with one that delays evaluation as well.
+                var originalLimit = dependentObservable.limit;
+                dependentObservable.limit = function(limitFunction) {
+                    originalLimit.call(dependentObservable, limitFunction);
+                    dependentObservable._evalRateLimited = function() {
+                        dependentObservable._rateLimitedBeforeChange(_latestValue);
+
+                        _needsEvaluation = true;    // Mark as dirty
+
+                        // Pass the observable to the rate-limit code, which will access it when
+                        // it's time to do the notification.
+                        dependentObservable._rateLimitedChange(dependentObservable);
+                    }
+                };
 
                 ko.exportProperty(dependentObservable, 'peek', dependentObservable.peek);
                 ko.exportProperty(dependentObservable, 'dispose', dependentObservable.dispose);
                 ko.exportProperty(dependentObservable, 'isActive', dependentObservable.isActive);
                 ko.exportProperty(dependentObservable, 'getDependenciesCount', dependentObservable.getDependenciesCount);
 
+                // Add a "disposeWhen" callback that, on each evaluation, disposes if the node was removed without using ko.removeNode.
+                if (disposeWhenNodeIsRemoved) {
+                    // Since this computed is associated with a DOM node, and we don't want to dispose the computed
+                    // until the DOM node is *removed* from the document (as opposed to never having been in the document),
+                    // we'll prevent disposal until "disposeWhen" first returns false.
+                    _suppressDisposalUntilDisposeWhenReturnsFalse = true;
+
+                    // Only watch for the node's disposal if the value really is a node. It might not be,
+                    // e.g., { disposeWhenNodeIsRemoved: true } can be used to opt into the "only dispose
+                    // after first false result" behaviour even if there's no specific node to watch. This
+                    // technique is intended for KO's internal use only and shouldn't be documented or used
+                    // by application code, as it's likely to change in a future version of KO.
+                    if (disposeWhenNodeIsRemoved.nodeType) {
+                        disposeWhen = function () {
+                            return !ko.utils.domNodeIsAttachedToDocument(disposeWhenNodeIsRemoved) || (disposeWhenOption && disposeWhenOption());
+                        };
+                    }
+                }
+
                 // Evaluate, unless deferEvaluation is true
                 if (options['deferEvaluation'] !== true)
                     evaluateImmediate();
 
-                // Build "disposeWhenNodeIsRemoved" and "disposeWhenNodeIsRemovedCallback" option values.
-                // But skip if isActive is false (there will never be any dependencies to dispose).
-                // (Note: "disposeWhenNodeIsRemoved" option both proactively disposes as soon as the node is removed using ko.removeNode(),
-                // plus adds a "disposeWhen" callback that, on each evaluation, disposes if the node was removed by some other means.)
-                if (disposeWhenNodeIsRemoved && isActive()) {
+                // Attach a DOM node disposal callback so that the computed will be proactively disposed as soon as the node is
+                // removed using ko.removeNode. But skip if isActive is false (there will never be any dependencies to dispose).
+                if (disposeWhenNodeIsRemoved && isActive() && disposeWhenNodeIsRemoved.nodeType) {
                     dispose = function() {
                         ko.utils.domNodeDisposal.removeDisposeCallback(disposeWhenNodeIsRemoved, dispose);
                         disposeAllSubscriptionsToDependencies();
                     };
                     ko.utils.domNodeDisposal.addDisposeCallback(disposeWhenNodeIsRemoved, dispose);
-                    var existingDisposeWhenFunction = disposeWhen;
-                    disposeWhen = function () {
-                        return !ko.utils.domNodeIsAttachedToDocument(disposeWhenNodeIsRemoved) || existingDisposeWhenFunction();
-                    }
                 }
 
                 return dependentObservable;
@@ -1374,9 +1794,17 @@
             var protoProp = ko.observable.protoProperty; // == "__ko_proto__"
             ko.dependentObservable[protoProp] = ko.observable;
 
-            ko.dependentObservable['fn'] = {};
+            ko.dependentObservable['fn'] = {
+                "equalityComparer": valuesArePrimitiveAndEqual
+            };
             ko.dependentObservable['fn'][protoProp] = ko.dependentObservable;
 
+// Note that for browsers that don't support proto assignment, the
+// inheritance chain is created manually in the ko.dependentObservable constructor
+            if (ko.utils.canSetPrototype) {
+                ko.utils.setPrototypeOf(ko.dependentObservable['fn'], ko.subscribable['fn']);
+            }
+
             ko.exportSymbol('dependentObservable', ko.dependentObservable);
             ko.exportSymbol('computed', ko.dependentObservable); // Make "ko.computed" an alias for "ko.dependentObservable"
             ko.exportSymbol('isComputed', ko.isComputed);
@@ -1498,7 +1926,7 @@
                         }
                     },
 
-                    writeValue: function(element, value) {
+                    writeValue: function(element, value, allowUnset) {
                         switch (ko.utils.tagNameLower(element)) {
                             case 'option':
                                 switch(typeof value) {
@@ -1520,19 +1948,19 @@
                                 }
                                 break;
                             case 'select':
-                                if (value === "")
+                                if (value === "" || value === null)       // A blank string or null value will select the caption
                                     value = undefined;
-                                if (value === null || value === undefined)
-                                    element.selectedIndex = -1;
-                                for (var i = element.options.length - 1; i >= 0; i--) {
-                                    if (ko.selectExtensions.readValue(element.options[i]) == value) {
-                                        element.selectedIndex = i;
+                                var selection = -1;
+                                for (var i = 0, n = element.options.length, optionValue; i < n; ++i) {
+                                    optionValue = ko.selectExtensions.readValue(element.options[i]);
+                                    // Include special check to handle selecting a caption with a blank string value
+                                    if (optionValue == value || (optionValue == "" && value === undefined)) {
+                                        selection = i;
                                         break;
                                     }
                                 }
-                                // for drop-down select, ensure first is selected
-                                if (!(element.size > 1) && element.selectedIndex === -1) {
-                                    element.selectedIndex = 0;
+                                if (allowUnset || selection >= 0 || (value === undefined && element.size > 1)) {
+                                    element.selectedIndex = selection;
                                 }
                                 break;
                             default:
@@ -1549,170 +1977,162 @@
             ko.exportSymbol('selectExtensions.readValue', ko.selectExtensions.readValue);
             ko.exportSymbol('selectExtensions.writeValue', ko.selectExtensions.writeValue);
             ko.expressionRewriting = (function () {
-                var restoreCapturedTokensRegex = /\@ko_token_(\d+)\@/g;
                 var javaScriptReservedWords = ["true", "false", "null", "undefined"];
 
                 // Matches something that can be assigned to--either an isolated identifier or something ending with a property accessor
                 // This is designed to be simple and avoid false negatives, but could produce false positives (e.g., a+b.c).
+                // This also will not properly handle nested brackets (e.g., obj1[obj2['prop']]; see #911).
                 var javaScriptAssignmentTarget = /^(?:[$_a-z][$\w]*|(.+)(\.\s*[$_a-z][$\w]*|\[.+\]))$/i;
 
-                function restoreTokens(string, tokens) {
-                    var prevValue = null;
-                    while (string != prevValue) { // Keep restoring tokens until it no longer makes a difference (they may be nested)
-                        prevValue = string;
-                        string = string.replace(restoreCapturedTokensRegex, function (match, tokenIndex) {
-                            return tokens[tokenIndex];
-                        });
-                    }
-                    return string;
-                }
-
                 function getWriteableValue(expression) {
-                    if (ko.utils.arrayIndexOf(javaScriptReservedWords, ko.utils.stringTrim(expression).toLowerCase()) >= 0)
+                    if (ko.utils.arrayIndexOf(javaScriptReservedWords, expression) >= 0)
                         return false;
                     var match = expression.match(javaScriptAssignmentTarget);
                     return match === null ? false : match[1] ? ('Object(' + match[1] + ')' + match[2]) : expression;
                 }
 
-                function ensureQuoted(key) {
-                    var trimmedKey = ko.utils.stringTrim(key);
-                    switch (trimmedKey.length && trimmedKey.charAt(0)) {
-                        case "'":
-                        case '"':
-                            return key;
-                        default:
-                            return "'" + trimmedKey + "'";
+                // The following regular expressions will be used to split an object-literal string into tokens
+
+                // These two match strings, either with double quotes or single quotes
+                var stringDouble = '"(?:[^"\\\\]|\\\\.)*"',
+                    stringSingle = "'(?:[^'\\\\]|\\\\.)*'",
+                // Matches a regular expression (text enclosed by slashes), but will also match sets of divisions
+                // as a regular expression (this is handled by the parsing loop below).
+                    stringRegexp = '/(?:[^/\\\\]|\\\\.)*/\w*',
+                // These characters have special meaning to the parser and must not appear in the middle of a
+                // token, except as part of a string.
+                    specials = ',"\'{}()/:[\\]',
+                // Match text (at least two characters) that does not contain any of the above special characters,
+                // although some of the special characters are allowed to start it (all but the colon and comma).
+                // The text can contain spaces, but leading or trailing spaces are skipped.
+                    everyThingElse = '[^\\s:,/][^' + specials + ']*[^\\s' + specials + ']',
+                // Match any non-space character not matched already. This will match colons and commas, since they're
+                // not matched by "everyThingElse", but will also match any other single character that wasn't already
+                // matched (for example: in "a: 1, b: 2", each of the non-space characters will be matched by oneNotSpace).
+                    oneNotSpace = '[^\\s]',
+
+                // Create the actual regular expression by or-ing the above strings. The order is important.
+                    bindingToken = RegExp(stringDouble + '|' + stringSingle + '|' + stringRegexp + '|' + everyThingElse + '|' + oneNotSpace, 'g'),
+
+                // Match end of previous token to determine whether a slash is a division or regex.
+                    divisionLookBehind = /[\])"'A-Za-z0-9_$]+$/,
+                    keywordRegexLookBehind = {'in':1,'return':1,'typeof':1};
+
+                function parseObjectLiteral(objectLiteralString) {
+                    // Trim leading and trailing spaces from the string
+                    var str = ko.utils.stringTrim(objectLiteralString);
+
+                    // Trim braces '{' surrounding the whole object literal
+                    if (str.charCodeAt(0) === 123) str = str.slice(1, -1);
+
+                    // Split into tokens
+                    var result = [], toks = str.match(bindingToken), key, values, depth = 0;
+
+                    if (toks) {
+                        // Append a comma so that we don't need a separate code block to deal with the last item
+                        toks.push(',');
+
+                        for (var i = 0, tok; tok = toks[i]; ++i) {
+                            var c = tok.charCodeAt(0);
+                            // A comma signals the end of a key/value pair if depth is zero
+                            if (c === 44) { // ","
+                                if (depth <= 0) {
+                                    if (key)
+                                        result.push(values ? {key: key, value: values.join('')} : {'unknown': key});
+                                    key = values = depth = 0;
+                                    continue;
+                                }
+                                // Simply skip the colon that separates the name and value
+                            } else if (c === 58) { // ":"
+                                if (!values)
+                                    continue;
+                                // A set of slashes is initially matched as a regular expression, but could be division
+                            } else if (c === 47 && i && tok.length > 1) {  // "/"
+                                // Look at the end of the previous token to determine if the slash is actually division
+                                var match = toks[i-1].match(divisionLookBehind);
+                                if (match && !keywordRegexLookBehind[match[0]]) {
+                                    // The slash is actually a division punctuator; re-parse the remainder of the string (not including the slash)
+                                    str = str.substr(str.indexOf(tok) + 1);
+                                    toks = str.match(bindingToken);
+                                    toks.push(',');
+                                    i = -1;
+                                    // Continue with just the slash
+                                    tok = '/';
+                                }
+                                // Increment depth for parentheses, braces, and brackets so that interior commas are ignored
+                            } else if (c === 40 || c === 123 || c === 91) { // '(', '{', '['
+                                ++depth;
+                            } else if (c === 41 || c === 125 || c === 93) { // ')', '}', ']'
+                                --depth;
+                                // The key must be a single token; if it's a string, trim the quotes
+                            } else if (!key && !values) {
+                                key = (c === 34 || c === 39) /* '"', "'" */ ? tok.slice(1, -1) : tok;
+                                continue;
+                            }
+                            if (values)
+                                values.push(tok);
+                            else
+                                values = [tok];
+                        }
                     }
+                    return result;
                 }
 
-                return {
-                    bindingRewriteValidators: [],
+                // Two-way bindings include a write function that allow the handler to update the value even if it's not an observable.
+                var twoWayBindings = {};
 
-                    parseObjectLiteral: function(objectLiteralString) {
-                        // A full tokeniser+lexer would add too much weight to this library, so here's a simple parser
-                        // that is sufficient just to split an object literal string into a set of top-level key-value pairs
-
-                        var str = ko.utils.stringTrim(objectLiteralString);
-                        if (str.length < 3)
-                            return [];
-                        if (str.charAt(0) === "{")// Ignore any braces surrounding the whole object literal
-                            str = str.substring(1, str.length - 1);
-
-                        // Pull out any string literals and regex literals
-                        var tokens = [];
-                        var tokenStart = null, tokenEndChar;
-                        for (var position = 0; position < str.length; position++) {
-                            var c = str.charAt(position);
-                            if (tokenStart === null) {
-                                switch (c) {
-                                    case '"':
-                                    case "'":
-                                    case "/":
-                                        tokenStart = position;
-                                        tokenEndChar = c;
-                                        break;
-                                }
-                            } else if ((c == tokenEndChar) && (str.charAt(position - 1) !== "\\")) {
-                                var token = str.substring(tokenStart, position + 1);
-                                tokens.push(token);
-                                var replacement = "@ko_token_" + (tokens.length - 1) + "@";
-                                str = str.substring(0, tokenStart) + replacement + str.substring(position + 1);
-                                position -= (token.length - replacement.length);
-                                tokenStart = null;
-                            }
-                        }
+                function preProcessBindings(bindingsStringOrKeyValueArray, bindingOptions) {
+                    bindingOptions = bindingOptions || {};
 
-                        // Next pull out balanced paren, brace, and bracket blocks
-                        tokenStart = null;
-                        tokenEndChar = null;
-                        var tokenDepth = 0, tokenStartChar = null;
-                        for (var position = 0; position < str.length; position++) {
-                            var c = str.charAt(position);
-                            if (tokenStart === null) {
-                                switch (c) {
-                                    case "{": tokenStart = position; tokenStartChar = c;
-                                        tokenEndChar = "}";
-                                        break;
-                                    case "(": tokenStart = position; tokenStartChar = c;
-                                        tokenEndChar = ")";
-                                        break;
-                                    case "[": tokenStart = position; tokenStartChar = c;
-                                        tokenEndChar = "]";
-                                        break;
-                                }
-                            }
+                    function processKeyValue(key, val) {
+                        var writableVal;
+                        function callPreprocessHook(obj) {
+                            return (obj && obj['preprocess']) ? (val = obj['preprocess'](val, key, processKeyValue)) : true;
+                        }
+                        if (!callPreprocessHook(ko['getBindingHandler'](key)))
+                            return;
 
-                            if (c === tokenStartChar)
-                                tokenDepth++;
-                            else if (c === tokenEndChar) {
-                                tokenDepth--;
-                                if (tokenDepth === 0) {
-                                    var token = str.substring(tokenStart, position + 1);
-                                    tokens.push(token);
-                                    var replacement = "@ko_token_" + (tokens.length - 1) + "@";
-                                    str = str.substring(0, tokenStart) + replacement + str.substring(position + 1);
-                                    position -= (token.length - replacement.length);
-                                    tokenStart = null;
-                                }
-                            }
+                        if (twoWayBindings[key] && (writableVal = getWriteableValue(val))) {
+                            // For two-way bindings, provide a write method in case the value
+                            // isn't a writable observable.
+                            propertyAccessorResultStrings.push("'" + key + "':function(_z){" + writableVal + "=_z}");
                         }
 
-                        // Now we can safely split on commas to get the key/value pairs
-                        var result = [];
-                        var keyValuePairs = str.split(",");
-                        for (var i = 0, j = keyValuePairs.length; i < j; i++) {
-                            var pair = keyValuePairs[i];
-                            var colonPos = pair.indexOf(":");
-                            if ((colonPos > 0) && (colonPos < pair.length - 1)) {
-                                var key = pair.substring(0, colonPos);
-                                var value = pair.substring(colonPos + 1);
-                                result.push({ 'key': restoreTokens(key, tokens), 'value': restoreTokens(value, tokens) });
-                            } else {
-                                result.push({ 'unknown': restoreTokens(pair, tokens) });
-                            }
+                        // Values are wrapped in a function so that each value can be accessed independently
+                        if (makeValueAccessors) {
+                            val = 'function(){return ' + val + ' }';
                         }
-                        return result;
-                    },
+                        resultStrings.push("'" + key + "':" + val);
+                    }
 
-                    preProcessBindings: function (objectLiteralStringOrKeyValueArray) {
-                        var keyValueArray = typeof objectLiteralStringOrKeyValueArray === "string"
-                            ? ko.expressionRewriting.parseObjectLiteral(objectLiteralStringOrKeyValueArray)
-                            : objectLiteralStringOrKeyValueArray;
-                        var resultStrings = [], propertyAccessorResultStrings = [];
+                    var resultStrings = [],
+                        propertyAccessorResultStrings = [],
+                        makeValueAccessors = bindingOptions['valueAccessors'],
+                        keyValueArray = typeof bindingsStringOrKeyValueArray === "string" ?
+                            parseObjectLiteral(bindingsStringOrKeyValueArray) : bindingsStringOrKeyValueArray;
 
-                        var keyValueEntry;
-                        for (var i = 0; keyValueEntry = keyValueArray[i]; i++) {
-                            if (resultStrings.length > 0)
-                                resultStrings.push(",");
+                    ko.utils.arrayForEach(keyValueArray, function(keyValue) {
+                        processKeyValue(keyValue.key || keyValue['unknown'], keyValue.value);
+                    });
 
-                            if (keyValueEntry['key']) {
-                                var quotedKey = ensureQuoted(keyValueEntry['key']), val = keyValueEntry['value'];
-                                resultStrings.push(quotedKey);
-                                resultStrings.push(":");
-                                resultStrings.push(val);
+                    if (propertyAccessorResultStrings.length)
+                        processKeyValue('_ko_property_writers', "{" + propertyAccessorResultStrings.join(",") + " }");
 
-                                if (val = getWriteableValue(ko.utils.stringTrim(val))) {
-                                    if (propertyAccessorResultStrings.length > 0)
-                                        propertyAccessorResultStrings.push(", ");
-                                    propertyAccessorResultStrings.push(quotedKey + " : function(__ko_value) { " + val + " = __ko_value; }");
-                                }
-                            } else if (keyValueEntry['unknown']) {
-                                resultStrings.push(keyValueEntry['unknown']);
-                            }
-                        }
+                    return resultStrings.join(",");
+                }
 
-                        var combinedResult = resultStrings.join("");
-                        if (propertyAccessorResultStrings.length > 0) {
-                            var allPropertyAccessors = propertyAccessorResultStrings.join("");
-                            combinedResult = combinedResult + ", '_ko_property_writers' : { " + allPropertyAccessors + " } ";
-                        }
+                return {
+                    bindingRewriteValidators: [],
 
-                        return combinedResult;
-                    },
+                    twoWayBindings: twoWayBindings,
+
+                    parseObjectLiteral: parseObjectLiteral,
+
+                    preProcessBindings: preProcessBindings,
 
                     keyValueArrayContainsKey: function(keyValueArray, key) {
                         for (var i = 0; i < keyValueArray.length; i++)
-                            if (ko.utils.stringTrim(keyValueArray[i]['key']) == key)
+                            if (keyValueArray[i]['key'] == key)
                                 return true;
                         return false;
                     },
@@ -1720,15 +2140,15 @@
                     // Internal, private KO utility for updating model properties from within bindings
                     // property:            If the property being updated is (or might be) an observable, pass it here
                     //                      If it turns out to be a writable observable, it will be written to directly
-                    // allBindingsAccessor: All bindings in the current execution context.
+                    // allBindings:         An object with a get method to retrieve bindings in the current execution context.
                     //                      This will be searched for a '_ko_property_writers' property in case you're writing to a non-observable
                     // key:                 The key identifying the property to be written. Example: for { hasFocus: myValue }, write to 'myValue' by specifying the key 'hasFocus'
                     // value:               The value to be written
                     // checkIfDifferent:    If true, and if the property being written is a writable observable, the value will only be written if
                     //                      it is !== existing value on that writable observable
-                    writeValueToProperty: function(property, allBindingsAccessor, key, value, checkIfDifferent) {
+                    writeValueToProperty: function(property, allBindings, key, value, checkIfDifferent) {
                         if (!property || !ko.isObservable(property)) {
-                            var propWriters = allBindingsAccessor()['_ko_property_writers'];
+                            var propWriters = allBindings.get('_ko_property_writers');
                             if (propWriters && propWriters[key])
                                 propWriters[key](value);
                         } else if (ko.isWriteableObservable(property) && (!checkIfDifferent || property.peek() !== value)) {
@@ -1743,10 +2163,20 @@
             ko.exportSymbol('expressionRewriting.parseObjectLiteral', ko.expressionRewriting.parseObjectLiteral);
             ko.exportSymbol('expressionRewriting.preProcessBindings', ko.expressionRewriting.preProcessBindings);
 
+// Making bindings explicitly declare themselves as "two way" isn't ideal in the long term (it would be better if
+// all bindings could use an official 'property writer' API without needing to declare that they might). However,
+// since this is not, and has never been, a public API (_ko_property_writers was never documented), it's acceptable
+// as an internal implementation detail in the short term.
+// For those developers who rely on _ko_property_writers in their custom bindings, we expose _twoWayBindings as an
+// undocumented feature that makes it relatively easy to upgrade to KO 3.0. However, this is still not an official
+// public API, and we reserve the right to remove it at any time if we create a real public property writers API.
+            ko.exportSymbol('expressionRewriting._twoWayBindings', ko.expressionRewriting.twoWayBindings);
+
 // For backward compatibility, define the following aliases. (Previously, these function names were misleading because
 // they referred to JSON specifically, even though they actually work with arbitrary JavaScript object literal expressions.)
             ko.exportSymbol('jsonExpressionRewriting', ko.expressionRewriting);
-            ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.expressionRewriting.preProcessBindings);(function() {
+            ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.expressionRewriting.preProcessBindings);
+            (function() {
                 // "Virtual elements" is an abstraction on top of the usual DOM API which understands the notion that comment nodes
                 // may be used to represent hierarchy (in addition to the DOM's natural hierarchy).
                 // If you call the DOM-manipulating functions on ko.virtualElements, you will be able to read and write the state
@@ -1760,16 +2190,16 @@
                 // So, use node.text where available, and node.nodeValue elsewhere
                 var commentNodesHaveTextProperty = document && document.createComment("test").text === "<!--test-->";
 
-                var startCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*ko(?:\s+(.+\s*\:[\s\S]*))?\s*-->$/ : /^\s*ko(?:\s+(.+\s*\:[\s\S]*))?\s*$/;
+                var startCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*ko(?:\s+([\s\S]+))?\s*-->$/ : /^\s*ko(?:\s+([\s\S]+))?\s*$/;
                 var endCommentRegex =   commentNodesHaveTextProperty ? /^<!--\s*\/ko\s*-->$/ : /^\s*\/ko\s*$/;
                 var htmlTagsWithOptionallyClosingChildren = { 'ul': true, 'ol': true };
 
                 function isStartComment(node) {
-                    return (node.nodeType == 8) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex);
+                    return (node.nodeType == 8) && startCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
                 }
 
                 function isEndComment(node) {
-                    return (node.nodeType == 8) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(endCommentRegex);
+                    return (node.nodeType == 8) && endCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
                 }
 
                 function getVirtualChildren(startComment, allowUnbalanced) {
@@ -1896,8 +2326,10 @@
                         return node.nextSibling;
                     },
 
+                    hasBindingValue: isStartComment,
+
                     virtualNodeBindingValue: function(node) {
-                        var regexMatch = isStartComment(node);
+                        var regexMatch = (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex);
                         return regexMatch ? regexMatch[1] : null;
                     },
 
@@ -1950,7 +2382,7 @@
                     'nodeHasBindings': function(node) {
                         switch (node.nodeType) {
                             case 1: return node.getAttribute(defaultBindingAttributeName) != null;   // Element
-                            case 8: return ko.virtualElements.virtualNodeBindingValue(node) != null; // Comment node
+                            case 8: return ko.virtualElements.hasBindingValue(node); // Comment node
                             default: return false;
                         }
                     },
@@ -1960,6 +2392,11 @@
                         return bindingsString ? this['parseBindingsString'](bindingsString, bindingContext, node) : null;
                     },
 
+                    'getBindingAccessors': function(node, bindingContext) {
+                        var bindingsString = this['getBindingsString'](node, bindingContext);
+                        return bindingsString ? this['parseBindingsString'](bindingsString, bindingContext, node, {'valueAccessors':true}) : null;
+                    },
+
                     // The following function is only used internally by this default provider.
                     // It's not part of the interface definition for a general binding provider.
                     'getBindingsString': function(node, bindingContext) {
@@ -1972,9 +2409,9 @@
 
                     // The following function is only used internally by this default provider.
                     // It's not part of the interface definition for a general binding provider.
-                    'parseBindingsString': function(bindingsString, bindingContext, node) {
+                    'parseBindingsString': function(bindingsString, bindingContext, node, options) {
                         try {
-                            var bindingFunction = createBindingsStringEvaluatorViaCache(bindingsString, this.bindingCache);
+                            var bindingFunction = createBindingsStringEvaluatorViaCache(bindingsString, this.bindingCache, options);
                             return bindingFunction(bindingContext, node);
                         } catch (ex) {
                             ex.message = "Unable to parse bindings.\nBindings value: " + bindingsString + "\nMessage: " + ex.message;
@@ -1985,17 +2422,17 @@
 
                 ko.bindingProvider['instance'] = new ko.bindingProvider();
 
-                function createBindingsStringEvaluatorViaCache(bindingsString, cache) {
-                    var cacheKey = bindingsString;
+                function createBindingsStringEvaluatorViaCache(bindingsString, cache, options) {
+                    var cacheKey = bindingsString + (options && options['valueAccessors'] || '');
                     return cache[cacheKey]
-                        || (cache[cacheKey] = createBindingsStringEvaluator(bindingsString));
+                        || (cache[cacheKey] = createBindingsStringEvaluator(bindingsString, options));
                 }
 
-                function createBindingsStringEvaluator(bindingsString) {
+                function createBindingsStringEvaluator(bindingsString, options) {
                     // Build the source for a function that evaluates "expression"
                     // For each scope variable, add an extra level of "with" nesting
                     // Example result: with(sc1) { with(sc0) { return (expression) } }
-                    var rewrittenBindings = ko.expressionRewriting.preProcessBindings(bindingsString),
+                    var rewrittenBindings = ko.expressionRewriting.preProcessBindings(bindingsString, options),
                         functionBody = "with($context){with($data||{}){return{" + rewrittenBindings + "}}}";
                     return new Function("$context", "$element", functionBody);
                 }
@@ -2005,49 +2442,214 @@
             (function () {
                 ko.bindingHandlers = {};
 
-                ko.bindingContext = function(dataItem, parentBindingContext, dataItemAlias) {
-                    if (parentBindingContext) {
-                        ko.utils.extend(this, parentBindingContext); // Inherit $root and any custom properties
-                        this['$parentContext'] = parentBindingContext;
-                        this['$parent'] = parentBindingContext['$data'];
-                        this['$parents'] = (parentBindingContext['$parents'] || []).slice(0);
-                        this['$parents'].unshift(this['$parent']);
-                    } else {
-                        this['$parents'] = [];
-                        this['$root'] = dataItem;
-                        // Export 'ko' in the binding context so it will be available in bindings and templates
-                        // even if 'ko' isn't exported as a global, such as when using an AMD loader.
-                        // See https://github.com/SteveSanderson/knockout/issues/490
-                        this['ko'] = ko;
-                    }
-                    this['$data'] = dataItem;
-                    if (dataItemAlias)
-                        this[dataItemAlias] = dataItem;
-                }
-                ko.bindingContext.prototype['createChildContext'] = function (dataItem, dataItemAlias) {
-                    return new ko.bindingContext(dataItem, this, dataItemAlias);
+                // The following element types will not be recursed into during binding. In the future, we
+                // may consider adding <template> to this list, because such elements' contents are always
+                // intended to be bound in a different context from where they appear in the document.
+                var bindingDoesNotRecurseIntoElementTypes = {
+                    // Don't want bindings that operate on text nodes to mutate <script> contents,
+                    // because it's unexpected and a potential XSS issue
+                    'script': true
+                };
+
+                // Use an overridable method for retrieving binding handlers so that a plugins may support dynamically created handlers
+                ko['getBindingHandler'] = function(bindingKey) {
+                    return ko.bindingHandlers[bindingKey];
+                };
+
+                // The ko.bindingContext constructor is only called directly to create the root context. For child
+                // contexts, use bindingContext.createChildContext or bindingContext.extend.
+                ko.bindingContext = function(dataItemOrAccessor, parentContext, dataItemAlias, extendCallback) {
+
+                    // The binding context object includes static properties for the current, parent, and root view models.
+                    // If a view model is actually stored in an observable, the corresponding binding context object, and
+                    // any child contexts, must be updated when the view model is changed.
+                    function updateContext() {
+                        // Most of the time, the context will directly get a view model object, but if a function is given,
+                        // we call the function to retrieve the view model. If the function accesses any obsevables or returns
+                        // an observable, the dependency is tracked, and those observables can later cause the binding
+                        // context to be updated.
+                        var dataItemOrObservable = isFunc ? dataItemOrAccessor() : dataItemOrAccessor,
+                            dataItem = ko.utils.unwrapObservable(dataItemOrObservable);
+
+                        if (parentContext) {
+                            // When a "parent" context is given, register a dependency on the parent context. Thus whenever the
+                            // parent context is updated, this context will also be updated.
+                            if (parentContext._subscribable)
+                                parentContext._subscribable();
+
+                            // Copy $root and any custom properties from the parent context
+                            ko.utils.extend(self, parentContext);
+
+                            // Because the above copy overwrites our own properties, we need to reset them.
+                            // During the first execution, "subscribable" isn't set, so don't bother doing the update then.
+                            if (subscribable) {
+                                self._subscribable = subscribable;
+                            }
+                        } else {
+                            self['$parents'] = [];
+                            self['$root'] = dataItem;
+
+                            // Export 'ko' in the binding context so it will be available in bindings and templates
+                            // even if 'ko' isn't exported as a global, such as when using an AMD loader.
+                            // See https://github.com/SteveSanderson/knockout/issues/490
+                            self['ko'] = ko;
+                        }
+                        self['$rawData'] = dataItemOrObservable;
+                        self['$data'] = dataItem;
+                        if (dataItemAlias)
+                            self[dataItemAlias] = dataItem;
+
+                        // The extendCallback function is provided when creating a child context or extending a context.
+                        // It handles the specific actions needed to finish setting up the binding context. Actions in this
+                        // function could also add dependencies to this binding context.
+                        if (extendCallback)
+                            extendCallback(self, parentContext, dataItem);
+
+                        return self['$data'];
+                    }
+                    function disposeWhen() {
+                        return nodes && !ko.utils.anyDomNodeIsAttachedToDocument(nodes);
+                    }
+
+                    var self = this,
+                        isFunc = typeof(dataItemOrAccessor) == "function" && !ko.isObservable(dataItemOrAccessor),
+                        nodes,
+                        subscribable = ko.dependentObservable(updateContext, null, { disposeWhen: disposeWhen, disposeWhenNodeIsRemoved: true });
+
+                    // At this point, the binding context has been initialized, and the "subscribable" computed observable is
+                    // subscribed to any observables that were accessed in the process. If there is nothing to track, the
+                    // computed will be inactive, and we can safely throw it away. If it's active, the computed is stored in
+                    // the context object.
+                    if (subscribable.isActive()) {
+                        self._subscribable = subscribable;
+
+                        // Always notify because even if the model ($data) hasn't changed, other context properties might have changed
+                        subscribable['equalityComparer'] = null;
+
+                        // We need to be able to dispose of this computed observable when it's no longer needed. This would be
+                        // easy if we had a single node to watch, but binding contexts can be used by many different nodes, and
+                        // we cannot assume that those nodes have any relation to each other. So instead we track any node that
+                        // the context is attached to, and dispose the computed when all of those nodes have been cleaned.
+
+                        // Add properties to *subscribable* instead of *self* because any properties added to *self* may be overwritten on updates
+                        nodes = [];
+                        subscribable._addNode = function(node) {
+                            nodes.push(node);
+                            ko.utils.domNodeDisposal.addDisposeCallback(node, function(node) {
+                                ko.utils.arrayRemoveItem(nodes, node);
+                                if (!nodes.length) {
+                                    subscribable.dispose();
+                                    self._subscribable = subscribable = undefined;
+                                }
+                            });
+                        };
+                    }
+                }
+
+                // Extend the binding context hierarchy with a new view model object. If the parent context is watching
+                // any obsevables, the new child context will automatically get a dependency on the parent context.
+                // But this does not mean that the $data value of the child context will also get updated. If the child
+                // view model also depends on the parent view model, you must provide a function that returns the correct
+                // view model on each update.
+                ko.bindingContext.prototype['createChildContext'] = function (dataItemOrAccessor, dataItemAlias, extendCallback) {
+                    return new ko.bindingContext(dataItemOrAccessor, this, dataItemAlias, function(self, parentContext) {
+                        // Extend the context hierarchy by setting the appropriate pointers
+                        self['$parentContext'] = parentContext;
+                        self['$parent'] = parentContext['$data'];
+                        self['$parents'] = (parentContext['$parents'] || []).slice(0);
+                        self['$parents'].unshift(self['$parent']);
+                        if (extendCallback)
+                            extendCallback(self);
+                    });
                 };
+
+                // Extend the binding context with new custom properties. This doesn't change the context hierarchy.
+                // Similarly to "child" contexts, provide a function here to make sure that the correct values are set
+                // when an observable view model is updated.
                 ko.bindingContext.prototype['extend'] = function(properties) {
-                    var clone = ko.utils.extend(new ko.bindingContext(), this);
-                    return ko.utils.extend(clone, properties);
+                    // If the parent context references an observable view model, "_subscribable" will always be the
+                    // latest view model object. If not, "_subscribable" isn't set, and we can use the static "$data" value.
+                    return new ko.bindingContext(this._subscribable || this['$data'], this, null, function(self, parentContext) {
+                        // This "child" context doesn't directly track a parent observable view model,
+                        // so we need to manually set the $rawData value to match the parent.
+                        self['$rawData'] = parentContext['$rawData'];
+                        ko.utils.extend(self, typeof(properties) == "function" ? properties() : properties);
+                    });
                 };
 
+                // Returns the valueAccesor function for a binding value
+                function makeValueAccessor(value) {
+                    return function() {
+                        return value;
+                    };
+                }
+
+                // Returns the value of a valueAccessor function
+                function evaluateValueAccessor(valueAccessor) {
+                    return valueAccessor();
+                }
+
+                // Given a function that returns bindings, create and return a new object that contains
+                // binding value-accessors functions. Each accessor function calls the original function
+                // so that it always gets the latest value and all dependencies are captured. This is used
+                // by ko.applyBindingsToNode and getBindingsAndMakeAccessors.
+                function makeAccessorsFromFunction(callback) {
+                    return ko.utils.objectMap(ko.dependencyDetection.ignore(callback), function(value, key) {
+                        return function() {
+                            return callback()[key];
+                        };
+                    });
+                }
+
+                // Given a bindings function or object, create and return a new object that contains
+                // binding value-accessors functions. This is used by ko.applyBindingsToNode.
+                function makeBindingAccessors(bindings, context, node) {
+                    if (typeof bindings === 'function') {
+                        return makeAccessorsFromFunction(bindings.bind(null, context, node));
+                    } else {
+                        return ko.utils.objectMap(bindings, makeValueAccessor);
+                    }
+                }
+
+                // This function is used if the binding provider doesn't include a getBindingAccessors function.
+                // It must be called with 'this' set to the provider instance.
+                function getBindingsAndMakeAccessors(node, context) {
+                    return makeAccessorsFromFunction(this['getBindings'].bind(this, node, context));
+                }
+
                 function validateThatBindingIsAllowedForVirtualElements(bindingName) {
                     var validator = ko.virtualElements.allowedBindings[bindingName];
                     if (!validator)
                         throw new Error("The binding '" + bindingName + "' cannot be used with virtual elements")
                 }
 
-                function applyBindingsToDescendantsInternal (viewModel, elementOrVirtualElement, bindingContextsMayDifferFromDomParentElement) {
-                    var currentChild, nextInQueue = ko.virtualElements.firstChild(elementOrVirtualElement);
+                function applyBindingsToDescendantsInternal (bindingContext, elementOrVirtualElement, bindingContextsMayDifferFromDomParentElement) {
+                    var currentChild,
+                        nextInQueue = ko.virtualElements.firstChild(elementOrVirtualElement),
+                        provider = ko.bindingProvider['instance'],
+                        preprocessNode = provider['preprocessNode'];
+
+                    // Preprocessing allows a binding provider to mutate a node before bindings are applied to it. For example it's
+                    // possible to insert new siblings after it, and/or replace the node with a different one. This can be used to
+                    // implement custom binding syntaxes, such as {{ value }} for string interpolation, or custom element types that
+                    // trigger insertion of <template> contents at that point in the document.
+                    if (preprocessNode) {
+                        while (currentChild = nextInQueue) {
+                            nextInQueue = ko.virtualElements.nextSibling(currentChild);
+                            preprocessNode.call(provider, currentChild);
+                        }
+                        // Reset nextInQueue for the next loop
+                        nextInQueue = ko.virtualElements.firstChild(elementOrVirtualElement);
+                    }
+
                     while (currentChild = nextInQueue) {
                         // Keep a record of the next child *before* applying bindings, in case the binding removes the current child from its position
                         nextInQueue = ko.virtualElements.nextSibling(currentChild);
-                        applyBindingsToNodeAndDescendantsInternal(viewModel, currentChild, bindingContextsMayDifferFromDomParentElement);
+                        applyBindingsToNodeAndDescendantsInternal(bindingContext, currentChild, bindingContextsMayDifferFromDomParentElement);
                     }
                 }
 
-                function applyBindingsToNodeAndDescendantsInternal (viewModel, nodeVerified, bindingContextMayDifferFromDomParentElement) {
+                function applyBindingsToNodeAndDescendantsInternal (bindingContext, nodeVerified, bindingContextMayDifferFromDomParentElement) {
                     var shouldBindDescendants = true;
 
                     // Perf optimisation: Apply bindings only if...
@@ -2061,137 +2663,218 @@
                     var shouldApplyBindings = (isElement && bindingContextMayDifferFromDomParentElement)             // Case (1)
                         || ko.bindingProvider['instance']['nodeHasBindings'](nodeVerified);       // Case (2)
                     if (shouldApplyBindings)
-                        shouldBindDescendants = applyBindingsToNodeInternal(nodeVerified, null, viewModel, bindingContextMayDifferFromDomParentElement).shouldBindDescendants;
+                        shouldBindDescendants = applyBindingsToNodeInternal(nodeVerified, null, bindingContext, bindingContextMayDifferFromDomParentElement)['shouldBindDescendants'];
 
-                    if (shouldBindDescendants) {
+                    if (shouldBindDescendants && !bindingDoesNotRecurseIntoElementTypes[ko.utils.tagNameLower(nodeVerified)]) {
                         // We're recursing automatically into (real or virtual) child nodes without changing binding contexts. So,
                         //  * For children of a *real* element, the binding context is certainly the same as on their DOM .parentNode,
                         //    hence bindingContextsMayDifferFromDomParentElement is false
                         //  * For children of a *virtual* element, we can't be sure. Evaluating .parentNode on those children may
                         //    skip over any number of intermediate virtual elements, any of which might define a custom binding context,
                         //    hence bindingContextsMayDifferFromDomParentElement is true
-                        applyBindingsToDescendantsInternal(viewModel, nodeVerified, /* bindingContextsMayDifferFromDomParentElement: */ !isElement);
+                        applyBindingsToDescendantsInternal(bindingContext, nodeVerified, /* bindingContextsMayDifferFromDomParentElement: */ !isElement);
                     }
                 }
 
-                var boundElementDomDataKey = '__ko_boundElement';
-                function applyBindingsToNodeInternal (node, bindings, viewModelOrBindingContext, bindingContextMayDifferFromDomParentElement) {
-                    // Need to be sure that inits are only run once, and updates never run until all the inits have been run
-                    var initPhase = 0; // 0 = before all inits, 1 = during inits, 2 = after all inits
-
-                    // Each time the dependentObservable is evaluated (after data changes),
-                    // the binding attribute is reparsed so that it can pick out the correct
-                    // model properties in the context of the changed data.
-                    // DOM event callbacks need to be able to access this changed data,
-                    // so we need a single parsedBindings variable (shared by all callbacks
-                    // associated with this node's bindings) that all the closures can access.
-                    var parsedBindings;
-                    function makeValueAccessor(bindingKey) {
-                        return function () { return parsedBindings[bindingKey] }
-                    }
-                    function parsedBindingsAccessor() {
-                        return parsedBindings;
-                    }
+                var boundElementDomDataKey = ko.utils.domData.nextKey();
+
+
+                function topologicalSortBindings(bindings) {
+                    // Depth-first sort
+                    var result = [],                // The list of key/handler pairs that we will return
+                        bindingsConsidered = {},    // A temporary record of which bindings are already in 'result'
+                        cyclicDependencyStack = []; // Keeps track of a depth-search so that, if there's a cycle, we know which bindings caused it
+                    ko.utils.objectForEach(bindings, function pushBinding(bindingKey) {
+                        if (!bindingsConsidered[bindingKey]) {
+                            var binding = ko['getBindingHandler'](bindingKey);
+                            if (binding) {
+                                // First add dependencies (if any) of the current binding
+                                if (binding['after']) {
+                                    cyclicDependencyStack.push(bindingKey);
+                                    ko.utils.arrayForEach(binding['after'], function(bindingDependencyKey) {
+                                        if (bindings[bindingDependencyKey]) {
+                                            if (ko.utils.arrayIndexOf(cyclicDependencyStack, bindingDependencyKey) !== -1) {
+                                                throw Error("Cannot combine the following bindings, because they have a cyclic dependency: " + cyclicDependencyStack.join(", "));
+                                            } else {
+                                                pushBinding(bindingDependencyKey);
+                                            }
+                                        }
+                                    });
+                                    cyclicDependencyStack.length--;
+                                }
+                                // Next add the current binding
+                                result.push({ key: bindingKey, handler: binding });
+                            }
+                            bindingsConsidered[bindingKey] = true;
+                        }
+                    });
 
-                    var bindingHandlerThatControlsDescendantBindings;
+                    return result;
+                }
 
+                function applyBindingsToNodeInternal(node, sourceBindings, bindingContext, bindingContextMayDifferFromDomParentElement) {
                     // Prevent multiple applyBindings calls for the same node, except when a binding value is specified
                     var alreadyBound = ko.utils.domData.get(node, boundElementDomDataKey);
-                    if (!bindings) {
+                    if (!sourceBindings) {
                         if (alreadyBound) {
                             throw Error("You cannot apply bindings multiple times to the same element.");
                         }
                         ko.utils.domData.set(node, boundElementDomDataKey, true);
                     }
 
-                    ko.dependentObservable(
-                        function () {
-                            // Ensure we have a nonnull binding context to work with
-                            var bindingContextInstance = viewModelOrBindingContext && (viewModelOrBindingContext instanceof ko.bindingContext)
-                                ? viewModelOrBindingContext
-                                : new ko.bindingContext(ko.utils.unwrapObservable(viewModelOrBindingContext));
-                            var viewModel = bindingContextInstance['$data'];
-
-                            // Optimization: Don't store the binding context on this node if it's definitely the same as on node.parentNode, because
-                            // we can easily recover it just by scanning up the node's ancestors in the DOM
-                            // (note: here, parent node means "real DOM parent" not "virtual parent", as there's no O(1) way to find the virtual parent)
-                            if (!alreadyBound && bindingContextMayDifferFromDomParentElement)
-                                ko.storedBindingContextForNode(node, bindingContextInstance);
-
-                            // Use evaluatedBindings if given, otherwise fall back on asking the bindings provider to give us some bindings
-                            var evaluatedBindings = (typeof bindings == "function") ? bindings(bindingContextInstance, node) : bindings;
-                            parsedBindings = evaluatedBindings || ko.bindingProvider['instance']['getBindings'](node, bindingContextInstance);
-
-                            if (parsedBindings) {
-                                // First run all the inits, so bindings can register for notification on changes
-                                if (initPhase === 0) {
-                                    initPhase = 1;
-                                    ko.utils.objectForEach(parsedBindings, function(bindingKey) {
-                                        var binding = ko.bindingHandlers[bindingKey];
-                                        if (binding && node.nodeType === 8)
-                                            validateThatBindingIsAllowedForVirtualElements(bindingKey);
-
-                                        if (binding && typeof binding["init"] == "function") {
-                                            var handlerInitFn = binding["init"];
-                                            var initResult = handlerInitFn(node, makeValueAccessor(bindingKey), parsedBindingsAccessor, viewModel, bindingContextInstance);
-
-                                            // If this binding handler claims to control descendant bindings, make a note of this
-                                            if (initResult && initResult['controlsDescendantBindings']) {
-                                                if (bindingHandlerThatControlsDescendantBindings !== undefined)
-                                                    throw new Error("Multiple bindings (" + bindingHandlerThatControlsDescendantBindings + " and " + bindingKey + ") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.");
-                                                bindingHandlerThatControlsDescendantBindings = bindingKey;
-                                            }
+                    // Optimization: Don't store the binding context on this node if it's definitely the same as on node.parentNode, because
+                    // we can easily recover it just by scanning up the node's ancestors in the DOM
+                    // (note: here, parent node means "real DOM parent" not "virtual parent", as there's no O(1) way to find the virtual parent)
+                    if (!alreadyBound && bindingContextMayDifferFromDomParentElement)
+                        ko.storedBindingContextForNode(node, bindingContext);
+
+                    // Use bindings if given, otherwise fall back on asking the bindings provider to give us some bindings
+                    var bindings;
+                    if (sourceBindings && typeof sourceBindings !== 'function') {
+                        bindings = sourceBindings;
+                    } else {
+                        var provider = ko.bindingProvider['instance'],
+                            getBindings = provider['getBindingAccessors'] || getBindingsAndMakeAccessors;
+
+                        // Get the binding from the provider within a computed observable so that we can update the bindings whenever
+                        // the binding context is updated or if the binding provider accesses observables.
+                        var bindingsUpdater = ko.dependentObservable(
+                            function() {
+                                bindings = sourceBindings ? sourceBindings(bindingContext, node) : getBindings.call(provider, node, bindingContext);
+                                // Register a dependency on the binding context to support obsevable view models.
+                                if (bindings && bindingContext._subscribable)
+                                    bindingContext._subscribable();
+                                return bindings;
+                            },
+                            null, { disposeWhenNodeIsRemoved: node }
+                        );
+
+                        if (!bindings || !bindingsUpdater.isActive())
+                            bindingsUpdater = null;
+                    }
+
+                    var bindingHandlerThatControlsDescendantBindings;
+                    if (bindings) {
+                        // Return the value accessor for a given binding. When bindings are static (won't be updated because of a binding
+                        // context update), just return the value accessor from the binding. Otherwise, return a function that always gets
+                        // the latest binding value and registers a dependency on the binding updater.
+                        var getValueAccessor = bindingsUpdater
+                            ? function(bindingKey) {
+                            return function() {
+                                return evaluateValueAccessor(bindingsUpdater()[bindingKey]);
+                            };
+                        } : function(bindingKey) {
+                            return bindings[bindingKey];
+                        };
+
+                        // Use of allBindings as a function is maintained for backwards compatibility, but its use is deprecated
+                        function allBindings() {
+                            return ko.utils.objectMap(bindingsUpdater ? bindingsUpdater() : bindings, evaluateValueAccessor);
+                        }
+                        // The following is the 3.x allBindings API
+                        allBindings['get'] = function(key) {
+                            return bindings[key] && evaluateValueAccessor(getValueAccessor(key));
+                        };
+                        allBindings['has'] = function(key) {
+                            return key in bindings;
+                        };
+
+                        // First put the bindings into the right order
+                        var orderedBindings = topologicalSortBindings(bindings);
+
+                        // Go through the sorted bindings, calling init and update for each
+                        ko.utils.arrayForEach(orderedBindings, function(bindingKeyAndHandler) {
+                            // Note that topologicalSortBindings has already filtered out any nonexistent binding handlers,
+                            // so bindingKeyAndHandler.handler will always be nonnull.
+                            var handlerInitFn = bindingKeyAndHandler.handler["init"],
+                                handlerUpdateFn = bindingKeyAndHandler.handler["update"],
+                                bindingKey = bindingKeyAndHandler.key;
+
+                            if (node.nodeType === 8) {
+                                validateThatBindingIsAllowedForVirtualElements(bindingKey);
+                            }
+
+                            try {
+                                // Run init, ignoring any dependencies
+                                if (typeof handlerInitFn == "function") {
+                                    ko.dependencyDetection.ignore(function() {
+                                        var initResult = handlerInitFn(node, getValueAccessor(bindingKey), allBindings, bindingContext['$data'], bindingContext);
+
+                                        // If this binding handler claims to control descendant bindings, make a note of this
+                                        if (initResult && initResult['controlsDescendantBindings']) {
+                                            if (bindingHandlerThatControlsDescendantBindings !== undefined)
+                                                throw new Error("Multiple bindings (" + bindingHandlerThatControlsDescendantBindings + " and " + bindingKey + ") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.");
+                                            bindingHandlerThatControlsDescendantBindings = bindingKey;
                                         }
                                     });
-                                    initPhase = 2;
                                 }
 
-                                // ... then run all the updates, which might trigger changes even on the first evaluation
-                                if (initPhase === 2) {
-                                    ko.utils.objectForEach(parsedBindings, function(bindingKey) {
-                                        var binding = ko.bindingHandlers[bindingKey];
-                                        if (binding && typeof binding["update"] == "function") {
-                                            var handlerUpdateFn = binding["update"];
-                                            handlerUpdateFn(node, makeValueAccessor(bindingKey), parsedBindingsAccessor, viewModel, bindingContextInstance);
-                                        }
-                                    });
+                                // Run update in its own computed wrapper
+                                if (typeof handlerUpdateFn == "function") {
+                                    ko.dependentObservable(
+                                        function() {
+                                            handlerUpdateFn(node, getValueAccessor(bindingKey), allBindings, bindingContext['$data'], bindingContext);
+                                        },
+                                        null,
+                                        { disposeWhenNodeIsRemoved: node }
+                                    );
                                 }
+                            } catch (ex) {
+                                ex.message = "Unable to process binding \"" + bindingKey + ": " + bindings[bindingKey] + "\"\nMessage: " + ex.message;
+                                throw ex;
                             }
-                        },
-                        null,
-                        { disposeWhenNodeIsRemoved : node }
-                    );
+                        });
+                    }
 
                     return {
-                        shouldBindDescendants: bindingHandlerThatControlsDescendantBindings === undefined
+                        'shouldBindDescendants': bindingHandlerThatControlsDescendantBindings === undefined
                     };
                 };
 
-                var storedBindingContextDomDataKey = "__ko_bindingContext__";
+                var storedBindingContextDomDataKey = ko.utils.domData.nextKey();
                 ko.storedBindingContextForNode = function (node, bindingContext) {
-                    if (arguments.length == 2)
+                    if (arguments.length == 2) {
                         ko.utils.domData.set(node, storedBindingContextDomDataKey, bindingContext);
-                    else
+                        if (bindingContext._subscribable)
+                            bindingContext._subscribable._addNode(node);
+                    } else {
                         return ko.utils.domData.get(node, storedBindingContextDomDataKey);
+                    }
+                }
+
+                function getBindingContext(viewModelOrBindingContext) {
+                    return viewModelOrBindingContext && (viewModelOrBindingContext instanceof ko.bindingContext)
+                        ? viewModelOrBindingContext
+                        : new ko.bindingContext(viewModelOrBindingContext);
                 }
 
-                ko.applyBindingsToNode = function (node, bindings, viewModel) {
+                ko.applyBindingAccessorsToNode = function (node, bindings, viewModelOrBindingContext) {
                     if (node.nodeType === 1) // If it's an element, workaround IE <= 8 HTML parsing weirdness
                         ko.virtualElements.normaliseVirtualElementDomStructure(node);
-                    return applyBindingsToNodeInternal(node, bindings, viewModel, true);
+                    return applyBindingsToNodeInternal(node, bindings, getBindingContext(viewModelOrBindingContext), true);
                 };
 
-                ko.applyBindingsToDescendants = function(viewModel, rootNode) {
+                ko.applyBindingsToNode = function (node, bindings, viewModelOrBindingContext) {
+                    var context = getBindingContext(viewModelOrBindingContext);
+                    return ko.applyBindingAccessorsToNode(node, makeBindingAccessors(bindings, context, node), context);
+                };
+
+                ko.applyBindingsToDescendants = function(viewModelOrBindingContext, rootNode) {
                     if (rootNode.nodeType === 1 || rootNode.nodeType === 8)
-                        applyBindingsToDescendantsInternal(viewModel, rootNode, true);
+                        applyBindingsToDescendantsInternal(getBindingContext(viewModelOrBindingContext), rootNode, true);
                 };
 
-                ko.applyBindings = function (viewModel, rootNode) {
+                ko.applyBindings = function (viewModelOrBindingContext, rootNode) {
+                    // If jQuery is loaded after Knockout, we won't initially have access to it. So save it here.
+                    if (!jQuery && window['jQuery']) {
+                        jQuery = window['jQuery'];
+                    }
+
                     if (rootNode && (rootNode.nodeType !== 1) && (rootNode.nodeType !== 8))
                         throw new Error("ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node");
                     rootNode = rootNode || window.document.body; // Make "rootNode" parameter optional
 
-                    applyBindingsToNodeAndDescendantsInternal(viewModel, rootNode, true);
+                    applyBindingsToNodeAndDescendantsInternal(getBindingContext(viewModelOrBindingContext), rootNode, true);
                 };
 
                 // Retrieving binding context from arbitrary nodes
@@ -2215,13 +2898,14 @@
                 ko.exportSymbol('bindingHandlers', ko.bindingHandlers);
                 ko.exportSymbol('applyBindings', ko.applyBindings);
                 ko.exportSymbol('applyBindingsToDescendants', ko.applyBindingsToDescendants);
+                ko.exportSymbol('applyBindingAccessorsToNode', ko.applyBindingAccessorsToNode);
                 ko.exportSymbol('applyBindingsToNode', ko.applyBindingsToNode);
                 ko.exportSymbol('contextFor', ko.contextFor);
                 ko.exportSymbol('dataFor', ko.dataFor);
             })();
             var attrHtmlToJavascriptMap = { 'class': 'className', 'for': 'htmlFor' };
             ko.bindingHandlers['attr'] = {
-                'update': function(element, valueAccessor, allBindingsAccessor) {
+                'update': function(element, valueAccessor, allBindings) {
                     var value = ko.utils.unwrapObservable(valueAccessor()) || {};
                     ko.utils.objectForEach(value, function(attrName, attrValue) {
                         attrValue = ko.utils.unwrapObservable(attrValue);
@@ -2257,50 +2941,108 @@
                     });
                 }
             };
-            ko.bindingHandlers['checked'] = {
-                'init': function (element, valueAccessor, allBindingsAccessor) {
-                    var updateHandler = function() {
-                        var valueToWrite;
-                        if (element.type == "checkbox") {
-                            valueToWrite = element.checked;
-                        } else if ((element.type == "radio") && (element.checked)) {
-                            valueToWrite = element.value;
-                        } else {
-                            return; // "checked" binding only responds to checkboxes and selected radio buttons
-                        }
+            (function() {
 
-                        var modelValue = valueAccessor(), unwrappedValue = ko.utils.unwrapObservable(modelValue);
-                        if ((element.type == "checkbox") && (unwrappedValue instanceof Array)) {
-                            // For checkboxes bound to an array, we add/remove the checkbox value to that array
-                            // This works for both observable and non-observable arrays
-                            ko.utils.addOrRemoveItem(modelValue, element.value, element.checked);
-                        } else {
-                            ko.expressionRewriting.writeValueToProperty(modelValue, allBindingsAccessor, 'checked', valueToWrite, true);
+                ko.bindingHandlers['checked'] = {
+                    'after': ['value', 'attr'],
+                    'init': function (element, valueAccessor, allBindings) {
+                        function checkedValue() {
+                            return allBindings['has']('checkedValue')
+                                ? ko.utils.unwrapObservable(allBindings.get('checkedValue'))
+                                : element.value;
                         }
-                    };
-                    ko.utils.registerEventHandler(element, "click", updateHandler);
 
-                    // IE 6 won't allow radio buttons to be selected unless they have a name
-                    if ((element.type == "radio") && !element.name)
-                        ko.bindingHandlers['uniqueName']['init'](element, function() { return true });
-                },
-                'update': function (element, valueAccessor) {
-                    var value = ko.utils.unwrapObservable(valueAccessor());
+                        function updateModel() {
+                            // This updates the model value from the view value.
+                            // It runs in response to DOM events (click) and changes in checkedValue.
+                            var isChecked = element.checked,
+                                elemValue = useCheckedValue ? checkedValue() : isChecked;
 
-                    if (element.type == "checkbox") {
-                        if (value instanceof Array) {
-                            // When bound to an array, the checkbox being checked represents its value being present in that array
-                            element.checked = ko.utils.arrayIndexOf(value, element.value) >= 0;
-                        } else {
-                            // When bound to any other value (not an array), the checkbox being checked represents the value being trueish
-                            element.checked = value;
+                            // When we're first setting up this computed, don't change any model state.
+                            if (ko.computedContext.isInitial()) {
+                                return;
+                            }
+
+                            // We can ignore unchecked radio buttons, because some other radio
+                            // button will be getting checked, and that one can take care of updating state.
+                            if (isRadio && !isChecked) {
+                                return;
+                            }
+
+                            var modelValue = ko.dependencyDetection.ignore(valueAccessor);
+                            if (isValueArray) {
+                                if (oldElemValue !== elemValue) {
+                                    // When we're responding to the checkedValue changing, and the element is
+                                    // currently checked, replace the old elem value with the new elem value
+                                    // in the model array.
+                                    if (isChecked) {
+                                        ko.utils.addOrRemoveItem(modelValue, elemValue, true);
+                                        ko.utils.addOrRemoveItem(modelValue, oldElemValue, false);
+                                    }
+
+                                    oldElemValue = elemValue;
+                                } else {
+                                    // When we're responding to the user having checked/unchecked a checkbox,
+                                    // add/remove the element value to the model array.
+                                    ko.utils.addOrRemoveItem(modelValue, elemValue, isChecked);
+                                }
+                            } else {
+                                ko.expressionRewriting.writeValueToProperty(modelValue, allBindings, 'checked', elemValue, true);
+                            }
+                        };
+
+                        function updateView() {
+                            // This updates the view value from the model value.
+                            // It runs in response to changes in the bound (checked) value.
+                            var modelValue = ko.utils.unwrapObservable(valueAccessor());
+
+                            if (isValueArray) {
+                                // When a checkbox is bound to an array, being checked represents its value being present in that array
+                                element.checked = ko.utils.arrayIndexOf(modelValue, checkedValue()) >= 0;
+                            } else if (isCheckbox) {
+                                // When a checkbox is bound to any other value (not an array), being checked represents the value being trueish
+                                element.checked = modelValue;
+                            } else {
+                                // For radio buttons, being checked means that the radio button's value corresponds to the model value
+                                element.checked = (checkedValue() === modelValue);
+                            }
+                        };
+
+                        var isCheckbox = element.type == "checkbox",
+                            isRadio = element.type == "radio";
+
+                        // Only bind to check boxes and radio buttons
+                        if (!isCheckbox && !isRadio) {
+                            return;
                         }
-                    } else if (element.type == "radio") {
-                        element.checked = (element.value == value);
+
+                        var isValueArray = isCheckbox && (ko.utils.unwrapObservable(valueAccessor()) instanceof Array),
+                            oldElemValue = isValueArray ? checkedValue() : undefined,
+                            useCheckedValue = isRadio || isValueArray;
+
+                        // IE 6 won't allow radio buttons to be selected unless they have a name
+                        if (isRadio && !element.name)
+                            ko.bindingHandlers['uniqueName']['init'](element, function() { return true });
+
+                        // Set up two computeds to update the binding:
+
+                        // The first responds to changes in the checkedValue value and to element clicks
+                        ko.computed(updateModel, null, { disposeWhenNodeIsRemoved: element });
+                        ko.utils.registerEventHandler(element, "click", updateModel);
+
+                        // The second responds to changes in the model value (the one associated with the checked binding)
+                        ko.computed(updateView, null, { disposeWhenNodeIsRemoved: element });
                     }
-                }
-            };
-            var classesWrittenByBindingKey = '__ko__cssValue';
+                };
+                ko.expressionRewriting.twoWayBindings['checked'] = true;
+
+                ko.bindingHandlers['checkedValue'] = {
+                    'update': function (element, valueAccessor) {
+                        element.value = ko.utils.unwrapObservable(valueAccessor());
+                    }
+                };
+
+            })();var classesWrittenByBindingKey = '__ko__cssValue';
             ko.bindingHandlers['css'] = {
                 'update': function (element, valueAccessor) {
                     var value = ko.utils.unwrapObservable(valueAccessor());
@@ -2336,19 +3078,19 @@
 // e.g. click:handler instead of the usual full-length event:{click:handler}
             function makeEventHandlerShortcut(eventName) {
                 ko.bindingHandlers[eventName] = {
-                    'init': function(element, valueAccessor, allBindingsAccessor, viewModel) {
+                    'init': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
                         var newValueAccessor = function () {
                             var result = {};
                             result[eventName] = valueAccessor();
                             return result;
                         };
-                        return ko.bindingHandlers['event']['init'].call(this, element, newValueAccessor, allBindingsAccessor, viewModel);
+                        return ko.bindingHandlers['event']['init'].call(this, element, newValueAccessor, allBindings, viewModel, bindingContext);
                     }
                 }
             }
 
             ko.bindingHandlers['event'] = {
-                'init' : function (element, valueAccessor, allBindingsAccessor, viewModel) {
+                'init' : function (element, valueAccessor, allBindings, viewModel, bindingContext) {
                     var eventsToHandle = valueAccessor() || {};
                     ko.utils.objectForEach(eventsToHandle, function(eventName) {
                         if (typeof eventName == "string") {
@@ -2357,11 +3099,11 @@
                                 var handlerFunction = valueAccessor()[eventName];
                                 if (!handlerFunction)
                                     return;
-                                var allBindings = allBindingsAccessor();
 
                                 try {
                                     // Take all the event args, and prefix with the viewmodel
                                     var argsForHandler = ko.utils.makeArray(arguments);
+                                    viewModel = bindingContext['$data'];
                                     argsForHandler.unshift(viewModel);
                                     handlerReturnValue = handlerFunction.apply(viewModel, argsForHandler);
                                 } finally {
@@ -2373,7 +3115,7 @@
                                     }
                                 }
 
-                                var bubble = allBindings[eventName + 'Bubble'] !== false;
+                                var bubble = allBindings.get(eventName + 'Bubble') !== false;
                                 if (!bubble) {
                                     event.cancelBubble = true;
                                     if (event.stopPropagation)
@@ -2413,11 +3155,11 @@
                         };
                     };
                 },
-                'init': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+                'init': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
                     return ko.bindingHandlers['template']['init'](element, ko.bindingHandlers['foreach'].makeTemplateValueAccessor(valueAccessor));
                 },
-                'update': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-                    return ko.bindingHandlers['template']['update'](element, ko.bindingHandlers['foreach'].makeTemplateValueAccessor(valueAccessor), allBindingsAccessor, viewModel, bindingContext);
+                'update': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
+                    return ko.bindingHandlers['template']['update'](element, ko.bindingHandlers['foreach'].makeTemplateValueAccessor(valueAccessor), allBindings, viewModel, bindingContext);
                 }
             };
             ko.expressionRewriting.bindingRewriteValidators['foreach'] = false; // Can't rewrite control flow bindings
@@ -2425,7 +3167,7 @@
             var hasfocusUpdatingProperty = '__ko_hasfocusUpdating';
             var hasfocusLastValue = '__ko_hasfocusLastValue';
             ko.bindingHandlers['hasfocus'] = {
-                'init': function(element, valueAccessor, allBindingsAccessor) {
+                'init': function(element, valueAccessor, allBindings) {
                     var handleElementFocusChange = function(isFocused) {
                         // Where possible, ignore which event was raised and determine focus state using activeElement,
                         // as this avoids phantom focus/blur events raised when changing tabs in modern browsers.
@@ -2446,7 +3188,7 @@
                             isFocused = (active === element);
                         }
                         var modelValue = valueAccessor();
-                        ko.expressionRewriting.writeValueToProperty(modelValue, allBindingsAccessor, 'hasfocus', isFocused, true);
+                        ko.expressionRewriting.writeValueToProperty(modelValue, allBindings, 'hasfocus', isFocused, true);
 
                         //cache the latest value, so we can avoid unnecessarily calling focus/blur in the update function
                         element[hasfocusLastValue] = isFocused;
@@ -2468,8 +3210,10 @@
                     }
                 }
             };
+            ko.expressionRewriting.twoWayBindings['hasfocus'] = true;
 
             ko.bindingHandlers['hasFocus'] = ko.bindingHandlers['hasfocus']; // Make "hasFocus" an alias
+            ko.expressionRewriting.twoWayBindings['hasFocus'] = true;
             ko.bindingHandlers['html'] = {
                 'init': function() {
                     // Prevent binding on the dynamically-injected HTML (as developers are unlikely to expect that, and it has security implications)
@@ -2480,37 +3224,37 @@
                     ko.utils.setHtml(element, valueAccessor());
                 }
             };
-            var withIfDomDataKey = '__ko_withIfBindingData';
 // Makes a binding like with or if
             function makeWithIfBinding(bindingKey, isWith, isNot, makeContextCallback) {
                 ko.bindingHandlers[bindingKey] = {
-                    'init': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-                        ko.utils.domData.set(element, withIfDomDataKey, {});
-                        return { 'controlsDescendantBindings': true };
-                    },
-                    'update': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-                        var withIfData = ko.utils.domData.get(element, withIfDomDataKey),
-                            dataValue = ko.utils.unwrapObservable(valueAccessor()),
-                            shouldDisplay = !isNot !== !dataValue, // equivalent to isNot ? !dataValue : !!dataValue
-                            isFirstRender = !withIfData.savedNodes,
-                            needsRefresh = isFirstRender || isWith || (shouldDisplay !== withIfData.didDisplayOnLastUpdate);
-
-                        if (needsRefresh) {
-                            if (isFirstRender) {
-                                withIfData.savedNodes = ko.utils.cloneNodes(ko.virtualElements.childNodes(element), true /* shouldCleanNodes */);
-                            }
+                    'init': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
+                        var didDisplayOnLastUpdate,
+                            savedNodes;
+                        ko.computed(function() {
+                            var dataValue = ko.utils.unwrapObservable(valueAccessor()),
+                                shouldDisplay = !isNot !== !dataValue, // equivalent to isNot ? !dataValue : !!dataValue
+                                isFirstRender = !savedNodes,
+                                needsRefresh = isFirstRender || isWith || (shouldDisplay !== didDisplayOnLastUpdate);
+
+                            if (needsRefresh) {
+                                // Save a copy of the inner nodes on the initial update, but only if we have dependencies.
+                                if (isFirstRender && ko.computedContext.getDependenciesCount()) {
+                                    savedNodes = ko.utils.cloneNodes(ko.virtualElements.childNodes(element), true /* shouldCleanNodes */);
+                                }
 
-                            if (shouldDisplay) {
-                                if (!isFirstRender) {
-                                    ko.virtualElements.setDomNodeChildren(element, ko.utils.cloneNodes(withIfData.savedNodes));
+                                if (shouldDisplay) {
+                                    if (!isFirstRender) {
+                                        ko.virtualElements.setDomNodeChildren(element, ko.utils.cloneNodes(savedNodes));
+                                    }
+                                    ko.applyBindingsToDescendants(makeContextCallback ? makeContextCallback(bindingContext, dataValue) : bindingContext, element);
+                                } else {
+                                    ko.virtualElements.emptyNode(element);
                                 }
-                                ko.applyBindingsToDescendants(makeContextCallback ? makeContextCallback(bindingContext, dataValue) : bindingContext, element);
-                            } else {
-                                ko.virtualElements.emptyNode(element);
-                            }
 
-                            withIfData.didDisplayOnLastUpdate = shouldDisplay;
-                        }
+                                didDisplayOnLastUpdate = shouldDisplay;
+                            }
+                        }, null, { disposeWhenNodeIsRemoved: element });
+                        return { 'controlsDescendantBindings': true };
                     }
                 };
                 ko.expressionRewriting.bindingRewriteValidators[bindingKey] = false; // Can't rewrite control flow bindings
@@ -2525,19 +3269,7 @@
                     return bindingContext['createChildContext'](dataValue);
                 }
             );
-            function ensureDropdownSelectionIsConsistentWithModelValue(element, modelValue, preferModelValue) {
-                if (preferModelValue) {
-                    if (modelValue !== ko.selectExtensions.readValue(element))
-                        ko.selectExtensions.writeValue(element, modelValue);
-                }
-
-                // No matter which direction we're syncing in, we want the end result to be equality between dropdown value and model value.
-                // If they aren't equal, either we prefer the dropdown value, or the model value couldn't be represented, so either way,
-                // change the model value to match the dropdown.
-                if (modelValue !== ko.selectExtensions.readValue(element))
-                    ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, "change"]);
-            };
-
+            var captionPlaceholder = {};
             ko.bindingHandlers['options'] = {
                 'init': function(element) {
                     if (ko.utils.tagNameLower(element) !== "select")
@@ -2551,24 +3283,24 @@
                     // Ensures that the binding processor doesn't try to bind the options
                     return { 'controlsDescendantBindings': true };
                 },
-                'update': function (element, valueAccessor, allBindingsAccessor) {
+                'update': function (element, valueAccessor, allBindings) {
+                    function selectedOptions() {
+                        return ko.utils.arrayFilter(element.options, function (node) { return node.selected; });
+                    }
+
                     var selectWasPreviouslyEmpty = element.length == 0;
                     var previousScrollTop = (!selectWasPreviouslyEmpty && element.multiple) ? element.scrollTop : null;
-
                     var unwrappedArray = ko.utils.unwrapObservable(valueAccessor());
-                    var allBindings = allBindingsAccessor();
-                    var includeDestroyed = allBindings['optionsIncludeDestroyed'];
-                    var captionPlaceholder = {};
+                    var includeDestroyed = allBindings.get('optionsIncludeDestroyed');
+                    var arrayToDomNodeChildrenOptions = {};
                     var captionValue;
+                    var filteredArray;
                     var previousSelectedValues;
+
                     if (element.multiple) {
-                        previousSelectedValues = ko.utils.arrayMap(element.selectedOptions || ko.utils.arrayFilter(element.childNodes, function (node) {
-                            return node.tagName && (ko.utils.tagNameLower(node) === "option") && node.selected;
-                        }), function (node) {
-                            return ko.selectExtensions.readValue(node);
-                        });
-                    } else if (element.selectedIndex >= 0) {
-                        previousSelectedValues = [ ko.selectExtensions.readValue(element.options[element.selectedIndex]) ];
+                        previousSelectedValues = ko.utils.arrayMap(selectedOptions(), ko.selectExtensions.readValue);
+                    } else {
+                        previousSelectedValues = element.selectedIndex >= 0 ? [ ko.selectExtensions.readValue(element.options[element.selectedIndex]) ] : [];
                     }
 
                     if (unwrappedArray) {
@@ -2576,13 +3308,13 @@
                             unwrappedArray = [unwrappedArray];
 
                         // Filter out any entries marked as destroyed
-                        var filteredArray = ko.utils.arrayFilter(unwrappedArray, function(item) {
+                        filteredArray = ko.utils.arrayFilter(unwrappedArray, function(item) {
                             return includeDestroyed || item === undefined || item === null || !ko.utils.unwrapObservable(item['_destroy']);
                         });
 
                         // If caption is included, add it to the array
-                        if ('optionsCaption' in allBindings) {
-                            captionValue = ko.utils.unwrapObservable(allBindings['optionsCaption']);
+                        if (allBindings['has']('optionsCaption')) {
+                            captionValue = ko.utils.unwrapObservable(allBindings.get('optionsCaption'));
                             // If caption value is null or undefined, don't show a caption
                             if (captionValue !== null && captionValue !== undefined) {
                                 filteredArray.unshift(captionPlaceholder);
@@ -2590,7 +3322,6 @@
                         }
                     } else {
                         // If a falsy value is provided (e.g. null), we'll simply empty the select element
-                        unwrappedArray = [];
                     }
 
                     function applyToObject(object, predicate, defaultValue) {
@@ -2607,54 +3338,85 @@
                     // The first is when the whole array is being updated directly from this binding handler.
                     // The second is when an observable value for a specific array entry is updated.
                     // oldOptions will be empty in the first case, but will be filled with the previously generated option in the second.
+                    var itemUpdate = false;
                     function optionForArrayItem(arrayEntry, index, oldOptions) {
                         if (oldOptions.length) {
-                            previousSelectedValues = oldOptions[0].selected && [ ko.selectExtensions.readValue(oldOptions[0]) ];
+                            previousSelectedValues = oldOptions[0].selected ? [ ko.selectExtensions.readValue(oldOptions[0]) ] : [];
+                            itemUpdate = true;
                         }
-                        var option = document.createElement("option");
+                        var option = element.ownerDocument.createElement("option");
                         if (arrayEntry === captionPlaceholder) {
-                            ko.utils.setHtml(option, captionValue);
+                            ko.utils.setTextContent(option, allBindings.get('optionsCaption'));
                             ko.selectExtensions.writeValue(option, undefined);
                         } else {
                             // Apply a value to the option element
-                            var optionValue = applyToObject(arrayEntry, allBindings['optionsValue'], arrayEntry);
+                            var optionValue = applyToObject(arrayEntry, allBindings.get('optionsValue'), arrayEntry);
                             ko.selectExtensions.writeValue(option, ko.utils.unwrapObservable(optionValue));
 
                             // Apply some text to the option element
-                            var optionText = applyToObject(arrayEntry, allBindings['optionsText'], optionValue);
+                            var optionText = applyToObject(arrayEntry, allBindings.get('optionsText'), optionValue);
                             ko.utils.setTextContent(option, optionText);
                         }
                         return [option];
                     }
 
+                    // By using a beforeRemove callback, we delay the removal until after new items are added. This fixes a selection
+                    // problem in IE<=8 and Firefox. See https://github.com/knockout/knockout/issues/1208
+                    arrayToDomNodeChildrenOptions['beforeRemove'] =
+                        function (option) {
+                            element.removeChild(option);
+                        };
+
                     function setSelectionCallback(arrayEntry, newOptions) {
                         // IE6 doesn't like us to assign selection to OPTION nodes before they're added to the document.
                         // That's why we first added them without selection. Now it's time to set the selection.
-                        if (previousSelectedValues) {
+                        if (previousSelectedValues.length) {
                             var isSelected = ko.utils.arrayIndexOf(previousSelectedValues, ko.selectExtensions.readValue(newOptions[0])) >= 0;
                             ko.utils.setOptionNodeSelectionState(newOptions[0], isSelected);
+
+                            // If this option was changed from being selected during a single-item update, notify the change
+                            if (itemUpdate && !isSelected)
+                                ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, "change"]);
                         }
                     }
 
                     var callback = setSelectionCallback;
-                    if (allBindings['optionsAfterRender']) {
+                    if (allBindings['has']('optionsAfterRender')) {
                         callback = function(arrayEntry, newOptions) {
                             setSelectionCallback(arrayEntry, newOptions);
-                            ko.dependencyDetection.ignore(allBindings['optionsAfterRender'], null, [newOptions[0], arrayEntry !== captionPlaceholder ? arrayEntry : undefined]);
+                            ko.dependencyDetection.ignore(allBindings.get('optionsAfterRender'), null, [newOptions[0], arrayEntry !== captionPlaceholder ? arrayEntry : undefined]);
                         }
                     }
 
-                    ko.utils.setDomNodeChildrenFromArrayMapping(element, filteredArray, optionForArrayItem, null, callback);
+                    ko.utils.setDomNodeChildrenFromArrayMapping(element, filteredArray, optionForArrayItem, arrayToDomNodeChildrenOptions, callback);
 
-                    // Clear previousSelectedValues so that future updates to individual objects don't get stale data
-                    previousSelectedValues = null;
+                    ko.dependencyDetection.ignore(function () {
+                        if (allBindings.get('valueAllowUnset') && allBindings['has']('value')) {
+                            // The model value is authoritative, so make sure its value is the one selected
+                            ko.selectExtensions.writeValue(element, ko.utils.unwrapObservable(allBindings.get('value')), true /* allowUnset */);
+                        } else {
+                            // Determine if the selection has changed as a result of updating the options list
+                            var selectionChanged;
+                            if (element.multiple) {
+                                // For a multiple-select box, compare the new selection count to the previous one
+                                // But if nothing was selected before, the selection can't have changed
+                                selectionChanged = previousSelectedValues.length && selectedOptions().length < previousSelectedValues.length;
+                            } else {
+                                // For a single-select box, compare the current value to the previous value
+                                // But if nothing was selected before or nothing is selected now, just look for a change in selection
+                                selectionChanged = (previousSelectedValues.length && element.selectedIndex >= 0)
+                                    ? (ko.selectExtensions.readValue(element.options[element.selectedIndex]) !== previousSelectedValues[0])
+                                    : (previousSelectedValues.length || element.selectedIndex >= 0);
+                            }
 
-                    if (selectWasPreviouslyEmpty && ('value' in allBindings)) {
-                        // Ensure consistency between model value and selected option.
-                        // If the dropdown is being populated for the first time here (or was otherwise previously empty),
-                        // the dropdown selection state is meaningless, so we preserve the model value.
-                        ensureDropdownSelectionIsConsistentWithModelValue(element, ko.utils.peekObservable(allBindings['value']), /* preferModelValue */ true);
-                    }
+                            // Ensure consistency between model value and selected option.
+                            // If the dropdown was changed so that selection is no longer the same,
+                            // notify the value or selectedOptions binding.
+                            if (selectionChanged) {
+                                ko.utils.triggerEvent(element, "change");
+                            }
+                        }
+                    });
 
                     // Workaround for IE bug
                     ko.utils.ensureSelectElementIsRenderedCorrectly(element);
@@ -2663,16 +3425,17 @@
                         element.scrollTop = previousScrollTop;
                 }
             };
-            ko.bindingHandlers['options'].optionValueDomDataKey = '__ko.optionValueDomData__';
+            ko.bindingHandlers['options'].optionValueDomDataKey = ko.utils.domData.nextKey();
             ko.bindingHandlers['selectedOptions'] = {
-                'init': function (element, valueAccessor, allBindingsAccessor) {
+                'after': ['options', 'foreach'],
+                'init': function (element, valueAccessor, allBindings) {
                     ko.utils.registerEventHandler(element, "change", function () {
                         var value = valueAccessor(), valueToWrite = [];
                         ko.utils.arrayForEach(element.getElementsByTagName("option"), function(node) {
                             if (node.selected)
                                 valueToWrite.push(ko.selectExtensions.readValue(node));
                         });
-                        ko.expressionRewriting.writeValueToProperty(value, allBindingsAccessor, 'selectedOptions', valueToWrite);
+                        ko.expressionRewriting.writeValueToProperty(value, allBindings, 'selectedOptions', valueToWrite);
                     });
                 },
                 'update': function (element, valueAccessor) {
@@ -2688,6 +3451,7 @@
                     }
                 }
             };
+            ko.expressionRewriting.twoWayBindings['selectedOptions'] = true;
             ko.bindingHandlers['style'] = {
                 'update': function (element, valueAccessor) {
                     var value = ko.utils.unwrapObservable(valueAccessor() || {});
@@ -2698,13 +3462,13 @@
                 }
             };
             ko.bindingHandlers['submit'] = {
-                'init': function (element, valueAccessor, allBindingsAccessor, viewModel) {
+                'init': function (element, valueAccessor, allBindings, viewModel, bindingContext) {
                     if (typeof valueAccessor() != "function")
                         throw new Error("The value for a submit binding must be a function");
                     ko.utils.registerEventHandler(element, "submit", function (event) {
                         var handlerReturnValue;
                         var value = valueAccessor();
-                        try { handlerReturnValue = value.call(viewModel, element); }
+                        try { handlerReturnValue = value.call(bindingContext['$data'], element); }
                         finally {
                             if (handlerReturnValue !== true) { // Normally we want to prevent default action. Developer can override this be explicitly returning true.
                                 if (event.preventDefault)
@@ -2717,6 +3481,11 @@
                 }
             };
             ko.bindingHandlers['text'] = {
+                'init': function() {
+                    // Prevent binding on the dynamically-injected text node (as developers are unlikely to expect that, and it has security implications).
+                    // It should also make things faster, as we no longer have to consider whether the text node might be bindable.
+                    return { 'controlsDescendantBindings': true };
+                },
                 'update': function (element, valueAccessor) {
                     ko.utils.setTextContent(element, valueAccessor());
                 }
@@ -2732,10 +3501,11 @@
             };
             ko.bindingHandlers['uniqueName'].currentIndex = 0;
             ko.bindingHandlers['value'] = {
-                'init': function (element, valueAccessor, allBindingsAccessor) {
+                'after': ['options', 'foreach'],
+                'init': function (element, valueAccessor, allBindings) {
                     // Always catch "change" event; possibly other events too if asked
                     var eventsToCatch = ["change"];
-                    var requestedEventsToCatch = allBindingsAccessor()["valueUpdate"];
+                    var requestedEventsToCatch = allBindings.get("valueUpdate");
                     var propertyChangedFired = false;
                     if (requestedEventsToCatch) {
                         if (typeof requestedEventsToCatch == "string") // Allow both individual event names, and arrays of event names
@@ -2748,7 +3518,7 @@
                         propertyChangedFired = false;
                         var modelValue = valueAccessor();
                         var elementValue = ko.selectExtensions.readValue(element);
-                        ko.expressionRewriting.writeValueToProperty(modelValue, allBindingsAccessor, 'value', elementValue);
+                        ko.expressionRewriting.writeValueToProperty(modelValue, allBindings, 'value', elementValue);
                     }
 
                     // Workaround for https://github.com/SteveSanderson/knockout/issues/122
@@ -2757,6 +3527,7 @@
                         && element.autocomplete != "off" && (!element.form || element.form.autocomplete != "off");
                     if (ieAutoCompleteHackNeeded && ko.utils.arrayIndexOf(eventsToCatch, "propertychange") == -1) {
                         ko.utils.registerEventHandler(element, "propertychange", function () { propertyChangedFired = true });
+                        ko.utils.registerEventHandler(element, "focus", function () { propertyChangedFired = false });
                         ko.utils.registerEventHandler(element, "blur", function() {
                             if (propertyChangedFired) {
                                 valueUpdateHandler();
@@ -2776,30 +3547,36 @@
                         ko.utils.registerEventHandler(element, eventName, handler);
                     });
                 },
-                'update': function (element, valueAccessor) {
-                    var valueIsSelectOption = ko.utils.tagNameLower(element) === "select";
+                'update': function (element, valueAccessor, allBindings) {
                     var newValue = ko.utils.unwrapObservable(valueAccessor());
                     var elementValue = ko.selectExtensions.readValue(element);
                     var valueHasChanged = (newValue !== elementValue);
 
                     if (valueHasChanged) {
-                        var applyValueAction = function () { ko.selectExtensions.writeValue(element, newValue); };
-                        applyValueAction();
-
-                        // Workaround for IE6 bug: It won't reliably apply values to SELECT nodes during the same execution thread
-                        // right after you've changed the set of OPTION nodes on it. So for that node type, we'll schedule a second thread
-                        // to apply the value as well.
-                        var alsoApplyAsynchronously = valueIsSelectOption;
-                        if (alsoApplyAsynchronously)
-                            setTimeout(applyValueAction, 0);
+                        if (ko.utils.tagNameLower(element) === "select") {
+                            var allowUnset = allBindings.get('valueAllowUnset');
+                            var applyValueAction = function () {
+                                ko.selectExtensions.writeValue(element, newValue, allowUnset);
+                            };
+                            applyValueAction();
+
+                            if (!allowUnset && newValue !== ko.selectExtensions.readValue(element)) {
+                                // If you try to set a model value that can't be represented in an already-populated dropdown, reject that change,
+                                // because you're not allowed to have a model value that disagrees with a visible UI selection.
+                                ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, "change"]);
+                            } else {
+                                // Workaround for IE6 bug: It won't reliably apply values to SELECT nodes during the same execution thread
+                                // right after you've changed the set of OPTION nodes on it. So for that node type, we'll schedule a second thread
+                                // to apply the value as well.
+                                setTimeout(applyValueAction, 0);
+                            }
+                        } else {
+                            ko.selectExtensions.writeValue(element, newValue);
+                        }
                     }
-
-                    // If you try to set a model value that can't be represented in an already-populated dropdown, reject that change,
-                    // because you're not allowed to have a model value that disagrees with a visible UI selection.
-                    if (valueIsSelectOption && (element.length > 0))
-                        ensureDropdownSelectionIsConsistentWithModelValue(element, newValue, /* preferModelValue */ false);
                 }
             };
+            ko.expressionRewriting.twoWayBindings['value'] = true;
             ko.bindingHandlers['visible'] = {
                 'update': function (element, valueAccessor) {
                     var value = ko.utils.unwrapObservable(valueAccessor());
@@ -2909,7 +3686,7 @@
                 function constructMemoizedTagReplacement(dataBindAttributeValue, tagToRetain, nodeName, templateEngine) {
                     var dataBindKeyValueArray = ko.expressionRewriting.parseObjectLiteral(dataBindAttributeValue);
                     validateDataBindValuesForRewriting(dataBindKeyValueArray);
-                    var rewrittenDataBindAttributeValue = ko.expressionRewriting.preProcessBindings(dataBindKeyValueArray);
+                    var rewrittenDataBindAttributeValue = ko.expressionRewriting.preProcessBindings(dataBindKeyValueArray, {'valueAccessors':true});
 
                     // For no obvious reason, Opera fails to evaluate rewrittenDataBindAttributeValue unless it's wrapped in an additional
                     // anonymous function, even though Opera's built-in debugger can evaluate it anyway. No other browser requires this
@@ -2939,7 +3716,7 @@
                         return ko.memoization.memoize(function (domNode, bindingContext) {
                             var nodeToBind = domNode.nextSibling;
                             if (nodeToBind && nodeToBind.nodeName.toLowerCase() === nodeName) {
-                                ko.applyBindingsToNode(nodeToBind, bindings, bindingContext);
+                                ko.applyBindingAccessorsToNode(nodeToBind, bindings, bindingContext);
                             }
                         });
                     }
@@ -2999,11 +3776,12 @@
                     }
                 };
 
+                var dataDomDataPrefix = ko.utils.domData.nextKey() + "_";
                 ko.templateSources.domElement.prototype['data'] = function(key /*, valueToWrite */) {
                     if (arguments.length === 1) {
-                        return ko.utils.domData.get(this.domElement, "templateSourceData_" + key);
+                        return ko.utils.domData.get(this.domElement, dataDomDataPrefix + key);
                     } else {
-                        ko.utils.domData.set(this.domElement, "templateSourceData_" + key, arguments[1]);
+                        ko.utils.domData.set(this.domElement, dataDomDataPrefix + key, arguments[1]);
                     }
                 };
 
@@ -3012,7 +3790,7 @@
                 // For compatibility, you can also read "text"; it will be serialized from the nodes on demand.
                 // Writing to "text" is still supported, but then the template data will not be available as DOM nodes.
 
-                var anonymousTemplatesDomDataKey = "__ko_anon_template__";
+                var anonymousTemplatesDomDataKey = ko.utils.domData.nextKey();
                 ko.templateSources.anonymousTemplate = function(element) {
                     this.domElement = element;
                 }
@@ -3051,12 +3829,11 @@
                     _templateEngine = templateEngine;
                 }
 
-                function invokeForEachNodeOrCommentInContinuousRange(firstNode, lastNode, action) {
+                function invokeForEachNodeInContinuousRange(firstNode, lastNode, action) {
                     var node, nextInQueue = firstNode, firstOutOfRangeNode = ko.virtualElements.nextSibling(lastNode);
                     while (nextInQueue && ((node = nextInQueue) !== firstOutOfRangeNode)) {
                         nextInQueue = ko.virtualElements.nextSibling(node);
-                        if (node.nodeType === 1 || node.nodeType === 8)
-                            action(node);
+                        action(node, nextInQueue);
                     }
                 }
 
@@ -3068,16 +3845,52 @@
                     // (2) Unmemoizes any memos in the DOM subtree (e.g., to activate bindings that had been memoized during template rewriting)
 
                     if (continuousNodeArray.length) {
-                        var firstNode = continuousNodeArray[0], lastNode = continuousNodeArray[continuousNodeArray.length - 1];
+                        var firstNode = continuousNodeArray[0],
+                            lastNode = continuousNodeArray[continuousNodeArray.length - 1],
+                            parentNode = firstNode.parentNode,
+                            provider = ko.bindingProvider['instance'],
+                            preprocessNode = provider['preprocessNode'];
+
+                        if (preprocessNode) {
+                            invokeForEachNodeInContinuousRange(firstNode, lastNode, function(node, nextNodeInRange) {
+                                var nodePreviousSibling = node.previousSibling;
+                                var newNodes = preprocessNode.call(provider, node);
+                                if (newNodes) {
+                                    if (node === firstNode)
+                                        firstNode = newNodes[0] || nextNodeInRange;
+                                    if (node === lastNode)
+                                        lastNode = newNodes[newNodes.length - 1] || nodePreviousSibling;
+                                }
+                            });
+
+                            // Because preprocessNode can change the nodes, including the first and last nodes, update continuousNodeArray to match.
+                            // We need the full set, including inner nodes, because the unmemoize step might remove the first node (and so the real
+                            // first node needs to be in the array).
+                            continuousNodeArray.length = 0;
+                            if (!firstNode) { // preprocessNode might have removed all the nodes, in which case there's nothing left to do
+                                return;
+                            }
+                            if (firstNode === lastNode) {
+                                continuousNodeArray.push(firstNode);
+                            } else {
+                                continuousNodeArray.push(firstNode, lastNode);
+                                ko.utils.fixUpContinuousNodeArray(continuousNodeArray, parentNode);
+                            }
+                        }
 
                         // Need to applyBindings *before* unmemoziation, because unmemoization might introduce extra nodes (that we don't want to re-bind)
                         // whereas a regular applyBindings won't introduce new memoized nodes
-                        invokeForEachNodeOrCommentInContinuousRange(firstNode, lastNode, function(node) {
-                            ko.applyBindings(bindingContext, node);
+                        invokeForEachNodeInContinuousRange(firstNode, lastNode, function(node) {
+                            if (node.nodeType === 1 || node.nodeType === 8)
+                                ko.applyBindings(bindingContext, node);
                         });
-                        invokeForEachNodeOrCommentInContinuousRange(firstNode, lastNode, function(node) {
-                            ko.memoization.unmemoizeDomNodeAndDescendants(node, [bindingContext]);
+                        invokeForEachNodeInContinuousRange(firstNode, lastNode, function(node) {
+                            if (node.nodeType === 1 || node.nodeType === 8)
+                                ko.memoization.unmemoizeDomNodeAndDescendants(node, [bindingContext]);
                         });
+
+                        // Make sure any changes done by applyBindings or unmemoize are reflected in the array
+                        ko.utils.fixUpContinuousNodeArray(continuousNodeArray, parentNode);
                     }
                 }
 
@@ -3143,7 +3956,8 @@
                                     : new ko.bindingContext(ko.utils.unwrapObservable(dataOrBindingContext));
 
                                 // Support selecting template as a function of the data being rendered
-                                var templateName = typeof(template) == 'function' ? template(bindingContext['$data'], bindingContext) : template;
+                                var templateName = ko.isObservable(template) ? template()
+                                    : typeof(template) == 'function' ? template(bindingContext['$data'], bindingContext) : template;
 
                                 var renderedNodesArray = executeTemplate(targetNodeOrNodeArray, renderMode, templateName, bindingContext, options);
                                 if (renderMode == "replaceNode") {
@@ -3170,8 +3984,9 @@
                     // This will be called by setDomNodeChildrenFromArrayMapping to get the nodes to add to targetNode
                     var executeTemplateForArrayItem = function (arrayValue, index) {
                         // Support selecting template as a function of the data being rendered
-                        arrayItemContext = parentBindingContext['createChildContext'](ko.utils.unwrapObservable(arrayValue), options['as']);
-                        arrayItemContext['$index'] = index;
+                        arrayItemContext = parentBindingContext['createChildContext'](arrayValue, options['as'], function(context) {
+                            context['$index'] = index;
+                        });
                         var templateName = typeof(template) == 'function' ? template(arrayValue, arrayItemContext) : template;
                         return executeTemplate(null, "ignoreTargetNode", templateName, arrayItemContext, options);
                     }
@@ -3200,7 +4015,7 @@
                     }, null, { disposeWhenNodeIsRemoved: targetNode });
                 };
 
-                var templateComputedDomDataKey = '__ko__templateComputedDomDataKey__';
+                var templateComputedDomDataKey = ko.utils.domData.nextKey();
                 function disposeOldComputedAndStoreNewOne(element, newComputed) {
                     var oldComputed = ko.utils.domData.get(element, templateComputedDomDataKey);
                     if (oldComputed && (typeof(oldComputed.dispose) == 'function'))
@@ -3212,24 +4027,30 @@
                     'init': function(element, valueAccessor) {
                         // Support anonymous templates
                         var bindingValue = ko.utils.unwrapObservable(valueAccessor());
-                        if ((typeof bindingValue != "string") && (!bindingValue['name']) && (element.nodeType == 1 || element.nodeType == 8)) {
+                        if (typeof bindingValue == "string" || bindingValue['name']) {
+                            // It's a named template - clear the element
+                            ko.virtualElements.emptyNode(element);
+                        } else {
                             // It's an anonymous template - store the element contents, then clear the element
-                            var templateNodes = element.nodeType == 1 ? element.childNodes : ko.virtualElements.childNodes(element),
+                            var templateNodes = ko.virtualElements.childNodes(element),
                                 container = ko.utils.moveCleanedNodesToContainerElement(templateNodes); // This also removes the nodes from their current parent
                             new ko.templateSources.anonymousTemplate(element)['nodes'](container);
                         }
                         return { 'controlsDescendantBindings': true };
                     },
-                    'update': function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-                        var templateName = ko.utils.unwrapObservable(valueAccessor()),
-                            options = {},
-                            shouldDisplay = true,
+                    'update': function (element, valueAccessor, allBindings, viewModel, bindingContext) {
+                        var value = valueAccessor(),
                             dataValue,
-                            templateComputed = null;
+                            options = ko.utils.unwrapObservable(value),
+                            shouldDisplay = true,
+                            templateComputed = null,
+                            templateName;
 
-                        if (typeof templateName != "string") {
-                            options = templateName;
-                            templateName = ko.utils.unwrapObservable(options['name']);
+                        if (typeof options == "string") {
+                            templateName = value;
+                            options = {};
+                        } else {
+                            templateName = options['name'];
 
                             // Support "if"/"ifnot" conditions
                             if ('if' in options)
@@ -3276,22 +4097,43 @@
 
             ko.exportSymbol('setTemplateEngine', ko.setTemplateEngine);
             ko.exportSymbol('renderTemplate', ko.renderTemplate);
+// Go through the items that have been added and deleted and try to find matches between them.
+            ko.utils.findMovesInArrayComparison = function (left, right, limitFailedCompares) {
+                if (left.length && right.length) {
+                    var failedCompares, l, r, leftItem, rightItem;
+                    for (failedCompares = l = 0; (!limitFailedCompares || failedCompares < limitFailedCompares) && (leftItem = left[l]); ++l) {
+                        for (r = 0; rightItem = right[r]; ++r) {
+                            if (leftItem['value'] === rightItem['value']) {
+                                leftItem['moved'] = rightItem['index'];
+                                rightItem['moved'] = leftItem['index'];
+                                right.splice(r, 1);         // This item is marked as moved; so remove it from right list
+                                failedCompares = r = 0;     // Reset failed compares count because we're checking for consecutive failures
+                                break;
+                            }
+                        }
+                        failedCompares += r;
+                    }
+                }
+            };
 
             ko.utils.compareArrays = (function () {
                 var statusNotInOld = 'added', statusNotInNew = 'deleted';
 
                 // Simple calculation based on Levenshtein distance.
-                function compareArrays(oldArray, newArray, dontLimitMoves) {
+                function compareArrays(oldArray, newArray, options) {
+                    // For backward compatibility, if the third arg is actually a bool, interpret
+                    // it as the old parameter 'dontLimitMoves'. Newer code should use { dontLimitMoves: true }.
+                    options = (typeof options === 'boolean') ? { 'dontLimitMoves': options } : (options || {});
                     oldArray = oldArray || [];
                     newArray = newArray || [];
 
                     if (oldArray.length <= newArray.length)
-                        return compareSmallArrayToBigArray(oldArray, newArray, statusNotInOld, statusNotInNew, dontLimitMoves);
+                        return compareSmallArrayToBigArray(oldArray, newArray, statusNotInOld, statusNotInNew, options);
                     else
-                        return compareSmallArrayToBigArray(newArray, oldArray, statusNotInNew, statusNotInOld, dontLimitMoves);
+                        return compareSmallArrayToBigArray(newArray, oldArray, statusNotInNew, statusNotInOld, options);
                 }
 
-                function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusNotInBig, dontLimitMoves) {
+                function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusNotInBig, options) {
                     var myMin = Math.min,
                         myMax = Math.max,
                         editDistanceMatrix = [],
@@ -3336,32 +4178,20 @@
                                 'value': smlArray[--smlIndex],
                                 'index': smlIndex });
                         } else {
-                            editScript.push({
-                                'status': "retained",
-                                'value': bigArray[--bigIndex] });
+                            --bigIndex;
                             --smlIndex;
-                        }
-                    }
-
-                    if (notInSml.length && notInBig.length) {
-                        // Set a limit on the number of consecutive non-matching comparisons; having it a multiple of
-                        // smlIndexMax keeps the time complexity of this algorithm linear.
-                        var limitFailedCompares = smlIndexMax * 10, failedCompares,
-                            a, d, notInSmlItem, notInBigItem;
-                        // Go through the items that have been added and deleted and try to find matches between them.
-                        for (failedCompares = a = 0; (dontLimitMoves || failedCompares < limitFailedCompares) && (notInSmlItem = notInSml[a]); a++) {
-                            for (d = 0; notInBigItem = notInBig[d]; d++) {
-                                if (notInSmlItem['value'] === notInBigItem['value']) {
-                                    notInSmlItem['moved'] = notInBigItem['index'];
-                                    notInBigItem['moved'] = notInSmlItem['index'];
-                                    notInBig.splice(d,1);       // This item is marked as moved; so remove it from notInBig list
-                                    failedCompares = d = 0;     // Reset failed compares count because we're checking for consecutive failures
-                                    break;
-                                }
+                            if (!options['sparse']) {
+                                editScript.push({
+                                    'status': "retained",
+                                    'value': bigArray[bigIndex] });
                             }
-                            failedCompares += d;
                         }
                     }
+
+                    // Set a limit on the number of consecutive non-matching comparisons; having it a multiple of
+                    // smlIndexMax keeps the time complexity of this algorithm linear.
+                    ko.utils.findMovesInArrayComparison(notInSml, notInBig, smlIndexMax * 10);
+
                     return editScript.reverse();
                 }
 
@@ -3369,7 +4199,6 @@
             })();
 
             ko.exportSymbol('utils.compareArrays', ko.utils.compareArrays);
-
             (function () {
                 // Objective:
                 // * Given an input array, a container DOM node, and a function from array elements to arrays of DOM nodes,
@@ -3381,47 +4210,11 @@
                 // "callbackAfterAddingNodes" will be invoked after any "mapping"-generated nodes are inserted into the container node
                 // You can use this, for example, to activate bindings on those nodes.
 
-                function fixUpNodesToBeMovedOrRemoved(contiguousNodeArray) {
-                    // Before moving, deleting, or replacing a set of nodes that were previously outputted by the "map" function, we have to reconcile
-                    // them against what is in the DOM right now. It may be that some of the nodes have already been removed from the document,
-                    // or that new nodes might have been inserted in the middle, for example by a binding. Also, there may previously have been
-                    // leading comment nodes (created by rewritten string-based templates) that have since been removed during binding.
-                    // So, this function translates the old "map" output array into its best guess of what set of current DOM nodes should be removed.
-                    //
-                    // Rules:
-                    //   [A] Any leading nodes that aren't in the document any more should be ignored
-                    //       These most likely correspond to memoization nodes that were already removed during binding
-                    //       See https://github.com/SteveSanderson/knockout/pull/440
-                    //   [B] We want to output a contiguous series of nodes that are still in the document. So, ignore any nodes that
-                    //       have already been removed, and include any nodes that have been inserted among the previous collection
-
-                    // Rule [A]
-                    while (contiguousNodeArray.length && !ko.utils.domNodeIsAttachedToDocument(contiguousNodeArray[0]))
-                        contiguousNodeArray.splice(0, 1);
-
-                    // Rule [B]
-                    if (contiguousNodeArray.length > 1) {
-                        // Build up the actual new contiguous node set
-                        var current = contiguousNodeArray[0], last = contiguousNodeArray[contiguousNodeArray.length - 1], newContiguousSet = [current];
-                        while (current !== last) {
-                            current = current.nextSibling;
-                            if (!current) // Won't happen, except if the developer has manually removed some DOM elements (then we're in an undefined scenario)
-                                return;
-                            newContiguousSet.push(current);
-                        }
-
-                        // ... then mutate the input array to match this.
-                        // (The following line replaces the contents of contiguousNodeArray with newContiguousSet)
-                        Array.prototype.splice.apply(contiguousNodeArray, [0, contiguousNodeArray.length].concat(newContiguousSet));
-                    }
-                    return contiguousNodeArray;
-                }
-
                 function mapNodeAndRefreshWhenChanged(containerNode, mapping, valueToMap, callbackAfterAddingNodes, index) {
                     // Map this array value inside a dependentObservable so we re-map when any dependency changes
                     var mappedNodes = [];
                     var dependentObservable = ko.dependentObservable(function() {
-                        var newMappedNodes = mapping(valueToMap, index, fixUpNodesToBeMovedOrRemoved(mappedNodes)) || [];
+                        var newMappedNodes = mapping(valueToMap, index, ko.utils.fixUpContinuousNodeArray(mappedNodes, containerNode)) || [];
 
                         // On subsequent evaluations, just replace the previously-inserted DOM nodes
                         if (mappedNodes.length > 0) {
@@ -3432,13 +4225,13 @@
 
                         // Replace the contents of the mappedNodes array, thereby updating the record
                         // of which nodes would be deleted if valueToMap was itself later removed
-                        mappedNodes.splice(0, mappedNodes.length);
+                        mappedNodes.length = 0;
                         ko.utils.arrayPushAll(mappedNodes, newMappedNodes);
                     }, null, { disposeWhenNodeIsRemoved: containerNode, disposeWhen: function() { return !ko.utils.anyDomNodeIsAttachedToDocument(mappedNodes); } });
                     return { mappedNodes : mappedNodes, dependentObservable : (dependentObservable.isActive() ? dependentObservable : undefined) };
                 }
 
-                var lastMappingResultDomDataKey = "setDomNodeChildrenFromArrayMapping_lastMappingResult";
+                var lastMappingResultDomDataKey = ko.utils.domData.nextKey();
 
                 ko.utils.setDomNodeChildrenFromArrayMapping = function (domNode, array, mapping, options, callbackAfterAddingNodes) {
                     // Compare the provided array against the previous one
@@ -3465,9 +4258,9 @@
                         mapData = lastMappingResult[oldPosition];
                         if (newMappingResultIndex !== oldPosition)
                             itemsForMoveCallbacks[editScriptIndex] = mapData;
-                        // Since updating the index might change the nodes, do so before calling fixUpNodesToBeMovedOrRemoved
+                        // Since updating the index might change the nodes, do so before calling fixUpContinuousNodeArray
                         mapData.indexObservable(newMappingResultIndex++);
-                        fixUpNodesToBeMovedOrRemoved(mapData.mappedNodes);
+                        ko.utils.fixUpContinuousNodeArray(mapData.mappedNodes, domNode);
                         newMappingResult.push(mapData);
                         itemsToProcess.push(mapData);
                     }
@@ -3496,7 +4289,7 @@
                                         mapData.dependentObservable.dispose();
 
                                     // Queue these nodes for later removal
-                                    nodesToDelete.push.apply(nodesToDelete, fixUpNodesToBeMovedOrRemoved(mapData.mappedNodes));
+                                    nodesToDelete.push.apply(nodesToDelete, ko.utils.fixUpContinuousNodeArray(mapData.mappedNodes, domNode));
                                     if (options['beforeRemove']) {
                                         itemsForBeforeRemoveCallbacks[i] = mapData;
                                         itemsToProcess.push(mapData);
@@ -3595,7 +4388,7 @@
                     // Note that as of Knockout 1.3, we only support jQuery.tmpl 1.0.0pre and later,
                     // which KO internally refers to as version "2", so older versions are no longer detected.
                     var jQueryTmplVersion = this.jQueryTmplVersion = (function() {
-                        if ((typeof(jQuery) == "undefined") || !(jQuery['tmpl']))
+                        if (!jQuery || !(jQuery['tmpl']))
                             return 0;
                         // Since it exposes no official version number, we use our own numbering system. To be updated as jquery-tmpl evolves.
                         try {