diff --git a/.gitignore b/.gitignore
index 7f54548c1..537d6e9e6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,3 +11,10 @@ desktop.ini
 .eprj
 perf/*
 *.orig
+
+MBestKnockout.csproj
+MBestKnockout.sln
+Properties/AssemblyInfo.cs
+Web.config
+Web.Debug.config
+Web.Release.config
\ No newline at end of file
diff --git a/build/fragments/version.txt b/build/fragments/version.txt
index 8cd40ba87..5a9dfc4b3 100644
--- a/build/fragments/version.txt
+++ b/build/fragments/version.txt
@@ -1 +1 @@
-2.1.0pre+mbest/smart-binding/beta.3
\ No newline at end of file
+2.1.0pre+mbest/smart-binding/beta.3+GilesBradshaw/BindingProviderConfiguration
\ No newline at end of file
diff --git a/build/output/knockout-latest.debug.js b/build/output/knockout-latest.debug.js
index f91f9c9af..d24f22b8b 100644
--- a/build/output/knockout-latest.debug.js
+++ b/build/output/knockout-latest.debug.js
@@ -1,9 +1,11 @@
-// Knockout JavaScript library v2.1.0pre
+// Knockout JavaScript library v2.1.0pre+mbest/smart-binding/beta.3+GilesBradshaw/BindingProviderConfiguration
 // (c) Steven Sanderson - http://knockoutjs.com/
 // License: MIT (http://www.opensource.org/licenses/mit-license.php)
 
-(function(window,document,navigator,undefined){ 
-!function(factory) {
+(function(){
+var DEBUG=true;
+(function(window,document,navigator,undefined){function ko_throw(e){throw Error(e)} 
+(function(factory) {
     // Support three module loading scenarios
     if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
         // [1] CommonJS/Node.js
@@ -16,7 +18,7 @@
         // [3] No module loader (plain <script> tag) - put directly in global namespace
         factory(window['ko'] = {});
     }
-}(function(koExports){
+})(function(koExports){
 // Internally, all KO objects are attached to koExports (even the non-exported ones whose names will be minified by the closure compiler).
 // In the future, the following "ko" variable may be made distinct from "koExports" so that private objects are not externally reachable.
 var ko = typeof koExports !== 'undefined' ? koExports : {};
@@ -35,10 +37,16 @@ ko.exportSymbol = function(koPath, object) {
 ko.exportProperty = function(owner, publicName, object) {
   owner[publicName] = object;
 };
-ko.version = "2.1.0pre";
+ko.exportProperties = function(owner /*name, object, name, object ...*/) {
+    for (var i=1, a=arguments, n=a.length-1; i < n; i += 2) {
+        owner[a[i]] = a[i+1];
+    }
+    return owner;
+};
+ko.version = "2.1.0pre+mbest/smart-binding/beta.3+GilesBradshaw/BindingProviderConfiguration";
 
 ko.exportSymbol('version', ko.version);
-ko.utils = new (function () {
+ko.utils = (function () {
     var stringTrimRegex = /^(\s|\u00A0)+|(\s|\u00A0)+$/g;
     
     // 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)
@@ -62,7 +70,7 @@ ko.utils = new (function () {
         while (
             div.innerHTML = '<!--[if gt IE ' + (++version) + ']><i></i><![endif]-->',
             iElems[0]
-        );        
+        ) {};
         return version > 4 ? version : undefined;        
     }());
     var isIe6 = ieVersion === 6,
@@ -74,8 +82,8 @@ ko.utils = new (function () {
         var inputType = element.type.toLowerCase();
         return (inputType == "checkbox") || (inputType == "radio");
     }
-    
-    return {
+
+    var utils = {
         fieldsIncludedWithJsonPost: ['authenticity_token', /^__RequestVerificationToken(_.*)?$/],
         
         arrayForEach: function (array, action) {
@@ -100,7 +108,7 @@ ko.utils = new (function () {
         },
 
         arrayRemoveItem: function (array, itemToRemove) {
-            var index = ko.utils.arrayIndexOf(array, itemToRemove);
+            var index = utils.arrayIndexOf(array, itemToRemove);
             if (index >= 0)
                 array.splice(index, 1);
         },
@@ -109,7 +117,7 @@ ko.utils = new (function () {
             array = array || [];
             var result = [];
             for (var i = 0, j = array.length; i < j; i++) {
-                if (ko.utils.arrayIndexOf(result, array[i]) < 0)
+                if (utils.arrayIndexOf(result, array[i]) < 0)
                     result.push(array[i]);
             }
             return result;
@@ -141,7 +149,7 @@ ko.utils = new (function () {
             return array;
         },
 
-        extend: function (target, source) {
+        extendInternal: function (target, source) {
             for(var prop in source) {
                 if(source.hasOwnProperty(prop)) {
                     target[prop] = source[prop];
@@ -150,16 +158,26 @@ ko.utils = new (function () {
             return target;
         },
 
+        objectMap: function(source, mapping) {
+            var target = {};
+            for(var prop in source) {
+                if(source.hasOwnProperty(prop)) {
+                    target[prop] = mapping(source[prop]);
+                }
+            }
+            return target;
+        },
+
         emptyDomNode: function (domNode) {
             while (domNode.firstChild) {
-                ko.removeNode(domNode.firstChild);
+                ko.cleanAndRemoveNode(domNode.firstChild);
             }
         },
 
         moveNodesToContainerElement: function(nodes) {
             // Ensure it's a real array, as we're about to reparent the nodes and
             // we don't want the underlying collection to change while we're doing that.
-            var nodesArray = ko.utils.makeArray(nodes);
+            var nodesArray = utils.makeArray(nodes);
 
             var container = document.createElement('div');
             for (var i = 0, j = nodesArray.length; i < j; i++)
@@ -168,7 +186,7 @@ ko.utils = new (function () {
         },
 
         setDomNodeChildren: function (domNode, childNodes) {
-            ko.utils.emptyDomNode(domNode);
+            utils.emptyDomNode(domNode);
             if (childNodes) {
                 for (var i = 0, j = childNodes.length; i < j; i++)
                     domNode.appendChild(childNodes[i]);
@@ -183,7 +201,7 @@ ko.utils = new (function () {
                 for (var i = 0, j = newNodesArray.length; i < j; i++)
                     parent.insertBefore(newNodesArray[i], insertionPoint);
                 for (var i = 0, j = nodesToReplaceArray.length; i < j; i++) {
-                    ko.removeNode(nodesToReplaceArray[i]);
+                    ko.cleanAndRemoveNode(nodesToReplaceArray[i]);
                 }
             }
         },
@@ -204,7 +222,7 @@ ko.utils = new (function () {
             var result = [];
             var tokens = (string || "").split(delimiter);
             for (var i = 0, j = tokens.length; i < j; i++) {
-                var trimmed = ko.utils.stringTrim(tokens[i]);
+                var trimmed = utils.stringTrim(tokens[i]);
                 if (trimmed !== "")
                     result.push(trimmed);
             }
@@ -241,7 +259,7 @@ ko.utils = new (function () {
         },
 
         domNodeIsAttachedToDocument: function (node) {
-            return ko.utils.domNodeIsContainedBy(node, document);
+            return utils.domNodeIsContainedBy(node, document);
         },
 
         registerEventHandler: function (element, eventType, handler) {
@@ -268,12 +286,12 @@ ko.utils = new (function () {
                     handler.call(element, event);
                 });
             else
-                throw new Error("Browser doesn't support addEventListener or attachEvent");
+                ko_throw("Browser doesn't support addEventListener or attachEvent");
         },
 
         triggerEvent: function (element, eventType) {
             if (!(element && element.nodeType))
-                throw new Error("element must be a DOM node when calling triggerEvent");
+                ko_throw("element must be a DOM node when calling triggerEvent");
 
             if (typeof jQuery != "undefined") {
                 var eventData = [];
@@ -290,7 +308,7 @@ ko.utils = new (function () {
                     element.dispatchEvent(event);
                 }
                 else
-                    throw new Error("The supplied element doesn't support dispatchEvent");
+                    ko_throw("The supplied element doesn't support dispatchEvent");
             } 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
@@ -301,44 +319,30 @@ ko.utils = new (function () {
                 element.fireEvent("on" + eventType);
             }
             else
-                throw new Error("Browser doesn't support triggering events");
+                ko_throw("Browser doesn't support triggering events");
         },
 
         unwrapObservable: function (value) {
             return ko.isObservable(value) ? value() : value;
         },
 
-        domNodeHasCssClass: function (node, className) {
-            var currentClassNames = (node.className || "").split(/\s+/);
-            return ko.utils.arrayIndexOf(currentClassNames, className) >= 0;
+        possiblyWrap: function(readFunction, nodeOrNodes) {
+            return ko.dependentObservable(readFunction, null,
+                { returnValueIfNoDependencies: true, disposalNodes: nodeOrNodes });
         },
 
         toggleDomNodeCssClass: function (node, className, shouldHaveClass) {
-            var hasClass = ko.utils.domNodeHasCssClass(node, className);
+            var currentClassNames = (node.className || "").split(/\s+/);
+            var hasClass = utils.arrayIndexOf(currentClassNames, className) >= 0;
+
             if (shouldHaveClass && !hasClass) {
-                node.className = (node.className || "") + " " + className;
+                node.className += (currentClassNames[0] ? " " : "") + className;
             } else if (hasClass && !shouldHaveClass) {
-                var currentClassNames = (node.className || "").split(/\s+/);
                 var newClassName = "";
                 for (var i = 0; i < currentClassNames.length; i++)
                     if (currentClassNames[i] != className)
                         newClassName += currentClassNames[i] + " ";
-                node.className = ko.utils.stringTrim(newClassName);
-            }
-        },
-
-        setTextContent: function(element, textContent) {
-            var value = ko.utils.unwrapObservable(textContent);
-            if ((value === null) || (value === undefined))
-                value = "";
-
-            'innerText' in element ? element.innerText = value
-                                   : element.textContent = value;
-                                   
-            if (ieVersion >= 9) {
-                // Believe it or not, this actually fixes an IE9 rendering bug
-                // (See https://github.com/SteveSanderson/knockout/issues/209)
-                element.style.display = element.style.display;
+                node.className = utils.stringTrim(newClassName);
             }
         },
 
@@ -353,8 +357,8 @@ ko.utils = new (function () {
         },
 
         range: function (min, max) {
-            min = ko.utils.unwrapObservable(min);
-            max = ko.utils.unwrapObservable(max);
+            min = utils.unwrapObservable(min);
+            max = utils.unwrapObservable(max);
             var result = [];
             for (var i = min; i <= max; i++)
                 result.push(i);
@@ -372,9 +376,9 @@ ko.utils = new (function () {
         isIe6 : isIe6,
         isIe7 : isIe7,
         ieVersion : ieVersion,
-        
+
         getFormFields: function(form, fieldName) {
-            var fields = ko.utils.makeArray(form.getElementsByTagName("INPUT")).concat(ko.utils.makeArray(form.getElementsByTagName("TEXTAREA")));
+            var fields = utils.makeArray(form.getElementsByTagName("INPUT")).concat(utils.makeArray(form.getElementsByTagName("TEXTAREA")));
             var isMatchingField = (typeof fieldName == 'string') 
                 ? function(field) { return field.name === fieldName }
                 : function(field) { return fieldName.test(field.name) }; // Treat fieldName as regex or object containing predicate
@@ -388,7 +392,7 @@ ko.utils = new (function () {
         
         parseJson: function (jsonString) {
             if (typeof jsonString == "string") {
-                jsonString = ko.utils.stringTrim(jsonString);
+                jsonString = utils.stringTrim(jsonString);
                 if (jsonString) {
                     if (window.JSON && window.JSON.parse) // Use native parsing where available
                         return window.JSON.parse(jsonString);
@@ -398,10 +402,10 @@ ko.utils = new (function () {
             return null;
         },
 
-        stringifyJson: function (data) {
+        stringifyJson: function (data, replacer, space) {   // replacer and space are optional 
             if ((typeof JSON == "undefined") || (typeof JSON.stringify == "undefined"))
-                throw new Error("Cannot find JSON.stringify(). Some browsers (e.g., IE < 8) don't support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js");
-            return JSON.stringify(ko.utils.unwrapObservable(data));
+                ko_throw("Cannot find JSON.stringify(). Some browsers (e.g., IE < 8) don't support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js");
+            return JSON.stringify(utils.unwrapObservable(data), replacer, space);
         },
 
         postJson: function (urlOrForm, data, options) {
@@ -415,13 +419,13 @@ ko.utils = new (function () {
                 var originalForm = urlOrForm;
                 url = originalForm.action;
                 for (var i = includeFields.length - 1; i >= 0; i--) {
-                    var fields = ko.utils.getFormFields(originalForm, includeFields[i]);
+                    var fields = utils.getFormFields(originalForm, includeFields[i]);
                     for (var j = fields.length - 1; j >= 0; j--)        				
                         params[fields[j].name] = fields[j].value;
                 }
             }        	
             
-            data = ko.utils.unwrapObservable(data);
+            data = utils.unwrapObservable(data);
             var form = document.createElement("FORM");
             form.style.display = "none";
             form.action = url;
@@ -429,7 +433,7 @@ ko.utils = new (function () {
             for (var key in data) {
                 var input = document.createElement("INPUT");
                 input.name = key;
-                input.value = ko.utils.stringifyJson(ko.utils.unwrapObservable(data[key]));
+                input.value = utils.stringifyJson(utils.unwrapObservable(data[key]));
                 form.appendChild(input);
             }
             for (var key in params) {
@@ -440,31 +444,34 @@ ko.utils = new (function () {
             }            
             document.body.appendChild(form);
             options['submitter'] ? options['submitter'](form) : form.submit();
-            setTimeout(function () { form.parentNode.removeChild(form); }, 0);
+            setTimeout(function () { form.parentNode.removeChild(form); });
         }
-    }
+    };
+
+    return ko.exportProperties(utils,
+        'arrayForEach', utils.arrayForEach,
+        'arrayFirst', utils.arrayFirst,
+        'arrayFilter', utils.arrayFilter,
+        'arrayGetDistinctValues', utils.arrayGetDistinctValues,
+        'arrayIndexOf', utils.arrayIndexOf,
+        'arrayMap', utils.arrayMap,
+        'arrayPushAll', utils.arrayPushAll,
+        'arrayRemoveItem', utils.arrayRemoveItem,
+        'extend', utils.extendInternal,
+        'fieldsIncludedWithJsonPost', utils.fieldsIncludedWithJsonPost,
+        'getFormFields', utils.getFormFields,
+        'postJson', utils.postJson,
+        'parseJson', utils.parseJson,
+        'registerEventHandler', utils.registerEventHandler,
+        'stringifyJson', utils.stringifyJson,
+        'range', utils.range,
+        'toggleDomNodeCssClass', utils.toggleDomNodeCssClass,
+        'triggerEvent', utils.triggerEvent,
+        'unwrapObservable', utils.unwrapObservable
+    );
 })();
 
 ko.exportSymbol('utils', ko.utils);
-ko.exportSymbol('utils.arrayForEach', ko.utils.arrayForEach);
-ko.exportSymbol('utils.arrayFirst', ko.utils.arrayFirst);
-ko.exportSymbol('utils.arrayFilter', ko.utils.arrayFilter);
-ko.exportSymbol('utils.arrayGetDistinctValues', ko.utils.arrayGetDistinctValues);
-ko.exportSymbol('utils.arrayIndexOf', ko.utils.arrayIndexOf);
-ko.exportSymbol('utils.arrayMap', ko.utils.arrayMap);
-ko.exportSymbol('utils.arrayPushAll', ko.utils.arrayPushAll);
-ko.exportSymbol('utils.arrayRemoveItem', ko.utils.arrayRemoveItem);
-ko.exportSymbol('utils.extend', ko.utils.extend);
-ko.exportSymbol('utils.fieldsIncludedWithJsonPost', ko.utils.fieldsIncludedWithJsonPost);
-ko.exportSymbol('utils.getFormFields', ko.utils.getFormFields);
-ko.exportSymbol('utils.postJson', ko.utils.postJson);
-ko.exportSymbol('utils.parseJson', ko.utils.parseJson);
-ko.exportSymbol('utils.registerEventHandler', ko.utils.registerEventHandler);
-ko.exportSymbol('utils.stringifyJson', ko.utils.stringifyJson);
-ko.exportSymbol('utils.range', ko.utils.range);
-ko.exportSymbol('utils.toggleDomNodeCssClass', ko.utils.toggleDomNodeCssClass);
-ko.exportSymbol('utils.triggerEvent', ko.utils.triggerEvent);
-ko.exportSymbol('utils.unwrapObservable', ko.utils.unwrapObservable);
 
 if (!Function.prototype['bind']) {
     // Function.prototype.bind is a standard part of ECMAScript 5th Edition (December 2009, http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf)
@@ -481,139 +488,233 @@ ko.utils.domData = new (function () {
     var uniqueId = 0;
     var dataStoreKeyExpandoPropertyName = "__ko__" + (new Date).getTime();
     var dataStore = {};
-    return {
-        get: function (node, key) {
-            var allDataForNode = ko.utils.domData.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)
-                    return;
-            }
-            var allDataForNode = ko.utils.domData.getAll(node, true);
-            allDataForNode[key] = value;
-        },
-        getAll: function (node, createIfNotFound) {
-            var dataStoreKey = node[dataStoreKeyExpandoPropertyName];
-            var hasExistingDataStore = dataStoreKey && (dataStoreKey !== "null");
-            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) {
-                delete dataStore[dataStoreKey];
-                node[dataStoreKeyExpandoPropertyName] = null;
-            }
+
+    function getData(node, key) {
+        var allDataForNode = getAll(node, false);
+        return allDataForNode === undefined ? undefined : allDataForNode[key];
+    }
+
+    function setData(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 (getAll(node, false) === undefined)
+                return;
         }
+        var allDataForNode = getAll(node, true);
+        allDataForNode[key] = value;
+    }
+
+    function getAll(node, createIfNotFound) {
+        var dataStoreKey = node[dataStoreKeyExpandoPropertyName];
+        var hasExistingDataStore = dataStoreKey && (dataStoreKey !== "null");
+        if (!hasExistingDataStore) {
+            if (!createIfNotFound)
+                return undefined;
+            dataStoreKey = node[dataStoreKeyExpandoPropertyName] = "ko" + uniqueId++;
+            dataStore[dataStoreKey] = {};
+        }
+        return dataStore[dataStoreKey];
     }
-})();
 
+    function clear(node) {
+        var dataStoreKey = node[dataStoreKeyExpandoPropertyName];
+        if (dataStoreKey) {
+            delete dataStore[dataStoreKey];
+            node[dataStoreKeyExpandoPropertyName] = null;
+        }
+    }
+    
+    function nextKey() {
+        return uniqueId++;
+    }
+
+    // add shortcuts
+    ko.domDataGet = getData;
+    ko.domDataSet = setData;
+
+    return {
+        get: getData,
+        set: setData,
+        clear: clear,
+        nextKey: nextKey
+    };
+})();
 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
 
     function getDisposeCallbacksCollection(node, createIfNotFound) {
-        var allDisposeCallbacks = ko.utils.domData.get(node, domDataKey);
+        var allDisposeCallbacks = ko.domDataGet(node, domDataKey);
         if ((allDisposeCallbacks === undefined) && createIfNotFound) {
             allDisposeCallbacks = [];
-            ko.utils.domData.set(node, domDataKey, allDisposeCallbacks);
+            ko.domDataSet(node, domDataKey, allDisposeCallbacks);
         }
         return allDisposeCallbacks;
     }
     function destroyCallbacksCollection(node) {
-        ko.utils.domData.set(node, domDataKey, undefined);
+        ko.domDataSet(node, domDataKey, undefined);
     }
     
-    function cleanSingleNode(node) {
+    function cleanSingleNode(node, onlyDispose) {
         // Run all the dispose callbacks
         var callbacks = getDisposeCallbacksCollection(node, false);
         if (callbacks) {
             callbacks = callbacks.slice(0); // Clone, as the array may be modified during iteration (typically, callbacks will remove themselves)
             for (var i = 0; i < callbacks.length; i++)
                 callbacks[i](node);
+            if (onlyDispose)
+                destroyCallbacksCollection(node);
         }
         
-        // Also erase the DOM data
-        ko.utils.domData.clear(node);
+        if (!onlyDispose) {
+            // Also 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]);
+            // 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]);
+        }
 
         // Also 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);
+            cleanImmediateCommentTypeChildren(node, onlyDispose);
     }
 
-    function cleanImmediateCommentTypeChildren(nodeWithChildren) {
+    function cleanImmediateCommentTypeChildren(nodeWithChildren, onlyDispose) {
         var child, nextChild = nodeWithChildren.firstChild;
         while (child = nextChild) {
             nextChild = child.nextSibling;
             if (child.nodeType === 8)
-                cleanSingleNode(child);
+                cleanSingleNode(child, onlyDispose);
         }
     }
-    
-    return {
-        addDisposeCallback : function(node, callback) {
-            if (typeof callback != "function")
-                throw new Error("Callback must be a function");
-            getDisposeCallbacksCollection(node, true).push(callback);
-        },
-        
-        removeDisposeCallback : function(node, callback) {
+
+    function addDisposeCallback(nodeOrNodes, disposeCallback, disposeWhen) {
+        var nodes = [];
+        function addNode(node) {
+            if (node.nodeType !== 3) {
+                nodes.push(node);
+                getDisposeCallbacksCollection(node, true).push(cleanNodeCallback);
+            }
+        }
+        function nodeIsDisposed(node) {
+            ko.utils.arrayRemoveItem(nodes, node);
+            if (!nodes.length)
+                disposeCallback();
+        }
+        function cleanNodeCallback(node, deleteNodeIfMatchingDispose) {
+            if (!deleteNodeIfMatchingDispose)
+                nodeIsDisposed(node);
+            else if (deleteNodeIfMatchingDispose == disposeCallback)
+                deleteNode(node);
+        }
+        function addNodeOrNodes(nodeOrNodes) {
+            nodeOrNodes.nodeType
+                ? addNode(nodeOrNodes)
+                : ko.utils.arrayForEach(nodeOrNodes, addNode);
+        }
+        function deleteNode(node) {
             var callbacksCollection = getDisposeCallbacksCollection(node, false);
             if (callbacksCollection) {
-                ko.utils.arrayRemoveItem(callbacksCollection, callback);
-                if (callbacksCollection.length == 0)
+                ko.utils.arrayRemoveItem(callbacksCollection, cleanNodeCallback);
+                if (!callbacksCollection.length)
                     destroyCallbacksCollection(node);
             }
-        },
-        
-        cleanNode : function(node) {
-            // First clean this node, where applicable
-            if (cleanableNodeTypes[node.nodeType]) {
-                cleanSingleNode(node);
-                
-                // ... then its descendants, where applicable
-                if (cleanableNodeTypesWithDescendants[node.nodeType]) {
-                    // Clone the descendants list in case it changes during iteration
-                    var descendants = [];
-                    ko.utils.arrayPushAll(descendants, node.getElementsByTagName("*"));
-                    for (var i = 0, j = descendants.length; i < j; i++)
-                        cleanSingleNode(descendants[i]);
-                }
+            ko.utils.arrayRemoveItem(nodes, node);
+        }
+        function deleteAll() {
+            while (nodes.length)
+                deleteNode(nodes[0]);
+        }
+        function dispose() {
+            deleteAll();
+            disposeCallback();
+        }
+        function shouldDispose() {
+            return !ko.utils.arrayFirst(nodes, ko.utils.domNodeIsAttachedToDocument) || (disposeWhen && disposeWhen());
+        }
+        function getNodes() {
+            return nodes;
+        }
+        function getNodesCount() {
+            return nodes.length;
+        }
+
+        if (typeof disposeCallback != "function")
+            ko_throw("Callback must be a function");
+        if (nodeOrNodes)
+            addNodeOrNodes(nodeOrNodes);
+
+        return {
+            addNodeOrNodes: addNodeOrNodes,
+            deleteNode: deleteNode,
+            deleteAll: deleteAll,
+            dispose: dispose,
+            shouldDispose: shouldDispose,
+            getNodes: getNodes,
+            getNodesCount: getNodesCount
+        };
+    }
+
+    function removeDisposeCallback(node, disposeCallback) {
+        var callbacksCollection = getDisposeCallbacksCollection(node, false);
+        if (callbacksCollection)
+            ko.utils.arrayForEach(callbacksCollection, function(cleanNodeCallback) {
+                cleanNodeCallback(node, disposeCallback);
+            });
+    }
+
+    function cleanOrDisposeNode(node, onlyDispose) {
+        // First clean this node, where applicable
+        if (cleanableNodeTypes[node.nodeType]) {
+            cleanSingleNode(node, onlyDispose);
+            
+            // ... then its descendants, where applicable
+            if (cleanableNodeTypesWithDescendants[node.nodeType]) {
+                // Clone the descendants list in case it changes during iteration
+                var descendants = [];
+                ko.utils.arrayPushAll(descendants, node.getElementsByTagName("*"));
+                for (var i = 0, j = descendants.length; i < j; i++)
+                    cleanSingleNode(descendants[i], onlyDispose);
             }
-        },
-        
-        removeNode : function(node) {
-            ko.cleanNode(node);
-            if (node.parentNode)
-                node.parentNode.removeChild(node);
         }
     }
+    
+    function disposeNode(node) {
+        cleanOrDisposeNode(node, true);
+    }
+
+    function cleanAndRemoveNode(node) {
+        cleanOrDisposeNode(node);
+        if (node.parentNode)
+            node.parentNode.removeChild(node);
+    }
+
+    ko.cleanNode = cleanOrDisposeNode;
+    ko.cleanAndRemoveNode = cleanAndRemoveNode;
+    ko.disposeNode = disposeNode;
+
+    var domNodeDisposal = {
+        addDisposeCallback : addDisposeCallback,
+        removeDisposeCallback : removeDisposeCallback
+    };
+
+    return ko.exportProperties(domNodeDisposal, 
+        'addDisposeCallback', domNodeDisposal.addDisposeCallback,
+        'removeDisposeCallback', domNodeDisposal.removeDisposeCallback
+    );
 })();
-ko.cleanNode = ko.utils.domNodeDisposal.cleanNode; // Shorthand name for convenience
-ko.removeNode = ko.utils.domNodeDisposal.removeNode; // Shorthand name for convenience
-ko.exportSymbol('cleanNode', ko.cleanNode); 
-ko.exportSymbol('removeNode', ko.removeNode);
+ko.exportSymbol('cleanNode', ko.cleanNode);
+ko.exportSymbol('cleanAndRemoveNode', ko.cleanAndRemoveNode);
+ko.exportSymbol('removeNode', ko.cleanAndRemoveNode);       // exported for compatibility
 ko.exportSymbol('utils.domNodeDisposal', ko.utils.domNodeDisposal);
-ko.exportSymbol('utils.domNodeDisposal.addDisposeCallback', ko.utils.domNodeDisposal.addDisposeCallback);
-ko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeDisposal.removeDisposeCallback);(function () {
+(function () {
     var leadingCommentRegex = /^(\s*)<!--(.*?)-->/;
 
     function simpleHtmlParse(html) {
@@ -721,10 +822,10 @@ ko.memoization = (function () {
         }
     }
 
-    return {
+    var memoization = {
         memoize: function (callback) {
             if (typeof callback != "function")
-                throw new Error("You can only pass a function to ko.memoization.memoize()");
+                ko_throw("You can only pass a function to ko.memoization.memoize()");
             var memoId = generateRandomId();
             memos[memoId] = callback;
             return "<!--[ko_memo:" + memoId + "]-->";
@@ -733,7 +834,7 @@ ko.memoization = (function () {
         unmemoize: function (memoId, callbackParams) {
             var callback = memos[memoId];
             if (callback === undefined)
-                throw new Error("Couldn't find any memo with ID " + memoId + ". Perhaps it's already been unmemoized.");
+                ko_throw("Couldn't find any memo with ID " + memoId + ". Perhaps it's already been unmemoized.");
             try {
                 callback.apply(null, callbackParams || []);
                 return true;
@@ -749,7 +850,7 @@ ko.memoization = (function () {
                 var combinedParams = [node];
                 if (extraCallbackParamsArray)
                     ko.utils.arrayPushAll(combinedParams, extraCallbackParamsArray);
-                ko.memoization.unmemoize(memos[i].memoId, combinedParams);
+                memoization.unmemoize(memos[i].memoId, combinedParams);
                 node.nodeValue = ""; // Neuter this node so we don't try to unmemoize it again
                 if (node.parentNode)
                     node.parentNode.removeChild(node); // If possible, erase it totally (not always possible - someone else might just hold a reference to it then call unmemoizeDomNodeAndDescendants again)
@@ -761,33 +862,39 @@ ko.memoization = (function () {
             return match ? match[1] : null;
         }
     };
+
+    return ko.exportProperties(memoization,
+        'memoize', memoization.memoize,
+        'unmemoize', memoization.unmemoize,
+        'parseMemoText', memoization.parseMemoText,
+        'unmemoizeDomNodeAndDescendants', memoization.unmemoizeDomNodeAndDescendants
+    );
 })();
 
 ko.exportSymbol('memoization', ko.memoization);
-ko.exportSymbol('memoization.memoize', ko.memoization.memoize);
-ko.exportSymbol('memoization.unmemoize', ko.memoization.unmemoize);
-ko.exportSymbol('memoization.parseMemoText', ko.memoization.parseMemoText);
-ko.exportSymbol('memoization.unmemoizeDomNodeAndDescendants', ko.memoization.unmemoizeDomNodeAndDescendants);
 ko.extenders = {
     'throttle': function(target, timeout) {
         // Throttling means two things:
-
-        // (1) For dependent observables, we throttle *evaluations* so that, no matter how fast its dependencies
-        //     notify updates, the target doesn't re-evaluate (and hence doesn't notify) faster than a certain rate
-        target['throttleEvaluation'] = timeout;
-
-        // (2) For writable targets (observables, or writable dependent observables), we throttle *writes*
-        //     so the target cannot change value synchronously or faster than a certain rate
-        var writeTimeoutInstance = null;
-        return ko.dependentObservable({
-            'read': target,
-            'write': function(value) {
-                clearTimeout(writeTimeoutInstance);
-                writeTimeoutInstance = setTimeout(function() {
-                    target(value);
-                }, timeout);                
-            }
-        });
+    
+        if (ko.isWriteableObservable(target)) {
+            // (1) For writable targets (observables, or writable dependent observables), we throttle *writes*
+            //     so the target cannot change value synchronously or faster than a certain rate
+            var writeTimeoutInstance = null;
+            return ko.dependentObservable({
+                'read': target,
+                'write': function(value) {
+                    clearTimeout(writeTimeoutInstance);
+                    writeTimeoutInstance = setTimeout(function() {
+                        target(value);
+                    }, timeout);
+                }
+            });
+        } else {
+            // (2) For dependent observables, we throttle *evaluations* so that, no matter how fast its dependencies
+            //     notify updates, the target doesn't re-evaluate (and hence doesn't notify) faster than a certain rate
+            target['throttleEvaluation'] = timeout;
+        }
+        return target;
     },
 
     'notify': function(target, notifyWhen) {
@@ -827,10 +934,12 @@ ko.subscription.prototype.dispose = function () {
 ko.subscribable = function () {
     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);
+    ko.utils.extendInternal(this, ko.subscribable['fn']);
+    ko.exportProperties(this, 
+        'subscribe', this.subscribe,
+        'extend', this.extend,
+        'getSubscriptionsCount', this.getSubscriptionsCount
+    );
 }
 
 var defaultEvent = "change";
@@ -838,15 +947,15 @@ var defaultEvent = "change";
 ko.subscribable['fn'] = {
     subscribe: function (callback, callbackTarget, event) {
         event = event || defaultEvent;
-        var boundCallback = callbackTarget ? callback.bind(callbackTarget) : callback;
+        var self = this, 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);
+        });
 
-        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;
     },
 
@@ -884,7 +993,7 @@ ko.exportSymbol('isSubscribable', ko.isSubscribable);
 
 ko.dependencyDetection = (function () {
     var _frames = [];
-    
+
     return {
         begin: function (callback) {
             _frames.push({ callback: callback, distinctDependencies:[] });
@@ -896,17 +1005,29 @@ ko.dependencyDetection = (function () {
 
         registerDependency: function (subscribable) {
             if (!ko.isSubscribable(subscribable))
-                throw new Error("Only subscribable things can act as dependencies");
+                ko_throw("Only subscribable things can act as dependencies");
             if (_frames.length > 0) {
                 var topFrame = _frames[_frames.length - 1];
-                if (ko.utils.arrayIndexOf(topFrame.distinctDependencies, subscribable) >= 0)
+                if (!topFrame || ko.utils.arrayIndexOf(topFrame.distinctDependencies, subscribable) >= 0)
                     return;
                 topFrame.distinctDependencies.push(subscribable);
                 topFrame.callback(subscribable);
             }
+        },
+
+        ignore: function(callback) {
+            try {
+                _frames.push(null);
+                return callback();
+            } finally {
+                _frames.pop();
+            }
         }
     };
-})();var primitiveTypes = { 'undefined':true, 'boolean':true, 'number':true, 'string':true };
+})();
+
+ko.exportSymbol('ignoreDependencies', ko.ignoreDependencies = ko.dependencyDetection.ignore);
+var primitiveTypes = { 'undefined':true, 'boolean':true, 'number':true, 'string':true };
 
 ko.observable = function (initialValue) {
     var _latestValue = initialValue;
@@ -919,6 +1040,7 @@ ko.observable = function (initialValue) {
             if ((!observable['equalityComparer']) || !observable['equalityComparer'](_latestValue, arguments[0])) {
                 observable.valueWillMutate();
                 _latestValue = arguments[0];
+                if (DEBUG) observable._latestValue = _latestValue;
                 observable.valueHasMutated();
             }
             return this; // Permits chained assignments
@@ -929,15 +1051,16 @@ ko.observable = function (initialValue) {
             return _latestValue;
         }
     }
+    if (DEBUG) observable._latestValue = _latestValue;
     ko.subscribable.call(observable);
     observable.valueHasMutated = function () { observable["notifySubscribers"](_latestValue); }
     observable.valueWillMutate = function () { observable["notifySubscribers"](_latestValue, "beforeChange"); }
-    ko.utils.extend(observable, ko.observable['fn']);
+    ko.utils.extendInternal(observable, ko.observable['fn']);
 
-    ko.exportProperty(observable, "valueHasMutated", observable.valueHasMutated);
-    ko.exportProperty(observable, "valueWillMutate", observable.valueWillMutate);
-    
-    return observable;
+    return ko.exportProperties(observable, 
+        "valueHasMutated", observable.valueHasMutated,
+        "valueWillMutate", observable.valueWillMutate
+    );
 }
 
 ko.observable['fn'] = {
@@ -950,10 +1073,14 @@ ko.observable['fn'] = {
 var protoProperty = ko.observable.protoProperty = "__ko_proto__";
 ko.observable['fn'][protoProperty] = ko.observable;
 
-ko.isObservable = function (instance) {
+ko.hasPrototype = function(instance, prototype) {
     if ((instance === null) || (instance === undefined) || (instance[protoProperty] === undefined)) return false;
-    if (instance[protoProperty] === ko.observable) return true;
-    return ko.isObservable(instance[protoProperty]); // Walk the prototype chain
+    if (instance[protoProperty] === prototype) return true;
+    return ko.hasPrototype(instance[protoProperty], prototype); // Walk the prototype chain 
+};
+
+ko.isObservable = function (instance) {
+    return ko.hasPrototype(instance, ko.observable);
 }
 ko.isWriteableObservable = function (instance) {
     // Observable
@@ -976,10 +1103,10 @@ ko.observableArray = function (initialValues) {
         initialValues = [];
     }
     if ((initialValues !== null) && (initialValues !== undefined) && !('length' in initialValues))
-        throw new Error("The argument passed when initializing an observable array must be an array, or null, or undefined.");
+        ko_throw("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']);
+    ko.utils.extendInternal(result, ko.observableArray['fn']);
     return result;
 }
 
@@ -1084,8 +1211,9 @@ ko.utils.arrayForEach(["slice"], function (methodName) {
 
 ko.exportSymbol('observableArray', ko.observableArray);
 ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunctionTarget, options) {
-    var _latestValue, 
-        _hasBeenEvaluated = false,
+    var _latestValue,
+        _needsEvaluation = true,
+        _isBeingEvaluated = false,
         readFunction = evaluatorFunctionOrOptions;
 
     if (readFunction && typeof readFunction == "object") {
@@ -1100,7 +1228,7 @@ ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunction
     }
     // By here, "options" is always non-null
     if (typeof readFunction != "function")
-        throw new Error("Pass a function that returns the value of the ko.computed");
+        ko_throw("Pass a function that returns the value of the ko.computed");
 
     var writeFunction = options["write"];
     if (!evaluatorFunctionTarget)
@@ -1112,28 +1240,13 @@ ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunction
             subscription.dispose();
         });
         _subscriptionsToDependencies = [];
+        _needsEvaluation = false;
     }
-    var dispose = disposeAllSubscriptionsToDependencies;
-    
-    // Build "disposeWhenNodeIsRemoved" and "disposeWhenNodeIsRemovedCallback" option values
-    // (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.)
-    var disposeWhenNodeIsRemoved = (typeof options["disposeWhenNodeIsRemoved"] == "object") ? options["disposeWhenNodeIsRemoved"] : null;
-    var disposeWhen = options["disposeWhen"] || function() { return false; };
-    if (disposeWhenNodeIsRemoved) {
-        dispose = function() { 
-            ko.utils.domNodeDisposal.removeDisposeCallback(disposeWhenNodeIsRemoved, arguments.callee);
-            disposeAllSubscriptionsToDependencies();
-        };
-        ko.utils.domNodeDisposal.addDisposeCallback(disposeWhenNodeIsRemoved, dispose);
-        var existingDisposeWhenFunction = disposeWhen;
-        disposeWhen = function () {
-            return !ko.utils.domNodeIsAttachedToDocument(disposeWhenNodeIsRemoved) || existingDisposeWhenFunction();
-        }    	
-    }
-    
+
+
     var evaluationTimeoutInstance = null;
     function evaluatePossiblyAsync() {
+        _needsEvaluation = true;
         var throttleEvaluationTimeout = dependentObservable['throttleEvaluation'];
         if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {
             clearTimeout(evaluationTimeoutInstance);
@@ -1142,15 +1255,21 @@ ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunction
             evaluateImmediate();
     }
 
+    function addDependency(subscribable) {
+        _subscriptionsToDependencies.push(subscribable.subscribe(evaluatePossiblyAsync));
+    }
+
     function evaluateImmediate() {
-        // 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();
+        if (_isBeingEvaluated || !_needsEvaluation)
+            return;
+
+        // disposeWhen won't be set until after initial evaluation
+        if (disposeWhen && disposeWhen()) {
+            dependentObservable.dispose();
             return;
         }
 
+        _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.
@@ -1161,7 +1280,7 @@ ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunction
                 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
-                    _subscriptionsToDependencies.push(subscribable.subscribe(evaluatePossiblyAsync)); // Brand new subscription - add it
+                    addDependency(subscribable); // Brand new subscription - add it
             });
 
             var newValue = readFunction.call(evaluatorFunctionTarget);
@@ -1174,19 +1293,32 @@ ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunction
 
             dependentObservable["notifySubscribers"](_latestValue, "beforeChange");
             _latestValue = newValue;
+            if (DEBUG) dependentObservable._latestValue = _latestValue;
+            _needsEvaluation = false;
         } finally {
             ko.dependencyDetection.end();
         }
 
         dependentObservable["notifySubscribers"](_latestValue);
-        _hasBeenEvaluated = true;
+        _isBeingEvaluated = false;
+    }
+
+    function evaluateInitial() {
+        _isBeingEvaluated = true;
+        try {
+            ko.dependencyDetection.begin(addDependency);
+            _latestValue = readFunction.call(evaluatorFunctionTarget);
+        } finally {
+            ko.dependencyDetection.end();
+        }
+        _needsEvaluation = _isBeingEvaluated = false;
     }
 
     function dependentObservable() {
         if (arguments.length > 0) {
             set.apply(dependentObservable, arguments);
         } else {
-            return get();             
+            return get();
         }
     }
     
@@ -1195,32 +1327,73 @@ ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunction
             // Writing a value
             writeFunction.apply(evaluatorFunctionTarget, arguments);
         } else {
-            throw new Error("Cannot write a value to a ko.computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.");
+            ko_throw("Cannot write a value to a ko.computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.");
         }
     }
 
     function get() {
         // Reading the value
-        if (!_hasBeenEvaluated)
+        if (_needsEvaluation)
             evaluateImmediate();
         ko.dependencyDetection.registerDependency(dependentObservable);
         return _latestValue;
     }
 
-    dependentObservable.getDependenciesCount = function () { return _subscriptionsToDependencies.length; };
-    dependentObservable.hasWriteFunction = typeof options["write"] === "function";
-    dependentObservable.dispose = function () { dispose(); };
-    
+    var disposer, disposalNodes = [];
+    function addDisposalNodes(nodeOrNodes) {
+        if (nodeOrNodes) {
+            if (!disposer)
+                disposer = ko.utils.domNodeDisposal.addDisposeCallback(null, disposeAllSubscriptionsToDependencies, disposeWhen);
+            disposer.addNodeOrNodes(nodeOrNodes);
+            dependentObservable.dispose = disposer.dispose;
+            disposeWhen = disposer.shouldDispose;
+            disposalNodes = disposer.getNodes();
+        }
+        return dependentObservable;
+    }
+    function replaceDisposalNodes(nodeOrNodes) {
+        if (disposer)
+            disposer.deleteAll();
+        return addDisposalNodes(nodeOrNodes);
+    }
+
+    // Evaluate, unless deferEvaluation is true, unless returnValueIfNoDependencies is true
+    if (options['deferEvaluation'] !== true || options.returnValueIfNoDependencies)
+        evaluateInitial();
+
+    // just return the value if returnValueIfNoDependencies is true and there are no dependencies
+    if (options.returnValueIfNoDependencies && !_subscriptionsToDependencies.length)
+        return _latestValue;
+
+    ko.utils.extendInternal(dependentObservable, {
+        hasWriteFunction:       typeof writeFunction === "function",
+        getDependenciesCount:   function () { return _subscriptionsToDependencies.length; },
+        addDisposalNodes:       addDisposalNodes,
+        replaceDisposalNodes:   replaceDisposalNodes,
+        getDisposalNodesCount:  function() { return disposalNodes.length; },
+        dispose:                disposeAllSubscriptionsToDependencies
+    });
+
+    var disposeWhen = options.disposeWhen || options["disposeWhen"];
+
+    // addDisposalNodes might replace the disposeWhen and dependentObservable.dispose functions
+    // So it needs to be called after they've been initialized with their default values.
+    addDisposalNodes(options.disposalNodes || options["disposeWhenNodeIsRemoved"]);
+
     ko.subscribable.call(dependentObservable);
-    ko.utils.extend(dependentObservable, ko.dependentObservable['fn']);
+    ko.utils.extendInternal(dependentObservable, ko.dependentObservable['fn']);
+
+    return ko.exportProperties(dependentObservable, 
+        'dispose', dependentObservable.dispose,
+        'getDependenciesCount', dependentObservable.getDependenciesCount,
+        'addDisposalNodes', dependentObservable.addDisposalNodes,
+        'replaceDisposalNodes', dependentObservable.replaceDisposalNodes,
+        'getDisposalNodesCount', dependentObservable.getDisposalNodesCount
+    );
+};
 
-    if (options['deferEvaluation'] !== true)
-        evaluateImmediate();
-    
-    ko.exportProperty(dependentObservable, 'dispose', dependentObservable.dispose);
-    ko.exportProperty(dependentObservable, 'getDependenciesCount', dependentObservable.getDependenciesCount);
-    
-    return dependentObservable;
+ko.isComputed = function(instance) {
+    return ko.hasPrototype(instance, ko.dependentObservable);
 };
 
 var protoProp = ko.observable.protoProperty; // == "__ko_proto__"
@@ -1231,12 +1404,13 @@ ko.dependentObservable['fn'][protoProp] = ko.dependentObservable;
 
 ko.exportSymbol('dependentObservable', ko.dependentObservable);
 ko.exportSymbol('computed', ko.dependentObservable); // Make "ko.computed" an alias for "ko.dependentObservable"
+ko.exportSymbol('isComputed', ko.isComputed);
 (function() {    
     var maxNestedObservableDepth = 10; // Escape the (unlikely) pathalogical case where an observable's current value is itself (or similar reference cycle)
     
     ko.toJS = function(rootObject) {
         if (arguments.length == 0)
-            throw new Error("When calling ko.toJS, pass the object you want to convert.");
+            ko_throw("When calling ko.toJS, pass the object you want to convert.");
         
         // We just unwrap everything at every level in the object graph
         return mapJsObjectGraph(rootObject, function(valueToMap) {
@@ -1247,9 +1421,9 @@ ko.exportSymbol('computed', ko.dependentObservable); // Make "ko.computed" an al
         });
     };
 
-    ko.toJSON = function(rootObject) {
+    ko.toJSON = function(rootObject, replacer, space) {     // replacer and space are optional
         var plainJavaScriptObject = ko.toJS(rootObject);
-        return ko.utils.stringifyJson(plainJavaScriptObject);
+        return ko.utils.stringifyJson(plainJavaScriptObject, replacer, space);
     };
     
     function mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects) {
@@ -1320,20 +1494,20 @@ ko.exportSymbol('computed', ko.dependentObservable); // Make "ko.computed" an al
 })();
 
 ko.exportSymbol('toJS', ko.toJS);
-ko.exportSymbol('toJSON', ko.toJSON);(function () {
+ko.exportSymbol('toJSON', ko.toJSON);ko.selectExtensions = (function () {
     var hasDomDataExpandoProperty = '__ko__hasDomDataOptionValue__';
 
     // Normally, SELECT elements and their OPTIONs can only take value of type 'string' (because the values
     // are stored on DOM attributes). ko.selectExtensions provides a way for SELECTs/OPTIONs to have values
     // that are arbitrary objects. This is very convenient when implementing things like cascading dropdowns.
-    ko.selectExtensions = {
+    var selectExtensions = {
         readValue : function(element) {
             if (element.tagName == 'OPTION') {
                 if (element[hasDomDataExpandoProperty] === true)
-                    return ko.utils.domData.get(element, ko.bindingHandlers.options.optionValueDomDataKey);
+                    return ko.domDataGet(element, ko.bindingHandlers.options.optionValueDomDataKey);
                 return element.getAttribute("value");
             } else if (element.tagName == 'SELECT')
-                return element.selectedIndex >= 0 ? ko.selectExtensions.readValue(element.options[element.selectedIndex]) : undefined;
+                return element.selectedIndex >= 0 ? selectExtensions.readValue(element.options[element.selectedIndex]) : undefined;
             else
                 return element.value;
         },
@@ -1342,7 +1516,7 @@ ko.exportSymbol('toJSON', ko.toJSON);(function () {
             if (element.tagName == 'OPTION') {
                 switch(typeof value) {
                     case "string":
-                        ko.utils.domData.set(element, ko.bindingHandlers.options.optionValueDomDataKey, undefined);
+                        ko.domDataSet(element, ko.bindingHandlers.options.optionValueDomDataKey, undefined);
                         if (hasDomDataExpandoProperty in element) { // IE <= 8 throws errors if you delete non-existent properties from a DOM node
                             delete element[hasDomDataExpandoProperty];
                         }
@@ -1350,7 +1524,7 @@ ko.exportSymbol('toJSON', ko.toJSON);(function () {
                         break;
                     default:
                         // Store arbitrary object using DomData
-                        ko.utils.domData.set(element, ko.bindingHandlers.options.optionValueDomDataKey, value);
+                        ko.domDataSet(element, ko.bindingHandlers.options.optionValueDomDataKey, value);
                         element[hasDomDataExpandoProperty] = true;
 
                         // Special treatment of numbers is just for backward compatibility. KO 1.2.1 wrote numerical values to element.value.
@@ -1359,7 +1533,7 @@ ko.exportSymbol('toJSON', ko.toJSON);(function () {
                 }			
             } else if (element.tagName == 'SELECT') {
                 for (var i = element.options.length - 1; i >= 0; i--) {
-                    if (ko.selectExtensions.readValue(element.options[i]) == value) {
+                    if (selectExtensions.readValue(element.options[i]) == value) {
                         element.selectedIndex = i;
                         break;
                     }
@@ -1371,16 +1545,19 @@ ko.exportSymbol('toJSON', ko.toJSON);(function () {
             }
         }
     };        
+
+    return ko.exportProperties(selectExtensions,
+        'readValue', selectExtensions.readValue,
+        'writeValue', selectExtensions.writeValue
+    );
 })();
 
 ko.exportSymbol('selectExtensions', ko.selectExtensions);
-ko.exportSymbol('selectExtensions.readValue', ko.selectExtensions.readValue);
-ko.exportSymbol('selectExtensions.writeValue', ko.selectExtensions.writeValue);
 
-ko.jsonExpressionRewriting = (function () {
+ko.bindingExpressionRewriting = (function () {
     var restoreCapturedTokensRegex = /\@ko_token_(\d+)\@/g;
     var javaScriptAssignmentTarget = /^[\_$a-z][\_$a-z0-9]*(\[.*?\])*(\.[\_$a-z][\_$a-z0-9]*(\[.*?\])*)*$/i;
-    var javaScriptReservedWords = ["true", "false"];
+    var javaScriptReservedWords = ["true", "false", "null"];
 
     function restoreTokens(string, tokens) {
         var prevValue = null;
@@ -1390,29 +1567,41 @@ ko.jsonExpressionRewriting = (function () {
                 return tokens[tokenIndex];
             });
         }
-        return string;
+        return ko.utils.stringTrim(string);
     }
 
     function isWriteableValue(expression) {
-        if (ko.utils.arrayIndexOf(javaScriptReservedWords, ko.utils.stringTrim(expression).toLowerCase()) >= 0)
+        if (ko.utils.arrayIndexOf(javaScriptReservedWords, expression) >= 0)
             return false;
         return expression.match(javaScriptAssignmentTarget) !== null;
     }
 
-    function ensureQuoted(key) {
-        var trimmedKey = ko.utils.stringTrim(key);
-        switch (trimmedKey.length && trimmedKey.charAt(0)) {
+    function isFunctionLiteral(expression) {
+        // match function literal, which must start with function end with }
+        return expression.match(/^\(*function\s*\(.*}\)*$/) !== null;
+    }
+
+    function isPossiblyUnwrappedObservable(expression) {
+        // match parentheses in the expression, but ignore initial parentheses
+        return expression.match(/[^(]+\(/) !== null;
+    }
+
+    function stripQuotes(key) {
+        switch (key.length && key.charAt(0)) {
             case "'":
-            case '"': 
-                return key;
+            case '"':
+                return key.substring(1, key.length - 1);
             default:
-                return "'" + trimmedKey + "'";
+                return key;
         }
+
+    }
+
+    function ensureQuoted(key) {
+        return "'" + key + "'";
     }
 
     return {
-        bindingRewriteValidators: [],
-        
         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
@@ -1491,45 +1680,74 @@ ko.jsonExpressionRewriting = (function () {
                 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) });
+                    result.push({ 'key': stripQuotes(restoreTokens(key, tokens)), 'value': restoreTokens(value, tokens) });
                 } else {
-                    result.push({ 'unknown': restoreTokens(pair, tokens) });
+                    result.push({ 'unknown': stripQuotes(restoreTokens(pair, tokens)) });
                 }
             }
             return result;            
         },
 
-        insertPropertyAccessorsIntoJson: function (objectLiteralStringOrKeyValueArray) {
-            var keyValueArray = typeof objectLiteralStringOrKeyValueArray === "string" 
-                ? ko.jsonExpressionRewriting.parseObjectLiteral(objectLiteralStringOrKeyValueArray)
-                : objectLiteralStringOrKeyValueArray;
-            var resultStrings = [], propertyAccessorResultStrings = [];
-
-            var keyValueEntry;
-            for (var i = 0; keyValueEntry = keyValueArray[i]; i++) {
-                if (resultStrings.length > 0)
-                    resultStrings.push(",");
-
-                if (keyValueEntry['key']) {
-                    var quotedKey = ensureQuoted(keyValueEntry['key']), val = keyValueEntry['value'];
-                    resultStrings.push(quotedKey);
-                    resultStrings.push(":");              
-                    resultStrings.push(val);
-
-                    if (isWriteableValue(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']);
+        insertPropertyAccessors: function (objectLiteralStringOrKeyValueArray, bindingOptions) {
+            bindingOptions = bindingOptions || {};
+            var resultStrings = [], propertyAccessorResultStrings = [],
+                eventHandlersUseObjectForThis = bindingOptions['eventHandlersUseObjectForThis'],
+                independentBindings = bindingOptions['independentBindings'];
+
+            function insertPropertyAccessorsHelper(objectLiteralStringOrKeyValueArray, parentBinding, parentBindingKey) {
+                var keyValueArray = typeof objectLiteralStringOrKeyValueArray === "string"
+                    ? ko.bindingExpressionRewriting.parseObjectLiteral(objectLiteralStringOrKeyValueArray)
+                    : objectLiteralStringOrKeyValueArray;
+                var keyValueEntry;
+                for (var i = 0; keyValueEntry = keyValueArray[i]; i++) {
+                    if (keyValueEntry['key']) {
+                        var key = keyValueEntry['key'], val = keyValueEntry['value'],
+                            quotedKey = ensureQuoted(parentBindingKey ? parentBindingKey+'.'+key : key),
+                            binding = parentBinding || ko.getBindingHandler(key),
+                            canWrap = binding || independentBindings;
+                        if (!parentBinding && binding && (binding['flags'] & bindingFlags_twoLevel) && val.charAt(0) === "{") {
+                            // Handle two-level binding specified as "binding: {key: value}" by parsing inner
+                            // object and converting to "binding.key: value"
+                            insertPropertyAccessorsHelper(val, binding, key);
+                        } else {
+                            if (!isFunctionLiteral(val)) {
+                                if (binding && isWriteableValue(val)) {
+                                    if (eventHandlersUseObjectForThis && binding['flags'] & bindingFlags_eventHandler) {
+                                        // call function literal in an anonymous function so that it is called
+                                        // with appropriate "this" value
+                                        val = 'function(_x,_y,_z){(' + val + ')(_x,_y,_z);}';
+                                    }
+                                    else if (binding['flags'] & bindingFlags_twoWay) {
+                                        // for two-way bindings, provide a write method in case the value
+                                        // isn't a writable observable
+                                        propertyAccessorResultStrings.push(quotedKey + ":function(_z){" + val + "=_z;}");
+                                    }
+                                }
+                                if (canWrap && isPossiblyUnwrappedObservable(val)) {
+                                    // Try to prevent observables from being accessed when parsing a binding;
+                                    // Instead they will be "unwrapped" within the context of the specific binding handler
+                                    val = 'ko.bindingValueWrap(function(){return ' + val + '})';
+                                }
+                            }
+                            resultStrings.push(quotedKey + ":" + val);
+                        }
+                    } else if (keyValueEntry['unknown']) {
+                        // Check if the 'unknown' entry matches a binding handler that can used without a value
+                        // and include it with a value of 'true'
+                        var key = keyValueEntry['unknown'], binding = ko.bindingHandlers[key];
+                        if (binding && (binding['flags'] & bindingFlags_noValue))
+                            resultStrings.push(ensureQuoted(key)+ ":true");
+                        else
+                            resultStrings.push(key);
+                    }
                 }
             }
+            insertPropertyAccessorsHelper(objectLiteralStringOrKeyValueArray);
 
-            var combinedResult = resultStrings.join("");
+            var combinedResult = resultStrings.join(",");
             if (propertyAccessorResultStrings.length > 0) {
-                var allPropertyAccessors = propertyAccessorResultStrings.join("");
-                combinedResult = combinedResult + ", '_ko_property_writers' : { " + allPropertyAccessors + " } ";                
+                var allPropertyAccessors = propertyAccessorResultStrings.join(",");
+                combinedResult = combinedResult + ",'_ko_property_writers':{" + allPropertyAccessors + "}";
             }
 
             return combinedResult;
@@ -1537,18 +1755,19 @@ ko.jsonExpressionRewriting = (function () {
 
         keyValueArrayContainsKey: function(keyValueArray, key) {
             for (var i = 0; i < keyValueArray.length; i++)
-                if (ko.utils.stringTrim(keyValueArray[i]['key']) == key)
-                    return true;            
+                if (keyValueArray[i]['key'] == key)
+                    return true;
             return false;
+        },
+
+        writeValueToProperty: function(allBindingsAccessor, key, value) {
+            var propWriters = allBindingsAccessor('_ko_property_writers');
+            if (propWriters && propWriters[key])
+                propWriters[key](value);
         }
     };
 })();
-
-ko.exportSymbol('jsonExpressionRewriting', ko.jsonExpressionRewriting);
-ko.exportSymbol('jsonExpressionRewriting.bindingRewriteValidators', ko.jsonExpressionRewriting.bindingRewriteValidators);
-ko.exportSymbol('jsonExpressionRewriting.parseObjectLiteral', ko.jsonExpressionRewriting.parseObjectLiteral);
-ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.jsonExpressionRewriting.insertPropertyAccessorsIntoJson);
-(function() {
+ko.virtualElements = (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 
@@ -1561,19 +1780,25 @@ ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.js
     // but it does give them a nonstandard alternative property called "text" that it can read reliably. Other browsers don't have that property.
     // So, use node.text where available, and node.nodeValue elsewhere
     var commentNodesHaveTextProperty = document.createComment("test").text === "<!--test-->";
+    var startCommentRegex = function (bindingProvider) {
+        return commentNodesHaveTextProperty ? new RegExp("^<!--\\s*" + ko.bindingProvider.configuration(bindingProvider).virtualElementTag + "\\s+(.*\\:.*)\\s*-->$") : new RegExp("^\\s*" + ko.bindingProvider.configuration(bindingProvider).virtualElementTag + "\\s+(.*\\:.*)\\s*$");
+    };
 
-    var startCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*ko\s+(.*\:.*)\s*-->$/ : /^\s*ko\s+(.*\:.*)\s*$/;
-    var endCommentRegex =   commentNodesHaveTextProperty ? /^<!--\s*\/ko\s*-->$/ : /^\s*\/ko\s*$/;
+    var endCommentRegex = function (bindingProvider) {
+        return commentNodesHaveTextProperty ? new RegExp("^<!--\\s*\\/" + ko.bindingProvider.configuration(bindingProvider).virtualElementTag + "\\s*-->$") : new RegExp("^\\s*\\/" + ko.bindingProvider.configuration(bindingProvider).virtualElementTag + "\\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) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex());
     }
 
     function isEndComment(node) {
-        return (node.nodeType == 8) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(endCommentRegex);
+        return (node.nodeType == 8) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(endCommentRegex());
     }
 
+
     function getVirtualChildren(startComment, allowUnbalanced) {
         var currentNode = startComment;
         var depth = 1;
@@ -1591,7 +1816,7 @@ ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.js
                 depth++;
         }
         if (!allowUnbalanced)
-            throw new Error("Cannot find closing comment tag to match: " + startComment.nodeValue);
+            ko_throw("Cannot find closing comment tag to match: " + startComment.nodeValue);
         return null;
     }
 
@@ -1627,7 +1852,7 @@ ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.js
         return captureRemaining;
     }
 
-    ko.virtualElements = {
+    var virtualElements = {
         allowedBindings: {},
 
         childNodes: function(node) {
@@ -1638,9 +1863,9 @@ ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.js
             if (!isStartComment(node))
                 ko.utils.emptyDomNode(node);
             else {
-                var virtualChildren = ko.virtualElements.childNodes(node);
+                var virtualChildren = virtualElements.childNodes(node);
                 for (var i = 0, j = virtualChildren.length; i < j; i++)
-                    ko.removeNode(virtualChildren[i]);
+                    ko.cleanAndRemoveNode(virtualChildren[i]);
             }
         },
 
@@ -1648,7 +1873,7 @@ ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.js
             if (!isStartComment(node))
                 ko.utils.setDomNodeChildren(node, childNodes);
             else {
-                ko.virtualElements.emptyNode(node);
+                virtualElements.emptyNode(node);
                 var endCommentNode = node.nextSibling; // Must be the next sibling, as we just emptied the children
                 for (var i = 0, j = childNodes.length; i < j; i++)
                     endCommentNode.parentNode.insertBefore(childNodes[i], endCommentNode);
@@ -1729,42 +1954,49 @@ ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.js
                 } while (childNode = childNode.nextSibling);
             }
         }  
-    };  
+    };
+
+    return ko.exportProperties(virtualElements, 
+        'allowedBindings', virtualElements.allowedBindings,
+        'emptyNode', virtualElements.emptyNode,
+        //'firstChild', virtualElements.firstChild,     // firstChild is not minified
+        'insertAfter', virtualElements.insertAfter,
+        //'nextSibling', virtualElements.nextSibling,   // nextSibling is not minified
+        'prepend', virtualElements.prepend,
+        'setDomNodeChildren', virtualElements.setDomNodeChildren
+    );
 })();
+
 ko.exportSymbol('virtualElements', ko.virtualElements);
-ko.exportSymbol('virtualElements.allowedBindings', ko.virtualElements.allowedBindings);
-ko.exportSymbol('virtualElements.emptyNode', ko.virtualElements.emptyNode);
-//ko.exportSymbol('virtualElements.firstChild', ko.virtualElements.firstChild);     // firstChild is not minified
-ko.exportSymbol('virtualElements.insertAfter', ko.virtualElements.insertAfter);
-//ko.exportSymbol('virtualElements.nextSibling', ko.virtualElements.nextSibling);   // nextSibling is not minified
-ko.exportSymbol('virtualElements.prepend', ko.virtualElements.prepend);
-ko.exportSymbol('virtualElements.setDomNodeChildren', ko.virtualElements.setDomNodeChildren);
-(function() {
-    var defaultBindingAttributeName = "data-bind";
+(function () {
 
-    ko.bindingProvider = function() {
+    ko.bindingProvider = function (configuration) {
+        this.configuration = setDefaultConfiguration(configuration);
         this.bindingCache = {};
+        this['clearCache'] = function () {
+            this.bindingCache = {};
+        };
     };
 
-    ko.utils.extend(ko.bindingProvider.prototype, {
-        'nodeHasBindings': function(node) {
+    ko.utils.extendInternal(ko.bindingProvider.prototype, {
+        'nodeHasBindings': function (node) {
             switch (node.nodeType) {
-                case 1: return node.getAttribute(defaultBindingAttributeName) != null;   // Element
+                case 1: return node.getAttribute(this.configuration.bindingAttribute) != null;   // Element
                 case 8: return ko.virtualElements.virtualNodeBindingValue(node) != null; // Comment node
                 default: return false;
             }
         },
 
-        'getBindings': function(node, bindingContext) {
+        'getBindings': function (node, bindingContext) {
             var bindingsString = this['getBindingsString'](node, bindingContext);
             return bindingsString ? this['parseBindingsString'](bindingsString, bindingContext) : 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) {
+        'getBindingsString': function (node, bindingContext) {
             switch (node.nodeType) {
-                case 1: return node.getAttribute(defaultBindingAttributeName);   // Element
+                case 1: return node.getAttribute(this.configuration.bindingAttribute);   // Element
                 case 8: return ko.virtualElements.virtualNodeBindingValue(node); // Comment node
                 default: return null;
             }
@@ -1772,206 +2004,422 @@ ko.exportSymbol('virtualElements.setDomNodeChildren', ko.virtualElements.setDomN
 
         // 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) {
+        'parseBindingsString': function (bindingsString, bindingContext) {
             try {
                 var viewModel = bindingContext['$data'],
                     scopes = (typeof viewModel == 'object' && viewModel != null) ? [viewModel, bindingContext] : [bindingContext],
-                    bindingFunction = createBindingsStringEvaluatorViaCache(bindingsString, scopes.length, this.bindingCache);
+                    bindingFunction = createBindingsStringEvaluatorViaCache(bindingsString, bindingContext['$options'], scopes.length, this.bindingCache);
                 return bindingFunction(scopes);
             } catch (ex) {
-                throw new Error("Unable to parse bindings.\nMessage: " + ex + ";\nBindings value: " + bindingsString);
-            }           
+                ko_throw("Unable to parse bindings.\nMessage: " + ex + ";\nBindings value: " + bindingsString);
+            }
         }
     });
 
     ko.bindingProvider['instance'] = new ko.bindingProvider();
 
-    function createBindingsStringEvaluatorViaCache(bindingsString, scopesCount, cache) {
+    ko.bindingProvider.configuration = function (bindingProvider) {
+        bindingProvider = bindingProvider ? bindingProvider : ko.bindingProvider["instance"];
+        var configuration = bindingProvider.configuration ? bindingProvider.configuration : {};
+        return setDefaultConfiguration(configuration);
+    };
+
+    function setDefaultConfiguration(configuration) {
+        if (!configuration) configuration = {};
+        configuration.name = configuration.name ? configuration.name : 'default';
+        configuration.bindingAttribute = configuration.bindingAttribute ? configuration.bindingAttribute : 'data-bind';
+        configuration.virtualElementTag = configuration.virtualElementTag ? configuration.virtualElementTag : "ko";
+        return configuration;
+    }
+
+    function createBindingsStringEvaluatorViaCache(bindingsString, bindingOptions, scopesCount, cache) {
         var cacheKey = scopesCount + '_' + bindingsString;
-        return cache[cacheKey] 
-            || (cache[cacheKey] = createBindingsStringEvaluator(bindingsString, scopesCount));
+        return cache[cacheKey]
+            || (cache[cacheKey] = createBindingsStringEvaluator(bindingsString, bindingOptions, scopesCount));
     }
 
-    function createBindingsStringEvaluator(bindingsString, scopesCount) {
-        var rewrittenBindings = " { " + ko.jsonExpressionRewriting.insertPropertyAccessorsIntoJson(bindingsString) + " } ";
+    function createBindingsStringEvaluator(bindingsString, bindingOptions, scopesCount) {
+        var rewrittenBindings = " { " + ko.bindingExpressionRewriting.insertPropertyAccessors(bindingsString, bindingOptions) + " } ";
         return ko.utils.buildEvalWithinScopeFunction(rewrittenBindings, scopesCount);
-    }    
+    }
 })();
 
 ko.exportSymbol('bindingProvider', ko.bindingProvider);
+/** @const */ var bindingFlags_twoWay=01;
+/** @const */ var bindingFlags_eventHandler=02;
+/** @const */ var bindingFlags_twoLevel=04;
+/** @const */ var bindingFlags_contentSet=010;
+/** @const */ var bindingFlags_contentBind=020;
+/** @const */ var bindingFlags_contentUpdate=040;
+/** @const */ var bindingFlags_canUseVirtual=0100;
+/** @const */ var bindingFlags_noValue=0200;
+
+// Internal flag for bindings used by the binding system itself
+/** @const */ var bindingFlags_builtIn=01000;
+
 (function () {
+    ko.bindingFlags = {
+        'twoWay': bindingFlags_twoWay,
+            // Two-way bindings initialliy write to the DOM from the model,
+            // but also will update the model property if the DOM changes
+        'eventHandler': bindingFlags_eventHandler,
+            // Event handler bindings call the given function in response to an event
+        'contentBind': bindingFlags_contentBind,
+            // Content-bind bindings are responsible for binding (or not) their contents
+        'contentSet': bindingFlags_contentSet,
+            // Content-set bindings erase or set their contents
+        'contentUpdate': bindingFlags_contentUpdate,
+            // Content-update bindings modify their contents after the content nodes bindings have run
+        'noValue': bindingFlags_noValue,
+            // No-value bindings don't require a value (default value is true)
+        'twoLevel': bindingFlags_twoLevel,
+            // Two-level bindings are like {attr.href: value} or {attr: {href: value}}
+        'canUseVirtual': bindingFlags_canUseVirtual
+            // Virtual element bindings can be used in comments: <!-- ko if: value --><!-- /ko -->
+    };
+
+    ko.checkBindingFlags = function(binding, flagsSet, flagsUnset) {
+        return (!flagsSet || (binding['flags'] & flagsSet)) && !(binding['flags'] & flagsUnset);
+    };
+
     ko.bindingHandlers = {};
 
-    ko.bindingContext = function(dataItem, parentBindingContext) {
-        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;        	
-        }
-        this['$data'] = dataItem;
+    // Accepts either a data value or a value accessor function; note that an observable qualifies as a value accessor function
+    ko.bindingContext = function(dataItemOrValueAccessor, parent, options) {
+        var self = this, isFunc = typeof(dataItemOrValueAccessor) == "function";
+        self._subscribable = ko.utils.possiblyWrap(parent ?
+            function() {
+                var oldSubscribable = self._subscribable;   // save previous subscribable value
+                // copy $root, $options, and any custom properties from parent binding context
+                ko.utils.extendInternal(self, parent);
+                self._subscribable = oldSubscribable;       // restore subscribable value
+                if (parent._subscribable)
+                    ko.dependencyDetection.registerDependency(parent._subscribable);
+                // set our properties
+                ko.utils.extendInternal(self['$options'], options);
+                self['$parentContext'] = parent;
+                self['$parents'] = parent['$parents'].slice(0);
+                self['$parents'].unshift(self['$parent'] = parent['$data']);
+                self['$data'] = isFunc ? dataItemOrValueAccessor() : dataItemOrValueAccessor;
+            } :
+            function() {
+                self['$options'] = options || {};
+                self['$parents'] = [];
+                self['$root'] = self['$data'] = isFunc ? dataItemOrValueAccessor() : dataItemOrValueAccessor;
+            }
+        );
     }
-    ko.bindingContext.prototype['createChildContext'] = function (dataItem) {
-        return new ko.bindingContext(dataItem, this);
+    ko.bindingContext.prototype['createChildContext'] = function (dataItemOrValueAccessor) {
+        return new ko.bindingContext(dataItemOrValueAccessor, this);
     };
     ko.bindingContext.prototype['extend'] = function(properties) {
-        var clone = new ko.bindingContext(this.$data, this);
-        return ko.utils.extend(clone, properties);
+        var clone = new ko.bindingContext(this['$data'], this);
+        return ko.utils.extendInternal(clone, properties);
     };
 
-    function validateThatBindingIsAllowedForVirtualElements(bindingName) {
-        var validator = ko.virtualElements.allowedBindings[bindingName];
-        if (!validator)
-            throw new Error("The binding '" + bindingName + "' cannot be used with virtual elements")
+    function getTwoLevelBindingData(bindingKey) {
+        var dotPos = bindingKey.indexOf(".");
+        if (dotPos > 0) {
+            var realKey = bindingKey.substring(0, dotPos), binding = ko.bindingHandlers[realKey];
+            if (binding) {
+                if (!(binding['flags'] & bindingFlags_twoLevel))
+                    ko_throw(realKey + " does not support two-level binding");
+                return {
+                    key: realKey,
+                    subKey: bindingKey.substring(dotPos + 1),
+                    handler: binding
+                };
+            }
+        }
+        return {};
     }
+    
+    ko.getBindingHandler = function(bindingKey) {
+        return ko.bindingHandlers[bindingKey] || getTwoLevelBindingData(bindingKey).handler;
+    };
+
+    ko.bindingValueWrap = function(valueFunction) {
+        valueFunction.__ko_wraptest = ko.bindingValueWrap;
+        return valueFunction;
+    };
+
+    function unwrapBindingValue(value) { 
+        return (value && value.__ko_wraptest && value.__ko_wraptest === ko.bindingValueWrap) ? value() : value;
+    };
 
-    function applyBindingsToDescendantsInternal (viewModel, elementOrVirtualElement, bindingContextsMayDifferFromDomParentElement) {
+    function applyBindingsToDescendantsInternal (bindingContext, elementOrVirtualElement, bindingContextsMayDifferFromDomParentElement) {
         var currentChild, 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) {
-        var shouldBindDescendants = true;
-
-        // Perf optimisation: Apply bindings only if...
-        // (1) We need to store the binding context on this node (because it may differ from the DOM parent node's binding context)
-        //     Note that we can't store binding contexts on non-elements (e.g., text nodes), as IE doesn't allow expando properties for those
-        // (2) It might have bindings (e.g., it has a data-bind attribute, or it's a marker for a containerless template)
-        var isElement = (nodeVerified.nodeType === 1);
+
+    var dependenciesName = 'dependencies', dependenciesBinding = { 'flags': bindingFlags_builtIn };
+    function applyBindingsToNodeAndDescendantsInternal (bindingContext, node, bindingContextsMayDifferFromDomParentElement, bindingsToApply, dontBindDescendants) {
+        var isElement = (node.nodeType === 1),
+            hasBindings = bindingsToApply || ko.bindingProvider['instance']['nodeHasBindings'](node),
+            independentBindings = bindingContext['$options']['independentBindings'];
+
         if (isElement) // Workaround IE <= 8 HTML parsing weirdness
-            ko.virtualElements.normaliseVirtualElementDomStructure(nodeVerified);
+            ko.virtualElements.normaliseVirtualElementDomStructure(node);
+
+        // We only need to store the bindingContext at the root of the subtree where it applies
+        // as all descendants will be able to find it by scanning up their ancestry
+        if (bindingContextsMayDifferFromDomParentElement && (isElement || hasBindings))
+            ko.storedBindingContextForNode(node, bindingContext);
+
+        if (!hasBindings) {
+            if (!dontBindDescendants) {
+                // 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(bindingContext, node, /* bindingContextsMayDifferFromDomParentElement: */ !isElement);
+            }
+            return;
+        }
 
-        var shouldApplyBindings = (isElement && bindingContextMayDifferFromDomParentElement)             // Case (1)
-                               || ko.bindingProvider['instance']['nodeHasBindings'](nodeVerified);       // Case (2)
-        if (shouldApplyBindings)
-            shouldBindDescendants = applyBindingsToNodeInternal(nodeVerified, null, viewModel, bindingContextMayDifferFromDomParentElement).shouldBindDescendants;
-            
-        if (shouldBindDescendants) {
-            // 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);
+        // Parse bindings; track observables so that the bindng are reparsed if needed
+        var parsedBindings, extraBindings, viewModel = bindingContext['$data'];
+        var bindingUpdater = ko.utils.possiblyWrap(function() {
+            // Make sure dependencies binding is set correctly
+            ko.bindingHandlers[dependenciesName] = dependenciesBinding;
+            // Use evaluatedBindings if given, otherwise fall back on asking the bindings provider to give us some bindings
+            var evaluatedBindings = (typeof bindingsToApply == "function") ? bindingsToApply() : bindingsToApply;
+            parsedBindings = evaluatedBindings || ko.bindingProvider['instance']['getBindings'](node, bindingContext);
+            extraBindings = {};
+
+            if (parsedBindings && bindingContext._subscribable)
+                ko.dependencyDetection.registerDependency(bindingContext._subscribable);
+        }, node);
+
+        // These functions make values accessible to bindings.
+        function makeValueAccessor(fullKey, subKey) {
+            return subKey
+            ? function() {
+                if (bindingUpdater)
+                    bindingUpdater();
+                var _z = {}; _z[subKey] = unwrapBindingValue(parsedBindings[fullKey]); return _z;
+            }
+            : function () {
+                if (bindingUpdater)
+                    bindingUpdater();
+                return unwrapBindingValue(parsedBindings[fullKey]);
+            };
+        }
+        function allBindingsAccessorIndependent(key) {
+            return key ? unwrapBindingValue(parsedBindings[key]) : ko.utils.objectMap(extraBindings, unwrapBindingValue);
+        }
+        function allBindingsAccessorDependent(key) {
+            return key ? parsedBindings[key] : parsedBindings;
         }
-    }    
 
-    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
+        // These functions let the user know something is wrong
+        function validateThatBindingIsAllowedForVirtualElements(binding) {
+            if (!isElement && !ko.virtualElements.allowedBindings[binding.key] && !(binding.flags & bindingFlags_canUseVirtual))
+                ko_throw("The binding '" + binding.key + "' cannot be used with virtual elements");
+        }
+        function multiContentBindError(key1, key2) {
+            ko_throw("Multiple bindings (" + key1 + " and " + key2 + ") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.");
+        }
 
-        // 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] }
+        // These functions call the binding handler functions
+        function initCaller(binding) {
+            return function() {
+                var handlerInitFn = binding.handler['init']; 
+                var initResult = handlerInitFn(node, binding.valueAccessor, allBindingsAccessor, viewModel, bindingContext);
+                // throw an error if binding handler is only using the old method of indicating that it controls binding descendants
+                if (initResult && !(binding.flags & bindingFlags_contentBind) && initResult['controlsDescendantBindings']) {
+                    if (independentBindings)
+                        ko_throw(binding.key + " binding handler must be updated to use contentBind flag");
+                    else if (bindings[contentBindBinding])
+                        multiContentBindError(bindings[contentBindBinding].key, binding.key);
+                    else
+                        bindings[binding.order = contentBindBinding] = binding;
+                }
+                return (initResult && initResult['subscribable']);
+            };
         }
-        function parsedBindingsAccessor() {
-            return parsedBindings;
+        function updateCaller(binding) {
+            return function() {
+                // dependentBindings is set if we're running in independent mode. Go through each
+                // and create a dependency on it's subscribable.
+                if (binding.dependentBindings)
+                    ko.utils.arrayForEach(binding.dependentBindings, function(dependentBinding) {
+                        if (dependentBinding.subscribable)
+                            ko.dependencyDetection.registerDependency(dependentBinding.subscribable);
+                    });
+                var handlerUpdateFn = binding.handler['update'];
+                return handlerUpdateFn(node, binding.valueAccessor, allBindingsAccessor, viewModel, bindingContext);
+            };
         }
-        
-        var bindingHandlerThatControlsDescendantBindings;
-        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 (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() : 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;
-                        for (var bindingKey in parsedBindings) {
-                            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;
+        function callHandlersIndependent(binding) {
+            // Observables accessed in init functions are not tracked
+            if (runInits && binding.handler['init'])
+                binding.subscribable = ko.dependencyDetection.ignore(initCaller(binding));
+            // Observables accessed in update function are tracked
+            if (binding.handler['update'])
+                binding.subscribable = ko.utils.possiblyWrap(updateCaller(binding), node) || binding.subscribable;
+        }
+        function callHandlersDependent(binding) {
+            if (binding.handler['update'])
+                updateCaller(binding)();
+        }
+        function applyListedBindings(bindings) {
+            ko.utils.arrayForEach(bindings, callHandlers);
+        }
+
+        var allBindingsAccessor = independentBindings ? allBindingsAccessorIndependent : allBindingsAccessorDependent,
+            callHandlers = independentBindings ? callHandlersIndependent : callHandlersDependent,
+            runInits = true,
+            allBindings = [],
+            bindings = [[], [], undefined, []];
+        /** @const */ var unorderedBindings = 0;
+        /** @const */ var contentSetBindings = 1;
+        /** @const */ var contentBindBinding = 2;
+        /** @const */ var contentUpdateBindings = 3;
+
+        ko.utils.possiblyWrap(function() {
+            if (runInits) {
+                var bindingIndexes = {}, dependencies = parsedBindings[dependenciesName] || {}, 
+                    lastIndex = unorderedBindings, thisIndex;
+
+                // Get binding handlers, call init function if not in independent mode, and determine run order
+                function pushBinding(bindingKey) {
+                    if (bindingKey in bindingIndexes)
+                        return allBindings[bindingIndexes[bindingKey]];
+
+                    var handler = ko.bindingHandlers[bindingKey],
+                        binding = handler ? { handler: handler, key: bindingKey } : getTwoLevelBindingData(bindingKey);
+
+                    if (handler = binding.handler) {
+                        binding.flags = handler['flags'];
+                        validateThatBindingIsAllowedForVirtualElements(binding);
+                        binding.valueAccessor = makeValueAccessor(bindingKey, binding.subKey);
+                        binding.dependencies = [].concat(handler[dependenciesName] || [], dependencies[bindingKey] || []);
+
+                        if (!independentBindings && handler['init'])
+                            initCaller(binding)();
+
+                        if (binding.flags & bindingFlags_contentBind) {
+                            if (bindings[contentBindBinding])
+                                multiContentBindError(bindings[contentBindBinding].key, binding.key);
+                            bindings[binding.order = contentBindBinding] = binding;
+                        } else {
+                            binding.order = 
+                                (binding.flags & bindingFlags_contentSet)
+                                    ? contentSetBindings
+                                : (binding.flags & bindingFlags_contentUpdate)
+                                    ? contentUpdateBindings
+                                    : unorderedBindings;
+                        }
+
+                        bindingIndexes[bindingKey] = -1;    // Allows for recursive dependencies check
+                        var dependentBindings = [];
+                        ko.utils.arrayForEach(binding.dependencies, function(dependencyKey) {
+                            var dependentBinding,
+                                dependencyError = "Binding " + bindingKey + " cannot depend on " + dependencyKey + ": ";
+                            if (!(dependencyKey in parsedBindings) || !(dependentBinding = pushBinding(dependencyKey)))
+                                ko_throw(dependencyError + "missing or recursive");
+                            if (binding.order) {
+                                if (dependentBinding.order > binding.order) {
+                                    ko_throw(dependencyError + "conflicting ordering");
+                                } else {
+                                    var dependentOrder = binding.order == contentBindBinding ? contentBindBinding-1 : binding.order;
+                                    dependentBinding.dependentOrder = dependentBinding.dependentOrder ? Math.min(dependentBinding.dependentOrder, dependentOrder) : dependentOrder;
                                 }
+                            } else if (dependentBinding.order) {
+                                binding.order = dependentBinding.order;
                             }
-                        }
-                        initPhase = 2;
+                            dependentBindings.push(dependentBinding);
+                        });
+                        // Save the dependent bindings if we're running in independent mode.
+                        if (independentBindings && dependentBindings[0])
+                            binding.dependentBindings = dependentBindings;
+
+                        bindingIndexes[bindingKey] = allBindings.length;
+                        allBindings.push(binding);
+                        return binding;
                     }
-                    
-                    // ... then run all the updates, which might trigger changes even on the first evaluation
-                    if (initPhase === 2) {
-                        for (var bindingKey in parsedBindings) {
-                            var binding = ko.bindingHandlers[bindingKey];
-                            if (binding && typeof binding["update"] == "function") {
-                                var handlerUpdateFn = binding["update"];
-                                handlerUpdateFn(node, makeValueAccessor(bindingKey), parsedBindingsAccessor, viewModel, bindingContextInstance);
-                            }
-                        }
+                    if (independentBindings)
+                        extraBindings[bindingKey] = parsedBindings[bindingKey];
+                }
+
+                for (var bindingKey in parsedBindings) {
+                    pushBinding(bindingKey);
+                }
+
+                // Organize bindings by run order
+                for (var i=0, binding; binding = allBindings[i]; i++) {
+                    if (binding.order == contentBindBinding) {
+                        thisIndex = contentBindBinding + 1;
+                    } else {
+                        thisIndex = binding.order || binding.dependentOrder || lastIndex;
+                        bindings[thisIndex].push(binding);
                     }
+                    if (thisIndex > lastIndex)
+                        lastIndex = thisIndex;
                 }
-            },
-            null,
-            { 'disposeWhenNodeIsRemoved' : node }
-        );
-        
-        return { 
-            shouldBindDescendants: bindingHandlerThatControlsDescendantBindings === undefined
-        };
+            }
+
+            // For backward compatibility: make sure all bindings are updated if binding is re-parsed
+            if (!independentBindings && bindingUpdater)
+                bindingUpdater();
+
+            // Apply the bindings in the correct order
+            applyListedBindings(bindings[unorderedBindings]);
+            applyListedBindings(bindings[contentSetBindings]);
+    
+            if (bindings[contentBindBinding])
+                callHandlers(bindings[contentBindBinding]);
+            else if (!dontBindDescendants)
+                applyBindingsToDescendantsInternal(bindingContext, node, /* bindingContextsMayDifferFromDomParentElement: */ !isElement);
+    
+            applyListedBindings(bindings[contentUpdateBindings]);
+        }, node);
+
+        // Don't want to call init function or bind descendents twice
+        runInits = dontBindDescendants = false;        
     };
 
-    var storedBindingContextDomDataKey = "__ko_bindingContext__";
+    var storedBindingContextDomDataKey = ko.utils.domData.nextKey();
     ko.storedBindingContextForNode = function (node, bindingContext) {
-        if (arguments.length == 2)
-            ko.utils.domData.set(node, storedBindingContextDomDataKey, bindingContext);
+        if (arguments.length == 2) {
+            ko.domDataSet(node, storedBindingContextDomDataKey, bindingContext);
+            if (bindingContext._subscribable)
+                bindingContext._subscribable.addDisposalNodes(node);
+        }
         else
-            return ko.utils.domData.get(node, storedBindingContextDomDataKey);
+            return ko.domDataGet(node, storedBindingContextDomDataKey);
     }
 
-    ko.applyBindingsToNode = function (node, bindings, viewModel) {
+    function getBindingContext(viewModelOrBindingContext, options) {
+        return viewModelOrBindingContext && (viewModelOrBindingContext instanceof ko.bindingContext)
+            ? viewModelOrBindingContext
+            : new ko.bindingContext(viewModelOrBindingContext, null, options);
+    }
+
+    ko.applyBindingsToNode = function (node, bindings, viewModelOrBindingContext, shouldBindDescendants) {
         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);
+            ko.virtualElements.normaliseVirtualElementDomStructure(node);
+        applyBindingsToNodeAndDescendantsInternal(getBindingContext(viewModelOrBindingContext), node, true, bindings, !shouldBindDescendants);
     };
 
-    ko.applyBindingsToDescendants = function(viewModel, rootNode) {
+    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, options) {
         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");
+            ko_throw("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, options), rootNode, true);
     };
 
     // Retrieving binding context from arbitrary nodes
@@ -1990,9 +2438,11 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
     ko.dataFor = function(node) {
         var context = ko.contextFor(node);
         return context ? context['$data'] : undefined;
-    };    
-    
+    };
+
     ko.exportSymbol('bindingHandlers', ko.bindingHandlers);
+    ko.exportSymbol('bindingFlags', ko.bindingFlags);
+    ko.exportSymbol('bindingValueWrap', ko.bindingValueWrap);       // must be exported because it's used in binding parser (which uses eval)
     ko.exportSymbol('applyBindings', ko.applyBindings);
     ko.exportSymbol('applyBindingsToDescendants', ko.applyBindingsToDescendants);
     ko.exportSymbol('applyBindingsToNode', ko.applyBindingsToNode);
@@ -2003,6 +2453,7 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
 var eventHandlersWithShortcuts = ['click'];
 ko.utils.arrayForEach(eventHandlersWithShortcuts, function(eventName) {
     ko.bindingHandlers[eventName] = {
+        'flags': bindingFlags_eventHandler,
         'init': function(element, valueAccessor, allBindingsAccessor, viewModel) {
             var newValueAccessor = function () {
                 var result = {};
@@ -2016,6 +2467,7 @@ ko.utils.arrayForEach(eventHandlersWithShortcuts, function(eventName) {
 
 
 ko.bindingHandlers['event'] = {
+    'flags': bindingFlags_eventHandler | bindingFlags_twoLevel,
     'init' : function (element, valueAccessor, allBindingsAccessor, viewModel) {
         var eventsToHandle = valueAccessor() || {};
         for(var eventNameOutsideClosure in eventsToHandle) {
@@ -2027,8 +2479,7 @@ ko.bindingHandlers['event'] = {
                         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);
@@ -2043,7 +2494,7 @@ ko.bindingHandlers['event'] = {
                             }
                         }
                         
-                        var bubble = allBindings[eventName + 'Bubble'] !== false;
+                        var bubble = allBindingsAccessor(eventName + 'Bubble') !== false;
                         if (!bubble) {
                             event.cancelBubble = true;
                             if (event.stopPropagation)
@@ -2057,9 +2508,10 @@ ko.bindingHandlers['event'] = {
 };
 
 ko.bindingHandlers['submit'] = {
+    'flags': bindingFlags_eventHandler,
     'init': function (element, valueAccessor, allBindingsAccessor, viewModel) {
         if (typeof valueAccessor() != "function")
-            throw new Error("The value for a submit binding must be a function");
+            ko_throw("The value for a submit binding must be a function");
         ko.utils.registerEventHandler(element, "submit", function (event) {
             var handlerReturnValue;
             var value = valueAccessor();
@@ -2099,28 +2551,16 @@ ko.bindingHandlers['enable'] = {
 
 ko.bindingHandlers['disable'] = { 
     'update': function (element, valueAccessor) { 
-        ko.bindingHandlers['enable']['update'](element, function() { return !ko.utils.unwrapObservable(valueAccessor()) }); 		
+        return ko.bindingHandlers['enable']['update'](element, function() { return !ko.utils.unwrapObservable(valueAccessor()) }); 		
     } 	
 };
 
-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.utils.triggerEvent(element, "change");
-};
-
 ko.bindingHandlers['value'] = {
+    'flags': bindingFlags_twoWay | bindingFlags_contentUpdate,
     'init': function (element, valueAccessor, allBindingsAccessor) { 
         // Always catch "change" event; possibly other events too if asked
         var eventsToCatch = ["change"];
-        var requestedEventsToCatch = allBindingsAccessor()["valueUpdate"];
+        var requestedEventsToCatch = allBindingsAccessor("valueUpdate");
         if (requestedEventsToCatch) {
             if (typeof requestedEventsToCatch == "string") // Allow both individual event names, and arrays of event names
                 requestedEventsToCatch = [requestedEventsToCatch];
@@ -2137,22 +2577,17 @@ ko.bindingHandlers['value'] = {
                 handleEventAsynchronously = true;
                 eventName = eventName.substring("after".length);
             }
-            var runEventHandler = handleEventAsynchronously ? function(handler) { setTimeout(handler, 0) }
-                                                            : function(handler) { handler() };
+            var getEventHandler = handleEventAsynchronously ? function(handler) { return function() { setTimeout(handler) } }
+                                                            : function(handler) { return handler };
             
-            ko.utils.registerEventHandler(element, eventName, function () {
-                runEventHandler(function() {
-                    var modelValue = valueAccessor();
-                    var elementValue = ko.selectExtensions.readValue(element);
-                    if (ko.isWriteableObservable(modelValue))
-                        modelValue(elementValue);
-                    else {
-                        var allBindings = allBindingsAccessor();
-                        if (allBindings['_ko_property_writers'] && allBindings['_ko_property_writers']['value'])
-                            allBindings['_ko_property_writers']['value'](elementValue); 
-                    }
-                });
-            });	    	
+            ko.utils.registerEventHandler(element, eventName, getEventHandler(function() {
+                var modelValue = valueAccessor();
+                var elementValue = ko.selectExtensions.readValue(element);
+                if (ko.isWriteableObservable(modelValue))
+                    modelValue(elementValue);
+                else
+                    ko.bindingExpressionRewriting.writeValueToProperty(allBindingsAccessor, 'value', elementValue);
+            }));	    	
         });
     },
     'update': function (element, valueAccessor) {
@@ -2172,22 +2607,24 @@ ko.bindingHandlers['value'] = {
             // 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 = element.tagName == "SELECT";
-            if (alsoApplyAsynchronously)
-                setTimeout(applyValueAction, 0);
+            var valueIsSelectOption = element.tagName == "SELECT";
+            if (valueIsSelectOption) {
+                // 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 (newValue !== ko.selectExtensions.readValue(element))
+                    ko.utils.triggerEvent(element, "change");
+                else
+                    setTimeout(applyValueAction);
+            }
         }
-        
-        // 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 ((element.tagName == "SELECT") && (element.length > 0))
-            ensureDropdownSelectionIsConsistentWithModelValue(element, newValue, /* preferModelValue */ false);
     }
 };
 
 ko.bindingHandlers['options'] = {
+    'flags': bindingFlags_contentBind | bindingFlags_contentSet,
     'update': function (element, valueAccessor, allBindingsAccessor) {
         if (element.tagName != "SELECT")
-            throw new Error("options binding applies only to SELECT elements");
+            ko_throw("options binding applies only to SELECT elements");
 
         var selectWasPreviouslyEmpty = element.length == 0;
         var previousSelectedValues = ko.utils.arrayMap(ko.utils.arrayFilter(element.childNodes, function (node) {
@@ -2196,7 +2633,6 @@ ko.bindingHandlers['options'] = {
             return ko.selectExtensions.readValue(node) || node.innerText || node.textContent;
         });
         var previousScrollTop = element.scrollTop;
-        element.scrollTop = 0; // Workaround for a Chrome rendering bug. Note that we restore the scroll position later. (https://github.com/SteveSanderson/knockout/issues/215)
 
         var value = ko.utils.unwrapObservable(valueAccessor());
         var selectedValue = element.value;
@@ -2235,10 +2671,9 @@ ko.bindingHandlers['options'] = {
                     optionText = value[i][optionsTextValue]; // Given a string; treat it as a property name on the data value
                 else
                     optionText = optionValue;				 // Given no optionsText arg; use the data value itself
-                if ((optionText === null) || (optionText === undefined))
-                    optionText = "";                                    
+                optionText = ko.utils.unwrapObservable(optionText);
 
-                ko.utils.setTextContent(option, optionText);
+                option.appendChild(document.createTextNode((optionText === null || optionText === undefined) ? "" : optionText));
 
                 element.appendChild(option);
             }
@@ -2253,25 +2688,20 @@ ko.bindingHandlers['options'] = {
                     countSelectionsRetained++;
                 }
             }
-            
-            if (previousScrollTop)
-                element.scrollTop = previousScrollTop;
+            element.scrollTop = previousScrollTop;
 
-            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.unwrapObservable(allBindings['value']), /* preferModelValue */ true);
-            }
+            if (countSelectionsRetained < previousSelectedValues.length)
+                ko.utils.triggerEvent(element, "change");
 
             // Workaround for IE9 bug
             ko.utils.ensureSelectElementIsRenderedCorrectly(element);
         }
     }
 };
-ko.bindingHandlers['options'].optionValueDomDataKey = '__ko.optionValueDomData__';
+ko.bindingHandlers['options'].optionValueDomDataKey = ko.utils.domData.nextKey();
 
 ko.bindingHandlers['selectedOptions'] = {
+    'flags': bindingFlags_twoWay | bindingFlags_contentUpdate,
     getSelectedValuesFromSelectNode: function (selectNode) {
         var result = [];
         var nodes = selectNode.childNodes;
@@ -2288,19 +2718,16 @@ ko.bindingHandlers['selectedOptions'] = {
     },
     'init': function (element, valueAccessor, allBindingsAccessor) {
         ko.utils.registerEventHandler(element, "change", function () { 
-            var value = valueAccessor();
+            var value = valueAccessor(), valueToWrite = ko.bindingHandlers['selectedOptions'].getSelectedValuesFromSelectNode(this);
             if (ko.isWriteableObservable(value))
-                value(ko.bindingHandlers['selectedOptions'].getSelectedValuesFromSelectNode(this));
-            else {
-                var allBindings = allBindingsAccessor();
-                if (allBindings['_ko_property_writers'] && allBindings['_ko_property_writers']['value'])
-                    allBindings['_ko_property_writers']['value'](ko.bindingHandlers['selectedOptions'].getSelectedValuesFromSelectNode(this));
-            }
+                value(valueToWrite);
+            else
+                ko.bindingExpressionRewriting.writeValueToProperty(allBindingsAccessor, 'value', valueToWrite);
         });    	
     },
     'update': function (element, valueAccessor) {
         if (element.tagName != "SELECT")
-            throw new Error("values binding applies only to SELECT elements");
+            ko_throw("values binding applies only to SELECT elements");
 
         var newValue = ko.utils.unwrapObservable(valueAccessor());
         if (newValue && typeof newValue.length == "number") {
@@ -2315,16 +2742,18 @@ ko.bindingHandlers['selectedOptions'] = {
 };
 
 ko.bindingHandlers['text'] = {
+    'flags': bindingFlags_contentBind | bindingFlags_contentSet | bindingFlags_canUseVirtual,
+    'init': function(element) {
+        ko.virtualElements.setDomNodeChildren(element, [document.createTextNode("")]);
+    },
     'update': function (element, valueAccessor) {
-        ko.utils.setTextContent(element, valueAccessor());
+        var value = ko.utils.unwrapObservable(valueAccessor());
+        ko.virtualElements.firstChild(element).data = (value === null || value === undefined) ? "" : value;
     }
 };
 
 ko.bindingHandlers['html'] = {
-    'init': function() {
-        // Prevent binding on the dynamically-injected HTML (as developers are unlikely to expect that, and it has security implications)
-        return { 'controlsDescendantBindings': true };
-    },
+    'flags': bindingFlags_contentBind | bindingFlags_contentSet,
     'update': function (element, valueAccessor) {
         var value = ko.utils.unwrapObservable(valueAccessor());
         ko.utils.setHtml(element, value);
@@ -2332,6 +2761,7 @@ ko.bindingHandlers['html'] = {
 };
 
 ko.bindingHandlers['css'] = {
+    'flags': bindingFlags_twoLevel,
     'update': function (element, valueAccessor) {
         var value = ko.utils.unwrapObservable(valueAccessor() || {});
         for (var className in value) {
@@ -2344,6 +2774,7 @@ ko.bindingHandlers['css'] = {
 };
 
 ko.bindingHandlers['style'] = {
+    'flags': bindingFlags_twoLevel,
     'update': function (element, valueAccessor) {
         var value = ko.utils.unwrapObservable(valueAccessor() || {});
         for (var styleName in value) {
@@ -2356,6 +2787,7 @@ ko.bindingHandlers['style'] = {
 };
 
 ko.bindingHandlers['uniqueName'] = {
+    'flags': bindingFlags_noValue,
     'init': function (element, valueAccessor) {
         if (valueAccessor()) {
             element.name = "ko_unique_" + (++ko.bindingHandlers['uniqueName'].currentIndex);
@@ -2371,6 +2803,7 @@ ko.bindingHandlers['uniqueName'] = {
 ko.bindingHandlers['uniqueName'].currentIndex = 0;
 
 ko.bindingHandlers['checked'] = {
+    'flags': bindingFlags_twoWay,
     'init': function (element, valueAccessor, allBindingsAccessor) {
         var updateHandler = function() {            
             var valueToWrite;
@@ -2396,10 +2829,7 @@ ko.bindingHandlers['checked'] = {
                     modelValue(valueToWrite);
                 }
             } else {
-                var allBindings = allBindingsAccessor();
-                if (allBindings['_ko_property_writers'] && allBindings['_ko_property_writers']['checked']) {
-                    allBindings['_ko_property_writers']['checked'](valueToWrite);
-                }
+                ko.bindingExpressionRewriting.writeValueToProperty(allBindingsAccessor, 'checked', valueToWrite);
             }
         };
         ko.utils.registerEventHandler(element, "click", updateHandler);
@@ -2425,26 +2855,52 @@ ko.bindingHandlers['checked'] = {
     }
 };
 
+var attrHtmlToJavascriptMap = { 'class': 'className', 'for': 'htmlFor' };
 ko.bindingHandlers['attr'] = {
+    'flags': bindingFlags_twoLevel,
     'update': function(element, valueAccessor, allBindingsAccessor) {
         var value = ko.utils.unwrapObservable(valueAccessor()) || {};
         for (var attrName in value) {
             if (typeof attrName == "string") {
                 var attrValue = ko.utils.unwrapObservable(value[attrName]);
-                
+
                 // To cover cases like "attr: { checked:someProp }", we want to remove the attribute entirely 
                 // when someProp is a "no value"-like value (strictly null, false, or undefined)
                 // (because the absence of the "checked" attr is how to mark an element as not checked, etc.)                
-                if ((attrValue === false) || (attrValue === null) || (attrValue === undefined))
+                var toRemove = (attrValue === false) || (attrValue === null) || (attrValue === undefined);
+                if (toRemove)
                     element.removeAttribute(attrName);
-                else 
+
+                // In IE <= 7 and IE8 Quirks Mode, you have to use the Javascript property name instead of the 
+                // HTML attribute name for certain attributes. IE8 Standards Mode supports the correct behavior,
+                // but instead of figuring out the mode, we'll just set the attribute through the Javascript 
+                // property for IE <= 8.
+                if (ko.utils.ieVersion <= 8 && attrName in attrHtmlToJavascriptMap) {
+                    attrName = attrHtmlToJavascriptMap[attrName];
+                    if (toRemove)
+                        element.removeAttribute(attrName);
+                    else
+                        element[attrName] = attrValue;
+                } else if (!toRemove) {
                     element.setAttribute(attrName, attrValue.toString());
+                }
             }
         }
     }
 };
 
+ko.bindingHandlers['withlight'] = {
+    'flags': bindingFlags_contentBind | bindingFlags_canUseVirtual,
+    'init': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+        var innerContext = bindingContext['createChildContext'](function() {
+            return ko.utils.unwrapObservable(valueAccessor());
+        });
+        ko.applyBindingsToDescendants(innerContext, element, true);
+    }
+};
+
 ko.bindingHandlers['hasfocus'] = {
+    'flags': bindingFlags_twoWay,
     'init': function(element, valueAccessor, allBindingsAccessor) {
         var writeValue = function(valueToWrite) {
             var modelValue = valueAccessor();
@@ -2453,12 +2909,8 @@ ko.bindingHandlers['hasfocus'] = {
 
             if (ko.isWriteableObservable(modelValue))
                 modelValue(valueToWrite);
-            else {
-                var allBindings = allBindingsAccessor();
-                if (allBindings['_ko_property_writers'] && allBindings['_ko_property_writers']['hasfocus']) {
-                    allBindings['_ko_property_writers']['hasfocus'](valueToWrite);
-                }                
-            }
+            else
+                ko.bindingExpressionRewriting.writeValueToProperty(allBindingsAccessor, 'hasfocus', valueToWrite);
         };
         ko.utils.registerEventHandler(element, "focus", function() { writeValue(true) });
         ko.utils.registerEventHandler(element, "focusin", function() { writeValue(true) }); // For IE
@@ -2472,82 +2924,75 @@ ko.bindingHandlers['hasfocus'] = {
     }
 };
 
-// "with: someExpression" is equivalent to "template: { if: someExpression, data: someExpression }"
-ko.bindingHandlers['with'] = {
-    makeTemplateValueAccessor: function(valueAccessor) {
-        return function() { var value = valueAccessor(); return { 'if': value, 'data': value, 'templateEngine': ko.nativeTemplateEngine.instance } };
-    },
-    'init': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-        return ko.bindingHandlers['template']['init'](element, ko.bindingHandlers['with'].makeTemplateValueAccessor(valueAccessor));
-    },
+/*var withDomDataKey = ko.utils.domData.nextKey();
+ko.bindingHandlers['withbroken'] = {
+    'flags': bindingFlags_contentBind | bindingFlags_canUseVirtual,
     'update': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-        return ko.bindingHandlers['template']['update'](element, ko.bindingHandlers['with'].makeTemplateValueAccessor(valueAccessor), allBindingsAccessor, viewModel, bindingContext);
+        var withData = ko.domDataGet(element, withDomDataKey) || {},
+            isBound = withData.isBound, container = withData.container,
+            dataValue = ko.utils.unwrapObservable(valueAccessor());
+
+        if (!isBound && dataValue) {
+            if (container)
+                ko.virtualElements.setDomNodeChildren(element, ko.utils.makeArray(container.childNodes));
+            var innerContext = bindingContext['createChildContext'](function() {
+                return ko.utils.unwrapObservable(valueAccessor());
+            });
+            ko.applyBindingsToDescendants(innerContext, element, true);
+            ko.domDataSet(element, withDomDataKey, {isBound: true});
+        }
+        else if (!dataValue && !container) {
+            var nodeArray = ko.virtualElements.childNodes(element);
+            if (isBound)
+                ko.utils.arrayForEach(nodeArray, ko.disposeNode);
+            container = ko.utils.moveNodesToContainerElement(nodeArray);
+            ko.domDataSet(element, withDomDataKey, {container: container});
+        }
     }
-};
-ko.jsonExpressionRewriting.bindingRewriteValidators['with'] = false; // Can't rewrite control flow bindings
-ko.virtualElements.allowedBindings['with'] = true;
+};*/
 
-// "if: someExpression" is equivalent to "template: { if: someExpression }"
-ko.bindingHandlers['if'] = {
-    makeTemplateValueAccessor: function(valueAccessor) {
-        return function() { return { 'if': valueAccessor(), 'templateEngine': ko.nativeTemplateEngine.instance } };
-    },	
-    'init': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-        return ko.bindingHandlers['template']['init'](element, ko.bindingHandlers['if'].makeTemplateValueAccessor(valueAccessor));
-    },
-    'update': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-        return ko.bindingHandlers['template']['update'](element, ko.bindingHandlers['if'].makeTemplateValueAccessor(valueAccessor), allBindingsAccessor, viewModel, bindingContext);
+function templateBasedBinding(makeOptionsFunction) {
+    function makeTemplateValueAccessor(valueAccessor) {
+        return function() {
+            var options = {'templateEngine': ko.nativeTemplateEngine.instance};
+            makeOptionsFunction(valueAccessor(), options);
+            return options;
+        };
     }
-};
-ko.jsonExpressionRewriting.bindingRewriteValidators['if'] = false; // Can't rewrite control flow bindings
-ko.virtualElements.allowedBindings['if'] = true;
+    return {
+        'flags': bindingFlags_contentBind | bindingFlags_canUseVirtual,
+        'init': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+            return ko.bindingHandlers['template']['init'](element, makeTemplateValueAccessor(valueAccessor));
+        },
+        'update': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+            return ko.bindingHandlers['template']['update'](element, makeTemplateValueAccessor(valueAccessor), allBindingsAccessor, viewModel, bindingContext);
+        }
+    };
+}
+
+// "with: someExpression" is equivalent to "template: { if: someExpression, data: someExpression }"
+ko.bindingHandlers['with'] = new templateBasedBinding( function(value, options) { options['if'] = value; options['data'] = value; });
+
+// "if: someExpression" is equivalent to "template: { if: someExpression }"
+ko.bindingHandlers['if'] = templateBasedBinding( function(value, options) { options['if'] = value; });
 
 // "ifnot: someExpression" is equivalent to "template: { ifnot: someExpression }"
-ko.bindingHandlers['ifnot'] = {
-    makeTemplateValueAccessor: function(valueAccessor) {
-        return function() { return { 'ifnot': valueAccessor(), 'templateEngine': ko.nativeTemplateEngine.instance } };
-    },	
-    'init': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-        return ko.bindingHandlers['template']['init'](element, ko.bindingHandlers['ifnot'].makeTemplateValueAccessor(valueAccessor));
-    },
-    'update': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-        return ko.bindingHandlers['template']['update'](element, ko.bindingHandlers['ifnot'].makeTemplateValueAccessor(valueAccessor), allBindingsAccessor, viewModel, bindingContext);
-    }
-};
-ko.jsonExpressionRewriting.bindingRewriteValidators['ifnot'] = false; // Can't rewrite control flow bindings
-ko.virtualElements.allowedBindings['ifnot'] = true;
+ko.bindingHandlers['ifnot'] = templateBasedBinding( function(value, options) { options['ifnot'] = value; });
 
 // "foreach: someExpression" is equivalent to "template: { foreach: someExpression }"
 // "foreach: { data: someExpression, afterAdd: myfn }" is equivalent to "template: { foreach: someExpression, afterAdd: myfn }"
-ko.bindingHandlers['foreach'] = {
-    makeTemplateValueAccessor: function(valueAccessor) {
-        return function() { 
-            var bindingValue = ko.utils.unwrapObservable(valueAccessor());
-            
+ko.bindingHandlers['foreach'] = templateBasedBinding(
+    function(value, options) {
+        if ((!value) || typeof value.length == "number") {
             // If bindingValue is the array, just pass it on its own
-            if ((!bindingValue) || typeof bindingValue.length == "number")
-                return { 'foreach': bindingValue, 'templateEngine': ko.nativeTemplateEngine.instance };
-            
-            // If bindingValue.data is the array, preserve all relevant options
-            return { 
-                'foreach': bindingValue['data'], 
-                'includeDestroyed': bindingValue['includeDestroyed'],
-                'afterAdd': bindingValue['afterAdd'],
-                'beforeRemove': bindingValue['beforeRemove'], 
-                'afterRender': bindingValue['afterRender'],
-                'templateEngine': ko.nativeTemplateEngine.instance
-            };
-        };
-    },
-    'init': function(element, valueAccessor, allBindingsAccessor, 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);
-    }
-};
-ko.jsonExpressionRewriting.bindingRewriteValidators['foreach'] = false; // Can't rewrite control flow bindings
-ko.virtualElements.allowedBindings['foreach'] = true;
+            options['foreach'] = value;
+        } else {
+            // If bindingValue is a object with options, copy it and set foreach to the data value
+            ko.utils.extendInternal(options, value);
+            options['foreach'] = options['data'];
+            delete options['name'];   // don't allow named templates
+        }
+    });
 // If you want to make a custom template engine,
 // 
 // [1] Inherit from this class (like ko.nativeTemplateEngine does)
@@ -2558,7 +3003,7 @@ ko.virtualElements.allowedBindings['foreach'] = true;
 //            // - bindingContext.$data is the data you should pass into the template
 //            //   - you might also want to make bindingContext.$parent, bindingContext.$parents, 
 //            //     and bindingContext.$root available in the template too
-//            // - options gives you access to any other properties set on "data-bind: { template: options }"
+//            // - options gives you access to any other properties set on "data-bind: { template: options }  (where data-bind is the configured binding attribute)"
 //            //
 //            // Return value: an array of DOM nodes
 //        }
@@ -2570,40 +3015,42 @@ ko.virtualElements.allowedBindings['foreach'] = true;
 //            //               For example, the jquery.tmpl template engine converts 'someScript' to '${ someScript }' 
 //        }
 //
-//     This is only necessary if you want to allow data-bind attributes to reference arbitrary template variables.
+//     This is only necessary if you want to allow binding attributes to reference arbitrary template variables.
 //     If you don't want to allow that, you can set the property 'allowTemplateRewriting' to false (like ko.nativeTemplateEngine does)
 //     and then you don't need to override 'createJavaScriptEvaluatorBlock'.
 
 ko.templateEngine = function () { };
 
-ko.templateEngine.prototype['renderTemplateSource'] = function (templateSource, bindingContext, options) {
-    throw new Error("Override renderTemplateSource");
-};
+ko.utils.extendInternal(ko.templateEngine.prototype, {
 
-ko.templateEngine.prototype['createJavaScriptEvaluatorBlock'] = function (script) {
-    throw new Error("Override createJavaScriptEvaluatorBlock");
-};
+'renderTemplateSource': function (templateSource, bindingContext, options) {
+    ko_throw("Override renderTemplateSource");
+},
 
-ko.templateEngine.prototype['makeTemplateSource'] = function(template) {
+'createJavaScriptEvaluatorBlock': function (script) {
+    ko_throw("Override createJavaScriptEvaluatorBlock");
+},
+
+'makeTemplateSource': function(template) {
     // Named template
     if (typeof template == "string") {
         var elem = document.getElementById(template);
         if (!elem)
-            throw new Error("Cannot find template with ID " + template);
+            ko_throw("Cannot find template with ID " + template);
         return new ko.templateSources.domElement(elem);
     } else if ((template.nodeType == 1) || (template.nodeType == 8)) {
         // Anonymous template
         return new ko.templateSources.anonymousTemplate(template);
     } else
-        throw new Error("Unknown template type: " + template);
-};
+        ko_throw("Unknown template type: " + template);
+},
 
-ko.templateEngine.prototype['renderTemplate'] = function (template, bindingContext, options) {
+'renderTemplate': function (template, bindingContext, options) {
     var templateSource = this['makeTemplateSource'](template);
     return this['renderTemplateSource'](templateSource, bindingContext, options);
-};
+},
 
-ko.templateEngine.prototype['isTemplateRewritten'] = function (template) {
+'isTemplateRewritten': function (template) {
     // Skip rewriting if requested
     if (this['allowTemplateRewriting'] === false)
         return true;
@@ -2613,9 +3060,9 @@ ko.templateEngine.prototype['isTemplateRewritten'] = function (template) {
         return true;
     
     return this['makeTemplateSource'](template)['data']("isRewritten");
-};
+},
 
-ko.templateEngine.prototype['rewriteTemplate'] = function (template, rewriterCallback) {
+'rewriteTemplate': function (template, rewriterCallback) {
     var templateSource = this['makeTemplateSource'](template);          
     var rewritten = rewriterCallback(templateSource['text']());
     templateSource['text'](rewritten);
@@ -2627,47 +3074,53 @@ ko.templateEngine.prototype['rewriteTemplate'] = function (template, rewriterCal
         this.knownRewrittenTemplates = this.knownRewrittenTemplates || {};
         this.knownRewrittenTemplates[template] = true;            
     }
-};
+}
+
+});
 
 ko.exportSymbol('templateEngine', ko.templateEngine);
 
 ko.templateRewriting = (function () {
-    var memoizeDataBindingAttributeSyntaxRegex = /(<[a-z]+\d*(\s+(?!data-bind=)[a-z0-9\-]+(=(\"[^\"]*\"|\'[^\']*\'))?)*\s+)data-bind=(["'])([\s\S]*?)\5/gi;
-    var memoizeVirtualContainerBindingSyntaxRegex = /<!--\s*ko\b\s*([\s\S]*?)\s*-->/g;
+    var memoizeDataBindingAttributeSyntaxRegex = function (bindingProvider) {
+        return new RegExp("(<[a-z]+\\d*(\\s+(?!" + ko.bindingProvider.configuration(bindingProvider).bindingAttribute + "=)[a-z0-9\\-]+(=(\\\"[^\\\"]*\\\"|\\'[^\\']*\\'))?)*\\s+)" + ko.bindingProvider.configuration(bindingProvider).bindingAttribute + "=([\"'])([\\s\\S]*?)\\5", "gi");
+    };
+    var memoizeVirtualContainerBindingSyntaxRegex = function (bindingProvider) {
+        return new RegExp("<!--\\s*" + ko.bindingProvider.configuration(bindingProvider).virtualElementTag + "\\b\\s*([\\s\\S]*?)\\s*-->", "g");
+    }
 
     function validateDataBindValuesForRewriting(keyValueArray) {
-        var allValidators = ko.jsonExpressionRewriting.bindingRewriteValidators;
+        var allValidators = ko.templateRewriting.bindingRewriteValidators;
         for (var i = 0; i < keyValueArray.length; i++) {
             var key = keyValueArray[i]['key'];
             if (allValidators.hasOwnProperty(key)) {
-                var validator = allValidators[key];    
-
-                if (typeof validator === "function") {
-                    var possibleErrorMessage = validator(keyValueArray[i]['value']);
-                    if (possibleErrorMessage)
-                        throw new Error(possibleErrorMessage);
-                } else if (!validator) {
-                    throw new Error("This template engine does not support the '" + key + "' binding within its templates");
-                }                
+                var possibleErrorMessage = allValidators[key](keyValueArray[i]['value']);
+                if (possibleErrorMessage)
+                    ko_throw(possibleErrorMessage);
+            } else {
+                var binding = ko.getBindingHandler(key);
+                // Don't rewrite bindings that bind their contents unless they also set their contents
+                if (binding && ko.checkBindingFlags(binding, bindingFlags_contentBind, bindingFlags_contentSet))
+                    ko_throw("This template engine does not support the '" + key + "' binding within its templates");
             }
         }
     }
 
     function constructMemoizedTagReplacement(dataBindAttributeValue, tagToRetain, templateEngine) {
-        var dataBindKeyValueArray = ko.jsonExpressionRewriting.parseObjectLiteral(dataBindAttributeValue);
+        var dataBindKeyValueArray = ko.bindingExpressionRewriting.parseObjectLiteral(dataBindAttributeValue);
         validateDataBindValuesForRewriting(dataBindKeyValueArray);
-        var rewrittenDataBindAttributeValue = ko.jsonExpressionRewriting.insertPropertyAccessorsIntoJson(dataBindKeyValueArray);
+        var rewrittenDataBindAttributeValue = ko.bindingExpressionRewriting.insertPropertyAccessors(dataBindKeyValueArray);
 
         // 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 
         // extra indirection.
-        var applyBindingsToNextSiblingScript = "ko.templateRewriting.applyMemoizedBindingsToNextSibling(function() { \
-            return (function() { return { " + rewrittenDataBindAttributeValue + " } })() \
-        })";
-        return templateEngine['createJavaScriptEvaluatorBlock'](applyBindingsToNextSiblingScript) + tagToRetain;        
+        var applyBindingsToNextSiblingScript =
+            "ko.__tr_ambtns(function(){return(function(){return{" + rewrittenDataBindAttributeValue + "}})()})";
+        return templateEngine['createJavaScriptEvaluatorBlock'](applyBindingsToNextSiblingScript) + tagToRetain;
     }
 
     return {
+        bindingRewriteValidators: {},
+
         ensureTemplateIsRewritten: function (template, templateEngine) {
             if (!templateEngine['isTemplateRewritten'](template))
                 templateEngine['rewriteTemplate'](template, function (htmlString) {
@@ -2676,10 +3129,10 @@ ko.templateRewriting = (function () {
         },
 
         memoizeBindingAttributeSyntax: function (htmlString, templateEngine) {
-            return htmlString.replace(memoizeDataBindingAttributeSyntaxRegex, function () {
-                return constructMemoizedTagReplacement(/* dataBindAttributeValue: */ arguments[6], /* tagToRetain: */ arguments[1], templateEngine);
-            }).replace(memoizeVirtualContainerBindingSyntaxRegex, function() {
-                return constructMemoizedTagReplacement(/* dataBindAttributeValue: */ arguments[1], /* tagToRetain: */ "<!-- ko -->", templateEngine);              
+            return htmlString.replace(memoizeDataBindingAttributeSyntaxRegex(), function () {
+                return constructMemoizedTagReplacement(/* dataBindAttributeValue: */arguments[6], /* tagToRetain: */arguments[1], templateEngine);
+            }).replace(memoizeVirtualContainerBindingSyntaxRegex(), function () {
+                return constructMemoizedTagReplacement(/* dataBindAttributeValue: */arguments[1], /* tagToRetain: */"<!-- ko -->", templateEngine);
             });
         },
 
@@ -2692,8 +3145,10 @@ ko.templateRewriting = (function () {
     }
 })();
 
-ko.exportSymbol('templateRewriting', ko.templateRewriting);
-ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templateRewriting.applyMemoizedBindingsToNextSibling); // Exported only because it has to be referenced by string lookup from within rewritten template
+ko.exportSymbol('bindingRewriteValidators', ko.templateRewriting.bindingRewriteValidators);
+
+// Exported only because it has to be referenced by string lookup from within rewritten template
+ko.exportSymbol('__tr_ambtns', ko.templateRewriting.applyMemoizedBindingsToNextSibling);
 (function() { 
     // A template source represents a read/write way of accessing a template. This is to eliminate the need for template loading/saving
     // logic to be duplicated in every template engine (and means they can all work with anonymous templates, etc.)
@@ -2728,12 +3183,14 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
     }
     
     ko.templateSources.domElement.prototype['text'] = function(/* valueToWrite */) {
+        var tagName = this.domElement.tagName.toLowerCase(),
+            elemProp = tagName == "script" ? "text" : tagName == "textarea" ? "value" : "innerHTML";
         if (arguments.length == 0) {
-            return this.domElement.tagName.toLowerCase() == "script" ? this.domElement.text : this.domElement.innerHTML;
+            return this.domElement[elemProp];
         } else {
             var valueToWrite = arguments[0];
-            if (this.domElement.tagName.toLowerCase() == "script")
-                this.domElement.text = valueToWrite;
+            if (elemProp != "innerHTML")
+                this.domElement[elemProp] = valueToWrite;
             else
                 ko.utils.setHtml(this.domElement, valueToWrite);
         }
@@ -2741,9 +3198,9 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
     
     ko.templateSources.domElement.prototype['data'] = function(key /*, valueToWrite */) {
         if (arguments.length === 1) {
-            return ko.utils.domData.get(this.domElement, "templateSourceData_" + key);
+            return ko.domDataGet(this.domElement, "templateSourceData_" + key);
         } else {
-            ko.utils.domData.set(this.domElement, "templateSourceData_" + key, arguments[1]);
+            ko.domDataSet(this.domElement, "templateSourceData_" + key, arguments[1]);
         }
     };
     
@@ -2759,22 +3216,22 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
     ko.templateSources.anonymousTemplate.prototype = new ko.templateSources.domElement();
     ko.templateSources.anonymousTemplate.prototype['text'] = function(/* valueToWrite */) {
         if (arguments.length == 0) {
-            var templateData = ko.utils.domData.get(this.domElement, anonymousTemplatesDomDataKey) || {};
+            var templateData = ko.domDataGet(this.domElement, anonymousTemplatesDomDataKey) || {};
             if (templateData.textData === undefined && templateData.containerData)
                 templateData.textData = templateData.containerData.innerHTML;
             return templateData.textData;
         } else {
             var valueToWrite = arguments[0];
-            ko.utils.domData.set(this.domElement, anonymousTemplatesDomDataKey, {textData: valueToWrite});
+            ko.domDataSet(this.domElement, anonymousTemplatesDomDataKey, {textData: valueToWrite});
         }
     };
     ko.templateSources.domElement.prototype['nodes'] = function(/* valueToWrite */) {
         if (arguments.length == 0) {
-            var templateData = ko.utils.domData.get(this.domElement, anonymousTemplatesDomDataKey) || {};
+            var templateData = ko.domDataGet(this.domElement, anonymousTemplatesDomDataKey) || {};
             return templateData.containerData;
         } else {
             var valueToWrite = arguments[0];
-            ko.utils.domData.set(this.domElement, anonymousTemplatesDomDataKey, {containerData: valueToWrite});
+            ko.domDataSet(this.domElement, anonymousTemplatesDomDataKey, {containerData: valueToWrite});
         }
     };
 
@@ -2785,7 +3242,7 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
     var _templateEngine;
     ko.setTemplateEngine = function (templateEngine) {
         if ((templateEngine != undefined) && !(templateEngine instanceof ko.templateEngine))
-            throw new Error("templateEngine must inherit from ko.templateEngine");
+            ko_throw("templateEngine must inherit from ko.templateEngine");
         _templateEngine = templateEngine;
     }
 
@@ -2798,7 +3255,7 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
         }
     }
 
-    function activateBindingsOnContinuousNodeArray(continuousNodeArray, bindingContext) {
+    function activateBindingsOnContinuousNodeArray(continuousNodeArray, bindingContext, subscription) {
         // To be used on any nodes that have been rendered by a template and have been inserted into some parent element
         // Walks through continuousNodeArray (which *must* be continuous, i.e., an uninterrupted sequence of sibling nodes, because
         // the algorithm for walking them relies on this), and for each top-level item in the virtual-element sense,
@@ -2812,6 +3269,8 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
             // whereas a regular applyBindings won't introduce new memoized nodes
             invokeForEachNodeOrCommentInContinuousRange(firstNode, lastNode, function(node) {
                 ko.applyBindings(bindingContext, node);
+                if (subscription)
+                    subscription.addDisposalNodes(node);
             });
             invokeForEachNodeOrCommentInContinuousRange(firstNode, lastNode, function(node) {
                 ko.memoization.unmemoizeDomNodeAndDescendants(node, [bindingContext]);
@@ -2819,12 +3278,6 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
         }
     }
 
-    function getFirstNodeFromPossibleArray(nodeOrNodeArray) {
-        return nodeOrNodeArray.nodeType ? nodeOrNodeArray
-                                        : nodeOrNodeArray.length > 0 ? nodeOrNodeArray[0]
-                                        : null;
-    }
-
     function executeTemplate(targetNodeOrNodeArray, renderMode, template, bindingContext, options) {
         options = options || {};
         var templateEngineToUse = (options['templateEngine'] || _templateEngine);
@@ -2833,7 +3286,7 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
 
         // Loosely check result is an array of DOM nodes
         if ((typeof renderedNodesArray.length != "number") || (renderedNodesArray.length > 0 && typeof renderedNodesArray[0].nodeType != "number"))
-            throw new Error("Template engine must return an array of DOM nodes");
+            ko_throw("Template engine must return an array of DOM nodes");
 
         var haveAddedNodesToParent = false;
         switch (renderMode) {
@@ -2847,7 +3300,7 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
                 break;
             case "ignoreTargetNode": break;
             default: 
-                throw new Error("Unknown renderMode: " + renderMode);
+                ko_throw("Unknown renderMode: " + renderMode);
         }
 
         if (haveAddedNodesToParent) {
@@ -2862,16 +3315,11 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
     ko.renderTemplate = function (template, dataOrBindingContext, options, targetNodeOrNodeArray, renderMode) {
         options = options || {};
         if ((options['templateEngine'] || _templateEngine) == undefined)
-            throw new Error("Set a template engine before calling renderTemplate");
+            ko_throw("Set a template engine before calling renderTemplate");
         renderMode = renderMode || "replaceChildren";
 
         if (targetNodeOrNodeArray) {
-            var firstTargetNode = getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
-            
-            var whenToDispose = function () { return (!firstTargetNode) || !ko.utils.domNodeIsAttachedToDocument(firstTargetNode); }; // Passive disposal (on next evaluation)
-            var activelyDisposeWhenNodeIsRemoved = (firstTargetNode && renderMode == "replaceNode") ? firstTargetNode.parentNode : firstTargetNode;
-            
-            return ko.dependentObservable( // So the DOM is automatically updated when any dependency changes
+            var subscription = ko.dependentObservable( // So the DOM is automatically updated when any dependency changes
                 function () {
                     // Ensure we've got a proper binding context to work with
                     var bindingContext = (dataOrBindingContext && (dataOrBindingContext instanceof ko.bindingContext))
@@ -2884,12 +3332,12 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
                     var renderedNodesArray = executeTemplate(targetNodeOrNodeArray, renderMode, templateName, bindingContext, options);
                     if (renderMode == "replaceNode") {
                         targetNodeOrNodeArray = renderedNodesArray;
-                        firstTargetNode = getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
+                        if (subscription)
+                            subscription.replaceDisposalNodes(targetNodeOrNodeArray);
                     }
-                },
-                null,
-                { 'disposeWhen': whenToDispose, 'disposeWhenNodeIsRemoved': activelyDisposeWhenNodeIsRemoved }
-            );
+                }
+            ).addDisposalNodes(targetNodeOrNodeArray);
+            return subscription;
         } else {
             // We don't yet have a DOM node to evaluate, so use a memo and render the template later when there is a DOM node
             return ko.memoization.memoize(function (domNode) {
@@ -2899,14 +3347,16 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
     };
 
     ko.renderTemplateForEach = function (template, arrayOrObservableArray, options, targetNode, parentBindingContext) {   
+        var lastContext, lastArrayValue;
         var createInnerBindingContext = function(arrayValue) {
-            return parentBindingContext['createChildContext'](ko.utils.unwrapObservable(arrayValue));
+            lastArrayValue = arrayValue;
+            return (lastContext = parentBindingContext['createChildContext'](ko.utils.unwrapObservable(arrayValue)));
         };
 
         // This will be called whenever setDomNodeChildrenFromArrayMapping has added nodes to targetNode
-        var activateBindingsCallback = function(arrayValue, addedNodesArray) {
-            var bindingContext = createInnerBindingContext(arrayValue);
-            activateBindingsOnContinuousNodeArray(addedNodesArray, bindingContext);
+        var activateBindingsCallback = function(arrayValue, addedNodesArray, subscription) {
+            var bindingContext = (lastContext && arrayValue == lastArrayValue) ? lastContext : createInnerBindingContext(arrayValue);
+            activateBindingsOnContinuousNodeArray(addedNodesArray, bindingContext, subscription);
             if (options['afterRender'])
                 options['afterRender'](addedNodesArray, bindingContext['$data']);                                                
         };
@@ -2927,81 +3377,82 @@ ko.exportSymbol('templateRewriting.applyMemoizedBindingsToNextSibling', ko.templ
                 return executeTemplate(null, "ignoreTargetNode", templateName, createInnerBindingContext(arrayValue), options);
             }, options, activateBindingsCallback);
             
-        }, null, { 'disposeWhenNodeIsRemoved': targetNode });
+        }).addDisposalNodes(targetNode);
     };
 
-    var templateSubscriptionDomDataKey = '__ko__templateSubscriptionDomDataKey__';
+    var templateSubscriptionDomDataKey = ko.utils.domData.nextKey();
     function disposeOldSubscriptionAndStoreNewOne(element, newSubscription) {
-        var oldSubscription = ko.utils.domData.get(element, templateSubscriptionDomDataKey);
+        var oldSubscription = ko.domDataGet(element, templateSubscriptionDomDataKey);
         if (oldSubscription && (typeof(oldSubscription.dispose) == 'function'))
             oldSubscription.dispose();
-        ko.utils.domData.set(element, templateSubscriptionDomDataKey, newSubscription);
+        ko.domDataSet(element, templateSubscriptionDomDataKey, newSubscription);
     }
     
     ko.bindingHandlers['template'] = {
+        'flags': bindingFlags_contentBind | bindingFlags_contentSet | bindingFlags_canUseVirtual,
         '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)) {
-                // It's an anonymous template - store the element contents, then clear the element
-                var templateNodes = element.nodeType == 1 ? element.childNodes : ko.virtualElements.childNodes(element),
-                    container = ko.utils.moveNodesToContainerElement(templateNodes); // This also removes the nodes from their current parent
-                new ko.templateSources.anonymousTemplate(element)['nodes'](container);
+                // It's an anonymous template - store the element contents and clear the element
+                // But if the template is already stored, don't do anything (init must have been called on this element before)
+                var templateSource = new ko.templateSources.anonymousTemplate(element);
+                if (!templateSource['nodes']()) {
+                    var templateNodes = ko.virtualElements.childNodes(element),
+                        container = ko.utils.moveNodesToContainerElement(templateNodes); // This also removes the nodes from their current parent
+                    templateSource['nodes'](container);
+                }
             }
-            return { 'controlsDescendantBindings': true };
         },
         'update': function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
             var bindingValue = ko.utils.unwrapObservable(valueAccessor());
-            var templateName; 
             var shouldDisplay = true;
             
             if (typeof bindingValue == "string") {
-                templateName = bindingValue;
+                bindingValue = {'name': bindingValue};
             } else {
-                templateName = bindingValue['name'];
-                
                 // Support "if"/"ifnot" conditions
                 if ('if' in bindingValue)
                     shouldDisplay = shouldDisplay && ko.utils.unwrapObservable(bindingValue['if']);
                 if ('ifnot' in bindingValue)
                     shouldDisplay = shouldDisplay && !ko.utils.unwrapObservable(bindingValue['ifnot']);
             }    
+            var template = bindingValue['name'] || element;
             
             var templateSubscription = null;
             
-            if ((typeof bindingValue === 'object') && ('foreach' in bindingValue)) { // Note: can't use 'in' operator on strings
+            if ('foreach' in bindingValue) {
                 // Render once for each data point (treating data set as empty if shouldDisplay==false)
                 var dataArray = (shouldDisplay && bindingValue['foreach']) || [];
-                templateSubscription = ko.renderTemplateForEach(templateName || element, dataArray, /* options: */ bindingValue, element, bindingContext);
+                templateSubscription = ko.renderTemplateForEach(template, dataArray, /* options: */ bindingValue, element, bindingContext);
             } else {
                 if (shouldDisplay) {
                     // Render once for this single data point (or use the viewModel if no data was provided)
-                    var innerBindingContext = (typeof bindingValue == 'object') && ('data' in bindingValue)
-                        ? bindingContext['createChildContext'](ko.utils.unwrapObservable(bindingValue['data'])) // Given an explitit 'data' value, we create a child binding context for it
+                    var innerBindingContext = ('data' in bindingValue)
+                        ? bindingContext['createChildContext'](bindingValue['data'])    // Given an explitit 'data' value, we create a child binding context for it
                         : bindingContext;                                                                       // Given no explicit 'data' value, we retain the same binding context
-                    templateSubscription = ko.renderTemplate(templateName || element, innerBindingContext, /* options: */ bindingValue, element);
+                    templateSubscription = ko.renderTemplate(template, innerBindingContext, /* options: */ bindingValue, element);
                 } else
                     ko.virtualElements.emptyNode(element);
             }
             
             // It only makes sense to have a single template subscription per element (otherwise which one should have its output displayed?)
             disposeOldSubscriptionAndStoreNewOne(element, templateSubscription);
+            return templateSubscription;
         }
     };
 
     // Anonymous templates can't be rewritten. Give a nice error message if you try to do it.
-    ko.jsonExpressionRewriting.bindingRewriteValidators['template'] = function(bindingValue) {
-        var parsedBindingValue = ko.jsonExpressionRewriting.parseObjectLiteral(bindingValue);
+    ko.templateRewriting.bindingRewriteValidators['template'] = function(bindingValue) {
+        var parsedBindingValue = ko.bindingExpressionRewriting.parseObjectLiteral(bindingValue);
 
         if ((parsedBindingValue.length == 1) && parsedBindingValue[0]['unknown'])
             return null; // It looks like a string literal, not an object literal, so treat it as a named template (which is allowed for rewriting)
 
-        if (ko.jsonExpressionRewriting.keyValueArrayContainsKey(parsedBindingValue, "name"))
+        if (ko.bindingExpressionRewriting.keyValueArrayContainsKey(parsedBindingValue, "name"))
             return null; // Named templates can be rewritten, so return "no error"
         return "This template engine does not support anonymous templates nested within its templates";
     };
-
-    ko.virtualElements.allowedBindings['template'] = true;
 })();
 
 ko.exportSymbol('setTemplateEngine', ko.setTemplateEngine);
@@ -3099,7 +3550,8 @@ ko.exportSymbol('utils.compareArrays', ko.utils.compareArrays);
     //   previously mapped - retain those nodes, and just insert/delete other ones
 
     // "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.
+    // You can use this, for example, to activate bindings on those nodes. Your function must also call
+    // addDisposalNodes with the given mappedNodes and subscription.
 
     function fixUpVirtualElements(contiguousNodeArray) {
         // Ensures that contiguousNodeArray really *is* an array of contiguous siblings, even if some of the interior
@@ -3123,6 +3575,20 @@ ko.exportSymbol('utils.compareArrays', ko.utils.compareArrays);
         }
     }
 
+    function defaultCallbackAfterAddingNodes(value, mappedNodes, subscription) {
+        subscription.addDisposalNodes(mappedNodes);
+    }
+
+    function wrapCallbackAfterAddingNodes(originalCallback) {
+        return originalCallback 
+            ? function(value, mappedNodes, subscription) {
+                originalCallback(value, mappedNodes, subscription);
+                if (mappedNodes.length && !subscription.getDisposalNodesCount())
+                    subscription.addDisposalNodes(mappedNodes);
+            }
+            : defaultCallbackAfterAddingNodes;
+    }
+
     function mapNodeAndRefreshWhenChanged(containerNode, mapping, valueToMap, callbackAfterAddingNodes) {
         // Map this array value inside a dependentObservable so we re-map when any dependency changes
         var mappedNodes = [];
@@ -3132,27 +3598,28 @@ ko.exportSymbol('utils.compareArrays', ko.utils.compareArrays);
             // On subsequent evaluations, just replace the previously-inserted DOM nodes
             if (mappedNodes.length > 0) {
                 fixUpVirtualElements(mappedNodes);
+                dependentObservable.replaceDisposalNodes();    // must clear before calling replaceDomNodes
                 ko.utils.replaceDomNodes(mappedNodes, newMappedNodes);
-                if (callbackAfterAddingNodes)
-                    callbackAfterAddingNodes(valueToMap, newMappedNodes);
+                callbackAfterAddingNodes(valueToMap, newMappedNodes, dependentObservable);
             }
             
             // 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);
             ko.utils.arrayPushAll(mappedNodes, newMappedNodes);
-        }, null, { 'disposeWhenNodeIsRemoved': containerNode, 'disposeWhen': function() { return (mappedNodes.length == 0) || !ko.utils.domNodeIsAttachedToDocument(mappedNodes[0]) } });
+        });
         return { mappedNodes : mappedNodes, dependentObservable : dependentObservable };
     }
     
-    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
         array = array || [];
         options = options || {};
-        var isFirstExecution = ko.utils.domData.get(domNode, lastMappingResultDomDataKey) === undefined;
-        var lastMappingResult = ko.utils.domData.get(domNode, lastMappingResultDomDataKey) || [];
+        callbackAfterAddingNodes = wrapCallbackAfterAddingNodes(callbackAfterAddingNodes);
+        var isFirstExecution = ko.domDataGet(domNode, lastMappingResultDomDataKey) === undefined;
+        var lastMappingResult = ko.domDataGet(domNode, lastMappingResultDomDataKey) || [];
         var lastArray = ko.utils.arrayMap(lastMappingResult, function (x) { return x.arrayEntry; });
         var editScript = ko.utils.compareArrays(lastArray, array);
 
@@ -3212,9 +3679,8 @@ ko.exportSymbol('utils.compareArrays', ko.utils.compareArrays);
                             ko.virtualElements.insertAfter(domNode, node, insertAfterNode);
                         }
                         insertAfterNode = node;
-                    } 
-                    if (callbackAfterAddingNodes)
-                        callbackAfterAddingNodes(valueToMap, mappedNodes);
+                    }
+                    callbackAfterAddingNodes(valueToMap, mappedNodes, mapData.dependentObservable);
                     break;
             }
         }
@@ -3235,11 +3701,11 @@ ko.exportSymbol('utils.compareArrays', ko.utils.compareArrays);
         }
         if (!invokedBeforeRemoveCallback)
             ko.utils.arrayForEach(nodesToDelete, function (node) {
-                ko.removeNode(node.element);
+                ko.cleanAndRemoveNode(node.element);
             });
 
         // Store a copy of the array items we just considered so we can difference it next time
-        ko.utils.domData.set(domNode, lastMappingResultDomDataKey, newMappingResult);
+        ko.domDataSet(domNode, lastMappingResultDomDataKey, newMappingResult);
     }
 })();
 
@@ -3248,8 +3714,9 @@ ko.nativeTemplateEngine = function () {
     this['allowTemplateRewriting'] = false;
 }
 
-ko.nativeTemplateEngine.prototype = new ko.templateEngine();
-ko.nativeTemplateEngine.prototype['renderTemplateSource'] = function (templateSource, bindingContext, options) {
+ko.nativeTemplateEngine.prototype = ko.utils.extendInternal(new ko.templateEngine(), {
+
+'renderTemplateSource': function (templateSource, bindingContext, options) {
     var useNodesIfAvailable = !(ko.utils.ieVersion < 9), // IE<9 cloneNode doesn't work properly
         templateNodesFunc = useNodesIfAvailable ? templateSource['nodes'] : null,
         templateNodes = templateNodesFunc ? templateSource['nodes']() : null;
@@ -3260,12 +3727,15 @@ ko.nativeTemplateEngine.prototype['renderTemplateSource'] = function (templateSo
         var templateText = templateSource['text']();
         return ko.utils.parseHtmlFragment(templateText);
     }
-};
+}
+
+});
 
 ko.nativeTemplateEngine.instance = new ko.nativeTemplateEngine();
 ko.setTemplateEngine(ko.nativeTemplateEngine.instance);
 
-ko.exportSymbol('nativeTemplateEngine', ko.nativeTemplateEngine);(function() {
+ko.exportSymbol('nativeTemplateEngine', ko.nativeTemplateEngine);
+(function() {
     ko.jqueryTmplTemplateEngine = function () {
         // Detect which version of jquery-tmpl you're using. Unfortunately jquery-tmpl 
         // doesn't expose a version number, so we have to infer it.
@@ -3287,7 +3757,7 @@ ko.exportSymbol('nativeTemplateEngine', ko.nativeTemplateEngine);(function() {
         
         function ensureHasReferencedJQueryTemplates() {
             if (jQueryTmplVersion < 2)
-                throw new Error("Your version of jQuery.tmpl is too old. Please upgrade to jQuery.tmpl 1.0.0pre or later.");
+                ko_throw("Your version of jQuery.tmpl is too old. Please upgrade to jQuery.tmpl 1.0.0pre or later.");
         }
 
         function executeTemplate(compiledTemplate, data, jQueryTemplateOptions) {
@@ -3347,5 +3817,5 @@ ko.exportSymbol('nativeTemplateEngine', ko.nativeTemplateEngine);(function() {
     
     ko.exportSymbol('jqueryTmplTemplateEngine', ko.jqueryTmplTemplateEngine);
 })();});
-})(window,document,navigator);                  
-
+})(window,document,navigator); 
+})();
diff --git a/build/output/knockout-latest.js b/build/output/knockout-latest.js
index 2a9193436..e1881896e 100644
--- a/build/output/knockout-latest.js
+++ b/build/output/knockout-latest.js
@@ -1,88 +1,14 @@
-// Knockout JavaScript library v2.1.0pre
+// Knockout JavaScript library v2.1.0pre+mbest/smart-binding/beta.3+GilesBradshaw/BindingProviderConfiguration
 // (c) Steven Sanderson - http://knockoutjs.com/
 // License: MIT (http://www.opensource.org/licenses/mit-license.php)
 
-(function(window,document,navigator,undefined){ 
-function l(u){throw u;}var m=void 0,o=!0,p=null,r=!1;function A(u){return function(){return u}}
-function D(u){function E(b,c,d){d&&c!==a.i.p(b)&&a.i.S(b,c);c!==a.i.p(b)&&a.a.ta(b,"change")}var a="undefined"!==typeof u?u:{};a.b=function(b,c){for(var d=b.split("."),e=a,f=0;f<d.length-1;f++)e=e[d[f]];e[d[d.length-1]]=c};a.A=function(a,c,d){a[c]=d};a.version="2.1.0pre";a.b("version",a.version);a.a=new function(){function b(a,b){if("INPUT"!=a.tagName||!a.type||"click"!=b.toLowerCase())return r;var f=a.type.toLowerCase();return"checkbox"==f||"radio"==f}var c=/^(\s|\u00A0)+|(\s|\u00A0)+$/g,d={},
-e={};d[/Firefox\/2/i.test(navigator.userAgent)?"KeyboardEvent":"UIEvents"]=["keyup","keydown","keypress"];d.MouseEvents="click,dblclick,mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave".split(",");for(var f in d){var h=d[f];if(h.length)for(var g=0,k=h.length;g<k;g++)e[h[g]]=f}var i=function(){for(var a=3,b=document.createElement("div"),f=b.getElementsByTagName("i");b.innerHTML="<\!--[if gt IE "+ ++a+"]><i></i><![endif]--\>",f[0];);return 4<a?a:m}();return{Aa:["authenticity_token",
-/^__RequestVerificationToken(_.*)?$/],q:function(a,b){for(var f=0,e=a.length;f<e;f++)b(a[f])},j:function(a,b){if("function"==typeof Array.prototype.indexOf)return Array.prototype.indexOf.call(a,b);for(var f=0,e=a.length;f<e;f++)if(a[f]===b)return f;return-1},Xa:function(a,b,f){for(var e=0,c=a.length;e<c;e++)if(b.call(f,a[e]))return a[e];return p},ba:function(b,f){var e=a.a.j(b,f);0<=e&&b.splice(e,1)},xa:function(b){for(var b=b||[],f=[],e=0,c=b.length;e<c;e++)0>a.a.j(f,b[e])&&f.push(b[e]);return f},
-T:function(a,b){for(var a=a||[],f=[],e=0,c=a.length;e<c;e++)f.push(b(a[e]));return f},aa:function(a,b){for(var a=a||[],f=[],e=0,c=a.length;e<c;e++)b(a[e])&&f.push(a[e]);return f},M:function(a,b){if(b instanceof Array)a.push.apply(a,b);else for(var f=0,e=b.length;f<e;f++)a.push(b[f]);return a},extend:function(a,b){for(var f in b)b.hasOwnProperty(f)&&(a[f]=b[f]);return a},ga:function(b){for(;b.firstChild;)a.removeNode(b.firstChild)},wb:function(b){for(var b=a.a.K(b),f=document.createElement("div"),
-e=0,c=b.length;e<c;e++)f.appendChild(b[e]);return f},Y:function(b,f){a.a.ga(b);if(f)for(var e=0,c=f.length;e<c;e++)b.appendChild(f[e])},Ja:function(b,f){var e=b.nodeType?[b]:b;if(0<e.length){for(var c=e[0],h=c.parentNode,d=0,g=f.length;d<g;d++)h.insertBefore(f[d],c);d=0;for(g=e.length;d<g;d++)a.removeNode(e[d])}},La:function(a,b){0<=navigator.userAgent.indexOf("MSIE 6")?a.setAttribute("selected",b):a.selected=b},v:function(a){return(a||"").replace(c,"")},Fb:function(b,f){for(var e=[],c=(b||"").split(f),
-h=0,d=c.length;h<d;h++){var g=a.a.v(c[h]);""!==g&&e.push(g)}return e},Db:function(a,b){a=a||"";return b.length>a.length?r:a.substring(0,b.length)===b},$a:function(a,b){for(var f="return ("+a+")",e=0;e<b;e++)f="with(sc["+e+"]) { "+f+" } ";return new Function("sc",f)},hb:function(a,b){if(b.compareDocumentPosition)return 16==(b.compareDocumentPosition(a)&16);for(;a!=p;){if(a==b)return o;a=a.parentNode}return r},fa:function(b){return a.a.hb(b,document)},s:function(a,f,e){if("undefined"!=typeof jQuery){if(b(a,
-f))var c=e,e=function(a,b){var f=this.checked;b&&(this.checked=b.ab!==o);c.call(this,a);this.checked=f};jQuery(a).bind(f,e)}else"function"==typeof a.addEventListener?a.addEventListener(f,e,r):"undefined"!=typeof a.attachEvent?a.attachEvent("on"+f,function(b){e.call(a,b)}):l(Error("Browser doesn't support addEventListener or attachEvent"))},ta:function(a,f){(!a||!a.nodeType)&&l(Error("element must be a DOM node when calling triggerEvent"));if("undefined"!=typeof jQuery){var c=[];b(a,f)&&c.push({ab:a.checked});
-jQuery(a).trigger(f,c)}else if("function"==typeof document.createEvent)"function"==typeof a.dispatchEvent?(c=document.createEvent(e[f]||"HTMLEvents"),c.initEvent(f,o,o,window,0,0,0,0,0,r,r,r,r,0,a),a.dispatchEvent(c)):l(Error("The supplied element doesn't support dispatchEvent"));else if("undefined"!=typeof a.fireEvent){if("click"==f&&"INPUT"==a.tagName&&("checkbox"==a.type.toLowerCase()||"radio"==a.type.toLowerCase()))a.checked=a.checked!==o;a.fireEvent("on"+f)}else l(Error("Browser doesn't support triggering events"))},
-d:function(b){return a.V(b)?b():b},gb:function(b,f){return 0<=a.a.j((b.className||"").split(/\s+/),f)},Qa:function(b,f,e){var c=a.a.gb(b,f);if(e&&!c)b.className=(b.className||"")+" "+f;else if(c&&!e){for(var e=(b.className||"").split(/\s+/),c="",h=0;h<e.length;h++)e[h]!=f&&(c+=e[h]+" ");b.className=a.a.v(c)}},Ma:function(b,f){var e=a.a.d(f);if(e===p||e===m)e="";"innerText"in b?b.innerText=e:b.textContent=e;9<=i&&(b.style.display=b.style.display)},ib:function(a){if(9<=i){var b=a.style.width;a.style.width=
-0;a.style.width=b}},Ab:function(b,f){for(var b=a.a.d(b),f=a.a.d(f),e=[],c=b;c<=f;c++)e.push(c);return e},K:function(a){for(var b=[],f=0,e=a.length;f<e;f++)b.push(a[f]);return b},pb:6===i,qb:7===i,nb:i,Ba:function(b,f){for(var e=a.a.K(b.getElementsByTagName("INPUT")).concat(a.a.K(b.getElementsByTagName("TEXTAREA"))),c="string"==typeof f?function(a){return a.name===f}:function(a){return f.test(a.name)},h=[],d=e.length-1;0<=d;d--)c(e[d])&&h.push(e[d]);return h},xb:function(b){return"string"==typeof b&&
-(b=a.a.v(b))?window.JSON&&window.JSON.parse?window.JSON.parse(b):(new Function("return "+b))():p},qa:function(b){("undefined"==typeof JSON||"undefined"==typeof JSON.stringify)&&l(Error("Cannot find JSON.stringify(). Some browsers (e.g., IE < 8) don't support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js"));return JSON.stringify(a.a.d(b))},yb:function(b,f,e){var e=e||{},c=e.params||{},h=e.includeFields||this.Aa,d=b;if("object"==
-typeof b&&"FORM"==b.tagName)for(var d=b.action,g=h.length-1;0<=g;g--)for(var i=a.a.Ba(b,h[g]),k=i.length-1;0<=k;k--)c[i[k].name]=i[k].value;var f=a.a.d(f),v=document.createElement("FORM");v.style.display="none";v.action=d;v.method="post";for(var u in f)b=document.createElement("INPUT"),b.name=u,b.value=a.a.qa(a.a.d(f[u])),v.appendChild(b);for(u in c)b=document.createElement("INPUT"),b.name=u,b.value=c[u],v.appendChild(b);document.body.appendChild(v);e.submitter?e.submitter(v):v.submit();setTimeout(function(){v.parentNode.removeChild(v)},
-0)}}};a.b("utils",a.a);a.b("utils.arrayForEach",a.a.q);a.b("utils.arrayFirst",a.a.Xa);a.b("utils.arrayFilter",a.a.aa);a.b("utils.arrayGetDistinctValues",a.a.xa);a.b("utils.arrayIndexOf",a.a.j);a.b("utils.arrayMap",a.a.T);a.b("utils.arrayPushAll",a.a.M);a.b("utils.arrayRemoveItem",a.a.ba);a.b("utils.extend",a.a.extend);a.b("utils.fieldsIncludedWithJsonPost",a.a.Aa);a.b("utils.getFormFields",a.a.Ba);a.b("utils.postJson",a.a.yb);a.b("utils.parseJson",a.a.xb);a.b("utils.registerEventHandler",a.a.s);a.b("utils.stringifyJson",
-a.a.qa);a.b("utils.range",a.a.Ab);a.b("utils.toggleDomNodeCssClass",a.a.Qa);a.b("utils.triggerEvent",a.a.ta);a.b("utils.unwrapObservable",a.a.d);Function.prototype.bind||(Function.prototype.bind=function(a){var c=this,d=Array.prototype.slice.call(arguments),a=d.shift();return function(){return c.apply(a,d.concat(Array.prototype.slice.call(arguments)))}});a.a.f=new function(){var b=0,c="__ko__"+(new Date).getTime(),d={};return{get:function(b,f){var c=a.a.f.getAll(b,r);return c===m?m:c[f]},set:function(b,
-f,c){c===m&&a.a.f.getAll(b,r)===m||(a.a.f.getAll(b,o)[f]=c)},getAll:function(a,f){var h=a[c];if(!(h&&"null"!==h)){if(!f)return;h=a[c]="ko"+b++;d[h]={}}return d[h]},clear:function(a){var b=a[c];b&&(delete d[b],a[c]=p)}}};a.b("utils.domData",a.a.f);a.b("utils.domData.clear",a.a.f.clear);a.a.D=new function(){function b(b,f){var e=a.a.f.get(b,d);e===m&&f&&(e=[],a.a.f.set(b,d,e));return e}function c(e){var d=b(e,r);if(d)for(var d=d.slice(0),k=0;k<d.length;k++)d[k](e);a.a.f.clear(e);"function"==typeof jQuery&&
-"function"==typeof jQuery.cleanData&&jQuery.cleanData([e]);if(f[e.nodeType])for(d=e.firstChild;e=d;)d=e.nextSibling,8===e.nodeType&&c(e)}var d="__ko_domNodeDisposal__"+(new Date).getTime(),e={1:o,8:o,9:o},f={1:o,9:o};return{ua:function(a,f){"function"!=typeof f&&l(Error("Callback must be a function"));b(a,o).push(f)},Ia:function(f,e){var c=b(f,r);c&&(a.a.ba(c,e),0==c.length&&a.a.f.set(f,d,m))},I:function(b){if(e[b.nodeType]&&(c(b),f[b.nodeType])){var d=[];a.a.M(d,b.getElementsByTagName("*"));for(var b=
-0,k=d.length;b<k;b++)c(d[b])}},removeNode:function(b){a.I(b);b.parentNode&&b.parentNode.removeChild(b)}}};a.I=a.a.D.I;a.removeNode=a.a.D.removeNode;a.b("cleanNode",a.I);a.b("removeNode",a.removeNode);a.b("utils.domNodeDisposal",a.a.D);a.b("utils.domNodeDisposal.addDisposeCallback",a.a.D.ua);a.b("utils.domNodeDisposal.removeDisposeCallback",a.a.D.Ia);(function(){a.a.na=function(b){var c;if("undefined"!=typeof jQuery){if((c=jQuery.clean([b]))&&c[0]){for(b=c[0];b.parentNode&&11!==b.parentNode.nodeType;)b=
-b.parentNode;b.parentNode&&b.parentNode.removeChild(b)}}else{var d=a.a.v(b).toLowerCase();c=document.createElement("div");d=d.match(/^<(thead|tbody|tfoot)/)&&[1,"<table>","</table>"]||!d.indexOf("<tr")&&[2,"<table><tbody>","</tbody></table>"]||(!d.indexOf("<td")||!d.indexOf("<th"))&&[3,"<table><tbody><tr>","</tr></tbody></table>"]||[0,"",""];b="ignored<div>"+d[1]+b+d[2]+"</div>";for("function"==typeof window.innerShiv?c.appendChild(window.innerShiv(b)):c.innerHTML=b;d[0]--;)c=c.lastChild;c=a.a.K(c.lastChild.childNodes)}return c};
-a.a.Z=function(b,c){a.a.ga(b);if(c!==p&&c!==m)if("string"!=typeof c&&(c=c.toString()),"undefined"!=typeof jQuery)jQuery(b).html(c);else for(var d=a.a.na(c),e=0;e<d.length;e++)b.appendChild(d[e])}})();a.b("utils.parseHtmlFragment",a.a.na);a.b("utils.setHtml",a.a.Z);a.r=function(){function b(){return(4294967296*(1+Math.random())|0).toString(16).substring(1)}function c(b,f){if(b)if(8==b.nodeType){var d=a.r.Fa(b.nodeValue);d!=p&&f.push({fb:b,ub:d})}else if(1==b.nodeType)for(var d=0,g=b.childNodes,k=g.length;d<
-k;d++)c(g[d],f)}var d={};return{la:function(a){"function"!=typeof a&&l(Error("You can only pass a function to ko.memoization.memoize()"));var f=b()+b();d[f]=a;return"<\!--[ko_memo:"+f+"]--\>"},Ra:function(a,b){var c=d[a];c===m&&l(Error("Couldn't find any memo with ID "+a+". Perhaps it's already been unmemoized."));try{return c.apply(p,b||[]),o}finally{delete d[a]}},Sa:function(b,f){var d=[];c(b,d);for(var g=0,k=d.length;g<k;g++){var i=d[g].fb,j=[i];f&&a.a.M(j,f);a.r.Ra(d[g].ub,j);i.nodeValue="";i.parentNode&&
-i.parentNode.removeChild(i)}},Fa:function(a){return(a=a.match(/^\[ko_memo\:(.*?)\]$/))?a[1]:p}}}();a.b("memoization",a.r);a.b("memoization.memoize",a.r.la);a.b("memoization.unmemoize",a.r.Ra);a.b("memoization.parseMemoText",a.r.Fa);a.b("memoization.unmemoizeDomNodeAndDescendants",a.r.Sa);a.za={throttle:function(b,c){b.throttleEvaluation=c;var d=p;return a.h({read:b,write:function(a){clearTimeout(d);d=setTimeout(function(){b(a)},c)}})},notify:function(b,c){b.equalityComparer="always"==c?A(r):a.m.fn.equalityComparer;
-return b}};a.b("extenders",a.za);a.Oa=function(b,c,d){this.target=b;this.ca=c;this.eb=d;a.A(this,"dispose",this.z)};a.Oa.prototype.z=function(){this.ob=o;this.eb()};a.R=function(){this.u={};a.a.extend(this,a.R.fn);a.A(this,"subscribe",this.ra);a.A(this,"extend",this.extend);a.A(this,"getSubscriptionsCount",this.lb)};a.R.fn={ra:function(b,c,d){var d=d||"change",b=c?b.bind(c):b,e=new a.Oa(this,b,function(){a.a.ba(this.u[d],e)}.bind(this));this.u[d]||(this.u[d]=[]);this.u[d].push(e);return e},notifySubscribers:function(b,
-c){c=c||"change";this.u[c]&&a.a.q(this.u[c].slice(0),function(a){a&&a.ob!==o&&a.ca(b)})},lb:function(){var a=0,c;for(c in this.u)this.u.hasOwnProperty(c)&&(a+=this.u[c].length);return a},extend:function(b){var c=this;if(b)for(var d in b){var e=a.za[d];"function"==typeof e&&(c=e(c,b[d]))}return c}};a.Da=function(a){return"function"==typeof a.ra&&"function"==typeof a.notifySubscribers};a.b("subscribable",a.R);a.b("isSubscribable",a.Da);a.U=function(){var b=[];return{Ya:function(a){b.push({ca:a,ya:[]})},
-end:function(){b.pop()},Ha:function(c){a.Da(c)||l(Error("Only subscribable things can act as dependencies"));if(0<b.length){var d=b[b.length-1];0<=a.a.j(d.ya,c)||(d.ya.push(c),d.ca(c))}}}}();var F={undefined:o,"boolean":o,number:o,string:o};a.m=function(b){function c(){if(0<arguments.length){if(!c.equalityComparer||!c.equalityComparer(d,arguments[0]))c.G(),d=arguments[0],c.F();return this}a.U.Ha(c);return d}var d=b;a.R.call(c);c.F=function(){c.notifySubscribers(d)};c.G=function(){c.notifySubscribers(d,
-"beforeChange")};a.a.extend(c,a.m.fn);a.A(c,"valueHasMutated",c.F);a.A(c,"valueWillMutate",c.G);return c};a.m.fn={equalityComparer:function(a,c){return a===p||typeof a in F?a===c:r}};var z=a.m.zb="__ko_proto__";a.m.fn[z]=a.m;a.V=function(b){return b===p||b===m||b[z]===m?r:b[z]===a.m?o:a.V(b[z])};a.P=function(b){return"function"==typeof b&&b[z]===a.m||"function"==typeof b&&b[z]===a.h&&b.mb?o:r};a.b("observable",a.m);a.b("isObservable",a.V);a.b("isWriteableObservable",a.P);a.Q=function(b){0==arguments.length&&
-(b=[]);b!==p&&b!==m&&!("length"in b)&&l(Error("The argument passed when initializing an observable array must be an array, or null, or undefined."));var c=a.m(b);a.a.extend(c,a.Q.fn);return c};a.Q.fn={remove:function(a){for(var c=this(),d=[],e="function"==typeof a?a:function(f){return f===a},f=0;f<c.length;f++){var h=c[f];e(h)&&(0===d.length&&this.G(),d.push(h),c.splice(f,1),f--)}d.length&&this.F();return d},removeAll:function(b){if(b===m){var c=this(),d=c.slice(0);this.G();c.splice(0,c.length);this.F();
-return d}return!b?[]:this.remove(function(e){return 0<=a.a.j(b,e)})},destroy:function(a){var c=this(),d="function"==typeof a?a:function(f){return f===a};this.G();for(var e=c.length-1;0<=e;e--)d(c[e])&&(c[e]._destroy=o);this.F()},destroyAll:function(b){return b===m?this.destroy(A(o)):!b?[]:this.destroy(function(c){return 0<=a.a.j(b,c)})},indexOf:function(b){var c=this();return a.a.j(c,b)},replace:function(a,c){var d=this.indexOf(a);0<=d&&(this.G(),this()[d]=c,this.F())}};a.a.q("pop,push,reverse,shift,sort,splice,unshift".split(","),
-function(b){a.Q.fn[b]=function(){var a=this();this.G();a=a[b].apply(a,arguments);this.F();return a}});a.a.q(["slice"],function(b){a.Q.fn[b]=function(){var a=this();return a[b].apply(a,arguments)}});a.b("observableArray",a.Q);a.h=function(b,c,d){function e(){a.a.q(t,function(a){a.z()});t=[]}function f(){var a=g.throttleEvaluation;a&&0<=a?(clearTimeout(y),y=setTimeout(h,a)):h()}function h(){if(j&&u())B();else{try{var b=a.a.T(t,function(a){return a.target});a.U.Ya(function(e){var c;0<=(c=a.a.j(b,e))?
-b[c]=m:t.push(e.ra(f))});for(var e=n.call(c),d=b.length-1;0<=d;d--)b[d]&&t.splice(d,1)[0].z();g.notifySubscribers(i,"beforeChange");i=e}finally{a.U.end()}g.notifySubscribers(i);j=o}}function g(){if(0<arguments.length)k.apply(g,arguments);else return j||h(),a.U.Ha(g),i}function k(){"function"===typeof s?s.apply(c,arguments):l(Error("Cannot write a value to a ko.computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters."))}var i,j=r,n=b;n&&"object"==
-typeof n?(d=n,n=d.read):(d=d||{},n||(n=d.read));"function"!=typeof n&&l(Error("Pass a function that returns the value of the ko.computed"));var s=d.write;c||(c=d.owner);var t=[],B=e,q="object"==typeof d.disposeWhenNodeIsRemoved?d.disposeWhenNodeIsRemoved:p,u=d.disposeWhen||A(r);if(q){B=function(){a.a.D.Ia(q,arguments.callee);e()};a.a.D.ua(q,B);var x=u,u=function(){return!a.a.fa(q)||x()}}var y=p;g.kb=function(){return t.length};g.mb="function"===typeof d.write;g.z=function(){B()};a.R.call(g);a.a.extend(g,
-a.h.fn);d.deferEvaluation!==o&&h();a.A(g,"dispose",g.z);a.A(g,"getDependenciesCount",g.kb);return g};u=a.m.zb;a.h[u]=a.m;a.h.fn={};a.h.fn[u]=a.h;a.b("dependentObservable",a.h);a.b("computed",a.h);(function(){function b(a,f,h){h=h||new d;a=f(a);if(!("object"==typeof a&&a!==p&&a!==m&&!(a instanceof Date)))return a;var g=a instanceof Array?[]:{};h.save(a,g);c(a,function(c){var d=f(a[c]);switch(typeof d){case "boolean":case "number":case "string":case "function":g[c]=d;break;case "object":case "undefined":var j=
-h.get(d);g[c]=j!==m?j:b(d,f,h)}});return g}function c(a,b){if(a instanceof Array){for(var c=0;c<a.length;c++)b(c);"function"==typeof a.toJSON&&b("toJSON")}else for(c in a)b(c)}function d(){var b=[],f=[];this.save=function(c,d){var k=a.a.j(b,c);0<=k?f[k]=d:(b.push(c),f.push(d))};this.get=function(c){c=a.a.j(b,c);return 0<=c?f[c]:m}}a.Pa=function(c){0==arguments.length&&l(Error("When calling ko.toJS, pass the object you want to convert."));return b(c,function(b){for(var c=0;a.V(b)&&10>c;c++)b=b();return b})};
-a.toJSON=function(b){b=a.Pa(b);return a.a.qa(b)}})();a.b("toJS",a.Pa);a.b("toJSON",a.toJSON);(function(){a.i={p:function(b){return"OPTION"==b.tagName?b.__ko__hasDomDataOptionValue__===o?a.a.f.get(b,a.c.options.ma):b.getAttribute("value"):"SELECT"==b.tagName?0<=b.selectedIndex?a.i.p(b.options[b.selectedIndex]):m:b.value},S:function(b,c){if("OPTION"==b.tagName)switch(typeof c){case "string":a.a.f.set(b,a.c.options.ma,m);"__ko__hasDomDataOptionValue__"in b&&delete b.__ko__hasDomDataOptionValue__;b.value=
-c;break;default:a.a.f.set(b,a.c.options.ma,c),b.__ko__hasDomDataOptionValue__=o,b.value="number"===typeof c?c:""}else if("SELECT"==b.tagName)for(var d=b.options.length-1;0<=d;d--){if(a.i.p(b.options[d])==c){b.selectedIndex=d;break}}else{if(c===p||c===m)c="";b.value=c}}}})();a.b("selectExtensions",a.i);a.b("selectExtensions.readValue",a.i.p);a.b("selectExtensions.writeValue",a.i.S);a.k=function(){function b(a,b){for(var e=p;a!=e;)e=a,a=a.replace(c,function(a,f){return b[f]});return a}var c=/\@ko_token_(\d+)\@/g,
-d=/^[\_$a-z][\_$a-z0-9]*(\[.*?\])*(\.[\_$a-z][\_$a-z0-9]*(\[.*?\])*)*$/i,e=["true","false"];return{C:[],X:function(f){var c=a.a.v(f);if(3>c.length)return[];"{"===c.charAt(0)&&(c=c.substring(1,c.length-1));for(var f=[],e=p,d,i=0;i<c.length;i++){var j=c.charAt(i);if(e===p)switch(j){case '"':case "'":case "/":e=i,d=j}else if(j==d&&"\\"!==c.charAt(i-1)){j=c.substring(e,i+1);f.push(j);var n="@ko_token_"+(f.length-1)+"@",c=c.substring(0,e)+n+c.substring(i+1),i=i-(j.length-n.length),e=p}}d=e=p;for(var s=
-0,t=p,i=0;i<c.length;i++){j=c.charAt(i);if(e===p)switch(j){case "{":e=i;t=j;d="}";break;case "(":e=i;t=j;d=")";break;case "[":e=i,t=j,d="]"}j===t?s++:j===d&&(s--,0===s&&(j=c.substring(e,i+1),f.push(j),n="@ko_token_"+(f.length-1)+"@",c=c.substring(0,e)+n+c.substring(i+1),i-=j.length-n.length,e=p))}d=[];c=c.split(",");e=0;for(i=c.length;e<i;e++)s=c[e],t=s.indexOf(":"),0<t&&t<s.length-1?(j=s.substring(t+1),d.push({key:b(s.substring(0,t),f),value:b(j,f)})):d.push({unknown:b(s,f)});return d},ja:function(b){for(var c=
-"string"===typeof b?a.k.X(b):b,g=[],b=[],k,i=0;k=c[i];i++)if(0<g.length&&g.push(","),k.key){var j;a:{j=k.key;var n=a.a.v(j);switch(n.length&&n.charAt(0)){case "'":case '"':break a;default:j="'"+n+"'"}}k=k.value;g.push(j);g.push(":");g.push(k);n=a.a.v(k);if(0<=a.a.j(e,a.a.v(n).toLowerCase())?0:n.match(d)!==p)0<b.length&&b.push(", "),b.push(j+" : function(__ko_value) { "+k+" = __ko_value; }")}else k.unknown&&g.push(k.unknown);c=g.join("");0<b.length&&(c=c+", '_ko_property_writers' : { "+b.join("")+
-" } ");return c},sb:function(b,c){for(var e=0;e<b.length;e++)if(a.a.v(b[e].key)==c)return o;return r}}}();a.b("jsonExpressionRewriting",a.k);a.b("jsonExpressionRewriting.bindingRewriteValidators",a.k.C);a.b("jsonExpressionRewriting.parseObjectLiteral",a.k.X);a.b("jsonExpressionRewriting.insertPropertyAccessorsIntoJson",a.k.ja);(function(){function b(a){return 8==a.nodeType&&(f?a.text:a.nodeValue).match(h)}function c(a){return 8==a.nodeType&&(f?a.text:a.nodeValue).match(g)}function d(a,f){for(var e=
-a,d=1,g=[];e=e.nextSibling;){if(c(e)&&(d--,0===d))return g;g.push(e);b(e)&&d++}f||l(Error("Cannot find closing comment tag to match: "+a.nodeValue));return p}function e(a,b){var c=d(a,b);return c?0<c.length?c[c.length-1].nextSibling:a.nextSibling:p}var f="<\!--test--\>"===document.createComment("test").text,h=f?/^<\!--\s*ko\s+(.*\:.*)\s*--\>$/:/^\s*ko\s+(.*\:.*)\s*$/,g=f?/^<\!--\s*\/ko\s*--\>$/:/^\s*\/ko\s*$/,k={ul:o,ol:o};a.e={B:{},childNodes:function(a){return b(a)?d(a):a.childNodes},ha:function(c){if(b(c))for(var c=
-a.e.childNodes(c),e=0,f=c.length;e<f;e++)a.removeNode(c[e]);else a.a.ga(c)},Y:function(c,e){if(b(c)){a.e.ha(c);for(var f=c.nextSibling,d=0,g=e.length;d<g;d++)f.parentNode.insertBefore(e[d],f)}else a.a.Y(c,e)},Ga:function(a,c){b(a)?a.parentNode.insertBefore(c,a.nextSibling):a.firstChild?a.insertBefore(c,a.firstChild):a.appendChild(c)},Ca:function(a,c,e){b(a)?a.parentNode.insertBefore(c,e.nextSibling):e.nextSibling?a.insertBefore(c,e.nextSibling):a.appendChild(c)},firstChild:function(a){return!b(a)?
-a.firstChild:!a.nextSibling||c(a.nextSibling)?p:a.nextSibling},nextSibling:function(a){b(a)&&(a=e(a));return a.nextSibling&&c(a.nextSibling)?p:a.nextSibling},Ta:function(a){return(a=b(a))?a[1]:p},Ea:function(a){if(k[a.tagName.toLowerCase()]){var f=a.firstChild;if(f){do if(1===f.nodeType){var d;d=f.firstChild;var g=p;if(d){do if(g)g.push(d);else if(b(d)){var h=e(d,o);h?d=h:g=[d]}else c(d)&&(g=[d]);while(d=d.nextSibling)}if(d=g){g=f.nextSibling;for(h=0;h<d.length;h++)g?a.insertBefore(d[h],g):a.appendChild(d[h])}}while(f=
-f.nextSibling)}}}}})();a.b("virtualElements",a.e);a.b("virtualElements.allowedBindings",a.e.B);a.b("virtualElements.emptyNode",a.e.ha);a.b("virtualElements.insertAfter",a.e.Ca);a.b("virtualElements.prepend",a.e.Ga);a.b("virtualElements.setDomNodeChildren",a.e.Y);(function(){a.H=function(){this.Za={}};a.a.extend(a.H.prototype,{nodeHasBindings:function(b){switch(b.nodeType){case 1:return b.getAttribute("data-bind")!=p;case 8:return a.e.Ta(b)!=p;default:return r}},getBindings:function(a,c){var d=this.getBindingsString(a,
-c);return d?this.parseBindingsString(d,c):p},getBindingsString:function(b){switch(b.nodeType){case 1:return b.getAttribute("data-bind");case 8:return a.e.Ta(b);default:return p}},parseBindingsString:function(b,c){try{var d=c.$data,d="object"==typeof d&&d!=p?[d,c]:[c],e=d.length,f=this.Za,h=e+"_"+b,g;if(!(g=f[h])){var k=" { "+a.k.ja(b)+" } ";g=f[h]=a.a.$a(k,e)}return g(d)}catch(i){l(Error("Unable to parse bindings.\nMessage: "+i+";\nBindings value: "+b))}}});a.H.instance=new a.H})();a.b("bindingProvider",
-a.H);(function(){function b(b,f,d){for(var g=a.e.firstChild(f);f=g;)g=a.e.nextSibling(f),c(b,f,d)}function c(c,f,h){var g=o,k=1===f.nodeType;k&&a.e.Ea(f);if(k&&h||a.H.instance.nodeHasBindings(f))g=d(f,p,c,h).Cb;g&&b(c,f,!k)}function d(b,c,d,g){function k(a){return function(){return n[a]}}function i(){return n}var j=0,n,s;a.h(function(){var t=d&&d instanceof a.w?d:new a.w(a.a.d(d)),u=t.$data;g&&a.Na(b,t);if(n=("function"==typeof c?c():c)||a.H.instance.getBindings(b,t)){if(0===j){j=1;for(var q in n){var w=
-a.c[q];w&&8===b.nodeType&&!a.e.B[q]&&l(Error("The binding '"+q+"' cannot be used with virtual elements"));if(w&&"function"==typeof w.init&&(w=(0,w.init)(b,k(q),i,u,t))&&w.controlsDescendantBindings)s!==m&&l(Error("Multiple bindings ("+s+" and "+q+") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.")),s=q}j=2}if(2===j)for(q in n)(w=a.c[q])&&"function"==typeof w.update&&(0,w.update)(b,k(q),i,u,t)}},p,{disposeWhenNodeIsRemoved:b});
-return{Cb:s===m}}a.c={};a.w=function(b,c){c?(a.a.extend(this,c),this.$parentContext=c,this.$parent=c.$data,this.$parents=(c.$parents||[]).slice(0),this.$parents.unshift(this.$parent)):(this.$parents=[],this.$root=b);this.$data=b};a.w.prototype.createChildContext=function(b){return new a.w(b,this)};a.w.prototype.extend=function(b){var c=new a.w(this.Eb,this);return a.a.extend(c,b)};a.Na=function(b,c){if(2==arguments.length)a.a.f.set(b,"__ko_bindingContext__",c);else return a.a.f.get(b,"__ko_bindingContext__")};
-a.wa=function(b,c,h){1===b.nodeType&&a.e.Ea(b);return d(b,c,h,o)};a.Ua=function(a,c){(1===c.nodeType||8===c.nodeType)&&b(a,c,o)};a.va=function(a,b){b&&1!==b.nodeType&&8!==b.nodeType&&l(Error("ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node"));b=b||window.document.body;c(a,b,o)};a.ea=function(b){switch(b.nodeType){case 1:case 8:var c=a.Na(b);if(c)return c;if(b.parentNode)return a.ea(b.parentNode)}};a.cb=function(b){return(b=a.ea(b))?b.$data:m};a.b("bindingHandlers",
-a.c);a.b("applyBindings",a.va);a.b("applyBindingsToDescendants",a.Ua);a.b("applyBindingsToNode",a.wa);a.b("contextFor",a.ea);a.b("dataFor",a.cb)})();a.a.q(["click"],function(b){a.c[b]={init:function(c,d,e,f){return a.c.event.init.call(this,c,function(){var a={};a[b]=d();return a},e,f)}}});a.c.event={init:function(b,c,d,e){var f=c()||{},h;for(h in f)(function(){var f=h;"string"==typeof f&&a.a.s(b,f,function(b){var h,j=c()[f];if(j){var n=d();try{var s=a.a.K(arguments);s.unshift(e);h=j.apply(e,s)}finally{h!==
-o&&(b.preventDefault?b.preventDefault():b.returnValue=r)}n[f+"Bubble"]===r&&(b.cancelBubble=o,b.stopPropagation&&b.stopPropagation())}})})()}};a.c.submit={init:function(b,c,d,e){"function"!=typeof c()&&l(Error("The value for a submit binding must be a function"));a.a.s(b,"submit",function(a){var d,g=c();try{d=g.call(e,b)}finally{d!==o&&(a.preventDefault?a.preventDefault():a.returnValue=r)}})}};a.c.visible={update:function(b,c){var d=a.a.d(c()),e="none"!=b.style.display;d&&!e?b.style.display="":!d&&
-e&&(b.style.display="none")}};a.c.enable={update:function(b,c){var d=a.a.d(c());d&&b.disabled?b.removeAttribute("disabled"):!d&&!b.disabled&&(b.disabled=o)}};a.c.disable={update:function(b,c){a.c.enable.update(b,function(){return!a.a.d(c())})}};a.c.value={init:function(b,c,d){var e=["change"],f=d().valueUpdate;f&&("string"==typeof f&&(f=[f]),a.a.M(e,f),e=a.a.xa(e));a.a.q(e,function(f){var e=r;a.a.Db(f,"after")&&(e=o,f=f.substring(5));var k=e?function(a){setTimeout(a,0)}:function(a){a()};a.a.s(b,f,
-function(){k(function(){var f=c(),e=a.i.p(b);a.P(f)?f(e):(f=d(),f._ko_property_writers&&f._ko_property_writers.value&&f._ko_property_writers.value(e))})})})},update:function(b,c){var d=a.a.d(c()),e=a.i.p(b),f=d!=e;0===d&&0!==e&&"0"!==e&&(f=o);f&&(e=function(){a.i.S(b,d)},e(),"SELECT"==b.tagName&&setTimeout(e,0));"SELECT"==b.tagName&&0<b.length&&E(b,d,r)}};a.c.options={update:function(b,c,d){"SELECT"!=b.tagName&&l(Error("options binding applies only to SELECT elements"));var e=0==b.length,f=a.a.T(a.a.aa(b.childNodes,
-function(a){return a.tagName&&"OPTION"==a.tagName&&a.selected}),function(b){return a.i.p(b)||b.innerText||b.textContent}),h=b.scrollTop;b.scrollTop=0;for(var g=a.a.d(c());0<b.length;)a.I(b.options[0]),b.remove(0);if(g){d=d();"number"!=typeof g.length&&(g=[g]);if(d.optionsCaption){var k=document.createElement("OPTION");a.a.Z(k,d.optionsCaption);a.i.S(k,m);b.appendChild(k)}for(var c=0,i=g.length;c<i;c++){var k=document.createElement("OPTION"),j="string"==typeof d.optionsValue?g[c][d.optionsValue]:g[c],
-j=a.a.d(j);a.i.S(k,j);var n=d.optionsText,j="function"==typeof n?n(g[c]):"string"==typeof n?g[c][n]:j;if(j===p||j===m)j="";a.a.Ma(k,j);b.appendChild(k)}g=b.getElementsByTagName("OPTION");c=k=0;for(i=g.length;c<i;c++)0<=a.a.j(f,a.i.p(g[c]))&&(a.a.La(g[c],o),k++);h&&(b.scrollTop=h);e&&"value"in d&&E(b,a.a.d(d.value),o);a.a.ib(b)}}};a.c.options.ma="__ko.optionValueDomData__";a.c.selectedOptions={ia:function(b){for(var c=[],b=b.childNodes,d=0,e=b.length;d<e;d++){var f=b[d];"OPTION"==f.tagName&&f.selected?
-c.push(a.i.p(f)):"OPTGROUP"==f.tagName&&(f=a.c.selectedOptions.ia(f),Array.prototype.splice.apply(c,[c.length,0].concat(f)))}return c},init:function(b,c,d){a.a.s(b,"change",function(){var b=c();a.P(b)?b(a.c.selectedOptions.ia(this)):(b=d(),b._ko_property_writers&&b._ko_property_writers.value&&b._ko_property_writers.value(a.c.selectedOptions.ia(this)))})},update:function(b,c){"SELECT"!=b.tagName&&l(Error("values binding applies only to SELECT elements"));var d=a.a.d(c());if(d&&"number"==typeof d.length)for(var e=
-b.childNodes,f=0,h=e.length;f<h;f++){var g=e[f];"OPTION"==g.tagName&&a.a.La(g,0<=a.a.j(d,a.i.p(g)))}}};a.c.text={update:function(b,c){a.a.Ma(b,c())}};a.c.html={init:function(){return{controlsDescendantBindings:o}},update:function(b,c){var d=a.a.d(c());a.a.Z(b,d)}};a.c.css={update:function(b,c){var d=a.a.d(c()||{}),e;for(e in d)if("string"==typeof e){var f=a.a.d(d[e]);a.a.Qa(b,e,f)}}};a.c.style={update:function(b,c){var d=a.a.d(c()||{}),e;for(e in d)if("string"==typeof e){var f=a.a.d(d[e]);b.style[e]=
-f||""}}};a.c.uniqueName={init:function(b,c){c()&&(b.name="ko_unique_"+ ++a.c.uniqueName.bb,(a.a.pb||a.a.qb)&&b.mergeAttributes(document.createElement("<input name='"+b.name+"'/>"),r))}};a.c.uniqueName.bb=0;a.c.checked={init:function(b,c,d){a.a.s(b,"click",function(){var e;if("checkbox"==b.type)e=b.checked;else if("radio"==b.type&&b.checked)e=b.value;else return;var f=c();"checkbox"==b.type&&a.a.d(f)instanceof Array?(e=a.a.j(a.a.d(f),b.value),b.checked&&0>e?f.push(b.value):!b.checked&&0<=e&&f.splice(e,
-1)):a.P(f)?f()!==e&&f(e):(f=d(),f._ko_property_writers&&f._ko_property_writers.checked&&f._ko_property_writers.checked(e))});"radio"==b.type&&!b.name&&a.c.uniqueName.init(b,A(o))},update:function(b,c){var d=a.a.d(c());"checkbox"==b.type?b.checked=d instanceof Array?0<=a.a.j(d,b.value):d:"radio"==b.type&&(b.checked=b.value==d)}};a.c.attr={update:function(b,c){var d=a.a.d(c())||{},e;for(e in d)if("string"==typeof e){var f=a.a.d(d[e]);f===r||f===p||f===m?b.removeAttribute(e):b.setAttribute(e,f.toString())}}};
-a.c.hasfocus={init:function(b,c,d){function e(b){var e=c();b!=a.a.d(e)&&(a.P(e)?e(b):(e=d(),e._ko_property_writers&&e._ko_property_writers.hasfocus&&e._ko_property_writers.hasfocus(b)))}a.a.s(b,"focus",function(){e(o)});a.a.s(b,"focusin",function(){e(o)});a.a.s(b,"blur",function(){e(r)});a.a.s(b,"focusout",function(){e(r)})},update:function(b,c){var d=a.a.d(c());d?b.focus():b.blur();a.a.ta(b,d?"focusin":"focusout")}};a.c["with"]={n:function(b){return function(){var c=b();return{"if":c,data:c,templateEngine:a.o.J}}},
-init:function(b,c){return a.c.template.init(b,a.c["with"].n(c))},update:function(b,c,d,e,f){return a.c.template.update(b,a.c["with"].n(c),d,e,f)}};a.k.C["with"]=r;a.e.B["with"]=o;a.c["if"]={n:function(b){return function(){return{"if":b(),templateEngine:a.o.J}}},init:function(b,c){return a.c.template.init(b,a.c["if"].n(c))},update:function(b,c,d,e,f){return a.c.template.update(b,a.c["if"].n(c),d,e,f)}};a.k.C["if"]=r;a.e.B["if"]=o;a.c.ifnot={n:function(b){return function(){return{ifnot:b(),templateEngine:a.o.J}}},
-init:function(b,c){return a.c.template.init(b,a.c.ifnot.n(c))},update:function(b,c,d,e,f){return a.c.template.update(b,a.c.ifnot.n(c),d,e,f)}};a.k.C.ifnot=r;a.e.B.ifnot=o;a.c.foreach={n:function(b){return function(){var c=a.a.d(b());return!c||"number"==typeof c.length?{foreach:c,templateEngine:a.o.J}:{foreach:c.data,includeDestroyed:c.includeDestroyed,afterAdd:c.afterAdd,beforeRemove:c.beforeRemove,afterRender:c.afterRender,templateEngine:a.o.J}}},init:function(b,c){return a.c.template.init(b,a.c.foreach.n(c))},
-update:function(b,c,d,e,f){return a.c.template.update(b,a.c.foreach.n(c),d,e,f)}};a.k.C.foreach=r;a.e.B.foreach=o;a.t=function(){};a.t.prototype.renderTemplateSource=function(){l(Error("Override renderTemplateSource"))};a.t.prototype.createJavaScriptEvaluatorBlock=function(){l(Error("Override createJavaScriptEvaluatorBlock"))};a.t.prototype.makeTemplateSource=function(b){if("string"==typeof b){var c=document.getElementById(b);c||l(Error("Cannot find template with ID "+b));return new a.l.g(c)}if(1==
-b.nodeType||8==b.nodeType)return new a.l.L(b);l(Error("Unknown template type: "+b))};a.t.prototype.renderTemplate=function(a,c,d){return this.renderTemplateSource(this.makeTemplateSource(a),c,d)};a.t.prototype.isTemplateRewritten=function(a){return this.allowTemplateRewriting===r||this.W&&this.W[a]?o:this.makeTemplateSource(a).data("isRewritten")};a.t.prototype.rewriteTemplate=function(a,c){var d=this.makeTemplateSource(a),e=c(d.text());d.text(e);d.data("isRewritten",o);"string"==typeof a&&(this.W=
-this.W||{},this.W[a]=o)};a.b("templateEngine",a.t);a.$=function(){function b(b,c,d){for(var b=a.k.X(b),g=a.k.C,k=0;k<b.length;k++){var i=b[k].key;if(g.hasOwnProperty(i)){var j=g[i];"function"===typeof j?(i=j(b[k].value))&&l(Error(i)):j||l(Error("This template engine does not support the '"+i+"' binding within its templates"))}}b="ko.templateRewriting.applyMemoizedBindingsToNextSibling(function() {             return (function() { return { "+a.k.ja(b)+" } })()         })";return d.createJavaScriptEvaluatorBlock(b)+
-c}var c=/(<[a-z]+\d*(\s+(?!data-bind=)[a-z0-9\-]+(=(\"[^\"]*\"|\'[^\']*\'))?)*\s+)data-bind=(["'])([\s\S]*?)\5/gi,d=/<\!--\s*ko\b\s*([\s\S]*?)\s*--\>/g;return{jb:function(b,c){c.isTemplateRewritten(b)||c.rewriteTemplate(b,function(b){return a.$.vb(b,c)})},vb:function(a,f){return a.replace(c,function(a,c,d,e,j,n,s){return b(s,c,f)}).replace(d,function(a,c){return b(c,"<\!-- ko --\>",f)})},Va:function(b){return a.r.la(function(c,d){c.nextSibling&&a.wa(c.nextSibling,b,d)})}}}();a.b("templateRewriting",
-a.$);a.b("templateRewriting.applyMemoizedBindingsToNextSibling",a.$.Va);(function(){a.l={};a.l.g=function(a){this.g=a};a.l.g.prototype.text=function(){if(0==arguments.length)return"script"==this.g.tagName.toLowerCase()?this.g.text:this.g.innerHTML;var b=arguments[0];"script"==this.g.tagName.toLowerCase()?this.g.text=b:a.a.Z(this.g,b)};a.l.g.prototype.data=function(b){if(1===arguments.length)return a.a.f.get(this.g,"templateSourceData_"+b);a.a.f.set(this.g,"templateSourceData_"+b,arguments[1])};a.l.L=
-function(a){this.g=a};a.l.L.prototype=new a.l.g;a.l.L.prototype.text=function(){if(0==arguments.length){var b=a.a.f.get(this.g,"__ko_anon_template__")||{};b.sa===m&&b.da&&(b.sa=b.da.innerHTML);return b.sa}a.a.f.set(this.g,"__ko_anon_template__",{sa:arguments[0]})};a.l.g.prototype.nodes=function(){if(0==arguments.length)return(a.a.f.get(this.g,"__ko_anon_template__")||{}).da;a.a.f.set(this.g,"__ko_anon_template__",{da:arguments[0]})};a.b("templateSources",a.l);a.b("templateSources.domElement",a.l.g);
-a.b("templateSources.anonymousTemplate",a.l.L)})();(function(){function b(b,c,d){for(var e,c=a.e.nextSibling(c);b&&(e=b)!==c;)b=a.e.nextSibling(e),(1===e.nodeType||8===e.nodeType)&&d(e)}function c(c,d){if(c.length){var e=c[0],k=c[c.length-1];b(e,k,function(b){a.va(d,b)});b(e,k,function(b){a.r.Sa(b,[d])})}}function d(b,d,g,k,i){var i=i||{},j=i.templateEngine||e;a.$.jb(g,j);g=j.renderTemplate(g,k,i);("number"!=typeof g.length||0<g.length&&"number"!=typeof g[0].nodeType)&&l(Error("Template engine must return an array of DOM nodes"));
-j=r;switch(d){case "replaceChildren":a.e.Y(b,g);j=o;break;case "replaceNode":a.a.Ja(b,g);j=o;break;case "ignoreTargetNode":break;default:l(Error("Unknown renderMode: "+d))}j&&(c(g,k),i.afterRender&&i.afterRender(g,k.$data));return g}var e;a.pa=function(b){b!=m&&!(b instanceof a.t)&&l(Error("templateEngine must inherit from ko.templateEngine"));e=b};a.oa=function(b,c,g,k,i){g=g||{};(g.templateEngine||e)==m&&l(Error("Set a template engine before calling renderTemplate"));i=i||"replaceChildren";if(k){var j=
-k.nodeType?k:0<k.length?k[0]:p;return a.h(function(){var e=c&&c instanceof a.w?c:new a.w(a.a.d(c)),s="function"==typeof b?b(e.$data):b,e=d(k,i,s,e,g);"replaceNode"==i&&(k=e,j=k.nodeType?k:0<k.length?k[0]:p)},p,{disposeWhen:function(){return!j||!a.a.fa(j)},disposeWhenNodeIsRemoved:j&&"replaceNode"==i?j.parentNode:j})}return a.r.la(function(d){a.oa(b,c,g,d,"replaceNode")})};a.Bb=function(b,e,g,k,i){function j(a,b){var d=n(a);c(b,d);g.afterRender&&g.afterRender(b,d.$data)}function n(b){return i.createChildContext(a.a.d(b))}
-return a.h(function(){var c=a.a.d(e)||[];"undefined"==typeof c.length&&(c=[c]);c=a.a.aa(c,function(b){return g.includeDestroyed||b===m||b===p||!a.a.d(b._destroy)});a.a.Ka(k,c,function(a){var c="function"==typeof b?b(a):b;return d(p,"ignoreTargetNode",c,n(a),g)},g,j)},p,{disposeWhenNodeIsRemoved:k})};a.c.template={init:function(b,c){var d=a.a.d(c());if("string"!=typeof d&&!d.name&&(1==b.nodeType||8==b.nodeType))d=1==b.nodeType?b.childNodes:a.e.childNodes(b),d=a.a.wb(d),(new a.l.L(b)).nodes(d);return{controlsDescendantBindings:o}},
-update:function(b,c,d,e,i){c=a.a.d(c());e=o;"string"==typeof c?d=c:(d=c.name,"if"in c&&(e=e&&a.a.d(c["if"])),"ifnot"in c&&(e=e&&!a.a.d(c.ifnot)));var j=p;"object"===typeof c&&"foreach"in c?j=a.Bb(d||b,e&&c.foreach||[],c,b,i):e?(i="object"==typeof c&&"data"in c?i.createChildContext(a.a.d(c.data)):i,j=a.oa(d||b,i,c,b)):a.e.ha(b);i=j;(c=a.a.f.get(b,"__ko__templateSubscriptionDomDataKey__"))&&"function"==typeof c.z&&c.z();a.a.f.set(b,"__ko__templateSubscriptionDomDataKey__",i)}};a.k.C.template=function(b){b=
-a.k.X(b);return 1==b.length&&b[0].unknown||a.k.sb(b,"name")?p:"This template engine does not support anonymous templates nested within its templates"};a.e.B.template=o})();a.b("setTemplateEngine",a.pa);a.b("renderTemplate",a.oa);(function(){a.a.N=function(b,c,d){if(d===m)return a.a.N(b,c,1)||a.a.N(b,c,10)||a.a.N(b,c,Number.MAX_VALUE);for(var b=b||[],c=c||[],e=b,f=c,h=[],g=0;g<=f.length;g++)h[g]=[];for(var g=0,k=Math.min(e.length,d);g<=k;g++)h[0][g]=g;g=1;for(k=Math.min(f.length,d);g<=k;g++)h[g][0]=
-g;for(var k=e.length,i,j=f.length,g=1;g<=k;g++){i=Math.max(1,g-d);for(var n=Math.min(j,g+d);i<=n;i++)h[i][g]=e[g-1]===f[i-1]?h[i-1][g-1]:Math.min(h[i-1][g]===m?Number.MAX_VALUE:h[i-1][g]+1,h[i][g-1]===m?Number.MAX_VALUE:h[i][g-1]+1)}d=b.length;e=c.length;f=[];g=h[e][d];if(g===m)h=p;else{for(;0<d||0<e;){k=h[e][d];j=0<e?h[e-1][d]:g+1;n=0<d?h[e][d-1]:g+1;i=0<e&&0<d?h[e-1][d-1]:g+1;if(j===m||j<k-1)j=g+1;if(n===m||n<k-1)n=g+1;i<k-1&&(i=g+1);j<=n&&j<i?(f.push({status:"added",value:c[e-1]}),e--):(n<j&&n<
-i?f.push({status:"deleted",value:b[d-1]}):(f.push({status:"retained",value:b[d-1]}),e--),d--)}h=f.reverse()}return h}})();a.b("utils.compareArrays",a.a.N);(function(){function b(a){if(2<a.length){for(var b=a[0],c=a[a.length-1],h=[b];b!==c;){b=b.nextSibling;if(!b)return;h.push(b)}Array.prototype.splice.apply(a,[0,a.length].concat(h))}}function c(c,e,f,h){var g=[],c=a.h(function(){var c=e(f)||[];0<g.length&&(b(g),a.a.Ja(g,c),h&&h(f,c));g.splice(0,g.length);a.a.M(g,c)},p,{disposeWhenNodeIsRemoved:c,
-disposeWhen:function(){return 0==g.length||!a.a.fa(g[0])}});return{tb:g,h:c}}a.a.Ka=function(d,e,f,h,g){for(var e=e||[],h=h||{},k=a.a.f.get(d,"setDomNodeChildrenFromArrayMapping_lastMappingResult")===m,i=a.a.f.get(d,"setDomNodeChildrenFromArrayMapping_lastMappingResult")||[],j=a.a.T(i,function(a){return a.Wa}),n=a.a.N(j,e),e=[],s=0,t=[],j=[],u=p,q=0,w=n.length;q<w;q++)switch(n[q].status){case "retained":var x=i[s];e.push(x);0<x.O.length&&(u=x.O[x.O.length-1]);s++;break;case "deleted":i[s].h.z();b(i[s].O);
-a.a.q(i[s].O,function(a){t.push({element:a,index:q,value:n[q].value});u=a});s++;break;case "added":var x=n[q].value,y=c(d,f,x,g),v=y.tb;e.push({Wa:n[q].value,O:v,h:y.h});for(var y=0,z=v.length;y<z;y++){var C=v[y];j.push({element:C,index:q,value:n[q].value});u==p?a.e.Ga(d,C):a.e.Ca(d,C,u);u=C}g&&g(x,v)}a.a.q(t,function(b){a.I(b.element)});f=r;if(!k){if(h.afterAdd)for(q=0;q<j.length;q++)h.afterAdd(j[q].element,j[q].index,j[q].value);if(h.beforeRemove){for(q=0;q<t.length;q++)h.beforeRemove(t[q].element,
-t[q].index,t[q].value);f=o}}f||a.a.q(t,function(b){a.removeNode(b.element)});a.a.f.set(d,"setDomNodeChildrenFromArrayMapping_lastMappingResult",e)}})();a.b("utils.setDomNodeChildrenFromArrayMapping",a.a.Ka);a.o=function(){this.allowTemplateRewriting=r};a.o.prototype=new a.t;a.o.prototype.renderTemplateSource=function(b){var c=!(9>a.a.nb)&&b.nodes?b.nodes():p;if(c)return a.a.K(c.cloneNode(o).childNodes);b=b.text();return a.a.na(b)};a.o.J=new a.o;a.pa(a.o.J);a.b("nativeTemplateEngine",a.o);(function(){a.ka=
-function(){var a=this.rb=function(){if("undefined"==typeof jQuery||!jQuery.tmpl)return 0;try{if(0<=jQuery.tmpl.tag.tmpl.open.toString().indexOf("__"))return 2}catch(a){}return 1}();this.renderTemplateSource=function(b,e,f){f=f||{};2>a&&l(Error("Your version of jQuery.tmpl is too old. Please upgrade to jQuery.tmpl 1.0.0pre or later."));var h=b.data("precompiled");h||(h=b.text()||"",h=jQuery.template(p,"{{ko_with $item.koBindingContext}}"+h+"{{/ko_with}}"),b.data("precompiled",h));b=[e.$data];e=jQuery.extend({koBindingContext:e},
-f.templateOptions);e=jQuery.tmpl(h,b,e);e.appendTo(document.createElement("div"));jQuery.fragments={};return e};this.createJavaScriptEvaluatorBlock=function(a){return"{{ko_code ((function() { return "+a+" })()) }}"};this.addTemplate=function(a,b){document.write("<script type='text/html' id='"+a+"'>"+b+"<\/script>")};0<a&&(jQuery.tmpl.tag.ko_code={open:"__.push($1 || '');"},jQuery.tmpl.tag.ko_with={open:"with($1) {",close:"} "})};a.ka.prototype=new a.t;var b=new a.ka;0<b.rb&&a.pa(b);a.b("jqueryTmplTemplateEngine",
-a.ka)})()}"function"===typeof require&&"object"===typeof exports&&"object"===typeof module?D(module.exports||exports):"function"===typeof define&&define.amd?define(["exports"],D):D(window.ko={});o;
-})(window,document,navigator);                  
 
+<html><head>
+<meta http-equiv="content-type" content="text/html;charset=utf-8">
+<title>500 Server Error</title>
+</head>
+<body text=#000000 bgcolor=#ffffff>
+<h1>Error: Server Error</h1>
+<h2>The server encountered an error and could not complete your request.<p>If the problem persists, please <A HREF="http://code.google.com/appengine/community.html">report</A> your problem and mention this error message and the query that caused it.</h2>
+<h2></h2>
+</body></html>
diff --git a/spec/bindingAttributeBehaviors.js b/spec/bindingAttributeBehaviors.js
index fd96ec254..2a8ff3f75 100644
--- a/spec/bindingAttributeBehaviors.js
+++ b/spec/bindingAttributeBehaviors.js
@@ -1,872 +1,894 @@
-describe('Binding attribute syntax', {
-    before_each: function () {
-        var existingNode = document.getElementById("testNode");
-        if (existingNode != null)
-            existingNode.parentNode.removeChild(existingNode);
-        testNode = document.createElement("div");
-        testNode.id = "testNode";
-        document.body.appendChild(testNode);
-    },
-    
-    'applyBindings should accept no parameters and then act on document.body with undefined model': function() {
-        var didInit = false;
-        ko.bindingHandlers.test = {
-            init: function (element, valueAccessor, allBindingsAccessor, viewModel) {
-                value_of(element.id).should_be("testElement");
-                value_of(viewModel).should_be(undefined);
-                didInit = true;
-            }
-        };
-        testNode.innerHTML = "<div id='testElement' data-bind='test:123'></div>";
-        ko.applyBindings();
-        value_of(didInit).should_be(true);
-
-        // Just to avoid interfering with other specs:
-        ko.utils.domData.clear(document.body);        
-    },
-
-    'applyBindings should accept one parameter and then act on document.body with parameter as model': function() {
-        var didInit = false;
-        var suppliedViewModel = {};
-        ko.bindingHandlers.test = {
-            init: function (element, valueAccessor, allBindingsAccessor, viewModel) {
-                value_of(element.id).should_be("testElement");
-                value_of(viewModel).should_be(suppliedViewModel);
-                didInit = true;
-            }
-        };
-        testNode.innerHTML = "<div id='testElement' data-bind='test:123'></div>";
-        ko.applyBindings(suppliedViewModel);
-        value_of(didInit).should_be(true);
-
-        // Just to avoid interfering with other specs:
-        ko.utils.domData.clear(document.body);
-    },
-    
-    'applyBindings should accept two parameters and then act on second param as DOM node with first param as model': function() {
-        var didInit = false;
-        var suppliedViewModel = {};
-        ko.bindingHandlers.test = {
-            init: function (element, valueAccessor, allBindingsAccessor, viewModel) {
-                value_of(element.id).should_be("testElement");
-                value_of(viewModel).should_be(suppliedViewModel);
-                didInit = true;
-            }
-        };
-        testNode.innerHTML = "<div id='testElement' data-bind='test:123'></div>";
-        var shouldNotMatchNode = document.createElement("DIV");
-        shouldNotMatchNode.innerHTML = "<div id='shouldNotMatchThisElement' data-bind='test:123'></div>";
-        document.body.appendChild(shouldNotMatchNode);
-        try {
-            ko.applyBindings(suppliedViewModel, testNode);
-            value_of(didInit).should_be(true);    	
-        } finally {
-            shouldNotMatchNode.parentNode.removeChild(shouldNotMatchNode);
-        }
-    },
-
-    'Should tolerate whitespace and nonexistent handlers': function () {
-        testNode.innerHTML = "<div data-bind=' nonexistentHandler : \"Hello\" '></div>";
-        ko.applyBindings(null, testNode); // No exception means success
-    },
-
-    'Should tolerate arbitrary literals as the values for a handler': function () {
-        testNode.innerHTML = "<div data-bind='stringLiteral: \"hello\", numberLiteral: 123, boolLiteral: true, objectLiteral: {}, functionLiteral: function() { }'></div>";
-        ko.applyBindings(null, testNode); // No exception means success
-    },
-
-    'Should tolerate wacky IE conditional comments': function() {
-        // Represents issue https://github.com/SteveSanderson/knockout/issues/186. Would fail on IE9, but work on earlier IE versions.
-        testNode.innerHTML = "<div><!--[if IE]><!-->Hello<!--<![endif]--></div>";
-        ko.applyBindings(null, testNode); // No exception means success          
-    },
-
-    'Should invoke registered handlers\' init() then update() methods passing binding data': function () {
-        var methodsInvoked = [];
-        ko.bindingHandlers.test = {
-            init: function (element, valueAccessor, allBindingsAccessor) {
-                methodsInvoked.push("init");
-                value_of(element.id).should_be("testElement");
-                value_of(valueAccessor()).should_be("Hello");
-                value_of(allBindingsAccessor().another).should_be(123);
-            },
-            update: function (element, valueAccessor, allBindingsAccessor) {
-                methodsInvoked.push("update");
-                value_of(element.id).should_be("testElement");
-                value_of(valueAccessor()).should_be("Hello");
-                value_of(allBindingsAccessor().another).should_be(123);
-            }
-        }
-        testNode.innerHTML = "<div id='testElement' data-bind='test:\"Hello\", another:123'></div>";
-        ko.applyBindings(null, testNode);
-        value_of(methodsInvoked.length).should_be(2);
-        value_of(methodsInvoked[0]).should_be("init");
-        value_of(methodsInvoked[1]).should_be("update");
-    },
-
-    'If the binding handler depends on an observable, invokes the init handler once and the update handler whenever a new value is available': function () {
-        var observable = new ko.observable();
-        var initPassedValues = [], updatePassedValues = [];
-        ko.bindingHandlers.test = {
-            init: function (element, valueAccessor) { initPassedValues.push(valueAccessor()()); },
-            update: function (element, valueAccessor) { updatePassedValues.push(valueAccessor()()); }
-        };
-        testNode.innerHTML = "<div data-bind='test: myObservable'></div>";
-
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(initPassedValues.length).should_be(1);
-        value_of(updatePassedValues.length).should_be(1);
-        value_of(initPassedValues[0]).should_be(undefined);
-        value_of(updatePassedValues[0]).should_be(undefined);
-
-        observable("A");
-        value_of(initPassedValues.length).should_be(1);
-        value_of(updatePassedValues.length).should_be(2);
-        value_of(updatePassedValues[1]).should_be("A");
-    },
-
-    'If the associated DOM element was removed by KO, handler subscriptions are disposed immediately': function () {
-        var observable = new ko.observable("A");
-        ko.bindingHandlers.anyHandler = {
-            update: function (element, valueAccessor) { valueAccessor(); }
-        };
-        testNode.innerHTML = "<div data-bind='anyHandler: myObservable()'></div>";
-        ko.applyBindings({ myObservable: observable }, testNode);
-        
-        value_of(observable.getSubscriptionsCount()).should_be(1);
+var bindingAttributeBehaviors =
 
-        ko.cleanAndRemoveNode(testNode);
-
-        value_of(observable.getSubscriptionsCount()).should_be(0);
-    },
-
-    'If the associated DOM element was removed independently of KO, handler subscriptions are disposed on the next evaluation': function () {
-        var observable = new ko.observable("A");
-        ko.bindingHandlers.anyHandler = {
-            update: function (element, valueAccessor) { valueAccessor(); }
-        };
-        testNode.innerHTML = "<div data-bind='anyHandler: myObservable()'></div>";
-        ko.applyBindings({ myObservable: observable }, testNode);
-        
-        value_of(observable.getSubscriptionsCount()).should_be(1);
-        
-        testNode.parentNode.removeChild(testNode);
-        observable("B"); // Force re-evaluation
-        
-        value_of(observable.getSubscriptionsCount()).should_be(0);
-    },
-
-    'If the binding attribute involves an observable, re-invokes the bindings if the observable notifies a change': function () {
-        var observable = new ko.observable({ message: "hello" });
-        var passedValues = [];
-        ko.bindingHandlers.test = { update: function (element, valueAccessor) { passedValues.push(valueAccessor()); } };
-        testNode.innerHTML = "<div data-bind='test: myObservable().message'></div>";
-
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(passedValues.length).should_be(1);
-        value_of(passedValues[0]).should_be("hello");
-
-        observable({ message: "goodbye" });
-        value_of(passedValues.length).should_be(2);
-        value_of(passedValues[1]).should_be("goodbye");
-    },
+function (testConfiguration) {
+    var existingBindingProvider = ko.bindingProvider.instance;
+    var myConfiguration = testConfiguration;
     
-    'Should be able to refer to the bound object itself (at the root scope, the viewmodel) via $data': function() {
-        testNode.innerHTML = "<div data-bind='text: $data.someProp'></div>";
-        ko.applyBindings({ someProp: 'My prop value' }, testNode);
-        value_of(testNode).should_contain_text("My prop value");
-    },
-
-    'Should be able to update bindings (including callbacks) using an observable view model': function() {
-        testNode.innerHTML = "<input data-bind='value:someProp' />";
-        var input = testNode.childNodes[0], vm = ko.observable({ someProp: 'My prop value' });
-        ko.applyBindings(vm, input);
-
-        value_of(input.value).should_be("My prop value");
-
-        // a change to the input value should be written to the model
-        input.value = "some user-entered value";
-        ko.utils.triggerEvent(input, "change");
-        value_of(vm().someProp).should_be("some user-entered value");
-
-        // set the view-model to a new object
-        vm({ someProp: ko.observable('My new prop value') });
-        value_of(input.value).should_be("My new prop value");
-
-        // a change to the input value should be written to the new model
-        input.value = "some new user-entered value";
-        ko.utils.triggerEvent(input, "change");
-        value_of(vm().someProp()).should_be("some new user-entered value");
-
-        // clear the element and the view-model (shouldn't be any errors)
-        testNode.innerHTML = "";
-        vm(null);
-    },
-
-    'Updates to an observable view model should update all child contexts (uncluding values copied from the parent)': function() {
-        ko.bindingHandlers.setChildContext = {
-            flags: ko.bindingFlags.contentBind,
-            init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-                ko.applyBindingsToDescendants(
-                    bindingContext.createChildContext(function() { return ko.utils.unwrapObservable(valueAccessor()) }), 
-                    element, true);
-            }
-        };
+    describe('Binding attribute syntax ' + (myConfiguration ? myConfiguration.name : "default provider settings"), {
+        before_each: function () {
+            var existingNode = document.getElementById("testNode");
+            if (existingNode != null)
+                existingNode.parentNode.removeChild(existingNode);
+            testNode = document.createElement("div");
+            testNode.id = "testNode";
+            document.body.appendChild(testNode);
+            ko.bindingProvider["instance"] = new ko.bindingProvider(myConfiguration);
+            virtualElementTag = ko.bindingProvider["instance"].configuration.virtualElementTag;
+            bindingAttribute = ko.bindingProvider["instance"].configuration.bindingAttribute;
+
+        },
         
-        testNode.innerHTML = "<div data-bind='setChildContext:obj1'><span data-bind='text:prop1'></span><span data-bind='text:$root.prop2'></span></div>";
-        var vm = ko.observable({obj1: {prop1: "First "}, prop2: "view model"});
-        ko.applyBindings(vm, testNode);
-        value_of(testNode).should_contain_text("First view model");
-
-        // change view model to new object
-        vm({obj1: {prop1: "Second view "}, prop2: "model"});
-        value_of(testNode).should_contain_text("Second view model");
-
-        // change it again
-        vm({obj1: {prop1: "Third view model"}, prop2: ""});
-        value_of(testNode).should_contain_text("Third view model");
-    },
-
-    'Should be able to get all updates to observables in both init and update': function() {
-        var lastBoundValueInit, lastBoundValueUpdate;
-        ko.bindingHandlers.testInit = {
-            init: function(element, valueAccessor) {
-                ko.dependentObservable(function() {
-                    lastBoundValueInit = ko.utils.unwrapObservable(valueAccessor());
-                });
-            }
-        };
-        ko.bindingHandlers.testUpdate = {
-            update: function(element, valueAccessor) {
-                lastBoundValueUpdate = ko.utils.unwrapObservable(valueAccessor());
-            }
-        };
-        testNode.innerHTML = "<div data-bind='testInit: myProp()'></div><div data-bind='testUpdate: myProp()'></div>";
-        var vm = ko.observable({ myProp: ko.observable("initial value") });
-        ko.applyBindings(vm, testNode);
-        value_of(lastBoundValueInit).should_be("initial value");
-        value_of(lastBoundValueUpdate).should_be("initial value");
-
-        // update value of observable
-        vm().myProp("second value");
-        value_of(lastBoundValueInit).should_be("second value");
-        value_of(lastBoundValueUpdate).should_be("second value");
-        
-        // update value of observable to another observable
-        vm().myProp(ko.observable("third value"));
-        value_of(lastBoundValueInit).should_be("third value");
-        value_of(lastBoundValueUpdate).should_be("third value");
-
-        // update view model with brand-new property
-        vm({ myProp: function() {return "fourth value"; }});
-        value_of(lastBoundValueInit).should_be("fourth value");
-        value_of(lastBoundValueUpdate).should_be("fourth value");
-    },
-
-    'Should be able to specify two-level bindings through a sub-object and through dot syntax': function() {
-        var results = {}, firstName = ko.observable('bob'), lastName = ko.observable('smith');
-        ko.bindingHandlers.twoLevelBinding = {
-            flags: ko.bindingFlags.twoLevel,
-            update: function(element, valueAccessor) {
-                var value = valueAccessor();
-                for (var prop in value) {
-                    results[prop] = ko.utils.unwrapObservable(value[prop]);
+        after_each : function() {
+            ko.bindingProvider.instance = existingBindingProvider;
+
+        },
+
+        'applyBindings should accept no parameters and then act on document.body with undefined model': function () {
+            var didInit = false;
+            ko.bindingHandlers.test = {
+                init: function (element, valueAccessor, allBindingsAccessor, viewModel) {
+                    value_of(element.id).should_be("testElement");
+                    value_of(viewModel).should_be(undefined);
+                    didInit = true;
+                }
+            };
+            testNode.innerHTML = "<div id='testElement' " + bindingAttribute + "='test:123'></div>";
+            ko.applyBindings();
+            value_of(didInit).should_be(true);
+
+            // Just to avoid interfering with other specs:
+            ko.utils.domData.clear(document.body);
+        },
+
+        'applyBindings should accept one parameter and then act on document.body with parameter as model': function () {
+            var didInit = false;
+            var suppliedViewModel = {};
+            ko.bindingHandlers.test = {
+                init: function (element, valueAccessor, allBindingsAccessor, viewModel) {
+                    value_of(element.id).should_be("testElement");
+                    value_of(viewModel).should_be(suppliedViewModel);
+                    didInit = true;
                 }
+            };
+            testNode.innerHTML = "<div id='testElement' " + bindingAttribute + "='test:123'></div>";
+            ko.applyBindings(suppliedViewModel);
+            value_of(didInit).should_be(true);
+
+            // Just to avoid interfering with other specs:
+            ko.utils.domData.clear(document.body);
+        },
+
+        'applyBindings should accept two parameters and then act on second param as DOM node with first param as model': function () {
+            var didInit = false;
+            var suppliedViewModel = {};
+            ko.bindingHandlers.test = {
+                init: function (element, valueAccessor, allBindingsAccessor, viewModel) {
+                    value_of(element.id).should_be("testElement");
+                    value_of(viewModel).should_be(suppliedViewModel);
+                    didInit = true;
+                }
+            };
+            testNode.innerHTML = "<div id='testElement' " + bindingAttribute + "='test:123'></div>";
+            var shouldNotMatchNode = document.createElement("DIV");
+            shouldNotMatchNode.innerHTML = "<div id='shouldNotMatchThisElement' " + bindingAttribute + "='test:123'></div>";
+            document.body.appendChild(shouldNotMatchNode);
+            try {
+                ko.applyBindings(suppliedViewModel, testNode);
+                value_of(didInit).should_be(true);
+            } finally {
+                shouldNotMatchNode.parentNode.removeChild(shouldNotMatchNode);
             }
-        };
-        testNode.innerHTML = "<div data-bind='twoLevelBinding: {first: firstName, full: firstName()+\" \"+lastName()}, twoLevelBinding.last: lastName'></div>";
-        ko.applyBindings({ firstName: firstName, lastName: lastName }, testNode);
-        value_of(results.first).should_be("bob");
-        value_of(results.last).should_be("smith");
-        value_of(results.full).should_be("bob smith");
-
-        lastName('jones');
-        value_of(results.last).should_be("jones");
-        value_of(results.full).should_be("bob jones");
-    },
-
-    'Value of \'this\' in call to event handler should be the function\'s object if option set': function() {
-        ko.bindingHandlers.testEvent = {
-            flags: ko.bindingFlags.eventHandler,
-            init: function(element, valueAccessor) {
-                valueAccessor()(); // call the function
+        },
+
+        'Should tolerate whitespace and nonexistent handlers': function () {
+            testNode.innerHTML = "<div " + bindingAttribute + "=' nonexistentHandler : \"Hello\" '></div>";
+            ko.applyBindings(null, testNode); // No exception means success
+        },
+
+        'Should tolerate arbitrary literals as the values for a handler': function () {
+            testNode.innerHTML = "<div " + bindingAttribute + "='stringLiteral: \"hello\", numberLiteral: 123, boolLiteral: true, objectLiteral: {}, functionLiteral: function() { }'></div>";
+            ko.applyBindings(null, testNode); // No exception means success
+        },
+
+        'Should tolerate wacky IE conditional comments': function () {
+            // Represents issue https://github.com/SteveSanderson/knockout/issues/186. Would fail on IE9, but work on earlier IE versions.
+            testNode.innerHTML = "<div><!--[if IE]><!-->Hello<!--<![endif]--></div>";
+            ko.applyBindings(null, testNode); // No exception means success          
+        },
+
+        'Should invoke registered handlers\' init() then update() methods passing binding data': function () {
+            var methodsInvoked = [];
+            ko.bindingHandlers.test = {
+                init: function (element, valueAccessor, allBindingsAccessor) {
+                    methodsInvoked.push("init");
+                    value_of(element.id).should_be("testElement");
+                    value_of(valueAccessor()).should_be("Hello");
+                    value_of(allBindingsAccessor().another).should_be(123);
+                },
+                update: function (element, valueAccessor, allBindingsAccessor) {
+                    methodsInvoked.push("update");
+                    value_of(element.id).should_be("testElement");
+                    value_of(valueAccessor()).should_be("Hello");
+                    value_of(allBindingsAccessor().another).should_be(123);
+                }
             }
-        };
-        var eventCalls = 0, vm = {
-            topLevelFunction: function() {
-                value_of(this).should_be(vm);
-                eventCalls++;
-            },
-            level2: {
-                secondLevelFunction: function() {
-                    value_of(this).should_be(vm.level2);
+            testNode.innerHTML = "<div id='testElement' " + bindingAttribute + "='test:\"Hello\", another:123'></div>";
+            ko.applyBindings(null, testNode);
+            value_of(methodsInvoked.length).should_be(2);
+            value_of(methodsInvoked[0]).should_be("init");
+            value_of(methodsInvoked[1]).should_be("update");
+        },
+
+        'If the binding handler depends on an observable, invokes the init handler once and the update handler whenever a new value is available': function () {
+            var observable = new ko.observable();
+            var initPassedValues = [], updatePassedValues = [];
+            ko.bindingHandlers.test = {
+                init: function (element, valueAccessor) { initPassedValues.push(valueAccessor()()); },
+                update: function (element, valueAccessor) { updatePassedValues.push(valueAccessor()()); }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test: myObservable'></div>";
+
+            ko.applyBindings({ myObservable: observable }, testNode);
+            value_of(initPassedValues.length).should_be(1);
+            value_of(updatePassedValues.length).should_be(1);
+            value_of(initPassedValues[0]).should_be(undefined);
+            value_of(updatePassedValues[0]).should_be(undefined);
+
+            observable("A");
+            value_of(initPassedValues.length).should_be(1);
+            value_of(updatePassedValues.length).should_be(2);
+            value_of(updatePassedValues[1]).should_be("A");
+        },
+
+        'If the associated DOM element was removed by KO, handler subscriptions are disposed immediately': function () {
+            var observable = new ko.observable("A");
+            ko.bindingHandlers.anyHandler = {
+                update: function (element, valueAccessor) { valueAccessor(); }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='anyHandler: myObservable()'></div>";
+            ko.applyBindings({ myObservable: observable }, testNode);
+
+            value_of(observable.getSubscriptionsCount()).should_be(1);
+
+            ko.cleanAndRemoveNode(testNode);
+
+            value_of(observable.getSubscriptionsCount()).should_be(0);
+        },
+
+        'If the associated DOM element was removed independently of KO, handler subscriptions are disposed on the next evaluation': function () {
+            var observable = new ko.observable("A");
+            ko.bindingHandlers.anyHandler = {
+                update: function (element, valueAccessor) { valueAccessor(); }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='anyHandler: myObservable()'></div>";
+            ko.applyBindings({ myObservable: observable }, testNode);
+
+            value_of(observable.getSubscriptionsCount()).should_be(1);
+
+            testNode.parentNode.removeChild(testNode);
+            observable("B"); // Force re-evaluation
+
+            value_of(observable.getSubscriptionsCount()).should_be(0);
+        },
+
+        'If the binding attribute involves an observable, re-invokes the bindings if the observable notifies a change': function () {
+            var observable = new ko.observable({ message: "hello" });
+            var passedValues = [];
+            ko.bindingHandlers.test = { update: function (element, valueAccessor) { passedValues.push(valueAccessor()); } };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test: myObservable().message'></div>";
+
+            ko.applyBindings({ myObservable: observable }, testNode);
+            value_of(passedValues.length).should_be(1);
+            value_of(passedValues[0]).should_be("hello");
+
+            observable({ message: "goodbye" });
+            value_of(passedValues.length).should_be(2);
+            value_of(passedValues[1]).should_be("goodbye");
+        },
+
+        'Should be able to refer to the bound object itself (at the root scope, the viewmodel) via $data': function () {
+            testNode.innerHTML = "<div " + bindingAttribute + "='text: $data.someProp'></div>";
+            ko.applyBindings({ someProp: 'My prop value' }, testNode);
+            value_of(testNode).should_contain_text("My prop value");
+        },
+
+        'Should be able to update bindings (including callbacks) using an observable view model': function () {
+            testNode.innerHTML = "<input " + bindingAttribute + "='value:someProp' />";
+            var input = testNode.childNodes[0], vm = ko.observable({ someProp: 'My prop value' });
+            ko.applyBindings(vm, input);
+
+            value_of(input.value).should_be("My prop value");
+
+            // a change to the input value should be written to the model
+            input.value = "some user-entered value";
+            ko.utils.triggerEvent(input, "change");
+            value_of(vm().someProp).should_be("some user-entered value");
+
+            // set the view-model to a new object
+            vm({ someProp: ko.observable('My new prop value') });
+            value_of(input.value).should_be("My new prop value");
+
+            // a change to the input value should be written to the new model
+            input.value = "some new user-entered value";
+            ko.utils.triggerEvent(input, "change");
+            value_of(vm().someProp()).should_be("some new user-entered value");
+
+            // clear the element and the view-model (shouldn't be any errors)
+            testNode.innerHTML = "";
+            vm(null);
+        },
+
+        'Updates to an observable view model should update all child contexts (uncluding values copied from the parent)': function () {
+            ko.bindingHandlers.setChildContext = {
+                flags: ko.bindingFlags.contentBind,
+                init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+                    ko.applyBindingsToDescendants(
+                    bindingContext.createChildContext(function () { return ko.utils.unwrapObservable(valueAccessor()) }),
+                    element, true);
+                }
+            };
+
+            testNode.innerHTML = "<div " + bindingAttribute + "='setChildContext:obj1'><span " + bindingAttribute + "='text:prop1'></span><span " + bindingAttribute + "='text:$root.prop2'></span></div>";
+            var vm = ko.observable({ obj1: { prop1: "First " }, prop2: "view model" });
+            ko.applyBindings(vm, testNode);
+            value_of(testNode).should_contain_text("First view model");
+
+            // change view model to new object
+            vm({ obj1: { prop1: "Second view " }, prop2: "model" });
+            value_of(testNode).should_contain_text("Second view model");
+
+            // change it again
+            vm({ obj1: { prop1: "Third view model" }, prop2: "" });
+            value_of(testNode).should_contain_text("Third view model");
+        },
+
+        'Should be able to get all updates to observables in both init and update': function () {
+            var lastBoundValueInit, lastBoundValueUpdate;
+            ko.bindingHandlers.testInit = {
+                init: function (element, valueAccessor) {
+                    ko.dependentObservable(function () {
+                        lastBoundValueInit = ko.utils.unwrapObservable(valueAccessor());
+                    });
+                }
+            };
+            ko.bindingHandlers.testUpdate = {
+                update: function (element, valueAccessor) {
+                    lastBoundValueUpdate = ko.utils.unwrapObservable(valueAccessor());
+                }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='testInit: myProp()'></div><div " + bindingAttribute + "='testUpdate: myProp()'></div>";
+            var vm = ko.observable({ myProp: ko.observable("initial value") });
+            ko.applyBindings(vm, testNode);
+            value_of(lastBoundValueInit).should_be("initial value");
+            value_of(lastBoundValueUpdate).should_be("initial value");
+
+            // update value of observable
+            vm().myProp("second value");
+            value_of(lastBoundValueInit).should_be("second value");
+            value_of(lastBoundValueUpdate).should_be("second value");
+
+            // update value of observable to another observable
+            vm().myProp(ko.observable("third value"));
+            value_of(lastBoundValueInit).should_be("third value");
+            value_of(lastBoundValueUpdate).should_be("third value");
+
+            // update view model with brand-new property
+            vm({ myProp: function () { return "fourth value"; } });
+            value_of(lastBoundValueInit).should_be("fourth value");
+            value_of(lastBoundValueUpdate).should_be("fourth value");
+        },
+
+        'Should be able to specify two-level bindings through a sub-object and through dot syntax': function () {
+            var results = {}, firstName = ko.observable('bob'), lastName = ko.observable('smith');
+            ko.bindingHandlers.twoLevelBinding = {
+                flags: ko.bindingFlags.twoLevel,
+                update: function (element, valueAccessor) {
+                    var value = valueAccessor();
+                    for (var prop in value) {
+                        results[prop] = ko.utils.unwrapObservable(value[prop]);
+                    }
+                }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='twoLevelBinding: {first: firstName, full: firstName()+\" \"+lastName()}, twoLevelBinding.last: lastName'></div>";
+            ko.applyBindings({ firstName: firstName, lastName: lastName }, testNode);
+            value_of(results.first).should_be("bob");
+            value_of(results.last).should_be("smith");
+            value_of(results.full).should_be("bob smith");
+
+            lastName('jones');
+            value_of(results.last).should_be("jones");
+            value_of(results.full).should_be("bob jones");
+        },
+
+        'Value of \'this\' in call to event handler should be the function\'s object if option set': function () {
+            ko.bindingHandlers.testEvent = {
+                flags: ko.bindingFlags.eventHandler,
+                init: function (element, valueAccessor) {
+                    valueAccessor()(); // call the function
+                }
+            };
+            var eventCalls = 0, vm = {
+                topLevelFunction: function () {
+                    value_of(this).should_be(vm);
                     eventCalls++;
+                },
+                level2: {
+                    secondLevelFunction: function () {
+                        value_of(this).should_be(vm.level2);
+                        eventCalls++;
+                    }
                 }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='testEvent: topLevelFunction'></div><div " + bindingAttribute + "='testEvent: level2.secondLevelFunction'></div>";
+            ko.applyBindings(vm, testNode, { eventHandlersUseObjectForThis: true });
+            value_of(eventCalls).should_be(2);
+        },
+
+        'Should be able to leave off the value if a binding specifies it doesn\'t require one (will default to true)': function () {
+            var initCalls = 0;
+            ko.bindingHandlers.doesntRequireValue = {
+                flags: ko.bindingFlags.noValue,
+                init: function (element, valueAccessor) { if (valueAccessor()) initCalls++; }
             }
-        };
-        testNode.innerHTML = "<div data-bind='testEvent: topLevelFunction'></div><div data-bind='testEvent: level2.secondLevelFunction'></div>";
-        ko.applyBindings(vm, testNode, {eventHandlersUseObjectForThis: true});
-        value_of(eventCalls).should_be(2);
-    },
-
-    'Should be able to leave off the value if a binding specifies it doesn\'t require one (will default to true)': function() {
-        var initCalls = 0;
-        ko.bindingHandlers.doesntRequireValue = {
-            flags: ko.bindingFlags.noValue,
-            init: function(element, valueAccessor) { if (valueAccessor()) initCalls++; }
-        }
-        testNode.innerHTML = "<div data-bind='doesntRequireValue, dummy: false'></div><div data-bind='doesntRequireValue: true, dummy: false'></div>";
-        ko.applyBindings(null, testNode);
-        value_of(initCalls).should_be(2);
-    },
-
-    'Should not be able to leave off the value if a binding doesn\'t specify the noValue flag': function() {
-        var initCalls = 0, didThrow = false;
-        ko.bindingHandlers.doesRequireValue = {
-            init: function(element, valueAccessor) { if (valueAccessor()) initCalls++; }
-        }
-        testNode.innerHTML = "<div data-bind='doesRequireValue, dummy: false'></div><div data-bind='doesRequireValue: true, dummy: false'></div>";
-
-        try { ko.applyBindings(null, testNode) }
-        catch(ex) { didThrow = true; value_of(ex.message).should_contain('Unable to parse bindings') }
-        value_of(didThrow).should_be(true);
-    },
-
-    'Bindings can signal that they control descendant bindings by setting contentBind flag': function() {
-        ko.bindingHandlers.test = {
-            flags: ko.bindingFlags.contentBind
-        };
-        testNode.innerHTML = "<div data-bind='test: true'>"
-                           +     "<div data-bind='text: 123'>456</div>"
-                           + "</div>"
-                           + "<div data-bind='text: 123'>456</div>";
-        ko.applyBindings(null, testNode);
-        
-        value_of(testNode.childNodes[0].childNodes[0].innerHTML).should_be("456");
-        value_of(testNode.childNodes[1].innerHTML).should_be("123");
-    },
-    
-    'Should not be allowed to have multiple bindings on the same element that claim to control descendant bindings': function() {
-        ko.bindingHandlers.test1 = {
-            flags: ko.bindingFlags.contentBind
-        };
-        ko.bindingHandlers.test2 = ko.bindingHandlers.test1;
-        testNode.innerHTML = "<div data-bind='test1: true, test2: true'></div>"
-        var didThrow = false;
-        
-        try { ko.applyBindings(null, testNode) }
-        catch(ex) { didThrow = true; value_of(ex.message).should_contain('Multiple bindings (test1 and test2) are trying to control descendant bindings of the same element.') }
-        value_of(didThrow).should_be(true);
-    },
-    
-    'Binding should not be allowed to use \'controlsDescendantBindings\' style with independent bindings': function() {
-        ko.bindingHandlers.test = {  
-            init: function() { return { controlsDescendantBindings : true } }
-        };
-        testNode.innerHTML = "<div data-bind='test: true'></div>"
-        var didThrow = false;
-        
-        try { ko.applyBindings(null, testNode, {independentBindings: true}) }
-        catch(ex) { didThrow = true; value_of(ex.message).should_contain('contentBind flag') }
-        value_of(didThrow).should_be(true);
-    },
-    
-    'Binding should be allowed to use \'controlsDescendantBindings\' with standard bindings': function() {
-        ko.bindingHandlers.test = {  
-            init: function() { return { controlsDescendantBindings : true } }
-        };
-        testNode.innerHTML = "<div data-bind='test: true'></div>"
-        
-        ko.applyBindings(null, testNode);
-        // shouldn't throw any error
-    },
-    
-    'Binding can use both \'controlsDescendantBindings\' and \'contentBind\' with independent bindings': function() {
-        ko.bindingHandlers.test = {  
-            flags: ko.bindingFlags.contentBind,
-            init: function() { return { controlsDescendantBindings : true } }
-        };
-        testNode.innerHTML = "<div data-bind='test: true'></div>"
-        
-        ko.applyBindings(null, testNode, {independentBindings: true});
-        // shouldn't throw any error
-    },
-    
-    'Binding can use both \'controlsDescendantBindings\' and \'contentBind\' with standard bindings': function() {
-        ko.bindingHandlers.test = {  
-            flags: ko.bindingFlags.contentBind,
-            init: function() { return { controlsDescendantBindings : true } }
-        };
-        testNode.innerHTML = "<div data-bind='test: true'></div>"
-        
-        ko.applyBindings(null, testNode);
-        // shouldn't throw any error
-    },
-    
-    'Should use properties on the view model in preference to properties on the binding context': function() {
-        testNode.innerHTML = "<div data-bind='text: $data.someProp'></div>";
-        ko.applyBindings({ '$data': { someProp: 'Inner value'}, someProp: 'Outer value' }, testNode);
-        value_of(testNode).should_contain_text("Inner value");
-    },
-
-    'Should be able to extend a binding context, adding new custom properties, without mutating the original binding context': function() {
-        ko.bindingHandlers.addCustomProperty = {
-            flags: ko.bindingFlags.contentBind,
-            init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-                ko.applyBindingsToDescendants(bindingContext.extend({ '$customProp': 'my value' }), element);
+            testNode.innerHTML = "<div " + bindingAttribute + "='doesntRequireValue, dummy: false'></div><div " + bindingAttribute + "='doesntRequireValue: true, dummy: false'></div>";
+            ko.applyBindings(null, testNode);
+            value_of(initCalls).should_be(2);
+        },
+
+        'Should not be able to leave off the value if a binding doesn\'t specify the noValue flag': function () {
+            var initCalls = 0, didThrow = false;
+            ko.bindingHandlers.doesRequireValue = {
+                init: function (element, valueAccessor) { if (valueAccessor()) initCalls++; }
             }
-        };
-        testNode.innerHTML = "<div data-bind='with: sub'><div data-bind='addCustomProperty: true'><div data-bind='text: $customProp'></div></div></div>";
+            testNode.innerHTML = "<div " + bindingAttribute + "='doesRequireValue, dummy: false'></div><div " + bindingAttribute + "='doesRequireValue: true, dummy: false'></div>";
+
+            try { ko.applyBindings(null, testNode) }
+            catch (ex) { didThrow = true; value_of(ex.message).should_contain('Unable to parse bindings') }
+            value_of(didThrow).should_be(true);
+        },
+
+        'Bindings can signal that they control descendant bindings by setting contentBind flag': function () {
+            ko.bindingHandlers.test = {
+                flags: ko.bindingFlags.contentBind
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test: true'>"
+                           + "<div " + bindingAttribute + "='text: 123'>456</div>"
+                           + "</div>"
+                           + "<div " + bindingAttribute + "='text: 123'>456</div>";
+            ko.applyBindings(null, testNode);
+
+            value_of(testNode.childNodes[0].childNodes[0].innerHTML).should_be("456");
+            value_of(testNode.childNodes[1].innerHTML).should_be("123");
+        },
+
+        'Should not be allowed to have multiple bindings on the same element that claim to control descendant bindings': function () {
+            ko.bindingHandlers.test1 = {
+                flags: ko.bindingFlags.contentBind
+            };
+            ko.bindingHandlers.test2 = ko.bindingHandlers.test1;
+            testNode.innerHTML = "<div " + bindingAttribute + "='test1: true, test2: true'></div>"
+            var didThrow = false;
+
+            try { ko.applyBindings(null, testNode) }
+            catch (ex) { didThrow = true; value_of(ex.message).should_contain('Multiple bindings (test1 and test2) are trying to control descendant bindings of the same element.') }
+            value_of(didThrow).should_be(true);
+        },
+
+        'Binding should not be allowed to use \'controlsDescendantBindings\' style with independent bindings': function () {
+            ko.bindingHandlers.test = {
+                init: function () { return { controlsDescendantBindings: true} }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test: true'></div>"
+            var didThrow = false;
+
+            try { ko.applyBindings(null, testNode, { independentBindings: true }) }
+            catch (ex) { didThrow = true; value_of(ex.message).should_contain('contentBind flag') }
+            value_of(didThrow).should_be(true);
+        },
+
+        'Binding should be allowed to use \'controlsDescendantBindings\' with standard bindings': function () {
+            ko.bindingHandlers.test = {
+                init: function () { return { controlsDescendantBindings: true} }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test: true'></div>"
+
+            ko.applyBindings(null, testNode);
+            // shouldn't throw any error
+        },
+
+        'Binding can use both \'controlsDescendantBindings\' and \'contentBind\' with independent bindings': function () {
+            ko.bindingHandlers.test = {
+                flags: ko.bindingFlags.contentBind,
+                init: function () { return { controlsDescendantBindings: true} }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test: true'></div>"
+
+            ko.applyBindings(null, testNode, { independentBindings: true });
+            // shouldn't throw any error
+        },
+
+        'Binding can use both \'controlsDescendantBindings\' and \'contentBind\' with standard bindings': function () {
+            ko.bindingHandlers.test = {
+                flags: ko.bindingFlags.contentBind,
+                init: function () { return { controlsDescendantBindings: true} }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test: true'></div>"
+
+            ko.applyBindings(null, testNode);
+            // shouldn't throw any error
+        },
+
+        'Should use properties on the view model in preference to properties on the binding context': function () {
+            testNode.innerHTML = "<div " + bindingAttribute + "='text: $data.someProp'></div>";
+            ko.applyBindings({ '$data': { someProp: 'Inner value' }, someProp: 'Outer value' }, testNode);
+            value_of(testNode).should_contain_text("Inner value");
+        },
+
+        'Should be able to extend a binding context, adding new custom properties, without mutating the original binding context': function () {
+            ko.bindingHandlers.addCustomProperty = {
+                flags: ko.bindingFlags.contentBind,
+                init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+                    ko.applyBindingsToDescendants(bindingContext.extend({ '$customProp': 'my value' }), element);
+                }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='with: sub'><div " + bindingAttribute + "='addCustomProperty: true'><div " + bindingAttribute + "='text: $customProp'></div></div></div>";
         var vm = { sub: {} };
         ko.applyBindings(vm, testNode);
-        value_of(testNode).should_contain_text("my value");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0]).$customProp).should_be("my value");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[0]).$customProp).should_be(undefined); // Should not affect original binding context
+            value_of(testNode).should_contain_text("my value");
+            value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0]).$customProp).should_be("my value");
+            value_of(ko.contextFor(testNode.childNodes[0].childNodes[0]).$customProp).should_be(undefined); // Should not affect original binding context
 
         // vale of $data and $parent should be unchanged in extended context
         value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0]).$data).should_be(vm.sub);
         value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0]).$parent).should_be(vm);
-    },
+        },
 
-    'Binding contexts should inherit any custom properties from ancestor binding contexts': function() {
-        ko.bindingHandlers.addCustomProperty = {
-            flags: ko.bindingFlags.contentBind,
-            init: function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-                ko.applyBindingsToDescendants(bindingContext.extend({ '$customProp': 'my value' }), element);
+        'Binding contexts should inherit any custom properties from ancestor binding contexts': function () {
+            ko.bindingHandlers.addCustomProperty = {
+                flags: ko.bindingFlags.contentBind,
+                init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+                    ko.applyBindingsToDescendants(bindingContext.extend({ '$customProp': 'my value' }), element);
+                }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='addCustomProperty: true'><div " + bindingAttribute + "='with: true'><div " + bindingAttribute + "='text: $customProp'></div></div></div>";
+            ko.applyBindings(null, testNode);
+            value_of(testNode).should_contain_text("my value");
+        },
+
+        'Should be able to retrieve the binding context associated with any node': function () {
+            testNode.innerHTML = "<div><div " + bindingAttribute + "='text: name'></div></div>";
+            ko.applyBindings({ name: 'Bert' }, testNode.childNodes[0]);
+
+            value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Bert");
+
+            // Can't get binding context for unbound nodes
+            value_of(ko.dataFor(testNode)).should_be(undefined);
+            value_of(ko.contextFor(testNode)).should_be(undefined);
+
+            // Can get binding context for directly bound nodes
+            value_of(ko.dataFor(testNode.childNodes[0]).name).should_be("Bert");
+            value_of(ko.contextFor(testNode.childNodes[0]).$data.name).should_be("Bert");
+
+            // Can get binding context for descendants of directly bound nodes
+            value_of(ko.dataFor(testNode.childNodes[0].childNodes[0]).name).should_be("Bert");
+            value_of(ko.contextFor(testNode.childNodes[0].childNodes[0]).$data.name).should_be("Bert");
+        },
+
+        'Should not be allowed to use containerless binding syntax for bindings other than whitelisted ones': function () {
+            testNode.innerHTML = "Hello <!-- " + virtualElementTag + " visible: false -->Some text<!--  /" + virtualElementTag + "  --> Goodbye"
+            var didThrow = false;
+            try {
+                ko.applyBindings(null, testNode);
+            } catch (ex) {
+                didThrow = true;
+                value_of(ex.message).should_be("The binding 'visible' cannot be used with virtual elements");
             }
-        };
-        testNode.innerHTML = "<div data-bind='addCustomProperty: true'><div data-bind='with: true'><div data-bind='text: $customProp'></div></div></div>";
-        ko.applyBindings(null, testNode);
-        value_of(testNode).should_contain_text("my value");
-    },
-    
-    'Should be able to retrieve the binding context associated with any node': function() {
-        testNode.innerHTML = "<div><div data-bind='text: name'></div></div>";
-        ko.applyBindings({ name: 'Bert' }, testNode.childNodes[0]);
+            value_of(didThrow).should_be(true);
+        },
+
+        'Should be able to set a custom binding to use containerless binding using \'canUseVirtual\' flag': function () {
+            var initCalls = 0;
+            ko.bindingHandlers.test = {
+                flags: ko.bindingFlags.canUseVirtual,
+                init: function () { initCalls++; }
+            };
+            testNode.innerHTML = "Hello <!-- " + virtualElementTag + " test: false -->Some text<!--  /" + virtualElementTag + "  --> Goodbye"
+            ko.applyBindings(null, testNode);
 
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Bert");
+            value_of(initCalls).should_be(1);
+            value_of(testNode).should_contain_text("Hello Some text Goodbye");
+        },
 
-        // Can't get binding context for unbound nodes
-        value_of(ko.dataFor(testNode)).should_be(undefined);
-        value_of(ko.contextFor(testNode)).should_be(undefined);
+        'Should be able to set a custom binding to use containerless binding using \'allowedBindings\'': function () {
+            var initCalls = 0;
+            ko.bindingHandlers.test = { init: function () { initCalls++ } };
+            ko.virtualElements.allowedBindings['test'] = true;
 
-        // Can get binding context for directly bound nodes
-        value_of(ko.dataFor(testNode.childNodes[0]).name).should_be("Bert");
-        value_of(ko.contextFor(testNode.childNodes[0]).$data.name).should_be("Bert");
+            testNode.innerHTML = "Hello <!-- " + virtualElementTag + " test: false -->Some text<!--  /" + virtualElementTag + "  --> Goodbye"
+            ko.applyBindings(null, testNode);
 
-        // Can get binding context for descendants of directly bound nodes
-        value_of(ko.dataFor(testNode.childNodes[0].childNodes[0]).name).should_be("Bert");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[0]).$data.name).should_be("Bert");
-    },
-    
-    'Should not be allowed to use containerless binding syntax for bindings other than whitelisted ones': function() {
-        testNode.innerHTML = "Hello <!-- ko visible: false -->Some text<!-- /ko --> Goodbye"
-        var didThrow = false;
-        try {
+            value_of(initCalls).should_be(1);
+            value_of(testNode).should_contain_text("Hello Some text Goodbye");
+        },
+
+        'Should be able to access virtual children in custom containerless binding': function () {
+            var countNodes = 0;
+            ko.bindingHandlers.test = {
+                flags: ko.bindingFlags.canUseVirtual | ko.bindingFlags.contentUpdate,
+                init: function (element, valueAccessor) {
+                    // Counts the number of virtual children, and overwrites the text contents of any text nodes
+                    for (var node = ko.virtualElements.firstChild(element); node; node = ko.virtualElements.nextSibling(node)) {
+                        countNodes++;
+                        if (node.nodeType === 3)
+                            node.data = 'new text';
+                    }
+                }
+            };
+            testNode.innerHTML = "Hello <!-- " + virtualElementTag + " test: false -->Some text<!--  /" + virtualElementTag + "  --> Goodbye"
             ko.applyBindings(null, testNode);
-        } catch(ex) {
-            didThrow = true;
-            value_of(ex.message).should_be("The binding 'visible' cannot be used with virtual elements");
-        }
-        value_of(didThrow).should_be(true);
-    },
-    
-    'Should be able to set a custom binding to use containerless binding using \'canUseVirtual\' flag': function() {
-        var initCalls = 0;
-        ko.bindingHandlers.test = {
-            flags: ko.bindingFlags.canUseVirtual,
-            init: function () { initCalls++; }
-        };
-        testNode.innerHTML = "Hello <!-- ko test: false -->Some text<!-- /ko --> Goodbye"
-        ko.applyBindings(null, testNode);
-
-        value_of(initCalls).should_be(1);
-        value_of(testNode).should_contain_text("Hello Some text Goodbye");
-    },
-    
-    'Should be able to set a custom binding to use containerless binding using \'allowedBindings\'': function() {
-        var initCalls = 0;
-        ko.bindingHandlers.test = { init: function () { initCalls++ } };
-        ko.virtualElements.allowedBindings['test'] = true;
 
-        testNode.innerHTML = "Hello <!-- ko test: false -->Some text<!-- /ko --> Goodbye"
-        ko.applyBindings(null, testNode);
+            value_of(countNodes).should_be(1);
+            value_of(testNode).should_contain_text("Hello new text Goodbye");
+        },
+
+        'Should only bind containerless binding once inside template': function () {
+            var initCalls = 0;
+            ko.bindingHandlers.test = {
+                flags: ko.bindingFlags.canUseVirtual,
+                init: function () { initCalls++; }
+            };
+            testNode.innerHTML = "Hello <!-- if: true --><!-- " + virtualElementTag + " test: false -->Some text<!--  /" + virtualElementTag + "  --><!--  /" + virtualElementTag + "  --> Goodbye"
+            ko.applyBindings(null, testNode);
 
-        value_of(initCalls).should_be(1);
-        value_of(testNode).should_contain_text("Hello Some text Goodbye");
-    },
-    
-    'Should be able to access virtual children in custom containerless binding': function() {
-        var countNodes = 0;
-        ko.bindingHandlers.test = {
-            flags: ko.bindingFlags.canUseVirtual | ko.bindingFlags.contentUpdate,
-            init: function (element, valueAccessor) {
-                // Counts the number of virtual children, and overwrites the text contents of any text nodes
-                for (var node = ko.virtualElements.firstChild(element); node; node = ko.virtualElements.nextSibling(node)) {
-                    countNodes++;
-                    if (node.nodeType === 3)
-                        node.data = 'new text';
+            value_of(initCalls).should_be(1);
+            value_of(testNode).should_contain_text("Hello Some text Goodbye");
+        },
+
+        'Bindings in containerless binding in templates should be bound only once': function () {
+            delete ko.bindingHandlers.nonexistentHandler;
+            var initCalls = 0;
+            ko.bindingHandlers.test = { init: function () { initCalls++; } };
+            testNode.innerHTML = "<div " + bindingAttribute + "='template: {\"if\":true}'>xxx<!-- " + virtualElementTag + " nonexistentHandler: true --><span " + bindingAttribute + "='test: true'></span><!--  /" + virtualElementTag + "  --></div>";
+            ko.applyBindings({}, testNode);
+            value_of(initCalls).should_be(1);
+        },
+
+        'Should automatically bind virtual descendants of containerless markers if no binding controlsDescendantBindings': function () {
+            testNode.innerHTML = "Hello <!-- " + virtualElementTag + " dummy: false --><span " + bindingAttribute + "='text: \"WasBound\"'>Some text</span><!--  /" + virtualElementTag + "  --> Goodbye";
+            ko.applyBindings(null, testNode);
+            value_of(testNode).should_contain_text("Hello WasBound Goodbye");
+        },
+
+        'Should be able to set and access correct context in custom containerless binding': function () {
+            ko.bindingHandlers.bindChildrenWithCustomContext = {
+                flags: ko.bindingFlags.canUseVirtual | ko.bindingFlags.contentBind,
+                init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+                    var innerContext = bindingContext.createChildContext({ myCustomData: 123 });
+                ko.applyBindingsToDescendants(innerContext, element);
                 }
-            }
-        };
-        testNode.innerHTML = "Hello <!-- ko test: false -->Some text<!-- /ko --> Goodbye"
-        ko.applyBindings(null, testNode);
+            };
 
-        value_of(countNodes).should_be(1);
-        value_of(testNode).should_contain_text("Hello new text Goodbye");
-    },
-    
-    'Should only bind containerless binding once inside template': function() {
-        var initCalls = 0;
-        ko.bindingHandlers.test = {
-            flags: ko.bindingFlags.canUseVirtual,
-            init: function () { initCalls++; }
-        };
-        testNode.innerHTML = "Hello <!-- if: true --><!-- ko test: false -->Some text<!-- /ko --><!-- /ko --> Goodbye"
-        ko.applyBindings(null, testNode);
-
-        value_of(initCalls).should_be(1);
-        value_of(testNode).should_contain_text("Hello Some text Goodbye");
-    },
-
-    'Bindings in containerless binding in templates should be bound only once': function() {
-        delete ko.bindingHandlers.nonexistentHandler;
-        var initCalls = 0;
-        ko.bindingHandlers.test = { init: function () { initCalls++; } };
-        testNode.innerHTML = "<div data-bind='template: {\"if\":true}'>xxx<!-- ko nonexistentHandler: true --><span data-bind='test: true'></span><!-- /ko --></div>";
-        ko.applyBindings({}, testNode);
-        value_of(initCalls).should_be(1);
-    },
-
-    'Should automatically bind virtual descendants of containerless markers if no binding controlsDescendantBindings': function() {
-          testNode.innerHTML = "Hello <!-- ko dummy: false --><span data-bind='text: \"WasBound\"'>Some text</span><!-- /ko --> Goodbye";
-          ko.applyBindings(null, testNode);
-          value_of(testNode).should_contain_text("Hello WasBound Goodbye");
-    },
-    
-    'Should be able to set and access correct context in custom containerless binding': function() {
-        ko.bindingHandlers.bindChildrenWithCustomContext = {
-            flags: ko.bindingFlags.canUseVirtual | ko.bindingFlags.contentBind,
-            init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-                var innerContext = bindingContext.createChildContext({ myCustomData: 123 });
-                ko.applyBindingsToDescendants(innerContext, element);
-            }
-        };
+            testNode.innerHTML = "Hello <!-- " + virtualElementTag + " bindChildrenWithCustomContext: true --><div>Some text</div><!--  /" + virtualElementTag + "  --> Goodbye"
+            ko.applyBindings(null, testNode);
 
-        testNode.innerHTML = "Hello <!-- ko bindChildrenWithCustomContext: true --><div>Some text</div><!-- /ko --> Goodbye"
-        ko.applyBindings(null, testNode);
+            value_of(ko.dataFor(testNode.childNodes[2]).myCustomData).should_be(123);
+        },
 
-        value_of(ko.dataFor(testNode.childNodes[2]).myCustomData).should_be(123);
-    },
-    
-    'Should be able to set and access correct context in nested containerless binding': function() {
-        delete ko.bindingHandlers.nonexistentHandler;
-        ko.bindingHandlers.bindChildrenWithCustomContext = {
-            flags: ko.bindingFlags.contentBind,
-            init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-                var innerContext = bindingContext.createChildContext({ myCustomData: 123 });
+        'Should be able to set and access correct context in nested containerless binding': function () {
+            delete ko.bindingHandlers.nonexistentHandler;
+            ko.bindingHandlers.bindChildrenWithCustomContext = {
+                flags: ko.bindingFlags.contentBind,
+                init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+                    var innerContext = bindingContext.createChildContext({ myCustomData: 123 });
                 ko.applyBindingsToDescendants(innerContext, element);
-            }
-        };
+                }
+            };
 
-        testNode.innerHTML = "Hello <div data-bind='bindChildrenWithCustomContext: true'><!-- ko nonexistentHandler: 123 --><div>Some text</div><!-- /ko --></div> Goodbye"
-        ko.applyBindings(null, testNode);
+            testNode.innerHTML = "Hello <div " + bindingAttribute + "='bindChildrenWithCustomContext: true'><!-- " + virtualElementTag + " nonexistentHandler: 123 --><div>Some text</div><!--  /" + virtualElementTag + "  --></div> Goodbye"
+            ko.applyBindings(null, testNode);
 
-        value_of(ko.dataFor(testNode.childNodes[1].childNodes[0]).myCustomData).should_be(123);
-        value_of(ko.dataFor(testNode.childNodes[1].childNodes[1]).myCustomData).should_be(123);
-    },
-    
-    'Should be able to access custom context variables in child context': function() {
-        ko.bindingHandlers.bindChildrenWithCustomContext = {
-            flags: ko.bindingFlags.contentBind,
-            init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
-                var innerContext = bindingContext.createChildContext({ myCustomData: 123 });
-                innerContext.customValue = 'xyz';
+            value_of(ko.dataFor(testNode.childNodes[1].childNodes[0]).myCustomData).should_be(123);
+            value_of(ko.dataFor(testNode.childNodes[1].childNodes[1]).myCustomData).should_be(123);
+        },
+
+        'Should be able to access custom context variables in child context': function () {
+            ko.bindingHandlers.bindChildrenWithCustomContext = {
+                flags: ko.bindingFlags.contentBind,
+                init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
+                    var innerContext = bindingContext.createChildContext({ myCustomData: 123 });
+                    innerContext.customValue = 'xyz';
                 ko.applyBindingsToDescendants(innerContext, element);
-            }
-        };
+                }
+            };
 
-        testNode.innerHTML = "Hello <div data-bind='bindChildrenWithCustomContext: true'><!-- ko with: myCustomData --><div>Some text</div><!-- /ko --></div> Goodbye"
-        ko.applyBindings(null, testNode);
+            testNode.innerHTML = "Hello <div " + bindingAttribute + "='bindChildrenWithCustomContext: true'><!-- " + virtualElementTag + " with: myCustomData --><div>Some text</div><!--  /" + virtualElementTag + "  --></div> Goodbye"
+            ko.applyBindings(null, testNode);
 
-        value_of(ko.contextFor(testNode.childNodes[1].childNodes[0]).customValue).should_be('xyz');
-        value_of(ko.dataFor(testNode.childNodes[1].childNodes[1])).should_be(123);
-        value_of(ko.contextFor(testNode.childNodes[1].childNodes[1]).$parent.myCustomData).should_be(123);
-        value_of(ko.contextFor(testNode.childNodes[1].childNodes[1]).$parentContext.customValue).should_be('xyz');
-    },
-    
-    'Should not reinvoke init for notifications triggered during first evaluation': function () {
-        var observable = ko.observable('A');
-        var initCalls = 0;
-        ko.bindingHandlers.test = {
-            init: function (element, valueAccessor) {
-                initCalls++;
-
-                var value = valueAccessor();
-                
-                // Read the observable (to set up a dependency on it), and then also write to it (to trigger re-eval of bindings)
-                // This logic probably wouldn't be in init but might be indirectly invoked by init
-                value();
-                value('B');
-            }
-        };
-        testNode.innerHTML = "<div data-bind='test: myObservable'></div>";
-
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(initCalls).should_be(1);
-    },
-
-    'Should not run update before init, even if an associated observable is updated by a different binding before init': function() {
-        // Represents the "theoretical issue" posed by Ryan in comments on https://github.com/SteveSanderson/knockout/pull/193
-
-        var observable = ko.observable('A'), hasInittedSecondBinding = false, hasUpdatedSecondBinding = false;
-        ko.bindingHandlers.test1 = {
-            init: function(element, valueAccessor) {
-                // Read the observable (to set up a dependency on it), and then also write to it (to trigger re-eval of bindings)
-                // This logic probably wouldn't be in init but might be indirectly invoked by init
-                var value = valueAccessor();
-                value();
-                value('B');                   
-            }
-        }
-        ko.bindingHandlers.test2 = {
-            init: function() {
-                hasInittedSecondBinding = true;
-            },
-            update: function() {
-                if (!hasInittedSecondBinding)
-                    throw new Error("Called 'update' before 'init'");
-                hasUpdatedSecondBinding = true;
-            }
-        }
-        testNode.innerHTML = "<div data-bind='test1: myObservable, test2: true'></div>";
-
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(hasUpdatedSecondBinding).should_be(true);
-    },
-
-    'Should not subscribe to observables accessed in init function if binding are run independently': function() {
-        var observable = ko.observable('A');
-        ko.bindingHandlers.test = {
-            init: function(element, valueAccessor) {
-                var value = valueAccessor();
-                value();
-            }
-        }
-        testNode.innerHTML = "<div data-bind='if: true'><div data-bind='test: myObservable'></div></div>";
-
-        ko.applyBindings({ myObservable: observable }, testNode, {independentBindings: true});
-        value_of(observable.getSubscriptionsCount()).should_be(0);
-    },
-
-    'Should not run updates for all bindings if only one needs to run if binding are run independently': function() {
-        var observable = ko.observable('A'), updateCount1 = 0, updateCount2 = 0;
-        ko.bindingHandlers.test1 = {
-            update: function(element, valueAccessor) {
-                valueAccessor()();  // access value to create a subscription
-                updateCount1++;
-            }
-        };
-        ko.bindingHandlers.test2 = {
-            update: function() {
-                updateCount2++;
+            value_of(ko.contextFor(testNode.childNodes[1].childNodes[0]).customValue).should_be('xyz');
+            value_of(ko.dataFor(testNode.childNodes[1].childNodes[1])).should_be(123);
+            value_of(ko.contextFor(testNode.childNodes[1].childNodes[1]).$parent.myCustomData).should_be(123);
+            value_of(ko.contextFor(testNode.childNodes[1].childNodes[1]).$parentContext.customValue).should_be('xyz');
+        },
+
+        'Should not reinvoke init for notifications triggered during first evaluation': function () {
+            var observable = ko.observable('A');
+            var initCalls = 0;
+            ko.bindingHandlers.test = {
+                init: function (element, valueAccessor) {
+                    initCalls++;
+
+                    var value = valueAccessor();
+
+                    // Read the observable (to set up a dependency on it), and then also write to it (to trigger re-eval of bindings)
+                    // This logic probably wouldn't be in init but might be indirectly invoked by init
+                    value();
+                    value('B');
+                }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test: myObservable'></div>";
+
+            ko.applyBindings({ myObservable: observable }, testNode);
+            value_of(initCalls).should_be(1);
+        },
+
+        'Should not run update before init, even if an associated observable is updated by a different binding before init': function () {
+            // Represents the "theoretical issue" posed by Ryan in comments on https://github.com/SteveSanderson/knockout/pull/193
+
+            var observable = ko.observable('A'), hasInittedSecondBinding = false, hasUpdatedSecondBinding = false;
+            ko.bindingHandlers.test1 = {
+                init: function (element, valueAccessor) {
+                    // Read the observable (to set up a dependency on it), and then also write to it (to trigger re-eval of bindings)
+                    // This logic probably wouldn't be in init but might be indirectly invoked by init
+                    var value = valueAccessor();
+                    value();
+                    value('B');
+                }
             }
-        };
-        testNode.innerHTML = "<div data-bind='test1: myObservable, test2: true'></div>";
-
-        ko.applyBindings({ myObservable: observable }, testNode, {independentBindings: true});
-        value_of(updateCount1).should_be(1);
-        value_of(updateCount2).should_be(1);
-
-        // update the observable and check that only the first binding was updated
-        observable('B');
-        value_of(updateCount1).should_be(2);
-        value_of(updateCount2).should_be(1);
-    },
-
-    'Update to a dependency should also update the dependent binding (independent mode)': function() {
-        var observable = ko.observable('A'), updateCount1 = 0, updateCount2 = 0;
-        ko.bindingHandlers.test1 = {
-            update: function(element, valueAccessor) {
-                valueAccessor()();  // access value to create a subscription
-                updateCount1++;
+            ko.bindingHandlers.test2 = {
+                init: function () {
+                    hasInittedSecondBinding = true;
+                },
+                update: function () {
+                    if (!hasInittedSecondBinding)
+                        throw new Error("Called 'update' before 'init'");
+                    hasUpdatedSecondBinding = true;
+                }
             }
-        };
-        ko.bindingHandlers.test2 = {
-            dependencies: 'test1',
-            update: function() {
-                updateCount2++;
+            testNode.innerHTML = "<div " + bindingAttribute + "='test1: myObservable, test2: true'></div>";
+
+            ko.applyBindings({ myObservable: observable }, testNode);
+            value_of(hasUpdatedSecondBinding).should_be(true);
+        },
+
+        'Should not subscribe to observables accessed in init function if binding are run independently': function () {
+            var observable = ko.observable('A');
+            ko.bindingHandlers.test = {
+                init: function (element, valueAccessor) {
+                    var value = valueAccessor();
+                    value();
+                }
             }
-        };
-        testNode.innerHTML = "<div data-bind='test1: myObservable, test2: true'></div>";
-
-        ko.applyBindings({ myObservable: observable }, testNode, {independentBindings: true});
-        value_of(updateCount1).should_be(1);
-        value_of(updateCount2).should_be(1);
-
-        // update the observable and check that both bindings were updated
-        observable('B');
-        value_of(updateCount1).should_be(2);
-        value_of(updateCount2).should_be(2);
-    },
-
-    'Binding should be able to return a subscribable value so dependent bindings can be updated (independent mode)': function() {
-        var observable = ko.observable('A'), updateCount1 = 0, updateCount2 = 0;
-        ko.bindingHandlers.test1 = {
-            update: function(element, valueAccessor) {
-                updateCount1++;
-                return ko.dependentObservable(function() {
+            testNode.innerHTML = "<div " + bindingAttribute + "='if: true'><div " + bindingAttribute + "='test: myObservable'></div></div>";
+
+            ko.applyBindings({ myObservable: observable }, testNode, { independentBindings: true });
+            value_of(observable.getSubscriptionsCount()).should_be(0);
+        },
+
+        'Should not run updates for all bindings if only one needs to run if binding are run independently': function () {
+            var observable = ko.observable('A'), updateCount1 = 0, updateCount2 = 0;
+            ko.bindingHandlers.test1 = {
+                update: function (element, valueAccessor) {
                     valueAccessor()();  // access value to create a subscription
-                }, null, {disposeWhenNodeIsRemoved: element});
-            }
-        };
-        ko.bindingHandlers.test2 = {
-            dependencies: 'test1',
-            update: function() {
-                updateCount2++;
-            }
-        };
-        testNode.innerHTML = "<div data-bind='test1: myObservable, test2: true'></div>";
-
-        ko.applyBindings({ myObservable: observable }, testNode, {independentBindings: true});
-        observable('B');
-        value_of(updateCount1).should_be(1);    // update happened inside inner dependentObservable so count isn't updated
-        value_of(updateCount2).should_be(2);
-    },
-
-    'Binding should be able to return a subscribable value from \'init\' so dependent bindings can be updated (independent mode)': function() {
-        var observable = ko.observable('A'), updateCount1 = 0, updateCount2 = 0;
-        ko.bindingHandlers.test1 = {
-            init: function(element, valueAccessor) {
-                return { subscribable: ko.dependentObservable(function() {
                     updateCount1++;
+                }
+            };
+            ko.bindingHandlers.test2 = {
+                update: function () {
+                    updateCount2++;
+                }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test1: myObservable, test2: true'></div>";
+
+            ko.applyBindings({ myObservable: observable }, testNode, { independentBindings: true });
+            value_of(updateCount1).should_be(1);
+            value_of(updateCount2).should_be(1);
+
+            // update the observable and check that only the first binding was updated
+            observable('B');
+            value_of(updateCount1).should_be(2);
+            value_of(updateCount2).should_be(1);
+        },
+
+        'Update to a dependency should also update the dependent binding (independent mode)': function () {
+            var observable = ko.observable('A'), updateCount1 = 0, updateCount2 = 0;
+            ko.bindingHandlers.test1 = {
+                update: function (element, valueAccessor) {
                     valueAccessor()();  // access value to create a subscription
-                }, null, {disposeWhenNodeIsRemoved: element}) };
-            }
-        };
-        ko.bindingHandlers.test2 = {
-            dependencies: 'test1',
-            update: function() {
-                updateCount2++;
+                    updateCount1++;
+                }
+            };
+            ko.bindingHandlers.test2 = {
+                dependencies: 'test1',
+                update: function () {
+                    updateCount2++;
+                }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test1: myObservable, test2: true'></div>";
+
+            ko.applyBindings({ myObservable: observable }, testNode, { independentBindings: true });
+            value_of(updateCount1).should_be(1);
+            value_of(updateCount2).should_be(1);
+
+            // update the observable and check that both bindings were updated
+            observable('B');
+            value_of(updateCount1).should_be(2);
+            value_of(updateCount2).should_be(2);
+        },
+
+        'Binding should be able to return a subscribable value so dependent bindings can be updated (independent mode)': function () {
+            var observable = ko.observable('A'), updateCount1 = 0, updateCount2 = 0;
+            ko.bindingHandlers.test1 = {
+                update: function (element, valueAccessor) {
+                    updateCount1++;
+                    return ko.dependentObservable(function () {
+                        valueAccessor()();  // access value to create a subscription
+                    }, null, { disposeWhenNodeIsRemoved: element });
+                }
+            };
+            ko.bindingHandlers.test2 = {
+                dependencies: 'test1',
+                update: function () {
+                    updateCount2++;
+                }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test1: myObservable, test2: true'></div>";
+
+            ko.applyBindings({ myObservable: observable }, testNode, { independentBindings: true });
+            observable('B');
+            value_of(updateCount1).should_be(1);    // update happened inside inner dependentObservable so count isn't updated
+            value_of(updateCount2).should_be(2);
+        },
+
+        'Binding should be able to return a subscribable value from \'init\' so dependent bindings can be updated (independent mode)': function () {
+            var observable = ko.observable('A'), updateCount1 = 0, updateCount2 = 0;
+            ko.bindingHandlers.test1 = {
+                init: function (element, valueAccessor) {
+                    return { subscribable: ko.dependentObservable(function () {
+                        updateCount1++;
+                        valueAccessor()();  // access value to create a subscription
+                    }, null, { disposeWhenNodeIsRemoved: element })
+                    };
+                }
+            };
+            ko.bindingHandlers.test2 = {
+                dependencies: 'test1',
+                update: function () {
+                    updateCount2++;
+                }
+            };
+            testNode.innerHTML = "<div " + bindingAttribute + "='test1: myObservable, test2: true'></div>";
+
+            ko.applyBindings({ myObservable: observable }, testNode, { independentBindings: true });
+            observable('B');
+            value_of(updateCount1).should_be(2);
+            value_of(updateCount2).should_be(2);
+        },
+
+        'Should update all bindings if a extra binding unwraps an observable (only in dependent mode)': function () {
+            delete ko.bindingHandlers.nonexistentHandler;
+            var countUpdates = 0, observable = ko.observable(1);
+            ko.bindingHandlers.existentHandler = {
+                update: function () { countUpdates++; }
             }
-        };
-        testNode.innerHTML = "<div data-bind='test1: myObservable, test2: true'></div>";
-
-        ko.applyBindings({ myObservable: observable }, testNode, {independentBindings: true});
-        observable('B');
-        value_of(updateCount1).should_be(2);
-        value_of(updateCount2).should_be(2);
-    },
-
-    'Should update all bindings if a extra binding unwraps an observable (only in dependent mode)': function() {
-        delete ko.bindingHandlers.nonexistentHandler;
-        var countUpdates = 0, observable = ko.observable(1);
-        ko.bindingHandlers.existentHandler = {
-            update: function() { countUpdates++; }
-        }
-        testNode.innerHTML = "<div data-bind='existentHandler: true, nonexistentHandler: myObservable()'></div>";
-
-        // dependent mode: should update
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(countUpdates).should_be(1);
-        observable(3);
-        value_of(countUpdates).should_be(2);
-
-        // reset
-        countUpdates = 0;
-        ko.cleanNode(testNode);
-        ko.bindingProvider.instance.clearCache();
-
-        // independent mode: should not update
-        ko.applyBindings({ myObservable: observable }, testNode, {independentBindings: true});
-        value_of(countUpdates).should_be(1);
-        observable(2);
-        value_of(countUpdates).should_be(1);
-    },
-
-    // TODO - This is a spec that succeeds in base Knockout, but fails with this update
-    /*'Should access latest value from extra binding when normal binding is updated': function() {
+            testNode.innerHTML = "<div " + bindingAttribute + "='existentHandler: true, nonexistentHandler: myObservable()'></div>";
+
+            // dependent mode: should update
+            ko.applyBindings({ myObservable: observable }, testNode);
+            value_of(countUpdates).should_be(1);
+            observable(3);
+            value_of(countUpdates).should_be(2);
+
+            // reset
+            countUpdates = 0;
+            ko.cleanNode(testNode);
+            ko.bindingProvider.instance.clearCache();
+
+            // independent mode: should not update
+            ko.applyBindings({ myObservable: observable }, testNode, { independentBindings: true });
+            value_of(countUpdates).should_be(1);
+            observable(2);
+            value_of(countUpdates).should_be(1);
+        },
+
+        // TODO - This is a spec that succeeds in base Knockout, but fails with this update
+        /*'Should access latest value from extra binding when normal binding is updated': function() {
         delete ko.bindingHandlers.nonexistentHandler;
         var observable = ko.observable(), updateValue;
         var vm = {myObservable: observable, myNonObservable: "first value"};
         ko.bindingHandlers.existentHandler = {
-            update: function(element, valueAccessor, allBindingsAccessor) {
-                valueAccessor()();  // create dependency
-                updateValue = allBindingsAccessor().nonexistentHandler;
-            }
+        update: function(element, valueAccessor, allBindingsAccessor) {
+        valueAccessor()();  // create dependency
+        updateValue = allBindingsAccessor().nonexistentHandler;
+        }
         }
-        testNode.innerHTML = "<div data-bind='existentHandler: myObservable, nonexistentHandler: myNonObservable'></div>";
+        testNode.innerHTML = "<div " + bindingAttribute + "='existentHandler: myObservable, nonexistentHandler: myNonObservable'></div>";
 
         ko.applyBindings(vm, testNode);
         value_of(updateValue).should_be("first value");
         vm.myNonObservable = "second value";
         observable.notifySubscribers();
         value_of(updateValue).should_be("second value");
-    },*/
-
-    'Should process bindings in a certain order based on their type and dependencies': function() {
-        var lastBindingIndex = 0;
-        function checkOrder(bindingIndex) {
-            if (bindingIndex < lastBindingIndex)
-                throw new Error("handler " + bindingIndex + " called after " + lastBindingIndex);
-            lastBindingIndex = bindingIndex; 
-        }
-        ko.bindingHandlers.test1 = { flags: 0, update: function() { checkOrder(1); } };
-        ko.bindingHandlers.test2 = { flags: ko.bindingFlags.contentSet, update: function() { checkOrder(2); } };
-        ko.bindingHandlers.test3 = { flags: ko.bindingFlags.contentBind, update: function() { checkOrder(3); } };
-        ko.bindingHandlers.test4 = { flags: ko.bindingFlags.contentUpdate, update: function() { checkOrder(4); } };
-        ko.bindingHandlers.test5 = { update: function() { checkOrder(5); } };
+        },*/
+
+        'Should process bindings in a certain order based on their type and dependencies': function () {
+            var lastBindingIndex = 0;
+            function checkOrder(bindingIndex) {
+                if (bindingIndex < lastBindingIndex)
+                    throw new Error("handler " + bindingIndex + " called after " + lastBindingIndex);
+                lastBindingIndex = bindingIndex;
+            }
+            ko.bindingHandlers.test1 = { flags: 0, update: function () { checkOrder(1); } };
+            ko.bindingHandlers.test2 = { flags: ko.bindingFlags.contentSet, update: function () { checkOrder(2); } };
+            ko.bindingHandlers.test3 = { flags: ko.bindingFlags.contentBind, update: function () { checkOrder(3); } };
+            ko.bindingHandlers.test4 = { flags: ko.bindingFlags.contentUpdate, update: function () { checkOrder(4); } };
+            ko.bindingHandlers.test5 = { update: function () { checkOrder(5); } };
 
-        testNode.innerHTML = "<div data-bind='test5: true, test4: true, test3: true, test2: true, test1: true, dependencies: {test2: \"test1\", test5: \"test4\"}'></div>";
+            testNode.innerHTML = "<div " + bindingAttribute + "='test5: true, test4: true, test3: true, test2: true, test1: true, dependencies: {test2: \"test1\", test5: \"test4\"}'></div>";
 
-        ko.applyBindings(null, testNode);
-    },
-    
-    'Should not be able to set recursive dependencies': function() {
-        ko.bindingHandlers.test1 = { };
-        ko.bindingHandlers.test2 = { };
-
-        testNode.innerHTML = "<div data-bind='test1: true, test2: true, dependencies: {test2: \"test1\", test1: \"test2\"}'></div>";
-
-        var didThrow = false;
-        try { ko.applyBindings(null, testNode) }
-        catch(ex) { didThrow = true; value_of(ex.message).should_contain('recursive') }
-        value_of(didThrow).should_be(true);
-    },
-
-    'Should not be able to set dependencies that conflict with the order set by flags': function() {
-        ko.bindingHandlers.test1 = { flags: ko.bindingFlags.contentSet };
-        ko.bindingHandlers.test2 = { flags: ko.bindingFlags.contentUpdate };
-
-        testNode.innerHTML = "<div data-bind='test1: true, test2: true, dependencies: {test1: \"test2\"}'></div>";
-
-        var didThrow = false;
-        try { ko.applyBindings(null, testNode) }
-        catch(ex) { didThrow = true; value_of(ex.message).should_contain('ordering') }
-        value_of(didThrow).should_be(true);
-    },
-
-    'Changing type of binding handler won\'t clear binding cache, but cache can be cleared by calling clearCache': function() {
-        var vm = ko.observable(1), updateCalls = 0, didThrow = false;
-        ko.bindingHandlers.sometimesRequiresValue = { 
-            flags: ko.bindingFlags.noValue,
-            update: function() { updateCalls++; }
+            ko.applyBindings(null, testNode);
+        },
+
+        'Should not be able to set recursive dependencies': function () {
+            ko.bindingHandlers.test1 = {};
+            ko.bindingHandlers.test2 = {};
+
+            testNode.innerHTML = "<div " + bindingAttribute + "='test1: true, test2: true, dependencies: {test2: \"test1\", test1: \"test2\"}'></div>";
+
+            var didThrow = false;
+            try { ko.applyBindings(null, testNode) }
+            catch (ex) { didThrow = true; value_of(ex.message).should_contain('recursive') }
+            value_of(didThrow).should_be(true);
+        },
+
+        'Should not be able to set dependencies that conflict with the order set by flags': function () {
+            ko.bindingHandlers.test1 = { flags: ko.bindingFlags.contentSet };
+            ko.bindingHandlers.test2 = { flags: ko.bindingFlags.contentUpdate };
+
+            testNode.innerHTML = "<div " + bindingAttribute + "='test1: true, test2: true, dependencies: {test1: \"test2\"}'></div>";
+
+            var didThrow = false;
+            try { ko.applyBindings(null, testNode) }
+            catch (ex) { didThrow = true; value_of(ex.message).should_contain('ordering') }
+            value_of(didThrow).should_be(true);
+        },
+
+        'Changing type of binding handler won\'t clear binding cache, but cache can be cleared by calling clearCache': function () {
+            var vm = ko.observable(1), updateCalls = 0, didThrow = false;
+            ko.bindingHandlers.sometimesRequiresValue = {
+                flags: ko.bindingFlags.noValue,
+                update: function () { updateCalls++; }
+            }
+            testNode.innerHTML = "<div " + bindingAttribute + "='sometimesRequiresValue'></div>";
+            // first time works fine
+            ko.applyBindings(vm, testNode);
+            value_of(updateCalls).should_be(1);
+
+            // change type of handler; it will still work because of cache
+            delete ko.bindingHandlers.sometimesRequiresValue.flags;
+            vm(2);      // forces reparsing of binding values (but cache will kick in)
+            value_of(updateCalls).should_be(2);
+
+            // now clear the cache; reparsing will fail
+            ko.bindingProvider.instance.clearCache();
+            try { vm(3); }
+            catch (ex) { didThrow = true; value_of(ex.message).should_contain('Unable to parse bindings') }
+            value_of(didThrow).should_be(true);
+            value_of(updateCalls).should_be(2);
         }
-        testNode.innerHTML = "<div data-bind='sometimesRequiresValue'></div>";
-        // first time works fine
-        ko.applyBindings(vm, testNode);
-        value_of(updateCalls).should_be(1);
-        
-        // change type of handler; it will still work because of cache
-        delete ko.bindingHandlers.sometimesRequiresValue.flags;
-        vm(2);      // forces reparsing of binding values (but cache will kick in)
-        value_of(updateCalls).should_be(2);
-
-        // now clear the cache; reparsing will fail
-        ko.bindingProvider.instance.clearCache();
-        try { vm(3); }
-        catch(ex) { didThrow = true; value_of(ex.message).should_contain('Unable to parse bindings') }
-        value_of(didThrow).should_be(true);
-        value_of(updateCalls).should_be(2);
-    }
-});
\ No newline at end of file
+    });
+
+};
+
+bindingAttributeBehaviors({ name: "alternativeConfiguration", virtualElementTag: "ko1", bindingAttribute: "data-bind1" });
+bindingAttributeBehaviors();
+
diff --git a/spec/defaultBindingsBehaviors.js b/spec/defaultBindingsBehaviors.js
index 8b9f3f306..0f3f5666c 100755
--- a/spec/defaultBindingsBehaviors.js
+++ b/spec/defaultBindingsBehaviors.js
@@ -1,463 +1,479 @@
-function prepareTestNode() {
-    var existingNode = document.getElementById("testNode");
-    if (existingNode != null)
-        existingNode.parentNode.removeChild(existingNode);
-    testNode = document.createElement("div");
-    testNode.id = "testNode";
-    document.body.appendChild(testNode);
-}
-
-function getSelectedValuesFromSelectNode(selectNode) {
-    var selectedNodes = ko.utils.arrayFilter(selectNode.childNodes, function (node) { return node.selected; });
-    return ko.utils.arrayMap(selectedNodes, function (node) { return ko.selectExtensions.readValue(node); });
-}
-
-describe('Binding: Enable/Disable', {
-    before_each: prepareTestNode,
-
-    'Enable means the node is enabled only when the value is true': function () {
-        var observable = new ko.observable();
-        testNode.innerHTML = "<input data-bind='enable:myModelProperty()' />";
-        ko.applyBindings({ myModelProperty: observable }, testNode);
-
-        value_of(testNode.childNodes[0].disabled).should_be(true);
-        observable(1);
-        value_of(testNode.childNodes[0].disabled).should_be(false);
-    },
+var defaultBindingsBehaviors =
+    function (testConfiguration) {
+        var existingBindingProvider = ko.bindingProvider.instance;
+        var myConfiguration = testConfiguration;
+        var bindingAttribute;
+
+
+        function prepareTestNode() {
+            var existingNode = document.getElementById("testNode");
+            if (existingNode != null)
+                existingNode.parentNode.removeChild(existingNode);
+            testNode = document.createElement("div");
+            testNode.id = "testNode";
+            document.body.appendChild(testNode);
+            ko.bindingProvider["instance"] = new ko.bindingProvider(myConfiguration);
+            virtualElementTag = ko.bindingProvider["instance"].configuration.virtualElementTag;
+            bindingAttribute = ko.bindingProvider["instance"].configuration.bindingAttribute;
+                        
 
-    'Disable means the node is enabled only when the value is false': function () {
-        var observable = new ko.observable();
-        testNode.innerHTML = "<input data-bind='disable:myModelProperty()' />";
-        ko.applyBindings({ myModelProperty: observable }, testNode);
+        }
 
-        value_of(testNode.childNodes[0].disabled).should_be(false);
-        observable(1);
-        value_of(testNode.childNodes[0].disabled).should_be(true);
-    },
+        function restore() {
+            ko.bindingProvider.instance = existingBindingProvider;
+        }
 
-    'Enable should unwrap observables implicitly': function () {
-        var observable = new ko.observable(false);
-        testNode.innerHTML = "<input data-bind='enable:myModelProperty' />";
-        ko.applyBindings({ myModelProperty: observable }, testNode);
-        value_of(testNode.childNodes[0].disabled).should_be(true);
-    },
+        function getSelectedValuesFromSelectNode(selectNode) {
+            var selectedNodes = ko.utils.arrayFilter(selectNode.childNodes, function (node) { return node.selected; });
+            return ko.utils.arrayMap(selectedNodes, function (node) { return ko.selectExtensions.readValue(node); });
+        }
 
-    'Disable should unwrap observables implicitly': function () {
-        var observable = new ko.observable(false);
-        testNode.innerHTML = "<input data-bind='disable:myModelProperty' />";
-        ko.applyBindings({ myModelProperty: observable }, testNode);
-        value_of(testNode.childNodes[0].disabled).should_be(false);
-    }
-});
+        describe('Binding: Enable/Disable ' + (myConfiguration ? myConfiguration.name : "default provider settings"), {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Enable means the node is enabled only when the value is true': function () {
+                var observable = new ko.observable();
+                testNode.innerHTML = "<input " + bindingAttribute + "='enable:myModelProperty()' />";
+                ko.applyBindings({ myModelProperty: observable }, testNode);
+
+                value_of(testNode.childNodes[0].disabled).should_be(true);
+                observable(1);
+                value_of(testNode.childNodes[0].disabled).should_be(false);
+            },
 
-describe('Binding: Visible', {
-    before_each: prepareTestNode,
+            'Disable means the node is enabled only when the value is false': function () {
+                var observable = new ko.observable();
+                testNode.innerHTML = "<input " + bindingAttribute + "='disable:myModelProperty()' />";
+                ko.applyBindings({ myModelProperty: observable }, testNode);
 
-    'Should display the node only when the value is true': function () {
-        var observable = new ko.observable(false);
-        testNode.innerHTML = "<input data-bind='visible:myModelProperty()' />";
-        ko.applyBindings({ myModelProperty: observable }, testNode);
+                value_of(testNode.childNodes[0].disabled).should_be(false);
+                observable(1);
+                value_of(testNode.childNodes[0].disabled).should_be(true);
+            },
 
-        value_of(testNode.childNodes[0].style.display).should_be("none");
-        observable(true);
-        value_of(testNode.childNodes[0].style.display).should_be("");
-    },
+            'Enable should unwrap observables implicitly': function () {
+                var observable = new ko.observable(false);
+                testNode.innerHTML = "<input " + bindingAttribute + "='enable:myModelProperty' />";
+                ko.applyBindings({ myModelProperty: observable }, testNode);
+                value_of(testNode.childNodes[0].disabled).should_be(true);
+            },
 
-    'Should unwrap observables implicitly': function () {
-        var observable = new ko.observable(false);
-        testNode.innerHTML = "<input data-bind='visible:myModelProperty' />";
-        ko.applyBindings({ myModelProperty: observable }, testNode);
-        value_of(testNode.childNodes[0].style.display).should_be("none");
-    }
-});
+            'Disable should unwrap observables implicitly': function () {
+                var observable = new ko.observable(false);
+                testNode.innerHTML = "<input " + bindingAttribute + "='disable:myModelProperty' />";
+                ko.applyBindings({ myModelProperty: observable }, testNode);
+                value_of(testNode.childNodes[0].disabled).should_be(false);
+            }
+        });
 
-describe('Binding: Text', {
-    before_each: prepareTestNode,
+        describe('Binding: Visible', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should display the node only when the value is true': function () {
+                var observable = new ko.observable(false);
+                testNode.innerHTML = "<input " + bindingAttribute + "='visible:myModelProperty()' />";
+                ko.applyBindings({ myModelProperty: observable }, testNode);
+
+                value_of(testNode.childNodes[0].style.display).should_be("none");
+                observable(true);
+                value_of(testNode.childNodes[0].style.display).should_be("");
+            },
 
-    'Should assign the value to the node, HTML-encoding the value': function () {    	
-        var model = { textProp: "'Val <with> \"special\" <i>characters</i>'" };
-        testNode.innerHTML = "<span data-bind='text:textProp'></span>";
-        ko.applyBindings(model, testNode);
-        value_of(testNode.childNodes[0].textContent || testNode.childNodes[0].innerText).should_be(model.textProp);
-    },
+            'Should unwrap observables implicitly': function () {
+                var observable = new ko.observable(false);
+                testNode.innerHTML = "<input " + bindingAttribute + "='visible:myModelProperty' />";
+                ko.applyBindings({ myModelProperty: observable }, testNode);
+                value_of(testNode.childNodes[0].style.display).should_be("none");
+            }
+        });
 
-    'Should assign an empty string as value if the model value is null': function () {
-        testNode.innerHTML = "<span data-bind='text:(null)' ></span>";
-        ko.applyBindings(null, testNode);
-        var actualText = "textContent" in testNode.childNodes[0] ? testNode.childNodes[0].textContent : testNode.childNodes[0].innerText;
-        value_of(actualText).should_be("");
-    },
-    
-    'Should assign an empty string as value if the model value is undefined': function () {
-        testNode.innerHTML = "<span data-bind='text:undefined' ></span>";
-        ko.applyBindings(null, testNode);
-        var actualText = "textContent" in testNode.childNodes[0] ? testNode.childNodes[0].textContent : testNode.childNodes[0].innerText;
-        value_of(actualText).should_be("");
-    },
-	    	
-    'Should work with virtual elements, adding a text node between the comments': function () {
-        var observable = ko.observable("Some text");
-        testNode.innerHTML = "xxx <!-- ko text: textProp --><!-- /ko -->";
-        ko.applyBindings({textProp: observable}, testNode);
-        value_of(testNode).should_contain_text("xxx Some text");
-        value_of(testNode).should_contain_html("xxx <!-- ko text: textprop -->some text<!-- /ko -->");
-
-        // update observable; should update text
-        observable("New text");
-        value_of(testNode).should_contain_text("xxx New text");
-        value_of(testNode).should_contain_html("xxx <!-- ko text: textprop -->new text<!-- /ko -->");
-
-        // clear observable; should remove text
-        observable(undefined);
-        value_of(testNode).should_contain_text("xxx ");
-        value_of(testNode).should_contain_html("xxx <!-- ko text: textprop --><!-- /ko -->");
-    },
+        describe('Binding: Text', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should assign the value to the node, HTML-encoding the value': function () {
+                var model = { textProp: "'Val <with> \"special\" <i>characters</i>'" };
+                testNode.innerHTML = "<span " + bindingAttribute + "='text:textProp'></span>";
+                ko.applyBindings(model, testNode);
+                value_of(testNode.childNodes[0].textContent || testNode.childNodes[0].innerText).should_be(model.textProp);
+            },
 
-    'Should work with virtual elements, removing any existing stuff between the comments': function () {
-        testNode.innerHTML = "xxx <!--ko text: undefined-->some random thing<span> that won't be here later</span><!--/ko-->";
-        ko.applyBindings(null, testNode);
-        value_of(testNode).should_contain_text("xxx ");
-        value_of(testNode).should_contain_html("xxx <!--ko text: undefined--><!--/ko-->");
-    }
-});
+            'Should assign an empty string as value if the model value is null': function () {
+                testNode.innerHTML = "<span " + bindingAttribute + "='text:(null)' ></span>";
+                ko.applyBindings(null, testNode);
+                var actualText = "textContent" in testNode.childNodes[0] ? testNode.childNodes[0].textContent : testNode.childNodes[0].innerText;
+                value_of(actualText).should_be("");
+            },
 
-describe('Binding: HTML', {
-    before_each: prepareTestNode,
+            'Should assign an empty string as value if the model value is undefined': function () {
+                testNode.innerHTML = "<span " + bindingAttribute + "='text:undefined' ></span>";
+                ko.applyBindings(null, testNode);
+                var actualText = "textContent" in testNode.childNodes[0] ? testNode.childNodes[0].textContent : testNode.childNodes[0].innerText;
+                value_of(actualText).should_be("");
+            },
 
-    'Should assign the value to the node without HTML-encoding the value': function () {    	
-        var model = { textProp: "My <span>HTML-containing</span> value" };
-        testNode.innerHTML = "<span data-bind='html:textProp'></span>";
-        ko.applyBindings(model, testNode);
-        value_of(testNode.childNodes[0].innerHTML.toLowerCase()).should_be(model.textProp.toLowerCase());
-        value_of(testNode.childNodes[0].childNodes[1].innerHTML).should_be("HTML-containing");
-    },
+            'Should work with virtual elements, adding a text node between the comments': function () {
+                var observable = ko.observable("Some text");
+                testNode.innerHTML = "xxx <!-- " + virtualElementTag + " text: textProp --><!--/" + virtualElementTag + " -->";
+                ko.applyBindings({ textProp: observable }, testNode);
+                value_of(testNode).should_contain_text("xxx Some text");
+                value_of(testNode).should_contain_html("xxx <!-- " + virtualElementTag + " text: textprop -->some text<!--/" + virtualElementTag + " -->");
+
+                // update observable; should update text
+                observable("New text");
+                value_of(testNode).should_contain_text("xxx New text");
+                value_of(testNode).should_contain_html("xxx <!-- " + virtualElementTag + " text: textprop -->new text<!--/" + virtualElementTag + " -->");
+
+                // clear observable; should remove text
+                observable(undefined);
+                value_of(testNode).should_contain_text("xxx ");
+                value_of(testNode).should_contain_html("xxx <!-- " + virtualElementTag + " text: textprop --><!--/" + virtualElementTag + " -->");
+            },
 
-    'Should assign an empty string as value if the model value is null': function () {
-        testNode.innerHTML = "<span data-bind='html:(null)' ></span>";
-        ko.applyBindings(null, testNode);
-        value_of(testNode.childNodes[0].innerHTML).should_be("");
-    },
-    
-    'Should assign an empty string as value if the model value is undefined': function () {
-        testNode.innerHTML = "<span data-bind='html:undefined' ></span>";
-        ko.applyBindings(null, testNode);
-        value_of(testNode.childNodes[0].innerHTML).should_be("");
-    },
-    
-    'Should be able to write arbitrary HTML, even if it is not semantically correct': function() {
-        // Represents issue #98 (https://github.com/SteveSanderson/knockout/issues/98)
-        // IE 8 and earlier is excessively strict about the use of .innerHTML - it throws
-        // if you try to write a <P> tag inside an existing <P> tag, for example.
-        var model = { textProp: "<p>hello</p><p>this isn't semantically correct</p>" };
-        testNode.innerHTML = "<p data-bind='html:textProp'></p>";
-        ko.applyBindings(model, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html(model.textProp);
-    },
-    
-    'Should be able to write arbitrary HTML, including <tr> elements into tables': function() {
-        // Some HTML elements are awkward, because the browser implicitly adds surrounding
-        // elements, or won't allow those elements to be direct children of others.
-        // The most common examples relate to tables.
-        var model = { textProp: "<tr><td>hello</td></tr>" };
-        testNode.innerHTML = "<table data-bind='html:textProp'></table>";
-        ko.applyBindings(model, testNode);
-        
-        // Accept either of the following outcomes - there may or may not be an implicitly added <tbody>.
-        var tr = testNode.childNodes[0].childNodes[0];
-        if (tr.tagName == 'TBODY')
-            tr = tr.childNodes[0];
-
-        var td = tr.childNodes[0];
-
-        value_of(tr.tagName).should_be("TR");
-        value_of(td.tagName).should_be("TD");
-        value_of('innerText' in td ? td.innerText : td.textContent).should_be("hello");
-    }
-});
+            'Should work with virtual elements, removing any existing stuff between the comments': function () {
+                testNode.innerHTML = "xxx <!--" + virtualElementTag + " text: undefined-->some random thing<span> that won't be here later</span><!--/" + virtualElementTag + "-->";
+                ko.applyBindings(null, testNode);
+                value_of(testNode).should_contain_text("xxx ");
+                value_of(testNode).should_contain_html("xxx <!--" + virtualElementTag + " text: undefined--><!--/" + virtualElementTag + "-->");
+            }
+        });
 
-describe('Binding: Value', {
-    before_each: prepareTestNode,
+        describe('Binding: HTML', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should assign the value to the node without HTML-encoding the value': function () {
+                var model = { textProp: "My <span>HTML-containing</span> value" };
+                testNode.innerHTML = "<span " + bindingAttribute + "='html:textProp'></span>";
+                ko.applyBindings(model, testNode);
+                value_of(testNode.childNodes[0].innerHTML.toLowerCase()).should_be(model.textProp.toLowerCase());
+                value_of(testNode.childNodes[0].childNodes[1].innerHTML).should_be("HTML-containing");
+            },
 
-    'Should assign the value to the node': function () {
-        testNode.innerHTML = "<input data-bind='value:123' />";
-        ko.applyBindings(null, testNode);
-        value_of(testNode.childNodes[0].value).should_be(123);
-    },
-    
-    'Should treat null values as empty strings': function () {
-        testNode.innerHTML = "<input data-bind='value:myProp' />";
-        ko.applyBindings({ myProp: ko.observable(0) }, testNode);
-        value_of(testNode.childNodes[0].value).should_be("0");
-    },    
-
-    'Should assign an empty string as value if the model value is null': function () {
-        testNode.innerHTML = "<input data-bind='value:(null)' />";
-        ko.applyBindings(null, testNode);
-        value_of(testNode.childNodes[0].value).should_be("");
-    },
+            'Should assign an empty string as value if the model value is null': function () {
+                testNode.innerHTML = "<span " + bindingAttribute + "='html:(null)' ></span>";
+                ko.applyBindings(null, testNode);
+                value_of(testNode.childNodes[0].innerHTML).should_be("");
+            },
 
-    'Should assign an empty string as value if the model value is undefined': function () {
-        testNode.innerHTML = "<input data-bind='value:undefined' />";
-        ko.applyBindings(null, testNode);
-        value_of(testNode.childNodes[0].value).should_be("");
-    },
+            'Should assign an empty string as value if the model value is undefined': function () {
+                testNode.innerHTML = "<span " + bindingAttribute + "='html:undefined' ></span>";
+                ko.applyBindings(null, testNode);
+                value_of(testNode.childNodes[0].innerHTML).should_be("");
+            },
 
-    'For observable values, should unwrap the value and update on change': function () {
-        var myobservable = new ko.observable(123);
-        testNode.innerHTML = "<input data-bind='value:someProp' />";
-        ko.applyBindings({ someProp: myobservable }, testNode);
-        value_of(testNode.childNodes[0].value).should_be(123);
-        myobservable(456);
-        value_of(testNode.childNodes[0].value).should_be(456);
-    },
+            'Should be able to write arbitrary HTML, even if it is not semantically correct': function () {
+                // Represents issue #98 (https://github.com/SteveSanderson/knockout/issues/98)
+                // IE 8 and earlier is excessively strict about the use of .innerHTML - it throws
+                // if you try to write a <P> tag inside an existing <P> tag, for example.
+                var model = { textProp: "<p>hello</p><p>this isn't semantically correct</p>" };
+                testNode.innerHTML = "<p " + bindingAttribute + "='html:textProp'></p>";
+                ko.applyBindings(model, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html(model.textProp);
+            },
 
-    'For writeable observable values, should catch the node\'s onchange and write values back to the observable': function () {
-        var myobservable = new ko.observable(123);
-        testNode.innerHTML = "<input data-bind='value:someProp' />";
-        ko.applyBindings({ someProp: myobservable }, testNode);
-        testNode.childNodes[0].value = "some user-entered value";
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        value_of(myobservable()).should_be("some user-entered value");
-    },
+            'Should be able to write arbitrary HTML, including <tr> elements into tables': function () {
+                // Some HTML elements are awkward, because the browser implicitly adds surrounding
+                // elements, or won't allow those elements to be direct children of others.
+                // The most common examples relate to tables.
+                var model = { textProp: "<tr><td>hello</td></tr>" };
+                testNode.innerHTML = "<table " + bindingAttribute + "='html:textProp'></table>";
+                ko.applyBindings(model, testNode);
 
-    'For non-observable property values, should catch the node\'s onchange and write values back to the property': function () {
-        var model = { modelProperty123: 456 };
-        testNode.innerHTML = "<input data-bind='value: modelProperty123' />";
-        ko.applyBindings(model, testNode);
-        value_of(testNode.childNodes[0].value).should_be(456);
+                // Accept either of the following outcomes - there may or may not be an implicitly added <tbody>.
+                var tr = testNode.childNodes[0].childNodes[0];
+                if (tr.tagName == 'TBODY')
+                    tr = tr.childNodes[0];
 
-        testNode.childNodes[0].value = 789;
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        value_of(model.modelProperty123).should_be(789);
-    },
-    
-    'Should be able to write to observable subproperties of an observable, even after the parent observable has changed': function () {
-        // This spec represents https://github.com/SteveSanderson/knockout/issues#issue/13
-        var originalSubproperty = ko.observable("original value");
-        var newSubproperty = ko.observable();
-        var model = { myprop: ko.observable({ subproperty : originalSubproperty }) };
-        
-        // Set up a text box whose value is linked to the subproperty of the observable's current value
-        testNode.innerHTML = "<input data-bind='value: myprop().subproperty' />";
-        ko.applyBindings(model, testNode);
-        value_of(testNode.childNodes[0].value).should_be("original value");
-        
-        model.myprop({ subproperty : newSubproperty }); // Note that myprop (and hence its subproperty) is changed *after* the bindings are applied
-        testNode.childNodes[0].value = "Some new value";
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");    	
-        
-        // Verify that the change was written to the *new* subproperty, not the one referenced when the bindings were first established
-        value_of(newSubproperty()).should_be("Some new value");
-        value_of(originalSubproperty()).should_be("original value");
-    },
+                var td = tr.childNodes[0];
 
-    'Should only register one single onchange handler': function () {
-        var notifiedValues = [];
-        var myobservable = new ko.observable(123);
-        myobservable.subscribe(function (value) { notifiedValues.push(value); });
-        value_of(notifiedValues.length).should_be(0);
-
-        testNode.innerHTML = "<input data-bind='value:someProp' />";
-        ko.applyBindings({ someProp: myobservable }, testNode);
-
-        // Implicitly observe the number of handlers by seeing how many times "myobservable"
-        // receives a new value for each onchange on the text box. If there's just one handler,
-        // we'll see one new value per onchange event. More handlers cause more notifications.
-        testNode.childNodes[0].value = "ABC";
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        value_of(notifiedValues.length).should_be(1);
-
-        testNode.childNodes[0].value = "DEF";
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        value_of(notifiedValues.length).should_be(2);
-    },
-    
-    'Should be able to catch updates after specific events (e.g., keyup) instead of onchange': function () {
-        var myobservable = new ko.observable(123);
-        testNode.innerHTML = "<input data-bind='value:someProp, valueUpdate: \"keyup\"' />";
-        ko.applyBindings({ someProp: myobservable }, testNode);
-        testNode.childNodes[0].value = "some user-entered value";
-        ko.utils.triggerEvent(testNode.childNodes[0], "keyup");
-        value_of(myobservable()).should_be("some user-entered value");
-    },
-    
-    'Should catch updates on change as well as the nominated valueUpdate event': function () {
-        // Represents issue #102 (https://github.com/SteveSanderson/knockout/issues/102)
-        var myobservable = new ko.observable(123);
-        testNode.innerHTML = "<input data-bind='value:someProp, valueUpdate: \"keyup\"' />";
-        ko.applyBindings({ someProp: myobservable }, testNode);
-        testNode.childNodes[0].value = "some user-entered value";
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        value_of(myobservable()).should_be("some user-entered value");
-    },           
-    
-    'For select boxes, should update selectedIndex when the model changes (options specified before value)': function() {
-        var observable = new ko.observable('B');
-        testNode.innerHTML = "<select data-bind='options:[\"A\", \"B\"], value:myObservable'></select>";
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(1);
-        value_of(observable()).should_be('B');
-
-        observable('A');
-        value_of(testNode.childNodes[0].selectedIndex).should_be(0);
-        value_of(observable()).should_be('A');
-    },
+                value_of(tr.tagName).should_be("TR");
+                value_of(td.tagName).should_be("TD");
+                value_of('innerText' in td ? td.innerText : td.textContent).should_be("hello");
+            }
+        });
 
-    'For select boxes, should update selectedIndex when the model changes (value specified before options)': function() {
-        var observable = new ko.observable('B');
-        testNode.innerHTML = "<select data-bind='value:myObservable, options:[\"A\", \"B\"]'></select>";
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(1);
-        value_of(observable()).should_be('B');
-
-        observable('A');
-        value_of(testNode.childNodes[0].selectedIndex).should_be(0);
-        value_of(observable()).should_be('A');
-    },    
-    
-    'For select boxes, should display the caption when the model value changes to undefined': function() {
-        var observable = new ko.observable('B');
-        testNode.innerHTML = "<select data-bind='options:[\"A\", \"B\"], optionsCaption:\"Select...\", value:myObservable'></select>";
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(2);
-        observable(undefined);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(0);    	
-    },
-    
-    'For select boxes, should update the model value when the UI is changed (setting it to undefined when the caption is selected)': function () {
-        var observable = new ko.observable('B');
-        testNode.innerHTML = "<select data-bind='options:[\"A\", \"B\"], optionsCaption:\"Select...\", value:myObservable'></select>";
-        ko.applyBindings({ myObservable: observable }, testNode);
-        var dropdown = testNode.childNodes[0];
-        
-        dropdown.selectedIndex = 1;
-        ko.utils.triggerEvent(dropdown, "change");
-        value_of(observable()).should_be("A");           	
-
-        dropdown.selectedIndex = 0;
-        ko.utils.triggerEvent(dropdown, "change");
-        value_of(observable()).should_be(undefined);           	
-    },
+        describe('Binding: Value', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should assign the value to the node': function () {
+                testNode.innerHTML = "<input " + bindingAttribute + "='value:123' />";
+                ko.applyBindings(null, testNode);
+                value_of(testNode.childNodes[0].value).should_be(123);
+            },
 
-    'For select boxes, should be able to associate option values with arbitrary objects (not just strings)': function() {
-        var x = {}, y = {};
-        var selectedValue = ko.observable(y);
-        testNode.innerHTML = "<select data-bind='options: myOptions, value: selectedValue'></select>";
-        var dropdown = testNode.childNodes[0];
-        ko.applyBindings({ myOptions: [x, y], selectedValue: selectedValue }, testNode);
-        
-        // Check the UI displays the entry corresponding to the chosen value
-        value_of(dropdown.selectedIndex).should_be(1);
-                
-        // Check that when we change the model value, the UI is updated
-        selectedValue(x);
-        value_of(dropdown.selectedIndex).should_be(0);
-        
-        // Check that when we change the UI, this changes the model value
-        dropdown.selectedIndex = 1;
-        ko.utils.triggerEvent(dropdown, "change");
-        value_of(selectedValue()).should_be(y);    	
-    },
-    
-    'For select boxes, should automatically initialize the model property to match the first option value if no option value matches the current model property value': function() {
-        // The rationale here is that we always want the model value to match the option that appears to be selected in the UI
-        //  * If there is *any* option value that equals the model value, we'd initalise the select box such that *that* option is the selected one
-        //  * If there is *no* option value that equals the model value (often because the model value is undefined), we should set the model
-        //    value to match an arbitrary option value to avoid inconsistency between the visible UI and the model
-        var observable = new ko.observable(); // Undefined by default
-
-        // Should work with options specified before value
-        testNode.innerHTML = "<select data-bind='options:[\"A\", \"B\"], value:myObservable'></select>";
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(observable()).should_be("A");
-
-        // ... and with value specified before options
-        testNode.innerHTML = "<select data-bind='value:myObservable, options:[\"A\", \"B\"]'></select>";
-        observable(undefined);
-        value_of(observable()).should_be(undefined);
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(observable()).should_be("A");        
-    },
-    
-    'For nonempty select boxes, should reject model values that don\'t match any option value, resetting the model value to whatever is visibly selected in the UI': function() {
-        var observable = new ko.observable('B');
-        testNode.innerHTML = "<select data-bind='options:[\"A\", \"B\", \"C\"], value:myObservable'></select>";
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(1);
-        
-        observable('D'); // This change should be rejected, as there's no corresponding option in the UI
-        value_of(observable()).should_not_be('D');
-    },
+            'Should treat null values as empty strings': function () {
+                testNode.innerHTML = "<input " + bindingAttribute + "='value:myProp' />";
+                ko.applyBindings({ myProp: ko.observable(0) }, testNode);
+                value_of(testNode.childNodes[0].value).should_be("0");
+            },
 
-    'For empty select boxes, should reject model values that don\'t match any option value, resetting the model value to undefined': function() {
-        var observable = new ko.observable('B');
-        testNode.innerHTML = "<select data-bind='options:[], value:myObservable'></select>";
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(-1);   // nothing selected
+            'Should assign an empty string as value if the model value is null': function () {
+                testNode.innerHTML = "<input " + bindingAttribute + "='value:(null)' />";
+                ko.applyBindings(null, testNode);
+                value_of(testNode.childNodes[0].value).should_be("");
+            },
 
-        observable('D'); // This change should be rejected, as there's no corresponding option in the UI
-        value_of(observable()).should_be(undefined);
-    },
+            'Should assign an empty string as value if the model value is undefined': function () {
+                testNode.innerHTML = "<input " + bindingAttribute + "='value:undefined' />";
+                ko.applyBindings(null, testNode);
+                value_of(testNode.childNodes[0].value).should_be("");
+            },
 
-    'For empty select boxes, should reject model values that don\'t match any option value (value before options [also with no options])': function() {
-        var observable = new ko.observable('B');
-        testNode.innerHTML = "<select data-bind='value:myObservable', options:[]></select>";
-        ko.applyBindings({ myObservable: observable }, testNode);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(-1);   // nothing selected
+            'For observable values, should unwrap the value and update on change': function () {
+                var myobservable = new ko.observable(123);
+                testNode.innerHTML = "<input " + bindingAttribute + "='value:someProp' />";
+                ko.applyBindings({ someProp: myobservable }, testNode);
+                value_of(testNode.childNodes[0].value).should_be(123);
+                myobservable(456);
+                value_of(testNode.childNodes[0].value).should_be(456);
+            },
 
-        observable('D'); // This change should be rejected, as there's no corresponding option in the UI
-        value_of(observable()).should_be(undefined);
-    },
+            'For writeable observable values, should catch the node\'s onchange and write values back to the observable': function () {
+                var myobservable = new ko.observable(123);
+                testNode.innerHTML = "<input " + bindingAttribute + "='value:someProp' />";
+                ko.applyBindings({ someProp: myobservable }, testNode);
+                testNode.childNodes[0].value = "some user-entered value";
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                value_of(myobservable()).should_be("some user-entered value");
+            },
 
-    'For select boxes, should clear value if selected item is deleted': function() {
-        var observable = new ko.observable('B');
-        var observableArray = new ko.observableArray(["A", "B"]);
-        testNode.innerHTML = "<select data-bind='value:myObservable, options:myObservableArray, optionsCaption:\"Select...\"'></select>";
-        ko.applyBindings({ myObservable: observable, myObservableArray: observableArray }, testNode);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(2);
+            'For non-observable property values, should catch the node\'s onchange and write values back to the property': function () {
+                var model = { modelProperty123: 456 };
+                testNode.innerHTML = "<input " + bindingAttribute + "='value: modelProperty123' />";
+                ko.applyBindings(model, testNode);
+                value_of(testNode.childNodes[0].value).should_be(456);
 
-        observableArray.remove('B');
-        value_of(testNode.childNodes[0].selectedIndex).should_be(0);
-        value_of(observable()).should_be(undefined);
-    },
+                testNode.childNodes[0].value = 789;
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                value_of(model.modelProperty123).should_be(789);
+            },
 
-    'For select boxes, should set value to first in list if selected item is deleted and no caption': function() {
-        var observable = new ko.observable('B');
-        var observableArray = new ko.observableArray(["A", "B"]);
-        testNode.innerHTML = "<select data-bind='value:myObservable, options:myObservableArray'></select>";
-        ko.applyBindings({ myObservable: observable, myObservableArray: observableArray }, testNode);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(1);
+            'Should be able to write to observable subproperties of an observable, even after the parent observable has changed': function () {
+                // This spec represents https://github.com/SteveSanderson/knockout/issues#issue/13
+                var originalSubproperty = ko.observable("original value");
+                var newSubproperty = ko.observable();
+                var model = { myprop: ko.observable({ subproperty: originalSubproperty }) };
 
-        observableArray.remove('B');
-        value_of(testNode.childNodes[0].selectedIndex).should_be(0);
-        value_of(observable()).should_be("A");
-    },
+                // Set up a text box whose value is linked to the subproperty of the observable's current value
+                testNode.innerHTML = "<input " + bindingAttribute + "='value: myprop().subproperty' />";
+                ko.applyBindings(model, testNode);
+                value_of(testNode.childNodes[0].value).should_be("original value");
 
-    'For select boxes, should clear value if select is cleared and no caption': function() {
-        var observable = new ko.observable('B');
-        var observableArray = new ko.observableArray(["A", "B"]);
-        testNode.innerHTML = "<select data-bind='options:myObservableArray, value:myObservable'></select>";
-        ko.applyBindings({ myObservable: observable, myObservableArray: observableArray }, testNode);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(1);
+                model.myprop({ subproperty: newSubproperty }); // Note that myprop (and hence its subproperty) is changed *after* the bindings are applied
+                testNode.childNodes[0].value = "Some new value";
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
 
-        observableArray([]);
-        value_of(testNode.childNodes[0].selectedIndex).should_be(-1);
-        value_of(observable()).should_be(undefined);
-    },
+                // Verify that the change was written to the *new* subproperty, not the one referenced when the bindings were first established
+                value_of(newSubproperty()).should_be("Some new value");
+                value_of(originalSubproperty()).should_be("original value");
+            },
+
+            'Should only register one single onchange handler': function () {
+                var notifiedValues = [];
+                var myobservable = new ko.observable(123);
+                myobservable.subscribe(function (value) { notifiedValues.push(value); });
+                value_of(notifiedValues.length).should_be(0);
+
+                testNode.innerHTML = "<input " + bindingAttribute + "='value:someProp' />";
+                ko.applyBindings({ someProp: myobservable }, testNode);
+
+                // Implicitly observe the number of handlers by seeing how many times "myobservable"
+                // receives a new value for each onchange on the text box. If there's just one handler,
+                // we'll see one new value per onchange event. More handlers cause more notifications.
+                testNode.childNodes[0].value = "ABC";
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                value_of(notifiedValues.length).should_be(1);
+
+                testNode.childNodes[0].value = "DEF";
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                value_of(notifiedValues.length).should_be(2);
+            },
+
+            'Should be able to catch updates after specific events (e.g., keyup) instead of onchange': function () {
+                var myobservable = new ko.observable(123);
+                testNode.innerHTML = "<input " + bindingAttribute + "='value:someProp, valueUpdate: \"keyup\"' />";
+                ko.applyBindings({ someProp: myobservable }, testNode);
+                testNode.childNodes[0].value = "some user-entered value";
+                ko.utils.triggerEvent(testNode.childNodes[0], "keyup");
+                value_of(myobservable()).should_be("some user-entered value");
+            },
+
+            'Should catch updates on change as well as the nominated valueUpdate event': function () {
+                // Represents issue #102 (https://github.com/SteveSanderson/knockout/issues/102)
+                var myobservable = new ko.observable(123);
+                testNode.innerHTML = "<input " + bindingAttribute + "='value:someProp, valueUpdate: \"keyup\"' />";
+                ko.applyBindings({ someProp: myobservable }, testNode);
+                testNode.childNodes[0].value = "some user-entered value";
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                value_of(myobservable()).should_be("some user-entered value");
+            },
 
-    'For select boxes, option values can be numerical, and are not implicitly converted to strings': function() {
-        var observable = new ko.observable(30);
-        testNode.innerHTML = "<select data-bind='options:[10,20,30,40], value:myObservable'></select>";
-        ko.applyBindings({ myObservable: observable }, testNode);
+            'For select boxes, should update selectedIndex when the model changes (options specified before value)': function () {
+                var observable = new ko.observable('B');
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:[\"A\", \"B\"], value:myObservable'></select>";
+                ko.applyBindings({ myObservable: observable }, testNode);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(1);
+                value_of(observable()).should_be('B');
+
+                observable('A');
+                value_of(testNode.childNodes[0].selectedIndex).should_be(0);
+                value_of(observable()).should_be('A');
+            },
+
+            'For select boxes, should update selectedIndex when the model changes (value specified before options)': function () {
+                var observable = new ko.observable('B');
+                testNode.innerHTML = "<select " + bindingAttribute + "='value:myObservable, options:[\"A\", \"B\"]'></select>";
+                ko.applyBindings({ myObservable: observable }, testNode);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(1);
+                value_of(observable()).should_be('B');
+
+                observable('A');
+                value_of(testNode.childNodes[0].selectedIndex).should_be(0);
+                value_of(observable()).should_be('A');
+            },
+
+            'For select boxes, should display the caption when the model value changes to undefined': function () {
+                var observable = new ko.observable('B');
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:[\"A\", \"B\"], optionsCaption:\"Select...\", value:myObservable'></select>";
+                ko.applyBindings({ myObservable: observable }, testNode);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(2);
+                observable(undefined);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(0);
+            },
+
+            'For select boxes, should update the model value when the UI is changed (setting it to undefined when the caption is selected)': function () {
+                var observable = new ko.observable('B');
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:[\"A\", \"B\"], optionsCaption:\"Select...\", value:myObservable'></select>";
+                ko.applyBindings({ myObservable: observable }, testNode);
+                var dropdown = testNode.childNodes[0];
+
+                dropdown.selectedIndex = 1;
+                ko.utils.triggerEvent(dropdown, "change");
+                value_of(observable()).should_be("A");
+
+                dropdown.selectedIndex = 0;
+                ko.utils.triggerEvent(dropdown, "change");
+                value_of(observable()).should_be(undefined);
+            },
+
+            'For select boxes, should be able to associate option values with arbitrary objects (not just strings)': function () {
+                var x = {}, y = {};
+                var selectedValue = ko.observable(y);
+                testNode.innerHTML = "<select " + bindingAttribute + "='options: myOptions, value: selectedValue'></select>";
+                var dropdown = testNode.childNodes[0];
+                ko.applyBindings({ myOptions: [x, y], selectedValue: selectedValue }, testNode);
+
+                // Check the UI displays the entry corresponding to the chosen value
+                value_of(dropdown.selectedIndex).should_be(1);
+
+                // Check that when we change the model value, the UI is updated
+                selectedValue(x);
+                value_of(dropdown.selectedIndex).should_be(0);
+
+                // Check that when we change the UI, this changes the model value
+                dropdown.selectedIndex = 1;
+                ko.utils.triggerEvent(dropdown, "change");
+                value_of(selectedValue()).should_be(y);
+            },
+
+            'For select boxes, should automatically initialize the model property to match the first option value if no option value matches the current model property value': function () {
+                // The rationale here is that we always want the model value to match the option that appears to be selected in the UI
+                //  * If there is *any* option value that equals the model value, we'd initalise the select box such that *that* option is the selected one
+                //  * If there is *no* option value that equals the model value (often because the model value is undefined), we should set the model
+                //    value to match an arbitrary option value to avoid inconsistency between the visible UI and the model
+                var observable = new ko.observable(); // Undefined by default
+
+                // Should work with options specified before value
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:[\"A\", \"B\"], value:myObservable'></select>";
+                ko.applyBindings({ myObservable: observable }, testNode);
+                value_of(observable()).should_be("A");
+
+                // ... and with value specified before options
+                testNode.innerHTML = "<select " + bindingAttribute + "='value:myObservable, options:[\"A\", \"B\"]'></select>";
+                observable(undefined);
+                value_of(observable()).should_be(undefined);
+                ko.applyBindings({ myObservable: observable }, testNode);
+                value_of(observable()).should_be("A");
+            },
+
+            'For nonempty select boxes, should reject model values that don\'t match any option value, resetting the model value to whatever is visibly selected in the UI': function () {
+                var observable = new ko.observable('B');
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:[\"A\", \"B\", \"C\"], value:myObservable'></select>";
+                ko.applyBindings({ myObservable: observable }, testNode);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(1);
+
+                observable('D'); // This change should be rejected, as there's no corresponding option in the UI
+                value_of(observable()).should_not_be('D');
+            },
+
+            'For empty select boxes, should reject model values that don\'t match any option value, resetting the model value to undefined': function () {
+                var observable = new ko.observable('B');
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:[], value:myObservable'></select>";
+                ko.applyBindings({ myObservable: observable }, testNode);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(-1);   // nothing selected
+
+                observable('D'); // This change should be rejected, as there's no corresponding option in the UI
+                value_of(observable()).should_be(undefined);
+            },
 
-        // First check that numerical model values will match a dropdown option
-        value_of(testNode.childNodes[0].selectedIndex).should_be(2); // 3rd element, zero-indexed
+            'For empty select boxes, should reject model values that don\'t match any option value (value before options [also with no options])': function () {
+                var observable = new ko.observable('B');
+                testNode.innerHTML = "<select " + bindingAttribute + "='value:myObservable', options:[]></select>";
+                ko.applyBindings({ myObservable: observable }, testNode);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(-1);   // nothing selected
 
-        // Then check that dropdown options map back to numerical model values
-        testNode.childNodes[0].selectedIndex = 1;
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        value_of(typeof observable()).should_be("number");
-        value_of(observable()).should_be(20);
+                observable('D'); // This change should be rejected, as there's no corresponding option in the UI
+                value_of(observable()).should_be(undefined);
+            },
+
+            'For select boxes, should clear value if selected item is deleted': function () {
+                var observable = new ko.observable('B');
+                var observableArray = new ko.observableArray(["A", "B"]);
+                testNode.innerHTML = "<select " + bindingAttribute + "='value:myObservable, options:myObservableArray, optionsCaption:\"Select...\"'></select>";
+                ko.applyBindings({ myObservable: observable, myObservableArray: observableArray }, testNode);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(2);
+
+                observableArray.remove('B');
+                value_of(testNode.childNodes[0].selectedIndex).should_be(0);
+                value_of(observable()).should_be(undefined);
+            },
+
+            'For select boxes, should set value to first in list if selected item is deleted and no caption': function () {
+                var observable = new ko.observable('B');
+                var observableArray = new ko.observableArray(["A", "B"]);
+                testNode.innerHTML = "<select " + bindingAttribute + "='value:myObservable, options:myObservableArray'></select>";
+                ko.applyBindings({ myObservable: observable, myObservableArray: observableArray }, testNode);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(1);
+
+                observableArray.remove('B');
+                value_of(testNode.childNodes[0].selectedIndex).should_be(0);
+                value_of(observable()).should_be("A");
+            },
+
+            'For select boxes, should clear value if select is cleared and no caption': function () {
+                var observable = new ko.observable('B');
+                var observableArray = new ko.observableArray(["A", "B"]);
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:myObservableArray, value:myObservable'></select>";
+                ko.applyBindings({ myObservable: observable, myObservableArray: observableArray }, testNode);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(1);
+
+                observableArray([]);
+                value_of(testNode.childNodes[0].selectedIndex).should_be(-1);
+                value_of(observable()).should_be(undefined);
+            },
+
+            'For select boxes, option values can be numerical, and are not implicitly converted to strings': function () {
+                var observable = new ko.observable(30);
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:[10,20,30,40], value:myObservable'></select>";
+                ko.applyBindings({ myObservable: observable }, testNode);
+
+                // First check that numerical model values will match a dropdown option
+                value_of(testNode.childNodes[0].selectedIndex).should_be(2); // 3rd element, zero-indexed
+
+                // Then check that dropdown options map back to numerical model values
+                testNode.childNodes[0].selectedIndex = 1;
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                value_of(typeof observable()).should_be("number");
+                value_of(observable()).should_be(20);
     },
 
     'On IE, should respond exactly once to "propertychange" followed by "blur" or "change" or both': function() {
@@ -467,7 +483,7 @@ describe('Binding: Value', {
             var myobservable = new ko.observable(123).extend({ notify: 'always' });
             var numUpdates = 0;
             myobservable.subscribe(function() { numUpdates++ });
-            testNode.innerHTML = "<input data-bind='value:someProp' />";
+            testNode.innerHTML = "<input " + bindingAttribute + "='value:someProp' />";
             ko.applyBindings({ someProp: myobservable }, testNode);
 
             // First try change then blur
@@ -488,1424 +504,1427 @@ describe('Binding: Value', {
             ko.utils.triggerEvent(testNode.childNodes[0], "change");
             value_of(numUpdates).should_be(2);
         }
-    }
-})
-
-describe('Binding: Options', {
-    before_each: prepareTestNode,
+            }
+        })
 
-    // Todo: when the options list is populated, this should trigger a change event so that observers are notified of the new value (i.e., the default selection)
+        describe('Binding: Options', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            // Todo: when the options list is populated, this should trigger a change event so that observers are notified of the new value (i.e., the default selection)
+
+            'Should only be applicable to SELECT nodes': function () {
+                var threw = false;
+                testNode.innerHTML = "<input " + bindingAttribute + "='options:{}' />";
+                try { ko.applyBindings({}, testNode); }
+                catch (ex) { threw = true; }
+                value_of(threw).should_be(true);
+            },
 
-    'Should only be applicable to SELECT nodes': function () {
-        var threw = false;
-        testNode.innerHTML = "<input data-bind='options:{}' />";
-        try { ko.applyBindings({}, testNode); }
-        catch (ex) { threw = true; }
-        value_of(threw).should_be(true);
-    },
+            'Should set the SELECT node\'s options set to match the model value': function () {
+                var observable = new ko.observableArray(["A", "B", "C"]);
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:myValues'><option>should be deleted</option></select>";
+                ko.applyBindings({ myValues: observable }, testNode);
+                var displayedOptions = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.innerHTML; });
+                value_of(displayedOptions).should_be(["A", "B", "C"]);
+            },
 
-    'Should set the SELECT node\'s options set to match the model value': function () {
-        var observable = new ko.observableArray(["A", "B", "C"]);
-        testNode.innerHTML = "<select data-bind='options:myValues'><option>should be deleted</option></select>";
-        ko.applyBindings({ myValues: observable }, testNode);
-        var displayedOptions = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.innerHTML; });
-        value_of(displayedOptions).should_be(["A", "B", "C"]);
-    },
-    
-    'Should accept optionsText and optionsValue params to display subproperties of the model values': function() {
-        var modelValues = new ko.observableArray([
+            'Should accept optionsText and optionsValue params to display subproperties of the model values': function () {
+                var modelValues = new ko.observableArray([
             { name: 'bob', id: ko.observable(6) }, // Note that subproperties can be observable
-            { name: ko.observable('frank'), id: 13 }
-        ]);	
-        testNode.innerHTML = "<select data-bind='options:myValues, optionsText: \"name\", optionsValue: \"id\"'><option>should be deleted</option></select>";
-        ko.applyBindings({ myValues: modelValues }, testNode);
-        var displayedText = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.innerHTML; });	
-        var displayedValues = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.value; });	
-        value_of(displayedText).should_be(["bob", "frank"]);
-        value_of(displayedValues).should_be([6, 13]);
-    },
+            {name: ko.observable('frank'), id: 13 }
+        ]);
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:myValues, optionsText: \"name\", optionsValue: \"id\"'><option>should be deleted</option></select>";
+                ko.applyBindings({ myValues: modelValues }, testNode);
+                var displayedText = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.innerHTML; });
+                var displayedValues = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.value; });
+                value_of(displayedText).should_be(["bob", "frank"]);
+                value_of(displayedValues).should_be([6, 13]);
+            },
 
-    'Should accept function in optionsText param to display subproperties of the model values': function() {
-        var modelValues = new ko.observableArray([
-            { name: 'bob', job: 'manager' }, 
+            'Should accept function in optionsText param to display subproperties of the model values': function () {
+                var modelValues = new ko.observableArray([
+            { name: 'bob', job: 'manager' },
             { name: 'frank', job: 'coder & tester' }
-        ]);	
-        testNode.innerHTML = "<select data-bind='options:myValues, optionsText: function (v) { return v[\"name\"] + \" (\" + v[\"job\"] + \")\"; }, optionsValue: \"id\"'><option>should be deleted</option></select>";
-        ko.applyBindings({ myValues: modelValues }, testNode);
-        var displayedText = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.innerText || node.textContent; });	
-        value_of(displayedText).should_be(["bob (manager)", "frank (coder & tester)"]);
-    },
+        ]);
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:myValues, optionsText: function (v) { return v[\"name\"] + \" (\" + v[\"job\"] + \")\"; }, optionsValue: \"id\"'><option>should be deleted</option></select>";
+                ko.applyBindings({ myValues: modelValues }, testNode);
+                var displayedText = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.innerText || node.textContent; });
+                value_of(displayedText).should_be(["bob (manager)", "frank (coder & tester)"]);
+            },
 
-    'Should update the SELECT node\'s options if the model changes': function () {
-        var observable = new ko.observableArray(["A", "B", "C"]);
-        testNode.innerHTML = "<select data-bind='options:myValues'><option>should be deleted</option></select>";
-        ko.applyBindings({ myValues: observable }, testNode);
-        observable.splice(1, 1);
-        var displayedOptions = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.innerHTML; });
-        value_of(displayedOptions).should_be(["A", "C"]);
-    },
+            'Should update the SELECT node\'s options if the model changes': function () {
+                var observable = new ko.observableArray(["A", "B", "C"]);
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:myValues'><option>should be deleted</option></select>";
+                ko.applyBindings({ myValues: observable }, testNode);
+                observable.splice(1, 1);
+                var displayedOptions = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.innerHTML; });
+                value_of(displayedOptions).should_be(["A", "C"]);
+            },
 
-    'Should retain as much selection as possible when changing the SELECT node\'s options': function () {
-        var observable = new ko.observableArray(["A", "B", "C"]);
-        testNode.innerHTML = "<select data-bind='options:myValues' multiple='multiple'><option>A</option><option selected='selected'>B</option><option selected='selected'>X</option></select>";
-        ko.applyBindings({ myValues: observable }, testNode);
-        value_of(getSelectedValuesFromSelectNode(testNode.childNodes[0])).should_be(["B"]);
-    },
-    
-    'Should place a caption at the top of the options list and display it when the model value is undefined': function() {
-        testNode.innerHTML = "<select data-bind='options:[\"A\", \"B\"], optionsCaption: \"Select one...\"'></select>";
-        ko.applyBindings({}, testNode);
-        var displayedOptions = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.innerHTML; });        
-        value_of(displayedOptions).should_be(["Select one...", "A", "B"]);
-    }
-});
+            'Should retain as much selection as possible when changing the SELECT node\'s options': function () {
+                var observable = new ko.observableArray(["A", "B", "C"]);
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:myValues' multiple='multiple'><option>A</option><option selected='selected'>B</option><option selected='selected'>X</option></select>";
+                ko.applyBindings({ myValues: observable }, testNode);
+                value_of(getSelectedValuesFromSelectNode(testNode.childNodes[0])).should_be(["B"]);
+            },
 
-describe('Binding: Selected Options', {
-    before_each: prepareTestNode,
+            'Should place a caption at the top of the options list and display it when the model value is undefined': function () {
+                testNode.innerHTML = "<select " + bindingAttribute + "='options:[\"A\", \"B\"], optionsCaption: \"Select one...\"'></select>";
+                ko.applyBindings({}, testNode);
+                var displayedOptions = ko.utils.arrayMap(testNode.childNodes[0].childNodes, function (node) { return node.innerHTML; });
+                value_of(displayedOptions).should_be(["Select one...", "A", "B"]);
+            }
+        });
 
-    'Should only be applicable to SELECT nodes': function () {
-        var threw = false;
-        testNode.innerHTML = "<input data-bind='selectedOptions:[]' />";
-        try { ko.applyBindings({}, testNode); }
-        catch (ex) { threw = true; }
-        value_of(threw).should_be(true);
-    },
+        describe('Binding: Selected Options', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should only be applicable to SELECT nodes': function () {
+                var threw = false;
+                testNode.innerHTML = "<input " + bindingAttribute + "='selectedOptions:[]' />";
+                try { ko.applyBindings({}, testNode); }
+                catch (ex) { threw = true; }
+                value_of(threw).should_be(true);
+            },
 
-    'Should set selection in the SELECT node to match the model': function () {
-        var bObject = {};
-        var values = new ko.observableArray(["A", bObject, "C"]);
-        var selection = new ko.observableArray([bObject]);
-        testNode.innerHTML = "<select multiple='multiple' data-bind='options:myValues, selectedOptions:mySelection'></select>";
-        ko.applyBindings({ myValues: values, mySelection: selection }, testNode);
+            'Should set selection in the SELECT node to match the model': function () {
+                var bObject = {};
+                var values = new ko.observableArray(["A", bObject, "C"]);
+                var selection = new ko.observableArray([bObject]);
+                testNode.innerHTML = "<select multiple='multiple' " + bindingAttribute + "='options:myValues, selectedOptions:mySelection'></select>";
+                ko.applyBindings({ myValues: values, mySelection: selection }, testNode);
 
-        value_of(getSelectedValuesFromSelectNode(testNode.childNodes[0])).should_be([bObject]);
-        selection.push("C");
-        value_of(getSelectedValuesFromSelectNode(testNode.childNodes[0])).should_be([bObject, "C"]);
-    },
+                value_of(getSelectedValuesFromSelectNode(testNode.childNodes[0])).should_be([bObject]);
+                selection.push("C");
+                value_of(getSelectedValuesFromSelectNode(testNode.childNodes[0])).should_be([bObject, "C"]);
+            },
 
-    'Should update the model when selection in the SELECT node changes': function () {
-        function setMultiSelectOptionSelectionState(optionElement, state) {
-            // Workaround an IE 6 bug (http://benhollis.net/experiments/browserdemos/ie6-adding-options.html)
-            if (/MSIE 6/i.test(navigator.userAgent)) 
-                optionElement.setAttribute('selected', state);
-            else
-                optionElement.selected = state;    			
-        }
-        
-        var cObject = {};
-        var values = new ko.observableArray(["A", "B", cObject]);
-        var selection = new ko.observableArray(["B"]);
-        testNode.innerHTML = "<select multiple='multiple' data-bind='options:myValues, selectedOptions:mySelection'></select>";
-        ko.applyBindings({ myValues: values, mySelection: selection }, testNode);		
-
-        value_of(selection()).should_be(["B"]);        
-        setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[0], true);
-        setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[1], false);
-        setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[2], true);
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        
-        value_of(selection()).should_be(["A", cObject]);
-        value_of(selection()[1] === cObject).should_be(true); // Also check with strict equality, because we don't want to falsely accept [object Object] == cObject
-    },
+            'Should update the model when selection in the SELECT node changes': function () {
+                function setMultiSelectOptionSelectionState(optionElement, state) {
+                    // Workaround an IE 6 bug (http://benhollis.net/experiments/browserdemos/ie6-adding-options.html)
+                    if (/MSIE 6/i.test(navigator.userAgent))
+                        optionElement.setAttribute('selected', state);
+                    else
+                        optionElement.selected = state;
+                }
 
-    'Should update the model when selection in the SELECT node inside an optgroup changes': function () {
-        function setMultiSelectOptionSelectionState(optionElement, state) {
-            // Workaround an IE 6 bug (http://benhollis.net/experiments/browserdemos/ie6-adding-options.html)
-            if (/MSIE 6/i.test(navigator.userAgent)) 
-                optionElement.setAttribute('selected', state);
-            else
-                optionElement.selected = state;             
-        }
+                var cObject = {};
+                var values = new ko.observableArray(["A", "B", cObject]);
+                var selection = new ko.observableArray(["B"]);
+                testNode.innerHTML = "<select multiple='multiple' " + bindingAttribute + "='options:myValues, selectedOptions:mySelection'></select>";
+                ko.applyBindings({ myValues: values, mySelection: selection }, testNode);
 
-        var selection = new ko.observableArray([]);
-        testNode.innerHTML = "<select multiple='multiple' data-bind='selectedOptions:mySelection'><optgroup label='group'><option value='a'>a-text</option><option value='b'>b-text</option><option value='c'>c-text</option></optgroup></select>";
-        ko.applyBindings({ mySelection: selection }, testNode);
+                value_of(selection()).should_be(["B"]);
+                setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[0], true);
+                setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[1], false);
+                setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[2], true);
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
 
-        value_of(selection()).should_be([]);
+                value_of(selection()).should_be(["A", cObject]);
+                value_of(selection()[1] === cObject).should_be(true); // Also check with strict equality, because we don't want to falsely accept [object Object] == cObject
+            },
 
-        setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[0].childNodes[0], true);
-        setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[0].childNodes[1], false);
-        setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[0].childNodes[2], true);
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
+            'Should update the model when selection in the SELECT node inside an optgroup changes': function () {
+                function setMultiSelectOptionSelectionState(optionElement, state) {
+                    // Workaround an IE 6 bug (http://benhollis.net/experiments/browserdemos/ie6-adding-options.html)
+                    if (/MSIE 6/i.test(navigator.userAgent))
+                        optionElement.setAttribute('selected', state);
+                    else
+                        optionElement.selected = state;
+                }
 
-        value_of(selection()).should_be(['a', 'c']);
-    }
-});
-
-describe('Binding: Submit', {
-    before_each: prepareTestNode,
-
-    'Should invoke the supplied function on submit and prevent default action, using model as \'this\' param and the form node as a param to the handler': function () {
-        var firstParamStored;
-        var model = { wasCalled: false, doCall: function (firstParam) { this.wasCalled = true; firstParamStored = firstParam; } };
-        testNode.innerHTML = "<form data-bind='submit:doCall' />";
-        var formNode = testNode.childNodes[0];
-        ko.applyBindings(model, testNode);
-        ko.utils.triggerEvent(testNode.childNodes[0], "submit");
-        value_of(model.wasCalled).should_be(true);
-        value_of(firstParamStored).should_be(formNode);
-    }
-});
+                var selection = new ko.observableArray([]);
+                testNode.innerHTML = "<select multiple='multiple' " + bindingAttribute + "='selectedOptions:mySelection'><optgroup label='group'><option value='a'>a-text</option><option value='b'>b-text</option><option value='c'>c-text</option></optgroup></select>";
+                ko.applyBindings({ mySelection: selection }, testNode);
 
-describe('Binding: Event', {
-    before_each: prepareTestNode,
+                value_of(selection()).should_be([]);
 
-    'Should invoke the supplied function when the event occurs, using model as \'this\' param and first arg, and event as second arg': function () {
-        var model = { 
-            firstWasCalled: false, 
-            firstHandler: function (passedModel, evt) { 
-                value_of(evt.type).should_be("click");
-                value_of(this).should_be(model);
-                value_of(passedModel).should_be(model);
+                setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[0].childNodes[0], true);
+                setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[0].childNodes[1], false);
+                setMultiSelectOptionSelectionState(testNode.childNodes[0].childNodes[0].childNodes[2], true);
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
 
-                value_of(model.firstWasCalled).should_be(false);
-                model.firstWasCalled = true; 
-            },
+                value_of(selection()).should_be(['a', 'c']);
+            }
+        });
 
-            secondWasCalled: false, 
-            secondHandler: function (passedModel, evt) {
-                value_of(evt.type).should_be("mouseover");
-                value_of(this).should_be(model);
-                value_of(passedModel).should_be(model);
+        describe('Binding: Submit', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should invoke the supplied function on submit and prevent default action, using model as \'this\' param and the form node as a param to the handler': function () {
+                var firstParamStored;
+                var model = { wasCalled: false, doCall: function (firstParam) { this.wasCalled = true; firstParamStored = firstParam; } };
+                testNode.innerHTML = "<form " + bindingAttribute + "='submit:doCall' />";
+                var formNode = testNode.childNodes[0];
+                ko.applyBindings(model, testNode);
+                ko.utils.triggerEvent(testNode.childNodes[0], "submit");
+                value_of(model.wasCalled).should_be(true);
+                value_of(firstParamStored).should_be(formNode);
+            }
+        });
 
+        describe('Binding: Event', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should invoke the supplied function when the event occurs, using model as \'this\' param and first arg, and event as second arg': function () {
+                var model = {
+                    firstWasCalled: false,
+                    firstHandler: function (passedModel, evt) {
+                        value_of(evt.type).should_be("click");
+                        value_of(this).should_be(model);
+                        value_of(passedModel).should_be(model);
+
+                        value_of(model.firstWasCalled).should_be(false);
+                        model.firstWasCalled = true;
+                    },
+
+                    secondWasCalled: false,
+                    secondHandler: function (passedModel, evt) {
+                        value_of(evt.type).should_be("mouseover");
+                        value_of(this).should_be(model);
+                        value_of(passedModel).should_be(model);
+
+                        value_of(model.secondWasCalled).should_be(false);
+                        model.secondWasCalled = true;
+                    }
+                };
+                testNode.innerHTML = "<button " + bindingAttribute + "='event:{click:firstHandler, mouseover:secondHandler, mouseout:null}'>hey</button>";
+                ko.applyBindings(model, testNode);
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(model.firstWasCalled).should_be(true);
                 value_of(model.secondWasCalled).should_be(false);
-                model.secondWasCalled = true; 
+                ko.utils.triggerEvent(testNode.childNodes[0], "mouseover");
+                value_of(model.secondWasCalled).should_be(true);
+                ko.utils.triggerEvent(testNode.childNodes[0], "mouseout"); // Shouldn't do anything (specifically, shouldn't throw)
+            },
+
+            'Should prevent default action': function () {
+                testNode.innerHTML = "<a href='http://www.example.com/' " + bindingAttribute + "='event: { click: function() { } }'>hey</a>";
+                ko.applyBindings(null, testNode);
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                // Assuming we haven't been redirected to http://www.example.com/, this spec has now passed
+            },
+
+            'Should let bubblable events bubble to parent elements by default': function () {
+                var model = {
+                    innerWasCalled: false, innerDoCall: function () { this.innerWasCalled = true; },
+                    outerWasCalled: false, outerDoCall: function () { this.outerWasCalled = true; }
+                };
+                testNode.innerHTML = "<div " + bindingAttribute + "='event:{click:outerDoCall}'><button " + bindingAttribute + "='event:{click:innerDoCall}'>hey</button></div>";
+                ko.applyBindings(model, testNode);
+                ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
+                value_of(model.innerWasCalled).should_be(true);
+                value_of(model.outerWasCalled).should_be(true);
+            },
+
+            'Should be able to prevent bubbling of bubblable events using the (eventname)Bubble:false option': function () {
+                var model = {
+                    innerWasCalled: false, innerDoCall: function () { this.innerWasCalled = true; },
+                    outerWasCalled: false, outerDoCall: function () { this.outerWasCalled = true; }
+                };
+                testNode.innerHTML = "<div " + bindingAttribute + "='event:{click:outerDoCall}'><button " + bindingAttribute + "='event:{click:innerDoCall}, clickBubble:false'>hey</button></div>";
+                ko.applyBindings(model, testNode);
+                ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
+                value_of(model.innerWasCalled).should_be(true);
+                value_of(model.outerWasCalled).should_be(false);
+            },
+
+            'Should be able to supply event type as event.type': function () {
+                var model = { clickCalled: false };
+                testNode.innerHTML = "<button " + bindingAttribute + "='event.click: function() { clickCalled = true; }'>hey</button>";
+                ko.applyBindings(model, testNode);
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(model.clickCalled).should_be(true);
+            },
+
+            'Should call function in correct context if using \'eventHandlersUseObjectForThis\' option': function () {
+                var model = { subModel: { wasCalled: false, clickFunc: function () { this.wasCalled = true } } };
+                testNode.innerHTML = "<button " + bindingAttribute + "='event: {click: subModel.clickFunc}'>hey</button>";
+                ko.applyBindings(model, testNode, { eventHandlersUseObjectForThis: true });
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(model.subModel.wasCalled).should_be(true);
+            },
+
+            'Should be able to supply handler params using "bind" helper': function () {
+                // Using "bind" like this just eliminates the function literal wrapper - it's purely stylistic
+                var didCallHandler = false, someObj = {};
+                var myHandler = function () {
+                    value_of(this).should_be(someObj);
+                    value_of(arguments.length).should_be(5);
+
+                    // First x args will be the ones you bound
+                    value_of(arguments[0]).should_be(123);
+                    value_of(arguments[1]).should_be("another");
+                    value_of(arguments[2].something).should_be(true);
+
+                    // Then you get the args we normally pass to handlers, i.e., the model then the event
+                    value_of(arguments[3]).should_be(viewModel);
+                    value_of(arguments[4].type).should_be("mouseover");
+
+                    didCallHandler = true;
+                };
+                testNode.innerHTML = "<button " + bindingAttribute + "='event:{ mouseover: myHandler.bind(someObj, 123, \"another\", { something: true }) }'>hey</button>";
+                var viewModel = { myHandler: myHandler, someObj: someObj };
+                ko.applyBindings(viewModel, testNode);
+                ko.utils.triggerEvent(testNode.childNodes[0], "mouseover");
+                value_of(didCallHandler).should_be(true);
             }
-        };
-        testNode.innerHTML = "<button data-bind='event:{click:firstHandler, mouseover:secondHandler, mouseout:null}'>hey</button>";
-        ko.applyBindings(model, testNode);
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        value_of(model.firstWasCalled).should_be(true);
-        value_of(model.secondWasCalled).should_be(false);
-        ko.utils.triggerEvent(testNode.childNodes[0], "mouseover");
-        value_of(model.secondWasCalled).should_be(true);
-        ko.utils.triggerEvent(testNode.childNodes[0], "mouseout"); // Shouldn't do anything (specifically, shouldn't throw)
-    },
+        });
 
-    'Should prevent default action': function () {
-        testNode.innerHTML = "<a href='http://www.example.com/' data-bind='event: { click: function() { } }'>hey</a>";
-        ko.applyBindings(null, testNode);
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        // Assuming we haven't been redirected to http://www.example.com/, this spec has now passed
-    },
-    
-    'Should let bubblable events bubble to parent elements by default': function() {
-        var model = { 
-            innerWasCalled: false, innerDoCall: function () { this.innerWasCalled = true; },
-            outerWasCalled: false, outerDoCall: function () { this.outerWasCalled = true; }
-        };
-        testNode.innerHTML = "<div data-bind='event:{click:outerDoCall}'><button data-bind='event:{click:innerDoCall}'>hey</button></div>";
-        ko.applyBindings(model, testNode);
-        ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
-        value_of(model.innerWasCalled).should_be(true);    	
-        value_of(model.outerWasCalled).should_be(true);    	
-    },
-    
-    'Should be able to prevent bubbling of bubblable events using the (eventname)Bubble:false option': function() {
-        var model = { 
-            innerWasCalled: false, innerDoCall: function () { this.innerWasCalled = true; },
-            outerWasCalled: false, outerDoCall: function () { this.outerWasCalled = true; }
-        };
-        testNode.innerHTML = "<div data-bind='event:{click:outerDoCall}'><button data-bind='event:{click:innerDoCall}, clickBubble:false'>hey</button></div>";
-        ko.applyBindings(model, testNode);
-        ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
-        value_of(model.innerWasCalled).should_be(true);    	
-        value_of(model.outerWasCalled).should_be(false);    	
-    },
+        describe('Binding: Click', {
+            // This is just a special case of the "event" binding, so not necessary to respecify all its behaviours	
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should invoke the supplied function on click, using model as \'this\' param and first arg, and event as second arg': function () {
+                var model = {
+                    wasCalled: false,
+                    doCall: function (arg1, arg2) {
+                        this.wasCalled = true;
+                        value_of(arg1).should_be(model);
+                        value_of(arg2.type).should_be("click");
+                    }
+                };
+                testNode.innerHTML = "<button " + bindingAttribute + "='click:doCall'>hey</button>";
+                ko.applyBindings(model, testNode);
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(model.wasCalled).should_be(true);
+            }
+        });
 
-    'Should be able to supply event type as event.type': function() {
-        var model = { clickCalled: false };
-        testNode.innerHTML = "<button data-bind='event.click: function() { clickCalled = true; }'>hey</button>";
-        ko.applyBindings(model, testNode);
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        value_of(model.clickCalled).should_be(true);
-    },
+        describe('Binding: CSS class name', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should give the element the specific CSS class only when the specified value is true': function () {
+                var observable1 = new ko.observable();
+                var observable2 = new ko.observable(true);
+                testNode.innerHTML = "<div class='unrelatedClass1 unrelatedClass2' " + bindingAttribute + "='css: { myRule: someModelProperty, anotherRule: anotherModelProperty }'>Hallo</div>";
+                ko.applyBindings({ someModelProperty: observable1, anotherModelProperty: observable2 }, testNode);
+
+                value_of(testNode.childNodes[0].className).should_be("unrelatedClass1 unrelatedClass2 anotherRule");
+                observable1(true);
+                value_of(testNode.childNodes[0].className).should_be("unrelatedClass1 unrelatedClass2 anotherRule myRule");
+                observable2(false);
+                value_of(testNode.childNodes[0].className).should_be("unrelatedClass1 unrelatedClass2 myRule");
+            },
 
-    'Should call function in correct context if using \'eventHandlersUseObjectForThis\' option': function() {
-        var model = { subModel: { wasCalled: false, clickFunc: function() {this.wasCalled = true} } };
-        testNode.innerHTML = "<button data-bind='event: {click: subModel.clickFunc}'>hey</button>";
-        ko.applyBindings(model, testNode, {eventHandlersUseObjectForThis: true});
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        value_of(model.subModel.wasCalled).should_be(true);
-    },
+            'Should give the element a single CSS class without a leading space when the specified value is true': function () {
+                var observable1 = new ko.observable();
+                testNode.innerHTML = "<div " + bindingAttribute + "='css: { myRule: someModelProperty }'>Hallo</div>";
+                ko.applyBindings({ someModelProperty: observable1 }, testNode);
 
-    'Should be able to supply handler params using "bind" helper': function() {
-        // Using "bind" like this just eliminates the function literal wrapper - it's purely stylistic
-        var didCallHandler = false, someObj = {};
-        var myHandler = function() {
-            value_of(this).should_be(someObj);
-            value_of(arguments.length).should_be(5);
-
-            // First x args will be the ones you bound
-            value_of(arguments[0]).should_be(123);
-            value_of(arguments[1]).should_be("another");
-            value_of(arguments[2].something).should_be(true);
-
-            // Then you get the args we normally pass to handlers, i.e., the model then the event
-            value_of(arguments[3]).should_be(viewModel);
-            value_of(arguments[4].type).should_be("mouseover");
-
-            didCallHandler = true;
-        };
-        testNode.innerHTML = "<button data-bind='event:{ mouseover: myHandler.bind(someObj, 123, \"another\", { something: true }) }'>hey</button>";
-        var viewModel = { myHandler: myHandler, someObj: someObj };
-        ko.applyBindings(viewModel, testNode);
-        ko.utils.triggerEvent(testNode.childNodes[0], "mouseover");
-        value_of(didCallHandler).should_be(true);        
-    }
-});
-
-describe('Binding: Click', {
-    // This is just a special case of the "event" binding, so not necessary to respecify all its behaviours	
-    before_each: prepareTestNode,
-
-    'Should invoke the supplied function on click, using model as \'this\' param and first arg, and event as second arg': function () {
-        var model = { 
-            wasCalled: false, 
-            doCall: function (arg1, arg2) { 
-                this.wasCalled = true;
-                value_of(arg1).should_be(model);
-                value_of(arg2.type).should_be("click");
-            } 
-        };
-        testNode.innerHTML = "<button data-bind='click:doCall'>hey</button>";
-        ko.applyBindings(model, testNode);
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        value_of(model.wasCalled).should_be(true);
-    }
-});
-
-describe('Binding: CSS class name', {
-    before_each: prepareTestNode,
-
-    'Should give the element the specific CSS class only when the specified value is true': function () {
-        var observable1 = new ko.observable();
-        var observable2 = new ko.observable(true);
-        testNode.innerHTML = "<div class='unrelatedClass1 unrelatedClass2' data-bind='css: { myRule: someModelProperty, anotherRule: anotherModelProperty }'>Hallo</div>";
-        ko.applyBindings({ someModelProperty: observable1, anotherModelProperty: observable2 }, testNode);
-
-        value_of(testNode.childNodes[0].className).should_be("unrelatedClass1 unrelatedClass2 anotherRule");
-        observable1(true);
-        value_of(testNode.childNodes[0].className).should_be("unrelatedClass1 unrelatedClass2 anotherRule myRule");
-        observable2(false);
-        value_of(testNode.childNodes[0].className).should_be("unrelatedClass1 unrelatedClass2 myRule");
-    },
-    
-    'Should give the element a single CSS class without a leading space when the specified value is true': function() {
-        var observable1 = new ko.observable();
-        testNode.innerHTML = "<div data-bind='css: { myRule: someModelProperty }'>Hallo</div>";
-        ko.applyBindings({ someModelProperty: observable1 }, testNode);
-
-        value_of(testNode.childNodes[0].className).should_be("");
-        observable1(true);
-        value_of(testNode.childNodes[0].className).should_be("myRule");
-    }
-});
+                value_of(testNode.childNodes[0].className).should_be("");
+                observable1(true);
+                value_of(testNode.childNodes[0].className).should_be("myRule");
+            }
+        });
 
-describe('Binding: CSS style', {
-    before_each: prepareTestNode,
+        describe('Binding: CSS style', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should give the element the specified CSS style value': function () {
+                var myObservable = new ko.observable("red");
+                testNode.innerHTML = "<div " + bindingAttribute + "='style: { backgroundColor: colorValue }'>Hallo</div>";
+                ko.applyBindings({ colorValue: myObservable }, testNode);
+
+                value_of(testNode.childNodes[0].style.backgroundColor).should_be_one_of(["red", "#ff0000"]); // Opera returns style color values in #rrggbb notation, unlike other browsers
+                myObservable("green");
+                value_of(testNode.childNodes[0].style.backgroundColor).should_be_one_of(["green", "#008000"]);
+                myObservable(undefined);
+                value_of(testNode.childNodes[0].style.backgroundColor).should_be("");
+            }
+        });
 
-    'Should give the element the specified CSS style value': function () {
-        var myObservable = new ko.observable("red");
-        testNode.innerHTML = "<div data-bind='style: { backgroundColor: colorValue }'>Hallo</div>";
-        ko.applyBindings({ colorValue: myObservable }, testNode);
+        describe('Binding: Unique Name', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should apply a different name to each element': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='uniqueName: true'></div><div " + bindingAttribute + "='uniqueName: true'></div>";
+                ko.applyBindings({}, testNode);
 
-        value_of(testNode.childNodes[0].style.backgroundColor).should_be_one_of(["red", "#ff0000"]); // Opera returns style color values in #rrggbb notation, unlike other browsers
-        myObservable("green");
-        value_of(testNode.childNodes[0].style.backgroundColor).should_be_one_of(["green", "#008000"]);
-        myObservable(undefined);
-        value_of(testNode.childNodes[0].style.backgroundColor).should_be("");
-    }
-});
+                value_of(testNode.childNodes[0].name.length > 0).should_be(true);
+                value_of(testNode.childNodes[1].name.length > 0).should_be(true);
+                value_of(testNode.childNodes[0].name == testNode.childNodes[1].name).should_be(false);
+            },
 
-describe('Binding: Unique Name', {
-    before_each: prepareTestNode,
+            'Should work without a value': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='uniqueName'></div><div " + bindingAttribute + "='uniqueName'></div>";
+                ko.applyBindings({}, testNode);
 
-    'Should apply a different name to each element': function () {
-        testNode.innerHTML = "<div data-bind='uniqueName: true'></div><div data-bind='uniqueName: true'></div>";
-        ko.applyBindings({}, testNode);
+                value_of(testNode.childNodes[0].name.length > 0).should_be(true);
+                value_of(testNode.childNodes[1].name.length > 0).should_be(true);
+                value_of(testNode.childNodes[0].name == testNode.childNodes[1].name).should_be(false);
+            }
+        });
 
-        value_of(testNode.childNodes[0].name.length > 0).should_be(true);
-        value_of(testNode.childNodes[1].name.length > 0).should_be(true);
-        value_of(testNode.childNodes[0].name == testNode.childNodes[1].name).should_be(false);
-    },
+        describe('Binding: Checked', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Triggering a click should toggle a checkbox\'s checked state before the event handler fires': function () {
+                // This isn't strictly to do with the checked binding, but if this doesn't work, the rest of the specs aren't meaningful
+                testNode.innerHTML = "<input type='checkbox' />";
+                var clickHandlerFireCount = 0, expectedCheckedStateInHandler;
+                ko.utils.registerEventHandler(testNode.childNodes[0], "click", function () {
+                    clickHandlerFireCount++;
+                    value_of(testNode.childNodes[0].checked).should_be(expectedCheckedStateInHandler);
+                })
+                value_of(testNode.childNodes[0].checked).should_be(false);
+                expectedCheckedStateInHandler = true;
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(testNode.childNodes[0].checked).should_be(true);
+                value_of(clickHandlerFireCount).should_be(1);
+
+                expectedCheckedStateInHandler = false;
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(testNode.childNodes[0].checked).should_be(false);
+                value_of(clickHandlerFireCount).should_be(2);
+            },
 
-    'Should work without a value': function () {
-        testNode.innerHTML = "<div data-bind='uniqueName'></div><div data-bind='uniqueName'></div>";
-        ko.applyBindings({}, testNode);
+            'Should be able to control a checkbox\'s checked state': function () {
+                var myobservable = new ko.observable(true);
+                testNode.innerHTML = "<input type='checkbox' " + bindingAttribute + "='checked:someProp' />";
 
-        value_of(testNode.childNodes[0].name.length > 0).should_be(true);
-        value_of(testNode.childNodes[1].name.length > 0).should_be(true);
-        value_of(testNode.childNodes[0].name == testNode.childNodes[1].name).should_be(false);
-    }
-});
-
-describe('Binding: Checked', {
-    before_each: prepareTestNode,
-
-    'Triggering a click should toggle a checkbox\'s checked state before the event handler fires': function() {
-        // This isn't strictly to do with the checked binding, but if this doesn't work, the rest of the specs aren't meaningful
-        testNode.innerHTML = "<input type='checkbox' />";	
-        var clickHandlerFireCount = 0, expectedCheckedStateInHandler;
-        ko.utils.registerEventHandler(testNode.childNodes[0], "click", function() { 
-            clickHandlerFireCount++; 
-            value_of(testNode.childNodes[0].checked).should_be(expectedCheckedStateInHandler);
-        })
-        value_of(testNode.childNodes[0].checked).should_be(false);
-        expectedCheckedStateInHandler = true;
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        value_of(testNode.childNodes[0].checked).should_be(true);
-        value_of(clickHandlerFireCount).should_be(1);
-        
-        expectedCheckedStateInHandler = false;
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        value_of(testNode.childNodes[0].checked).should_be(false);
-        value_of(clickHandlerFireCount).should_be(2);
-    },
+                ko.applyBindings({ someProp: myobservable }, testNode);
+                value_of(testNode.childNodes[0].checked).should_be(true);
 
-    'Should be able to control a checkbox\'s checked state': function () {
-        var myobservable = new ko.observable(true);
-        testNode.innerHTML = "<input type='checkbox' data-bind='checked:someProp' />";
+                myobservable(false);
+                value_of(testNode.childNodes[0].checked).should_be(false);
+            },
 
-        ko.applyBindings({ someProp: myobservable }, testNode);
-        value_of(testNode.childNodes[0].checked).should_be(true);
+            'Should update observable properties on the underlying model when the checkbox click event fires': function () {
+                var myobservable = new ko.observable(false);
+                testNode.innerHTML = "<input type='checkbox' " + bindingAttribute + "='checked:someProp' />";
+                ko.applyBindings({ someProp: myobservable }, testNode);
 
-        myobservable(false);
-        value_of(testNode.childNodes[0].checked).should_be(false);
-    },
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(myobservable()).should_be(true);
+            },
 
-    'Should update observable properties on the underlying model when the checkbox click event fires': function () {
-        var myobservable = new ko.observable(false);
-        testNode.innerHTML = "<input type='checkbox' data-bind='checked:someProp' />";
-        ko.applyBindings({ someProp: myobservable }, testNode);
+            'Should only notify observable properties on the underlying model *once* even if the checkbox change events fire multiple times': function () {
+                var myobservable = new ko.observable();
+                var timesNotified = 0;
+                myobservable.subscribe(function () { timesNotified++ });
+                testNode.innerHTML = "<input type='checkbox' " + bindingAttribute + "='checked:someProp' />";
+                ko.applyBindings({ someProp: myobservable }, testNode);
+
+                // Multiple events only cause one notification...
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                value_of(timesNotified).should_be(1);
+
+                // ... until the checkbox value actually changes
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                value_of(timesNotified).should_be(2);
+            },
 
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        value_of(myobservable()).should_be(true);
-    },
-    
-    'Should only notify observable properties on the underlying model *once* even if the checkbox change events fire multiple times': function () {
-        var myobservable = new ko.observable();
-        var timesNotified = 0;
-        myobservable.subscribe(function() { timesNotified++ });
-        testNode.innerHTML = "<input type='checkbox' data-bind='checked:someProp' />";
-        ko.applyBindings({ someProp: myobservable }, testNode);
-
-        // Multiple events only cause one notification...
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        value_of(timesNotified).should_be(1);
-        
-        // ... until the checkbox value actually changes
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        value_of(timesNotified).should_be(2);        
-    },    
-
-    'Should update non-observable properties on the underlying model when the checkbox click event fires': function () {
-        var model = { someProp: false };
-        testNode.innerHTML = "<input type='checkbox' data-bind='checked:someProp' />";
-        ko.applyBindings(model, testNode);
-
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        value_of(model.someProp).should_be(true);
-    },
+            'Should update non-observable properties on the underlying model when the checkbox click event fires': function () {
+                var model = { someProp: false };
+                testNode.innerHTML = "<input type='checkbox' " + bindingAttribute + "='checked:someProp' />";
+                ko.applyBindings(model, testNode);
 
-    'Should update observable properties on the underlying model when the checkbox is clicked': function () {
-        var myobservable = new ko.observable(false);
-        testNode.innerHTML = "<input type='checkbox' data-bind='checked:someProp' />";
-        ko.applyBindings({ someProp: myobservable }, testNode);
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(model.someProp).should_be(true);
+            },
 
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");		
-        value_of(myobservable()).should_be(true);
-    },
+            'Should update observable properties on the underlying model when the checkbox is clicked': function () {
+                var myobservable = new ko.observable(false);
+                testNode.innerHTML = "<input type='checkbox' " + bindingAttribute + "='checked:someProp' />";
+                ko.applyBindings({ someProp: myobservable }, testNode);
 
-    'Should update non-observable properties on the underlying model when the checkbox is clicked': function () {
-        var model = { someProp: false };
-        testNode.innerHTML = "<input type='checkbox' data-bind='checked:someProp' />";
-        ko.applyBindings(model, testNode);
-        
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        value_of(model.someProp).should_be(true);
-    },
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(myobservable()).should_be(true);
+            },
 
-    'Should make a radio button checked if and only if its value matches the bound model property': function () {
-        var myobservable = new ko.observable("another value");
-        testNode.innerHTML = "<input type='radio' value='This Radio Button Value' data-bind='checked:someProp' />";
+            'Should update non-observable properties on the underlying model when the checkbox is clicked': function () {
+                var model = { someProp: false };
+                testNode.innerHTML = "<input type='checkbox' " + bindingAttribute + "='checked:someProp' />";
+                ko.applyBindings(model, testNode);
 
-        ko.applyBindings({ someProp: myobservable }, testNode);
-        value_of(testNode.childNodes[0].checked).should_be(false);
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(model.someProp).should_be(true);
+            },
 
-        myobservable("This Radio Button Value");
-        value_of(testNode.childNodes[0].checked).should_be(true);
-    },
+            'Should make a radio button checked if and only if its value matches the bound model property': function () {
+                var myobservable = new ko.observable("another value");
+                testNode.innerHTML = "<input type='radio' value='This Radio Button Value' " + bindingAttribute + "='checked:someProp' />";
 
-    'Should set an observable model property to this radio button\'s value when checked': function () {
-        var myobservable = new ko.observable("another value");
-        testNode.innerHTML = "<input type='radio' value='this radio button value' data-bind='checked:someProp' />";
-        ko.applyBindings({ someProp: myobservable }, testNode);
+                ko.applyBindings({ someProp: myobservable }, testNode);
+                value_of(testNode.childNodes[0].checked).should_be(false);
 
-        value_of(myobservable()).should_be("another value");
-        testNode.childNodes[0].click();
-        value_of(myobservable()).should_be("this radio button value");
-    },
-    
-    'Should only notify observable properties on the underlying model *once* even if the radio button change/click events fire multiple times': function () {
-        var myobservable = new ko.observable("original value");
-        var timesNotified = 0;
-        myobservable.subscribe(function() { timesNotified++ });
-        testNode.innerHTML = "<input type='radio' value='this radio button value' data-bind='checked:someProp' /><input type='radio' value='different value' data-bind='checked:someProp' />";
-        ko.applyBindings({ someProp: myobservable }, testNode);
-
-        // Multiple events only cause one notification...
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        ko.utils.triggerEvent(testNode.childNodes[0], "change");
-        value_of(timesNotified).should_be(1);
-        
-        // ... until you click something with a different value
-        ko.utils.triggerEvent(testNode.childNodes[1], "click");
-        ko.utils.triggerEvent(testNode.childNodes[1], "change");
-        value_of(timesNotified).should_be(2);        
-    },     
-
-    'Should set a non-observable model property to this radio button\'s value when checked': function () {
-        var model = { someProp: "another value" };
-        testNode.innerHTML = "<input type='radio' value='this radio button value' data-bind='checked:someProp' />";
-        ko.applyBindings(model, testNode);
-
-        ko.utils.triggerEvent(testNode.childNodes[0], "click");
-        value_of(model.someProp).should_be("this radio button value");
-    },
-    
-    'When a checkbox is bound to an array, the checkbox should control whether its value is in that array': function() {
-        var model = { myArray: ["Existing value", "Unrelated value"] };
-        testNode.innerHTML = "<input type='checkbox' value='Existing value' data-bind='checked:myArray' />"
-                           + "<input type='checkbox' value='New value'      data-bind='checked:myArray' />";
-        ko.applyBindings(model, testNode);
-
-        value_of(model.myArray).should_be(["Existing value", "Unrelated value"]);
-
-        // Checkbox initial state is determined by whether the value is in the array
-        value_of(testNode.childNodes[0].checked).should_be(true);
-        value_of(testNode.childNodes[1].checked).should_be(false);
-        // Checking the checkbox puts it in the array
-        ko.utils.triggerEvent(testNode.childNodes[1], "click");        
-        value_of(testNode.childNodes[1].checked).should_be(true);
-        value_of(model.myArray).should_be(["Existing value", "Unrelated value", "New value"]);
-        // Unchecking the checkbox removes it from the array
-        ko.utils.triggerEvent(testNode.childNodes[1], "click");        
-        value_of(testNode.childNodes[1].checked).should_be(false);
-        value_of(model.myArray).should_be(["Existing value", "Unrelated value"]);
-    },
-    
-    'When a checkbox is bound to an observable array, the checkbox checked state responds to changes in the array': function() {
-        var model = { myObservableArray: ko.observableArray(["Unrelated value"]) };
-        testNode.innerHTML = "<input type='checkbox' value='My value' data-bind='checked:myObservableArray' />";
-        ko.applyBindings(model, testNode);
-
-        value_of(testNode.childNodes[0].checked).should_be(false);
-        
-        // Put the value in the array; observe the checkbox reflect this
-        model.myObservableArray.push("My value");
-        value_of(testNode.childNodes[0].checked).should_be(true);
-
-        // Remove the value from the array; observe the checkbox reflect this
-        model.myObservableArray.remove("My value");
-        value_of(testNode.childNodes[0].checked).should_be(false);
-    }    
-});
-
-describe('Binding: Attr', {
-    before_each: prepareTestNode,
-  
-    'Should be able to set arbitrary attribute values': function() {
-        var model = { myValue: "first value" };
-        testNode.innerHTML = "<div data-bind='attr: {firstAttribute: myValue, \"second-attribute\": true}'></div>";
-        ko.applyBindings(model, testNode);
-        value_of(testNode.childNodes[0].getAttribute("firstAttribute")).should_be("first value");
-        value_of(testNode.childNodes[0].getAttribute("second-attribute")).should_be("true");
-    },
-    
-    'Should be able to set arbitrary attribute values (without quotes)': function() {
-        var model = { myValue: "first value" };
-        testNode.innerHTML = "<div data-bind='attr: {firstAttribute: myValue, second-attribute: true}'></div>";
-        ko.applyBindings(model, testNode);
-        value_of(testNode.childNodes[0].getAttribute("firstAttribute")).should_be("first value");
-        value_of(testNode.childNodes[0].getAttribute("second-attribute")).should_be("true");
-    },
-    
-    'Should respond to changes in an observable value': function() {
-        var model = { myprop : ko.observable("initial value") };
-        testNode.innerHTML = "<div data-bind='attr: { someAttrib: myprop }'></div>";
-        ko.applyBindings(model, testNode);
-        value_of(testNode.childNodes[0].getAttribute("someAttrib")).should_be("initial value");
-        
-        // Change the observable; observe it reflected in the DOM
-        model.myprop("new value");
-        value_of(testNode.childNodes[0].getAttribute("someAttrib")).should_be("new value");
-    },
-    
-    'Should remove the attribute if the value is strictly false, null, or undefined': function() {
-        var model = { myprop : ko.observable() };
-        testNode.innerHTML = "<div data-bind='attr: { someAttrib: myprop }'></div>";
-        ko.applyBindings(model, testNode);
-        ko.utils.arrayForEach([false, null, undefined], function(testValue) {
-            model.myprop("nonempty value");
-            value_of(testNode.childNodes[0].getAttribute("someAttrib")).should_be("nonempty value");	
-            model.myprop(testValue);
-            value_of(testNode.childNodes[0].getAttribute("someAttrib")).should_be(null);        
-        });        
-    },
+                myobservable("This Radio Button Value");
+                value_of(testNode.childNodes[0].checked).should_be(true);
+            },
 
-    'Should be able to set class attribute and access it using className property': function() {
-        var model = { myprop : ko.observable("newClass") };
-        testNode.innerHTML = "<div class='oldClass' data-bind=\"attr: {'class': myprop}\"></div>";
-        value_of(testNode.childNodes[0].className).should_be("oldClass");
-        ko.applyBindings(model, testNode);
-        value_of(testNode.childNodes[0].className).should_be("newClass");
-        // Should be able to clear class also
-        model.myprop(undefined);
-        value_of(testNode.childNodes[0].className).should_be("");        
-        value_of(testNode.childNodes[0].getAttribute("class")).should_be(null);        
-    }  
-});
-
-describe('Binding: Hasfocus', {
-    before_each: prepareTestNode,
-
-    'Should respond to changes on an observable value by blurring or focusing the element': function() {
-        var currentState;
-        var model = { myVal: ko.observable() }
-        testNode.innerHTML = "<input data-bind='hasfocus: myVal' /><input />";        
-        ko.applyBindings(model, testNode);
-        ko.utils.registerEventHandler(testNode.childNodes[0], "focusin", function() { currentState = true });
-        ko.utils.registerEventHandler(testNode.childNodes[0], "focusout",  function() { currentState = false });
-
-        // When the value becomes true, we focus
-        model.myVal(true);
-        value_of(currentState).should_be(true);
-
-        // When the value becomes false, we blur
-        model.myVal(false);
-        value_of(currentState).should_be(false);        
-    },    
-
-    'Should set an observable value to be true on focus and false on blur': function() {
-        var model = { myVal: ko.observable() }
-        testNode.innerHTML = "<input data-bind='hasfocus: myVal' /><input />";
-        ko.applyBindings(model, testNode);
-
-        // Need to raise "focusin" and "focusout" manually, because simply calling ".focus()" and ".blur()"
-        // in IE doesn't reliably trigger the "focus" and "blur" events synchronously
-        
-        ko.utils.triggerEvent(testNode.childNodes[0], "focusin");
-        value_of(model.myVal()).should_be(true);
-
-        // Move the focus elsewhere
-        ko.utils.triggerEvent(testNode.childNodes[0], "focusout");
-        value_of(model.myVal()).should_be(false);
-    },
+            'Should set an observable model property to this radio button\'s value when checked': function () {
+                var myobservable = new ko.observable("another value");
+                testNode.innerHTML = "<input type='radio' value='this radio button value' " + bindingAttribute + "='checked:someProp' />";
+                ko.applyBindings({ someProp: myobservable }, testNode);
 
-    'Should set a non-observable value to be true on focus and false on blur': function() {
-        var model = { myVal: null }
-        testNode.innerHTML = "<input data-bind='hasfocus: myVal' /><input />";
-        ko.applyBindings(model, testNode);
+                value_of(myobservable()).should_be("another value");
+                testNode.childNodes[0].click();
+                value_of(myobservable()).should_be("this radio button value");
+            },
 
-        ko.utils.triggerEvent(testNode.childNodes[0], "focusin");
-        value_of(model.myVal).should_be(true);
+            'Should only notify observable properties on the underlying model *once* even if the radio button change/click events fire multiple times': function () {
+                var myobservable = new ko.observable("original value");
+                var timesNotified = 0;
+                myobservable.subscribe(function () { timesNotified++ });
+                testNode.innerHTML = "<input type='radio' value='this radio button value' " + bindingAttribute + "='checked:someProp' /><input type='radio' value='different value' " + bindingAttribute + "='checked:someProp' />";
+                ko.applyBindings({ someProp: myobservable }, testNode);
+
+                // Multiple events only cause one notification...
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                ko.utils.triggerEvent(testNode.childNodes[0], "change");
+                value_of(timesNotified).should_be(1);
+
+                // ... until you click something with a different value
+                ko.utils.triggerEvent(testNode.childNodes[1], "click");
+                ko.utils.triggerEvent(testNode.childNodes[1], "change");
+                value_of(timesNotified).should_be(2);
+            },
 
-        // Move the focus elsewhere
-        ko.utils.triggerEvent(testNode.childNodes[0], "focusout");
-        value_of(model.myVal).should_be(false);        
-    }
-});
+            'Should set a non-observable model property to this radio button\'s value when checked': function () {
+                var model = { someProp: "another value" };
+                testNode.innerHTML = "<input type='radio' value='this radio button value' " + bindingAttribute + "='checked:someProp' />";
+                ko.applyBindings(model, testNode);
 
-describe('Binding: If', {
-    before_each: prepareTestNode,
+                ko.utils.triggerEvent(testNode.childNodes[0], "click");
+                value_of(model.someProp).should_be("this radio button value");
+            },
 
-    'Should remove descendant nodes from the document (and not bind them) if the value is falsey': function() {
-        testNode.innerHTML = "<div data-bind='if: someItem'><span data-bind='text: someItem.nonExistentChildProp'></span></div>";
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        ko.applyBindings({ someItem: null }, testNode);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);		
-    },
-    
-    'Should leave descendant nodes in the document (and bind them) if the value is truey, independently of the active template engine': function() {		
-        ko.setTemplateEngine(new ko.templateEngine()); // This template engine will just throw errors if you try to use it
-        testNode.innerHTML = "<div data-bind='if: someItem'><span data-bind='text: someItem.existentChildProp'></span></div>";
-        value_of(testNode.childNodes.length).should_be(1);
-        ko.applyBindings({ someItem: { existentChildProp: 'Child prop value' } }, testNode);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
-    },
-    
-    'Should toggle the presence and bindedness of descendant nodes according to the truthiness of the value': function() {
-        var someItem = ko.observable(undefined);
-        testNode.innerHTML = "<div data-bind='if: someItem'><span data-bind='text: someItem().occasionallyExistentChildProp'></span></div>";
-        ko.applyBindings({ someItem: someItem }, testNode);
-        
-        // First it's not there
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);
-        
-        // Then it's there
-        someItem({ occasionallyExistentChildProp: 'Child prop value' });
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
-        
-        // Then it's gone again
-        someItem(null);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);
-    },
+            'When a checkbox is bound to an array, the checkbox should control whether its value is in that array': function () {
+                var model = { myArray: ["Existing value", "Unrelated value"] };
+                testNode.innerHTML = "<input type='checkbox' value='Existing value' " + bindingAttribute + "='checked:myArray' />"
+                           + "<input type='checkbox' value='New value'      " + bindingAttribute + "='checked:myArray' />";
+                ko.applyBindings(model, testNode);
+
+                value_of(model.myArray).should_be(["Existing value", "Unrelated value"]);
+
+                // Checkbox initial state is determined by whether the value is in the array
+                value_of(testNode.childNodes[0].checked).should_be(true);
+                value_of(testNode.childNodes[1].checked).should_be(false);
+                // Checking the checkbox puts it in the array
+                ko.utils.triggerEvent(testNode.childNodes[1], "click");
+                value_of(testNode.childNodes[1].checked).should_be(true);
+                value_of(model.myArray).should_be(["Existing value", "Unrelated value", "New value"]);
+                // Unchecking the checkbox removes it from the array
+                ko.utils.triggerEvent(testNode.childNodes[1], "click");
+                value_of(testNode.childNodes[1].checked).should_be(false);
+                value_of(model.myArray).should_be(["Existing value", "Unrelated value"]);
+            },
 
-    'Should not interfere with binding context': function() {
-        testNode.innerHTML = "<div data-bind='if: true'>Parents: <span data-bind='text: $parents.length'></span></div>";
-        ko.applyBindings({ }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_text("Parents: 0");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[1]).$parents.length).should_be(0);
-    },
-    
-    'Should be able to define an \"if\" region using a containerless template': function() {
-        var someitem = ko.observable(undefined);
-        testNode.innerHTML = "hello <!-- ko if: someitem --><span data-bind=\"text: someitem().occasionallyexistentchildprop\"></span><!-- /ko --> goodbye";
-        ko.applyBindings({ someitem: someitem }, testNode);
-        
-        // First it's not there
-        value_of(testNode).should_contain_html("hello <!-- ko if: someitem --><!-- /ko --> goodbye");
-        
-        // Then it's there
-        someitem({ occasionallyexistentchildprop: 'child prop value' });
-        value_of(testNode).should_contain_html("hello <!-- ko if: someitem --><span data-bind=\"text: someitem().occasionallyexistentchildprop\">child prop value</span><!-- /ko --> goodbye");
-
-        // Then it's gone again
-        someitem(null);
-        value_of(testNode).should_contain_html("hello <!-- ko if: someitem --><!-- /ko --> goodbye");
-    },
-    
-    'Should be able to nest \"if\" regions defined by containerless templates': function() {
-        var condition1 = ko.observable(false);
-        var condition2 = ko.observable(false);
-        testNode.innerHTML = "hello <!-- ko if: condition1 -->First is true<!-- ko if: condition2 -->Both are true<!-- /ko --><!-- /ko -->";
-        ko.applyBindings({ condition1: condition1, condition2: condition2 }, testNode);
-
-        // First neither are there
-        value_of(testNode).should_contain_html("hello <!-- ko if: condition1 --><!-- /ko -->");
-
-        // Make outer appear
-        condition1(true);
-        value_of(testNode).should_contain_html("hello <!-- ko if: condition1 -->first is true<!-- ko if: condition2 --><!-- /ko --><!-- /ko -->");
-
-        // Make inner appear
-        condition2(true);
-        value_of(testNode).should_contain_html("hello <!-- ko if: condition1 -->first is true<!-- ko if: condition2 -->both are true<!-- /ko --><!-- /ko -->");
-    } 
-});
-
-describe('Binding: Ifnot', {
-    before_each: prepareTestNode,
-
-    'Should remove descendant nodes from the document (and not bind them) if the value is truey': function() {
-        testNode.innerHTML = "<div data-bind='ifnot: condition'><span data-bind='text: someItem.nonExistentChildProp'></span></div>";
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        ko.applyBindings({ someItem: null, condition: true }, testNode);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);		
-    },
-    
-    'Should leave descendant nodes in the document (and bind them) if the value is falsey, independently of the active template engine': function() {		
-        ko.setTemplateEngine(new ko.templateEngine()); // This template engine will just throw errors if you try to use it
-        testNode.innerHTML = "<div data-bind='ifnot: condition'><span data-bind='text: someItem.existentChildProp'></span></div>";
-        value_of(testNode.childNodes.length).should_be(1);
-        ko.applyBindings({ someItem: { existentChildProp: 'Child prop value' }, condition: false }, testNode);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
-    },
-    
-    'Should toggle the presence and bindedness of descendant nodes according to the falsiness of the value': function() {
-        var someItem = ko.observable(undefined);
-        var condition = ko.observable(true);
-        testNode.innerHTML = "<div data-bind='ifnot: condition'><span data-bind='text: someItem().occasionallyExistentChildProp'></span></div>";
-        ko.applyBindings({ someItem: someItem, condition: condition }, testNode);
-        
-        // First it's not there
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);
-        
-        // Then it's there
-        someItem({ occasionallyExistentChildProp: 'Child prop value' });
-        condition(false);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
-        
-        // Then it's gone again
-        condition(true);
-        someItem(null);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);
-    },
+            'When a checkbox is bound to an observable array, the checkbox checked state responds to changes in the array': function () {
+                var model = { myObservableArray: ko.observableArray(["Unrelated value"]) };
+                testNode.innerHTML = "<input type='checkbox' value='My value' " + bindingAttribute + "='checked:myObservableArray' />";
+                ko.applyBindings(model, testNode);
 
-    'Should not interfere with binding context': function() {
-        testNode.innerHTML = "<div data-bind='ifnot: false'>Parents: <span data-bind='text: $parents.length'></span></div>";
-        ko.applyBindings({ }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_text("Parents: 0");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[1]).$parents.length).should_be(0);
-    }
-});
+                value_of(testNode.childNodes[0].checked).should_be(false);
 
-describe('Binding: With Light', {
-    before_each: prepareTestNode,
+                // Put the value in the array; observe the checkbox reflect this
+                model.myObservableArray.push("My value");
+                value_of(testNode.childNodes[0].checked).should_be(true);
 
-    'Should leave descendant nodes in the document (and bind them in the context of the supplied value) if the value is truey': function() {		
-        testNode.innerHTML = "<div data-bind='withlight: someItem'><span data-bind='text: existentChildProp'></span></div>";
-        value_of(testNode.childNodes.length).should_be(1);
-        ko.applyBindings({ someItem: { existentChildProp: 'Child prop value' } }, testNode);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
-    },
+                // Remove the value from the array; observe the checkbox reflect this
+                model.myObservableArray.remove("My value");
+                value_of(testNode.childNodes[0].checked).should_be(false);
+            }
+        });
+
+        describe('Binding: Attr', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should be able to set arbitrary attribute values': function () {
+                var model = { myValue: "first value" };
+                testNode.innerHTML = "<div " + bindingAttribute + "='attr: {firstAttribute: myValue, \"second-attribute\": true}'></div>";
+                ko.applyBindings(model, testNode);
+                value_of(testNode.childNodes[0].getAttribute("firstAttribute")).should_be("first value");
+                value_of(testNode.childNodes[0].getAttribute("second-attribute")).should_be("true");
+            },
 
-    'Should not bind the same elements more than once even if the supplied value notifies a change': function() {
-        var countedClicks = 0;
-        var someItem = ko.observable({
-            childProp: ko.observable('Hello'),
-            handleClick: function() { countedClicks++ }
+            'Should be able to set arbitrary attribute values (without quotes)': function () {
+                var model = { myValue: "first value" };
+                testNode.innerHTML = "<div " + bindingAttribute + "='attr: {firstAttribute: myValue, second-attribute: true}'></div>";
+                ko.applyBindings(model, testNode);
+                value_of(testNode.childNodes[0].getAttribute("firstAttribute")).should_be("first value");
+                value_of(testNode.childNodes[0].getAttribute("second-attribute")).should_be("true");
+            },
+
+            'Should respond to changes in an observable value': function () {
+                var model = { myprop: ko.observable("initial value") };
+                testNode.innerHTML = "<div " + bindingAttribute + "='attr: { someAttrib: myprop }'></div>";
+                ko.applyBindings(model, testNode);
+                value_of(testNode.childNodes[0].getAttribute("someAttrib")).should_be("initial value");
+
+                // Change the observable; observe it reflected in the DOM
+                model.myprop("new value");
+                value_of(testNode.childNodes[0].getAttribute("someAttrib")).should_be("new value");
+            },
+
+            'Should remove the attribute if the value is strictly false, null, or undefined': function () {
+                var model = { myprop: ko.observable() };
+                testNode.innerHTML = "<div " + bindingAttribute + "='attr: { someAttrib: myprop }'></div>";
+                ko.applyBindings(model, testNode);
+                ko.utils.arrayForEach([false, null, undefined], function (testValue) {
+                    model.myprop("nonempty value");
+                    value_of(testNode.childNodes[0].getAttribute("someAttrib")).should_be("nonempty value");
+                    model.myprop(testValue);
+                    value_of(testNode.childNodes[0].getAttribute("someAttrib")).should_be(null);
+                });
+            },
+
+            'Should be able to set class attribute and access it using className property': function () {
+                var model = { myprop: ko.observable("newClass") };
+                testNode.innerHTML = "<div class='oldClass' " + bindingAttribute + "=\"attr: {'class': myprop}\"></div>";
+                value_of(testNode.childNodes[0].className).should_be("oldClass");
+                ko.applyBindings(model, testNode);
+                value_of(testNode.childNodes[0].className).should_be("newClass");
+                // Should be able to clear class also
+                model.myprop(undefined);
+                value_of(testNode.childNodes[0].className).should_be("");
+                value_of(testNode.childNodes[0].getAttribute("class")).should_be(null);
+            }
         });
-        
-        testNode.innerHTML = "<div data-bind='withlight: someItem'><span data-bind='text: childProp, click: handleClick'></span></div>";
-        ko.applyBindings({ someItem: someItem }, testNode);
-        
-        // Initial state is one subscriber, one click handler
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Hello");
-        value_of(someItem().childProp.getSubscriptionsCount()).should_be(1);
-        ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
-        value_of(countedClicks).should_be(1);
-        
-        // Force "update" binding handler to fire, then check we still have one subscriber...
-        someItem.valueHasMutated();
-        value_of(someItem().childProp.getSubscriptionsCount()).should_be(1);
-        
-        // ... and one click handler
-        countedClicks = 0;
-        ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
-        value_of(countedClicks).should_be(1);		
-    },
-    
-    'Should be able to access parent binding context via $parent': function() {
-        testNode.innerHTML = "<div data-bind='withlight: someItem'><span data-bind='text: $parent.parentProp'></span></div>";
-        ko.applyBindings({ someItem: { }, parentProp: 'Parent prop value' }, testNode);
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Parent prop value");
-    },
-    
-    'Should be able to access all parent binding contexts via $parents, and root context via $root': function() {
-        testNode.innerHTML = "<div data-bind='withlight: topItem'>" +
-                                "<div data-bind='withlight: middleItem'>" +
-                                    "<div data-bind='withlight: bottomItem'>" +
-                                        "<span data-bind='text: name'></span>" +
-                                        "<span data-bind='text: $parent.name'></span>" +
-                                        "<span data-bind='text: $parents[1].name'></span>" +
-                                        "<span data-bind='text: $parents[2].name'></span>" +
-                                        "<span data-bind='text: $root.name'></span>" +
+
+        describe('Binding: Hasfocus', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should respond to changes on an observable value by blurring or focusing the element': function () {
+                var currentState;
+                var model = { myVal: ko.observable() }
+                testNode.innerHTML = "<input " + bindingAttribute + "='hasfocus: myVal' /><input />";
+                ko.applyBindings(model, testNode);
+                ko.utils.registerEventHandler(testNode.childNodes[0], "focusin", function () { currentState = true });
+                ko.utils.registerEventHandler(testNode.childNodes[0], "focusout", function () { currentState = false });
+
+                // When the value becomes true, we focus
+                model.myVal(true);
+                value_of(currentState).should_be(true);
+
+                // When the value becomes false, we blur
+                model.myVal(false);
+                value_of(currentState).should_be(false);
+            },
+
+            'Should set an observable value to be true on focus and false on blur': function () {
+                var model = { myVal: ko.observable() }
+                testNode.innerHTML = "<input " + bindingAttribute + "='hasfocus: myVal' /><input />";
+                ko.applyBindings(model, testNode);
+
+                // Need to raise "focusin" and "focusout" manually, because simply calling ".focus()" and ".blur()"
+                // in IE doesn't reliably trigger the "focus" and "blur" events synchronously
+
+                ko.utils.triggerEvent(testNode.childNodes[0], "focusin");
+                value_of(model.myVal()).should_be(true);
+
+                // Move the focus elsewhere
+                ko.utils.triggerEvent(testNode.childNodes[0], "focusout");
+                value_of(model.myVal()).should_be(false);
+            },
+
+            'Should set a non-observable value to be true on focus and false on blur': function () {
+                var model = { myVal: null }
+                testNode.innerHTML = "<input " + bindingAttribute + "='hasfocus: myVal' /><input />";
+                ko.applyBindings(model, testNode);
+
+                ko.utils.triggerEvent(testNode.childNodes[0], "focusin");
+                value_of(model.myVal).should_be(true);
+
+                // Move the focus elsewhere
+                ko.utils.triggerEvent(testNode.childNodes[0], "focusout");
+                value_of(model.myVal).should_be(false);
+            }
+        });
+
+        describe('Binding: If', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should remove descendant nodes from the document (and not bind them) if the value is falsey': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='if: someItem'><span " + bindingAttribute + "='text: someItem.nonExistentChildProp'></span></div>";
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                ko.applyBindings({ someItem: null }, testNode);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+            },
+
+            'Should leave descendant nodes in the document (and bind them) if the value is truey, independently of the active template engine': function () {
+                ko.setTemplateEngine(new ko.templateEngine()); // This template engine will just throw errors if you try to use it
+                testNode.innerHTML = "<div " + bindingAttribute + "='if: someItem'><span " + bindingAttribute + "='text: someItem.existentChildProp'></span></div>";
+                value_of(testNode.childNodes.length).should_be(1);
+                ko.applyBindings({ someItem: { existentChildProp: 'Child prop value'} }, testNode);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
+            },
+
+            'Should toggle the presence and bindedness of descendant nodes according to the truthiness of the value': function () {
+                var someItem = ko.observable(undefined);
+                testNode.innerHTML = "<div " + bindingAttribute + "='if: someItem'><span " + bindingAttribute + "='text: someItem().occasionallyExistentChildProp'></span></div>";
+                ko.applyBindings({ someItem: someItem }, testNode);
+
+                // First it's not there
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+
+                // Then it's there
+                someItem({ occasionallyExistentChildProp: 'Child prop value' });
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
+
+                // Then it's gone again
+                someItem(null);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+            },
+
+            'Should not interfere with binding context': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='if: true'>Parents: <span " + bindingAttribute + "='text: $parents.length'></span></div>";
+                ko.applyBindings({}, testNode);
+                value_of(testNode.childNodes[0]).should_contain_text("Parents: 0");
+                value_of(ko.contextFor(testNode.childNodes[0].childNodes[1]).$parents.length).should_be(0);
+            },
+
+            'Should be able to define an \"if\" region using a containerless template': function () {
+                var someitem = ko.observable(undefined);
+                testNode.innerHTML = "hello <!-- " + virtualElementTag + " if: someitem --><span " + bindingAttribute + "=\"text: someitem().occasionallyexistentchildprop\"></span><!--/" + virtualElementTag + " --> goodbye";
+                ko.applyBindings({ someitem: someitem }, testNode);
+
+                // First it's not there
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " if: someitem --><!--/" + virtualElementTag + " --> goodbye");
+
+                // Then it's there
+                someitem({ occasionallyexistentchildprop: 'child prop value' });
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " if: someitem --><span " + bindingAttribute + "=\"text: someitem().occasionallyexistentchildprop\">child prop value</span><!--/" + virtualElementTag + " --> goodbye");
+
+                // Then it's gone again
+                someitem(null);
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " if: someitem --><!--/" + virtualElementTag + " --> goodbye");
+            },
+
+            'Should be able to nest \"if\" regions defined by containerless templates': function () {
+                var condition1 = ko.observable(false);
+                var condition2 = ko.observable(false);
+                testNode.innerHTML = "hello <!-- " + virtualElementTag + " if: condition1 -->First is true<!-- " + virtualElementTag + " if: condition2 -->Both are true<!--/" + virtualElementTag + " --><!--/" + virtualElementTag + " -->";
+                ko.applyBindings({ condition1: condition1, condition2: condition2 }, testNode);
+
+                // First neither are there
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " if: condition1 --><!--/" + virtualElementTag + " -->");
+
+                // Make outer appear
+                condition1(true);
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " if: condition1 -->first is true<!-- " + virtualElementTag + " if: condition2 --><!--/" + virtualElementTag + " --><!--/" + virtualElementTag + " -->");
+
+                // Make inner appear
+                condition2(true);
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " if: condition1 -->first is true<!-- " + virtualElementTag + " if: condition2 -->both are true<!--/" + virtualElementTag + " --><!--/" + virtualElementTag + " -->");
+            }
+        });
+
+        describe('Binding: Ifnot', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should remove descendant nodes from the document (and not bind them) if the value is truey': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='ifnot: condition'><span " + bindingAttribute + "='text: someItem.nonExistentChildProp'></span></div>";
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                ko.applyBindings({ someItem: null, condition: true }, testNode);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+            },
+
+            'Should leave descendant nodes in the document (and bind them) if the value is falsey, independently of the active template engine': function () {
+                ko.setTemplateEngine(new ko.templateEngine()); // This template engine will just throw errors if you try to use it
+                testNode.innerHTML = "<div " + bindingAttribute + "='ifnot: condition'><span " + bindingAttribute + "='text: someItem.existentChildProp'></span></div>";
+                value_of(testNode.childNodes.length).should_be(1);
+                ko.applyBindings({ someItem: { existentChildProp: 'Child prop value' }, condition: false }, testNode);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
+            },
+
+            'Should toggle the presence and bindedness of descendant nodes according to the falsiness of the value': function () {
+                var someItem = ko.observable(undefined);
+                var condition = ko.observable(true);
+                testNode.innerHTML = "<div " + bindingAttribute + "='ifnot: condition'><span " + bindingAttribute + "='text: someItem().occasionallyExistentChildProp'></span></div>";
+                ko.applyBindings({ someItem: someItem, condition: condition }, testNode);
+
+                // First it's not there
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+
+                // Then it's there
+                someItem({ occasionallyExistentChildProp: 'Child prop value' });
+                condition(false);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
+
+                // Then it's gone again
+                condition(true);
+                someItem(null);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+            },
+
+            'Should not interfere with binding context': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='ifnot: false'>Parents: <span " + bindingAttribute + "='text: $parents.length'></span></div>";
+                ko.applyBindings({}, testNode);
+                value_of(testNode.childNodes[0]).should_contain_text("Parents: 0");
+                value_of(ko.contextFor(testNode.childNodes[0].childNodes[1]).$parents.length).should_be(0);
+            }
+        });
+
+        describe('Binding: With Light', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should leave descendant nodes in the document (and bind them in the context of the supplied value) if the value is truey': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='withlight: someItem'><span " + bindingAttribute + "='text: existentChildProp'></span></div>";
+                value_of(testNode.childNodes.length).should_be(1);
+                ko.applyBindings({ someItem: { existentChildProp: 'Child prop value'} }, testNode);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
+            },
+
+            'Should not bind the same elements more than once even if the supplied value notifies a change': function () {
+                var countedClicks = 0;
+                var someItem = ko.observable({
+                    childProp: ko.observable('Hello'),
+                    handleClick: function () { countedClicks++ }
+                });
+
+                testNode.innerHTML = "<div " + bindingAttribute + "='withlight: someItem'><span " + bindingAttribute + "='text: childProp, click: handleClick'></span></div>";
+                ko.applyBindings({ someItem: someItem }, testNode);
+
+                // Initial state is one subscriber, one click handler
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Hello");
+                value_of(someItem().childProp.getSubscriptionsCount()).should_be(1);
+                ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
+                value_of(countedClicks).should_be(1);
+
+                // Force "update" binding handler to fire, then check we still have one subscriber...
+                someItem.valueHasMutated();
+                value_of(someItem().childProp.getSubscriptionsCount()).should_be(1);
+
+                // ... and one click handler
+                countedClicks = 0;
+                ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
+                value_of(countedClicks).should_be(1);
+            },
+
+            'Should be able to access parent binding context via $parent': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='withlight: someItem'><span " + bindingAttribute + "='text: $parent.parentProp'></span></div>";
+                ko.applyBindings({ someItem: {}, parentProp: 'Parent prop value' }, testNode);
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Parent prop value");
+            },
+
+            'Should be able to access all parent binding contexts via $parents, and root context via $root': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='withlight: topItem'>" +
+                                "<div " + bindingAttribute + "='withlight: middleItem'>" +
+                                    "<div " + bindingAttribute + "='withlight: bottomItem'>" +
+                                        "<span " + bindingAttribute + "='text: name'></span>" +
+                                        "<span " + bindingAttribute + "='text: $parent.name'></span>" +
+                                        "<span " + bindingAttribute + "='text: $parents[1].name'></span>" +
+                                        "<span " + bindingAttribute + "='text: $parents[2].name'></span>" +
+                                        "<span " + bindingAttribute + "='text: $root.name'></span>" +
                                     "</div>" +
                                 "</div>" +
                               "</div>";
-        ko.applyBindings({ 
-            name: 'outer',
-            topItem: {
-                name: 'top',
-                middleItem: { 
-                    name: 'middle',
-                    bottomItem: {
-                        name: "bottom"
+                ko.applyBindings({
+                    name: 'outer',
+                    topItem: {
+                        name: 'top',
+                        middleItem: {
+                            name: 'middle',
+                            bottomItem: {
+                                name: "bottom"
+                            }
+                        }
                     }
-                }
-            }
-        }, testNode);
-        var finalContainer = testNode.childNodes[0].childNodes[0].childNodes[0];
-        value_of(finalContainer.childNodes[0]).should_contain_text("bottom");
-        value_of(finalContainer.childNodes[1]).should_contain_text("middle");
-        value_of(finalContainer.childNodes[2]).should_contain_text("top");
-        value_of(finalContainer.childNodes[3]).should_contain_text("outer");
-        value_of(finalContainer.childNodes[4]).should_contain_text("outer");
-
-        // Also check that, when we later retrieve the binding contexts, we get consistent results
-        value_of(ko.contextFor(testNode).$data.name).should_be("outer");
-        value_of(ko.contextFor(testNode.childNodes[0]).$data.name).should_be("outer");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[0]).$data.name).should_be("top");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0]).$data.name).should_be("middle");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0]).$data.name).should_be("bottom");
-        var firstSpan = testNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0];
-        value_of(firstSpan.tagName).should_be("SPAN");
-        value_of(ko.contextFor(firstSpan).$data.name).should_be("bottom");
-        value_of(ko.contextFor(firstSpan).$root.name).should_be("outer");
-        value_of(ko.contextFor(firstSpan).$parents[1].name).should_be("top");
-    },
+                }, testNode);
+                var finalContainer = testNode.childNodes[0].childNodes[0].childNodes[0];
+                value_of(finalContainer.childNodes[0]).should_contain_text("bottom");
+                value_of(finalContainer.childNodes[1]).should_contain_text("middle");
+                value_of(finalContainer.childNodes[2]).should_contain_text("top");
+                value_of(finalContainer.childNodes[3]).should_contain_text("outer");
+                value_of(finalContainer.childNodes[4]).should_contain_text("outer");
+
+                // Also check that, when we later retrieve the binding contexts, we get consistent results
+                value_of(ko.contextFor(testNode).$data.name).should_be("outer");
+                value_of(ko.contextFor(testNode.childNodes[0]).$data.name).should_be("outer");
+                value_of(ko.contextFor(testNode.childNodes[0].childNodes[0]).$data.name).should_be("top");
+                value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0]).$data.name).should_be("middle");
+                value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0]).$data.name).should_be("bottom");
+                var firstSpan = testNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0];
+                value_of(firstSpan.tagName).should_be("SPAN");
+                value_of(ko.contextFor(firstSpan).$data.name).should_be("bottom");
+                value_of(ko.contextFor(firstSpan).$root.name).should_be("outer");
+                value_of(ko.contextFor(firstSpan).$parents[1].name).should_be("top");
+            },
 
-    'Should be able to define a \"withlight\" region using a containerless binding': function() {
-        var someitem = ko.observable({someItem: 'first value'});
-        testNode.innerHTML = "xxx <!-- ko withlight: someitem --><span data-bind=\"text: someItem\"></span><!-- /ko -->";
-        ko.applyBindings({ someitem: someitem }, testNode);
+            'Should be able to define a \"withlight\" region using a containerless binding': function () {
+                var someitem = ko.observable({ someItem: 'first value' });
+                testNode.innerHTML = "xxx <!-- " + virtualElementTag + " withlight: someitem --><span " + bindingAttribute + "=\"text: someItem\"></span><!--/" + virtualElementTag + " -->";
+                ko.applyBindings({ someitem: someitem }, testNode);
 
-        value_of(testNode).should_contain_text("xxx first value");
+                value_of(testNode).should_contain_text("xxx first value");
 
-        someitem({ someItem: 'second value' });
-        value_of(testNode).should_contain_text("xxx second value");
-    },
+                someitem({ someItem: 'second value' });
+                value_of(testNode).should_contain_text("xxx second value");
+            },
 
-    'Should be able to use \"withlight\" within an observable top-level view model': function() {
-        var vm = ko.observable({someitem: ko.observable({someItem: 'first value'})});
-        testNode.innerHTML = "xxx <!-- ko withlight: someitem --><span data-bind=\"text: someItem\"></span><!-- /ko -->";
-        ko.applyBindings(vm, testNode);
+            'Should be able to use \"withlight\" within an observable top-level view model': function () {
+                var vm = ko.observable({ someitem: ko.observable({ someItem: 'first value' }) });
+                testNode.innerHTML = "xxx <!-- " + virtualElementTag + " withlight: someitem --><span " + bindingAttribute + "=\"text: someItem\"></span><!--/" + virtualElementTag + " -->";
+                ko.applyBindings(vm, testNode);
 
-        value_of(testNode).should_contain_text("xxx first value");
+                value_of(testNode).should_contain_text("xxx first value");
 
-        vm({someitem: ko.observable({ someItem: 'second value' })});
-        value_of(testNode).should_contain_text("xxx second value");
-    },
+                vm({ someitem: ko.observable({ someItem: 'second value' }) });
+                value_of(testNode).should_contain_text("xxx second value");
+            },
 
-    'Should be able to nest a containerless template within \"withlight\"': function() {
-        testNode.innerHTML = "<div data-bind='withlight: someitem'>text" +
-            "<!-- ko foreach: childprop --><span data-bind='text: $data'></span><!-- /ko --></div>";
+            'Should be able to nest a containerless template within \"withlight\"': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='withlight: someitem'>text" +
+            "<!-- " + virtualElementTag + " foreach: childprop --><span " + bindingAttribute + "='text: $data'></span><!--/" + virtualElementTag + " --></div>";
 
-        var childprop = ko.observableArray([]);
-        var someitem = ko.observable({childprop: childprop});
-        var viewModel = {someitem: someitem};
-        ko.applyBindings(viewModel, testNode);
+                var childprop = ko.observableArray([]);
+                var someitem = ko.observable({ childprop: childprop });
+                var viewModel = { someitem: someitem };
+                ko.applyBindings(viewModel, testNode);
 
-        // First it's not there (by template)
-        var container = testNode.childNodes[0];
-        value_of(container).should_contain_html("text<!-- ko foreach: childprop --><!-- /ko -->");
+                // First it's not there (by template)
+                var container = testNode.childNodes[0];
+                value_of(container).should_contain_html("text<!-- " + virtualElementTag + " foreach: childprop --><!--/" + virtualElementTag + " -->");
 
-        // Then it's there
-        childprop.push('me')
-        value_of(container).should_contain_html("text<!-- ko foreach: childprop --><span data-bind=\"text: $data\">me</span><!-- /ko -->");
+                // Then it's there
+                childprop.push('me')
+                value_of(container).should_contain_html("text<!-- " + virtualElementTag + " foreach: childprop --><span " + bindingAttribute + "=\"text: $data\">me</span><!--/" + virtualElementTag + " -->");
 
-        // Then there's a second one
-        childprop.push('me2')
-        value_of(container).should_contain_html("text<!-- ko foreach: childprop --><span data-bind=\"text: $data\">me</span><span data-bind=\"text: $data\">me2</span><!-- /ko -->");
+                // Then there's a second one
+                childprop.push('me2')
+                value_of(container).should_contain_html("text<!-- " + virtualElementTag + " foreach: childprop --><span " + bindingAttribute + "=\"text: $data\">me</span><span " + bindingAttribute + "=\"text: $data\">me2</span><!--/" + virtualElementTag + " -->");
 
-        // Then it changes
-        someitem({childprop: ['notme']});
-        container = testNode.childNodes[0];
-        value_of(container).should_contain_html("text<!-- ko foreach: childprop --><span data-bind=\"text: $data\">notme</span><!-- /ko -->");
-    }
-});
+                // Then it changes
+                someitem({ childprop: ['notme'] });
+                container = testNode.childNodes[0];
+                value_of(container).should_contain_html("text<!-- " + virtualElementTag + " foreach: childprop --><span " + bindingAttribute + "=\"text: $data\">notme</span><!--/" + virtualElementTag + " -->");
+            }
+        });
+
+        describe('Binding: With', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should remove descendant nodes from the document (and not bind them) if the value is falsey': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='with: someItem'><span " + bindingAttribute + "='text: someItem.nonExistentChildProp'></span></div>";
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                ko.applyBindings({ someItem: null }, testNode);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+            },
 
-describe('Binding: With', {
-    before_each: prepareTestNode,
+            'Should leave descendant nodes in the document (and bind them in the context of the supplied value) if the value is truey': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='with: someItem'><span " + bindingAttribute + "='text: existentChildProp'></span></div>";
+                value_of(testNode.childNodes.length).should_be(1);
+                ko.applyBindings({ someItem: { existentChildProp: 'Child prop value'} }, testNode);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
+            },
 
-    'Should remove descendant nodes from the document (and not bind them) if the value is falsey': function() {
-        testNode.innerHTML = "<div data-bind='with: someItem'><span data-bind='text: someItem.nonExistentChildProp'></span></div>";
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        ko.applyBindings({ someItem: null }, testNode);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);		
-    },
-    
-    'Should leave descendant nodes in the document (and bind them in the context of the supplied value) if the value is truey': function() {		
-        testNode.innerHTML = "<div data-bind='with: someItem'><span data-bind='text: existentChildProp'></span></div>";
-        value_of(testNode.childNodes.length).should_be(1);
-        ko.applyBindings({ someItem: { existentChildProp: 'Child prop value' } }, testNode);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
-    },
-    
-    'Should toggle the presence and bindedness of descendant nodes according to the truthiness of the value, performing binding in the context of the value': function() {
-        var someItem = ko.observable(undefined);
-        testNode.innerHTML = "<div data-bind='with: someItem'><span data-bind='text: occasionallyExistentChildProp'></span></div>";
-        ko.applyBindings({ someItem: someItem }, testNode);
-        
-        // First it's not there
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);
-        
-        // Then it's there
-        someItem({ occasionallyExistentChildProp: 'Child prop value' });
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
-        
-        // Then it's gone again
-        someItem(null);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);
-    },
-    
-    'Should not bind the same elements more than once even if the supplied value notifies a change': function() {
-        var countedClicks = 0;
-        var someItemContents = {
-            childProp: ko.observable('Hello'),
-            handleClick: function() { countedClicks++ }
-        };
-        var someItem = ko.observable(someItemContents);
-        
-        testNode.innerHTML = "<div data-bind='with: someItem'><span data-bind='click: handleClick, text: childProp'></span></div>";
-        ko.applyBindings({ someItem: someItem }, testNode);
-        
-        // Initial state is one subscriber, one click handler
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Hello");
-        value_of(someItem().childProp.getSubscriptionsCount()).should_be(1);
-        ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
-        value_of(countedClicks).should_be(1);
-        
-        // Force "update" binding handler to fire, then check we still have one subscriber...
-        someItem.valueHasMutated();
-        value_of(someItem().childProp.getSubscriptionsCount()).should_be(1);
-        
-        // ... and one click handler
-        countedClicks = 0;
-        ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
-        value_of(countedClicks).should_be(1);		
-
-        // Clear and restore data, then check we still have one subscriber...
-        someItem(null);
-        someItem(someItemContents);
-        value_of(someItem().childProp.getSubscriptionsCount()).should_be(1);
-        
-        // ... and one click handler
-        countedClicks = 0;
-        ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
-        value_of(countedClicks).should_be(1);		
-    },
-    
-    'Should be able to access parent binding context via $parent': function() {
-        testNode.innerHTML = "<div data-bind='with: someItem'><span data-bind='text: $parent.parentProp'></span></div>";
-        ko.applyBindings({ someItem: { }, parentProp: 'Parent prop value' }, testNode);
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Parent prop value");
-    },
-    
-    'Should be able to access all parent binding contexts via $parents, and root context via $root': function() {
-        testNode.innerHTML = "<div data-bind='with: topItem'>" +
-                                "<div data-bind='with: middleItem'>" +
-                                    "<div data-bind='with: bottomItem'>" +
-                                        "<span data-bind='text: name'></span>" +
-                                        "<span data-bind='text: $parent.name'></span>" +
-                                        "<span data-bind='text: $parents[1].name'></span>" +
-                                        "<span data-bind='text: $parents[2].name'></span>" +
-                                        "<span data-bind='text: $root.name'></span>" +
+            'Should toggle the presence and bindedness of descendant nodes according to the truthiness of the value, performing binding in the context of the value': function () {
+                var someItem = ko.observable(undefined);
+                testNode.innerHTML = "<div " + bindingAttribute + "='with: someItem'><span " + bindingAttribute + "='text: occasionallyExistentChildProp'></span></div>";
+                ko.applyBindings({ someItem: someItem }, testNode);
+
+                // First it's not there
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+
+                // Then it's there
+                someItem({ occasionallyExistentChildProp: 'Child prop value' });
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Child prop value");
+
+                // Then it's gone again
+                someItem(null);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+            },
+
+            'Should not bind the same elements more than once even if the supplied value notifies a change': function () {
+                var countedClicks = 0;
+                var someItemContents = {
+                    childProp: ko.observable('Hello'),
+                    handleClick: function () { countedClicks++ }
+                };
+                var someItem = ko.observable(someItemContents);
+
+                testNode.innerHTML = "<div " + bindingAttribute + "='with: someItem'><span " + bindingAttribute + "='click: handleClick, text: childProp'></span></div>";
+                ko.applyBindings({ someItem: someItem }, testNode);
+
+                // Initial state is one subscriber, one click handler
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Hello");
+                value_of(someItem().childProp.getSubscriptionsCount()).should_be(1);
+                ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
+                value_of(countedClicks).should_be(1);
+
+                // Force "update" binding handler to fire, then check we still have one subscriber...
+                someItem.valueHasMutated();
+                value_of(someItem().childProp.getSubscriptionsCount()).should_be(1);
+
+                // ... and one click handler
+                countedClicks = 0;
+                ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
+                value_of(countedClicks).should_be(1);
+
+                // Clear and restore data, then check we still have one subscriber...
+                someItem(null);
+                someItem(someItemContents);
+                value_of(someItem().childProp.getSubscriptionsCount()).should_be(1);
+
+                // ... and one click handler
+                countedClicks = 0;
+                ko.utils.triggerEvent(testNode.childNodes[0].childNodes[0], "click");
+                value_of(countedClicks).should_be(1);
+            },
+
+            'Should be able to access parent binding context via $parent': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='with: someItem'><span " + bindingAttribute + "='text: $parent.parentProp'></span></div>";
+                ko.applyBindings({ someItem: {}, parentProp: 'Parent prop value' }, testNode);
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Parent prop value");
+            },
+
+            'Should be able to access all parent binding contexts via $parents, and root context via $root': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='with: topItem'>" +
+                                "<div " + bindingAttribute + "='with: middleItem'>" +
+                                    "<div " + bindingAttribute + "='with: bottomItem'>" +
+                                        "<span " + bindingAttribute + "='text: name'></span>" +
+                                        "<span " + bindingAttribute + "='text: $parent.name'></span>" +
+                                        "<span " + bindingAttribute + "='text: $parents[1].name'></span>" +
+                                        "<span " + bindingAttribute + "='text: $parents[2].name'></span>" +
+                                        "<span " + bindingAttribute + "='text: $root.name'></span>" +
                                     "</div>" +
                                 "</div>" +
                               "</div>";
-        ko.applyBindings({ 
-            name: 'outer',
-            topItem: {
-                name: 'top',
-                middleItem: { 
-                    name: 'middle',
-                    bottomItem: {
-                        name: "bottom"
+                ko.applyBindings({
+                    name: 'outer',
+                    topItem: {
+                        name: 'top',
+                        middleItem: {
+                            name: 'middle',
+                            bottomItem: {
+                                name: "bottom"
+                            }
+                        }
                     }
-                }
-            }
-        }, testNode);
-        var finalContainer = testNode.childNodes[0].childNodes[0].childNodes[0];
-        value_of(finalContainer.childNodes[0]).should_contain_text("bottom");
-        value_of(finalContainer.childNodes[1]).should_contain_text("middle");
-        value_of(finalContainer.childNodes[2]).should_contain_text("top");
-        value_of(finalContainer.childNodes[3]).should_contain_text("outer");
-        value_of(finalContainer.childNodes[4]).should_contain_text("outer");
-
-        // Also check that, when we later retrieve the binding contexts, we get consistent results
-        value_of(ko.contextFor(testNode).$data.name).should_be("outer");
-        value_of(ko.contextFor(testNode.childNodes[0]).$data.name).should_be("outer");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[0]).$data.name).should_be("top");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0]).$data.name).should_be("middle");
-        value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0]).$data.name).should_be("bottom");
-        var firstSpan = testNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0];
-        value_of(firstSpan.tagName).should_be("SPAN");
-        value_of(ko.contextFor(firstSpan).$data.name).should_be("bottom");
-        value_of(ko.contextFor(firstSpan).$root.name).should_be("outer");
-        value_of(ko.contextFor(firstSpan).$parents[1].name).should_be("top");
-    },
-    
-    'Should be able to define a \"with\" region using a containerless binding': function() {
-        var someitem = ko.observable(undefined);
-        testNode.innerHTML = "hello <!-- ko with: someitem --><span data-bind=\"text: occasionallyexistentchildprop\"></span><!-- /ko --> goodbye";
-        ko.applyBindings({ someitem: someitem }, testNode);
-        
-        // First it's not there
-        value_of(testNode).should_contain_html("hello <!-- ko with: someitem --><!-- /ko --> goodbye");
-        
-        // Then it's there
-        someitem({ occasionallyexistentchildprop: 'child prop value' });
-        value_of(testNode).should_contain_html("hello <!-- ko with: someitem --><span data-bind=\"text: occasionallyexistentchildprop\">child prop value</span><!-- /ko --> goodbye");
-
-        // Then it's gone again
-        someitem(null);
-        value_of(testNode).should_contain_html("hello <!-- ko with: someitem --><!-- /ko --> goodbye");
-    },
-    
-    'Should be able to nest \"with\" regions defined by containerless templates': function() {
-        testNode.innerHTML = "hello <!-- ko with: topitem -->" 
-                               + "Got top: <span data-bind=\"text: topprop\"></span>" 
-                               + "<!-- ko with: childitem -->"
-                                   + "Got child: <span data-bind=\"text: childprop\"></span>"
-                               + "<!-- /ko -->"
-                           + "<!-- /ko -->";
-        var viewModel = { topitem: ko.observable(null) };
-        ko.applyBindings(viewModel, testNode);
-
-        // First neither are there
-        value_of(testNode).should_contain_html("hello <!-- ko with: topitem --><!-- /ko -->");
-
-        // Make top appear
-        viewModel.topitem({ topprop: 'property of top', childitem: ko.observable() });
-        value_of(testNode).should_contain_html("hello <!-- ko with: topitem -->got top: <span data-bind=\"text: topprop\">property of top</span><!-- ko with: childitem --><!-- /ko --><!-- /ko -->");
-
-        // Make child appear
-        viewModel.topitem().childitem({ childprop: 'property of child' });
-        value_of(testNode).should_contain_html("hello <!-- ko with: topitem -->got top: <span data-bind=\"text: topprop\">property of top</span><!-- ko with: childitem -->got child: <span data-bind=\"text: childprop\">property of child</span><!-- /ko --><!-- /ko -->");
-
-        // Make top disappear
-        viewModel.topitem(null);
-        value_of(testNode).should_contain_html("hello <!-- ko with: topitem --><!-- /ko -->");
-    },
+                }, testNode);
+                var finalContainer = testNode.childNodes[0].childNodes[0].childNodes[0];
+                value_of(finalContainer.childNodes[0]).should_contain_text("bottom");
+                value_of(finalContainer.childNodes[1]).should_contain_text("middle");
+                value_of(finalContainer.childNodes[2]).should_contain_text("top");
+                value_of(finalContainer.childNodes[3]).should_contain_text("outer");
+                value_of(finalContainer.childNodes[4]).should_contain_text("outer");
+
+                // Also check that, when we later retrieve the binding contexts, we get consistent results
+                value_of(ko.contextFor(testNode).$data.name).should_be("outer");
+                value_of(ko.contextFor(testNode.childNodes[0]).$data.name).should_be("outer");
+                value_of(ko.contextFor(testNode.childNodes[0].childNodes[0]).$data.name).should_be("top");
+                value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0]).$data.name).should_be("middle");
+                value_of(ko.contextFor(testNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0]).$data.name).should_be("bottom");
+                var firstSpan = testNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0];
+                value_of(firstSpan.tagName).should_be("SPAN");
+                value_of(ko.contextFor(firstSpan).$data.name).should_be("bottom");
+                value_of(ko.contextFor(firstSpan).$root.name).should_be("outer");
+                value_of(ko.contextFor(firstSpan).$parents[1].name).should_be("top");
+            },
 
-    'Should be able to nest a containerless template within \"with\"': function() {
-        testNode.innerHTML = "<div data-bind='with: someitem'>text" +
-            "<!-- ko foreach: childprop --><span data-bind='text: $data'></span><!-- /ko --></div>";
-
-        var childprop = ko.observableArray([]);
-        var someitem = ko.observable({childprop: childprop});
-        var viewModel = {someitem: someitem};
-        ko.applyBindings(viewModel, testNode);
-
-        // First it's not there (by template)
-        var container = testNode.childNodes[0];
-        value_of(container).should_contain_html("text<!-- ko foreach: childprop --><!-- /ko -->");
-
-        // Then it's there
-        childprop.push('me')
-        value_of(container).should_contain_html("text<!-- ko foreach: childprop --><span data-bind=\"text: $data\">me</span><!-- /ko -->");
-
-        // Then there's a second one
-        childprop.push('me2')
-        value_of(container).should_contain_html("text<!-- ko foreach: childprop --><span data-bind=\"text: $data\">me</span><span data-bind=\"text: $data\">me2</span><!-- /ko -->");
-
-        // Then it's not there (by with)
-        someitem(null);
-        value_of(testNode).should_contain_html('<div data-bind="with: someitem"></div>');
-        
-        // Then it changes
-        someitem({childprop: ['notme']});
-        container = testNode.childNodes[0];
-        value_of(container).should_contain_html("text<!-- ko foreach: childprop --><span data-bind=\"text: $data\">notme</span><!-- /ko -->");
-    }
-});
+            'Should be able to define a \"with\" region using a containerless binding': function () {
+                var someitem = ko.observable(undefined);
+                testNode.innerHTML = "hello <!-- " + virtualElementTag + " with: someitem --><span " + bindingAttribute + "=\"text: occasionallyexistentchildprop\"></span><!--/" + virtualElementTag + " --> goodbye";
+                ko.applyBindings({ someitem: someitem }, testNode);
 
-describe('Binding: Foreach', {
-    before_each: prepareTestNode,
+                // First it's not there
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " with: someitem --><!--/" + virtualElementTag + " --> goodbye");
 
-    'Should remove descendant nodes from the document (and not bind them) if the value is falsey': function() {
-        testNode.innerHTML = "<div data-bind='foreach: someItem'><span data-bind='text: someItem.nonExistentChildProp'></span></div>";
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        ko.applyBindings({ someItem: null }, testNode);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);		
-    },
+                // Then it's there
+                someitem({ occasionallyexistentchildprop: 'child prop value' });
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " with: someitem --><span " + bindingAttribute + "=\"text: occasionallyexistentchildprop\">child prop value</span><!--/" + virtualElementTag + " --> goodbye");
+
+                // Then it's gone again
+                someitem(null);
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " with: someitem --><!--/" + virtualElementTag + " --> goodbye");
+            },
+
+            'Should be able to nest \"with\" regions defined by containerless templates': function () {
+                testNode.innerHTML = "hello <!-- " + virtualElementTag + " with: topitem -->"
+                               + "Got top: <span " + bindingAttribute + "=\"text: topprop\"></span>"
+                               + "<!-- " + virtualElementTag + " with: childitem -->"
+                                   + "Got child: <span " + bindingAttribute + "=\"text: childprop\"></span>"
+                               + "<!--/" + virtualElementTag + " -->"
+                           + "<!--/" + virtualElementTag + " -->";
+                var viewModel = { topitem: ko.observable(null) };
+                ko.applyBindings(viewModel, testNode);
+
+                // First neither are there
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " with: topitem --><!--/" + virtualElementTag + " -->");
+
+                // Make top appear
+                viewModel.topitem({ topprop: 'property of top', childitem: ko.observable() });
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " with: topitem -->got top: <span " + bindingAttribute + "=\"text: topprop\">property of top</span><!-- " + virtualElementTag + " with: childitem --><!--/" + virtualElementTag + " --><!--/" + virtualElementTag + " -->");
+
+                // Make child appear
+                viewModel.topitem().childitem({ childprop: 'property of child' });
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " with: topitem -->got top: <span " + bindingAttribute + "=\"text: topprop\">property of top</span><!-- " + virtualElementTag + " with: childitem -->got child: <span " + bindingAttribute + "=\"text: childprop\">property of child</span><!--/" + virtualElementTag + " --><!--/" + virtualElementTag + " -->");
+
+                // Make top disappear
+                viewModel.topitem(null);
+                value_of(testNode).should_contain_html("hello <!-- " + virtualElementTag + " with: topitem --><!--/" + virtualElementTag + " -->");
+            },
+
+            'Should be able to nest a containerless template within \"with\"': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='with: someitem'>text" +
+            "<!-- " + virtualElementTag + " foreach: childprop --><span " + bindingAttribute + "='text: $data'></span><!--/" + virtualElementTag + " --></div>";
+
+                var childprop = ko.observableArray([]);
+                var someitem = ko.observable({ childprop: childprop });
+                var viewModel = { someitem: someitem };
+                ko.applyBindings(viewModel, testNode);
+
+                // First it's not there (by template)
+                var container = testNode.childNodes[0];
+                value_of(container).should_contain_html("text<!-- " + virtualElementTag + " foreach: childprop --><!--/" + virtualElementTag + " -->");
+
+                // Then it's there
+                childprop.push('me')
+                value_of(container).should_contain_html("text<!-- " + virtualElementTag + " foreach: childprop --><span " + bindingAttribute + "=\"text: $data\">me</span><!--/" + virtualElementTag + " -->");
+
+                // Then there's a second one
+                childprop.push('me2')
+                value_of(container).should_contain_html("text<!-- " + virtualElementTag + " foreach: childprop --><span " + bindingAttribute + "=\"text: $data\">me</span><span " + bindingAttribute + "=\"text: $data\">me2</span><!--/" + virtualElementTag + " -->");
+
+                // Then it's not there (by with)
+                someitem(null);
+                value_of(testNode).should_contain_html('<div ' + bindingAttribute + '="with: someitem"></div>');
+
+                // Then it changes
+                someitem({ childprop: ['notme'] });
+                container = testNode.childNodes[0];
+                value_of(container).should_contain_html("text<!-- " + virtualElementTag + " foreach: childprop --><span " + bindingAttribute + "=\"text: $data\">notme</span><!--/" + virtualElementTag + " -->");
+            }
+        });
+
+        describe('Binding: Foreach', {
+            before_each: prepareTestNode,
+            after_each: restore,
+            'Should remove descendant nodes from the document (and not bind them) if the value is falsey': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='foreach: someItem'><span " + bindingAttribute + "='text: someItem.nonExistentChildProp'></span></div>";
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                ko.applyBindings({ someItem: null }, testNode);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+            },
 
-    'Should remove descendant nodes from the document (and not bind them) if the value is undefined': function() {
-        testNode.innerHTML = "<div data-bind='foreach: someItem'><span data-bind='text: someItem.nonExistentChildProp'></span></div>";
-        value_of(testNode.childNodes[0].childNodes.length).should_be(1);
-        ko.applyBindings({ someItem: undefined }, testNode);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);        
-    },    
-    
-    'Should duplicate descendant nodes for each value in the array value (and bind them in the context of that supplied value)': function() {		
-        testNode.innerHTML = "<div data-bind='foreach: someItems'><span data-bind='text: childProp'></span></div>";
-        var someItems = [
+            'Should remove descendant nodes from the document (and not bind them) if the value is undefined': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='foreach: someItem'><span " + bindingAttribute + "='text: someItem.nonExistentChildProp'></span></div>";
+                value_of(testNode.childNodes[0].childNodes.length).should_be(1);
+                ko.applyBindings({ someItem: undefined }, testNode);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+            },
+
+            'Should duplicate descendant nodes for each value in the array value (and bind them in the context of that supplied value)': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='foreach: someItems'><span " + bindingAttribute + "='text: childProp'></span></div>";
+                var someItems = [
             { childProp: 'first child' },
             { childProp: 'second child' }
         ];
-        ko.applyBindings({ someItems: someItems }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">first child</span><span data-bind="text: childprop">second child</span>');
-    },
-    
-    'Should be able to use $data to reference each array item being bound': function() {		
-        testNode.innerHTML = "<div data-bind='foreach: someItems'><span data-bind='text: $data'></span></div>";
-        var someItems = ['alpha', 'beta'];
-        ko.applyBindings({ someItems: someItems }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: $data">alpha</span><span data-bind="text: $data">beta</span>');
-    },
-    
-    
-    'Should add and remove nodes to match changes in the bound array': function() {
-        testNode.innerHTML = "<div data-bind='foreach: someItems'><span data-bind='text: childProp'></span></div>";
-        var someItems = ko.observableArray([
+                ko.applyBindings({ someItems: someItems }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">second child</span>');
+            },
+
+            'Should be able to use $data to reference each array item being bound': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='foreach: someItems'><span " + bindingAttribute + "='text: $data'></span></div>";
+                var someItems = ['alpha', 'beta'];
+                ko.applyBindings({ someItems: someItems }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: $data">alpha</span><span ' + bindingAttribute + '="text: $data">beta</span>');
+            },
+
+
+            'Should add and remove nodes to match changes in the bound array': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='foreach: someItems'><span " + bindingAttribute + "='text: childProp'></span></div>";
+                var someItems = ko.observableArray([
             { childProp: 'first child' },
             { childProp: 'second child' }
         ]);
-        ko.applyBindings({ someItems: someItems }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">first child</span><span data-bind="text: childprop">second child</span>');
-
-        // Add items at the beginning...
-        someItems.unshift({ childProp: 'zeroth child' });
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">zeroth child</span><span data-bind="text: childprop">first child</span><span data-bind="text: childprop">second child</span>');
-        
-        // ... middle
-        someItems.splice(2, 0, { childProp: 'middle child' });
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">zeroth child</span><span data-bind="text: childprop">first child</span><span data-bind="text: childprop">middle child</span><span data-bind="text: childprop">second child</span>');
-        
-        // ... and end
-        someItems.push({ childProp: 'last child' });
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">zeroth child</span><span data-bind="text: childprop">first child</span><span data-bind="text: childprop">middle child</span><span data-bind="text: childprop">second child</span><span data-bind="text: childprop">last child</span>');
-        
-        // Also remove from beginning...
-        someItems.shift();
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">first child</span><span data-bind="text: childprop">middle child</span><span data-bind="text: childprop">second child</span><span data-bind="text: childprop">last child</span>');
-        
-        // ... and middle
-        someItems.splice(1, 1);
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">first child</span><span data-bind="text: childprop">second child</span><span data-bind="text: childprop">last child</span>');
-        
-        // ... and end
-        someItems.pop();
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">first child</span><span data-bind="text: childprop">second child</span>');
-        
-        // Also, marking as "destroy" should eliminate the item from display
-        someItems.destroy(someItems()[0]);
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">second child</span>');
-    },
+                ko.applyBindings({ someItems: someItems }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">second child</span>');
 
-    'Should remove all nodes corresponding to a removed array item, even if they were generated via containerless templates': function() {
-        // Represents issue https://github.com/SteveSanderson/knockout/issues/185
-        testNode.innerHTML = "<div data-bind='foreach: someitems'>a<!-- ko if:true -->b<!-- /ko --></div>";
-        var someitems = ko.observableArray([1,2]);
-        ko.applyBindings({ someitems: someitems }, testNode);
-        value_of(testNode).should_contain_html('<div data-bind="foreach: someitems">a<!-- ko if:true -->b<!-- /ko -->a<!-- ko if:true -->b<!-- /ko --></div>');
+                // Add items at the beginning...
+                someItems.unshift({ childProp: 'zeroth child' });
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">zeroth child</span><span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">second child</span>');
 
-        // Now remove items, and check the corresponding child nodes vanished
-        someitems.splice(1, 1);
-        value_of(testNode).should_contain_html('<div data-bind="foreach: someitems">a<!-- ko if:true -->b<!-- /ko --></div>');
-    },
+                // ... middle
+                someItems.splice(2, 0, { childProp: 'middle child' });
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">zeroth child</span><span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">middle child</span><span ' + bindingAttribute + '="text: childprop">second child</span>');
+
+                // ... and end
+                someItems.push({ childProp: 'last child' });
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">zeroth child</span><span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">middle child</span><span ' + bindingAttribute + '="text: childprop">second child</span><span ' + bindingAttribute + '="text: childprop">last child</span>');
+
+                // Also remove from beginning...
+                someItems.shift();
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">middle child</span><span ' + bindingAttribute + '="text: childprop">second child</span><span ' + bindingAttribute + '="text: childprop">last child</span>');
+
+                // ... and middle
+                someItems.splice(1, 1);
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">second child</span><span ' + bindingAttribute + '="text: childprop">last child</span>');
+
+                // ... and end
+                someItems.pop();
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">second child</span>');
 
-    'Should update all nodes corresponding to a changed array item, even if they were generated via containerless templates': function() {
-        testNode.innerHTML = "<div data-bind='foreach: someitems'><!-- ko if:true --><span data-bind='text: $data'></span><!-- /ko --></div>";
-        var someitems = [ ko.observable('A'), ko.observable('B') ];
-        ko.applyBindings({ someitems: someitems }, testNode);
-        value_of(testNode).should_contain_text('AB');
+                // Also, marking as "destroy" should eliminate the item from display
+                someItems.destroy(someItems()[0]);
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">second child</span>');
+            },
+
+            'Should remove all nodes corresponding to a removed array item, even if they were generated via containerless templates': function () {
+                // Represents issue https://github.com/SteveSanderson/knockout/issues/185
+                testNode.innerHTML = "<div " + bindingAttribute + "='foreach: someitems'>a<!-- " + virtualElementTag + " if:true -->b<!--/" + virtualElementTag + " --></div>";
+                var someitems = ko.observableArray([1, 2]);
+                ko.applyBindings({ someitems: someitems }, testNode);
+                value_of(testNode).should_contain_html('<div ' + bindingAttribute + '="foreach: someitems">a<!-- ' + virtualElementTag + ' if:true -->b<!--/' + virtualElementTag + ' -->a<!-- ' + virtualElementTag + ' if:true -->b<!--/' + virtualElementTag + ' --></div>');
+
+                // Now remove items, and check the corresponding child nodes vanished
+                someitems.splice(1, 1);
+                value_of(testNode).should_contain_html('<div ' + bindingAttribute + '="foreach: someitems">a<!-- ' + virtualElementTag + ' if:true -->b<!--/' + virtualElementTag + ' --></div>');
+            },
+
+            'Should update all nodes corresponding to a changed array item, even if they were generated via containerless templates': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='foreach: someitems'><!-- " + virtualElementTag + " if:true --><span " + bindingAttribute + "='text: $data'></span><!--/" + virtualElementTag + ' --></div>';
+                var someitems = [ko.observable('A'), ko.observable('B')];
+                ko.applyBindings({ someitems: someitems }, testNode);
+                value_of(testNode).should_contain_text('AB');
 
-        // Now update an item
-        someitems[0]('A2');
-        value_of(testNode).should_contain_text('A2B');
-    },    
+                // Now update an item
+                someitems[0]('A2');
+                value_of(testNode).should_contain_text('A2B');
+            },
 
-    'Should be able to supply show "_destroy"ed items via includeDestroyed option': function() {
-        testNode.innerHTML = "<div data-bind='foreach: { data: someItems, includeDestroyed: true }'><span data-bind='text: childProp'></span></div>";
-        var someItems = ko.observableArray([
+            'Should be able to supply show "_destroy"ed items via includeDestroyed option': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='foreach: { data: someItems, includeDestroyed: true }'><span " + bindingAttribute + "='text: childProp'></span></div>";
+                var someItems = ko.observableArray([
             { childProp: 'first child' },
             { childProp: 'second child', _destroy: true }
         ]);
-        ko.applyBindings({ someItems: someItems }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">first child</span><span data-bind="text: childprop">second child</span>');
-    },    	
-    
-    'Should be able to supply afterAdd and beforeRemove callbacks': function() {
-        testNode.innerHTML = "<div data-bind='foreach: { data: someItems, afterAdd: myAfterAdd, beforeRemove: myBeforeRemove }'><span data-bind='text: childprop'></span></div>";
-        var someItems = ko.observableArray([{ childprop: 'first child' }]);
-        var afterAddCallbackData = [], beforeRemoveCallbackData = [];
-        ko.applyBindings({ 
-            someItems: someItems,
-            myAfterAdd: function(elem, index, value) { afterAddCallbackData.push({ elem: elem, index: index, value: value, currentParentClone: elem.parentNode.cloneNode(true) }) },
-            myBeforeRemove: function(elem, index, value) { beforeRemoveCallbackData.push({ elem: elem, index: index, value: value, currentParentClone: elem.parentNode.cloneNode(true) }) }
-        }, testNode);
-        
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">first child</span>');
-        
-        // Try adding
-        someItems.push({ childprop: 'added child'});
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">first child</span><span data-bind="text: childprop">added child</span>');
-        value_of(afterAddCallbackData.length).should_be(1);
-        value_of(afterAddCallbackData[0].elem).should_be(testNode.childNodes[0].childNodes[1]);
-        value_of(afterAddCallbackData[0].index).should_be(1);
-        value_of(afterAddCallbackData[0].value.childprop).should_be("added child");
-        value_of(afterAddCallbackData[0].currentParentClone).should_contain_html('<span data-bind="text: childprop">first child</span><span data-bind="text: childprop">added child</span>');
-
-        // Try removing
-        someItems.shift();
-        value_of(beforeRemoveCallbackData.length).should_be(1);
-        value_of(beforeRemoveCallbackData[0].elem).should_contain_text("first child");
-        value_of(beforeRemoveCallbackData[0].index).should_be(0);
-        value_of(beforeRemoveCallbackData[0].value.childprop).should_be("first child");
-        // Note that when using "beforeRemove", we *don't* remove the node from the doc - it's up to the beforeRemove callback to do it. So, check it's still there.
-        value_of(beforeRemoveCallbackData[0].currentParentClone).should_contain_html('<span data-bind="text: childprop">first child</span><span data-bind="text: childprop">added child</span>');
-        value_of(testNode.childNodes[0]).should_contain_html('<span data-bind="text: childprop">first child</span><span data-bind="text: childprop">added child</span>');
-    },
+                ko.applyBindings({ someItems: someItems }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">second child</span>');
+            },
+
+            'Should be able to supply afterAdd and beforeRemove callbacks': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='foreach: { data: someItems, afterAdd: myAfterAdd, beforeRemove: myBeforeRemove }'><span " + bindingAttribute + "='text: childprop'></span></div>";
+                var someItems = ko.observableArray([{ childprop: 'first child'}]);
+                var afterAddCallbackData = [], beforeRemoveCallbackData = [];
+                ko.applyBindings({
+                    someItems: someItems,
+                    myAfterAdd: function (elem, index, value) { afterAddCallbackData.push({ elem: elem, index: index, value: value, currentParentClone: elem.parentNode.cloneNode(true) }) },
+                    myBeforeRemove: function (elem, index, value) { beforeRemoveCallbackData.push({ elem: elem, index: index, value: value, currentParentClone: elem.parentNode.cloneNode(true) }) }
+                }, testNode);
+
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span>');
+
+                // Try adding
+                someItems.push({ childprop: 'added child' });
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">added child</span>');
+                value_of(afterAddCallbackData.length).should_be(1);
+                value_of(afterAddCallbackData[0].elem).should_be(testNode.childNodes[0].childNodes[1]);
+                value_of(afterAddCallbackData[0].index).should_be(1);
+                value_of(afterAddCallbackData[0].value.childprop).should_be("added child");
+                value_of(afterAddCallbackData[0].currentParentClone).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">added child</span>');
+
+                // Try removing
+                someItems.shift();
+                value_of(beforeRemoveCallbackData.length).should_be(1);
+                value_of(beforeRemoveCallbackData[0].elem).should_contain_text("first child");
+                value_of(beforeRemoveCallbackData[0].index).should_be(0);
+                value_of(beforeRemoveCallbackData[0].value.childprop).should_be("first child");
+                // Note that when using "beforeRemove", we *don't* remove the node from the doc - it's up to the beforeRemove callback to do it. So, check it's still there.
+                value_of(beforeRemoveCallbackData[0].currentParentClone).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">added child</span>');
+                value_of(testNode.childNodes[0]).should_contain_html('<span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">added child</span>');
+            },
 
-    'Should be able to nest foreaches and access binding contexts both during and after binding': function() {
-        testNode.innerHTML = "<div data-bind='foreach: items'>"
-                                + "<div data-bind='foreach: children'>"
-                                    + "(Val: <span data-bind='text: $data'></span>, Parents: <span data-bind='text: $parents.length'></span>, Rootval: <span data-bind='text: $root.rootVal'></span>)"
+            'Should be able to nest foreaches and access binding contexts both during and after binding': function () {
+                testNode.innerHTML = "<div " + bindingAttribute + "='foreach: items'>"
+                                + "<div " + bindingAttribute + "='foreach: children'>"
+                                    + "(Val: <span " + bindingAttribute + "='text: $data'></span>, Parents: <span " + bindingAttribute + "='text: $parents.length'></span>, Rootval: <span " + bindingAttribute + "='text: $root.rootVal'></span>)"
                                 + "</div>"
-                           + "</div>";  
-        var viewModel = {
-            rootVal: 'ROOTVAL',
-            items: ko.observableArray([
+                           + "</div>";
+                var viewModel = {
+                    rootVal: 'ROOTVAL',
+                    items: ko.observableArray([
                 { children: ko.observableArray(['A1', 'A2', 'A3']) },
                 { children: ko.observableArray(['B1', 'B2']) }
             ])
-        };        
-        ko.applyBindings(viewModel, testNode);
-
-        // Verify we can access binding contexts during binding
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("(Val: A1, Parents: 2, Rootval: ROOTVAL)(Val: A2, Parents: 2, Rootval: ROOTVAL)(Val: A3, Parents: 2, Rootval: ROOTVAL)");
-        value_of(testNode.childNodes[0].childNodes[1]).should_contain_text("(Val: B1, Parents: 2, Rootval: ROOTVAL)(Val: B2, Parents: 2, Rootval: ROOTVAL)");
-
-        // Verify we can access them later
-        var firstInnerTextNode = testNode.childNodes[0].childNodes[0].childNodes[1];
-        value_of(firstInnerTextNode.nodeType).should_be(1); // The first span associated with A1
-        value_of(ko.dataFor(firstInnerTextNode)).should_be("A1");
-        value_of(ko.contextFor(firstInnerTextNode).$parent.children()[2]).should_be("A3");
-        value_of(ko.contextFor(firstInnerTextNode).$parents[1].items()[1].children()[1]).should_be("B2");
-        value_of(ko.contextFor(firstInnerTextNode).$root.rootVal).should_be("ROOTVAL");
-    },
+                };
+                ko.applyBindings(viewModel, testNode);
+
+                // Verify we can access binding contexts during binding
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("(Val: A1, Parents: 2, Rootval: ROOTVAL)(Val: A2, Parents: 2, Rootval: ROOTVAL)(Val: A3, Parents: 2, Rootval: ROOTVAL)");
+                value_of(testNode.childNodes[0].childNodes[1]).should_contain_text("(Val: B1, Parents: 2, Rootval: ROOTVAL)(Val: B2, Parents: 2, Rootval: ROOTVAL)");
+
+                // Verify we can access them later
+                var firstInnerTextNode = testNode.childNodes[0].childNodes[0].childNodes[1];
+                value_of(firstInnerTextNode.nodeType).should_be(1); // The first span associated with A1
+                value_of(ko.dataFor(firstInnerTextNode)).should_be("A1");
+                value_of(ko.contextFor(firstInnerTextNode).$parent.children()[2]).should_be("A3");
+                value_of(ko.contextFor(firstInnerTextNode).$parents[1].items()[1].children()[1]).should_be("B2");
+                value_of(ko.contextFor(firstInnerTextNode).$root.rootVal).should_be("ROOTVAL");
+            },
 
-    'Should be able to define a \'foreach\' region using a containerless template': function() {       
-        testNode.innerHTML = "hi <!-- ko foreach: someitems --><span data-bind='text: childprop'></span><!-- /ko -->";
-        var someitems = [
+            'Should be able to define a \'foreach\' region using a containerless template': function () {
+                testNode.innerHTML = "hi <!-- " + virtualElementTag + " foreach: someitems --><span " + bindingAttribute + "='text: childprop'></span><!--/" + virtualElementTag + " -->";
+                var someitems = [
             { childprop: 'first child' },
             { childprop: 'second child' }
         ];
-        ko.applyBindings({ someitems: someitems }, testNode);
-        value_of(testNode).should_contain_html('hi <!-- ko foreach: someitems --><span data-bind="text: childprop">first child</span><span data-bind="text: childprop">second child</span><!-- /ko -->');
+                ko.applyBindings({ someitems: someitems }, testNode);
+                value_of(testNode).should_contain_html('hi <!-- ' + virtualElementTag + ' foreach: someitems --><span ' + bindingAttribute + '="text: childprop">first child</span><span ' + bindingAttribute + '="text: childprop">second child</span><!--/' + virtualElementTag + ' -->');
 
-        // Check we can recover the binding contexts
-        value_of(ko.dataFor(testNode.childNodes[3]).childprop).should_be("second child");
-        value_of(ko.contextFor(testNode.childNodes[3]).$parent.someitems.length).should_be(2);
-    },
-    
-    'Should be able to nest \'foreach\' regions defined using containerless templates' : function() {
-        var innerContents = document.createElement("DIV");
-        testNode.innerHTML = "";
-        testNode.appendChild(document.createComment("ko foreach: items"));
-        testNode.appendChild(document.createComment(    "ko foreach: children"));
-        innerContents.innerHTML =                           "(Val: <span data-bind='text: $data'></span>, Parents: <span data-bind='text: $parents.length'></span>, Rootval: <span data-bind='text: $root.rootVal'></span>)";
-        while (innerContents.firstChild)
-            testNode.appendChild(innerContents.firstChild);
-        testNode.appendChild(document.createComment(    "/ko"));
-        testNode.appendChild(document.createComment("/ko"));
-
-        var viewModel = {
-            rootVal: 'ROOTVAL',
-            items: ko.observableArray([
+                // Check we can recover the binding contexts
+                value_of(ko.dataFor(testNode.childNodes[3]).childprop).should_be("second child");
+                value_of(ko.contextFor(testNode.childNodes[3]).$parent.someitems.length).should_be(2);
+            },
+
+            'Should be able to nest \'foreach\' regions defined using containerless templates': function () {
+                var innerContents = document.createElement("DIV");
+                testNode.innerHTML = "";
+                testNode.appendChild(document.createComment(virtualElementTag + " foreach: items"));
+                testNode.appendChild(document.createComment(virtualElementTag + " foreach: children"));
+                innerContents.innerHTML = "(Val: <span " + bindingAttribute + "='text: $data'></span>, Parents: <span " + bindingAttribute + "='text: $parents.length'></span>, Rootval: <span " + bindingAttribute + "='text: $root.rootVal'></span>)";
+                while (innerContents.firstChild)
+                    testNode.appendChild(innerContents.firstChild);
+                testNode.appendChild(document.createComment("/" + virtualElementTag));
+                testNode.appendChild(document.createComment("/" + virtualElementTag));
+
+                var viewModel = {
+                    rootVal: 'ROOTVAL',
+                    items: ko.observableArray([
                 { children: ko.observableArray(['A1', 'A2', 'A3']) },
                 { children: ko.observableArray(['B1', 'B2']) }
             ])
-        };        
-        ko.applyBindings(viewModel, testNode);
-
-        // Verify we can access binding contexts during binding
-        value_of(testNode).should_contain_text("(Val: A1, Parents: 2, Rootval: ROOTVAL)(Val: A2, Parents: 2, Rootval: ROOTVAL)(Val: A3, Parents: 2, Rootval: ROOTVAL)(Val: B1, Parents: 2, Rootval: ROOTVAL)(Val: B2, Parents: 2, Rootval: ROOTVAL)");
-
-        // Verify we can access them later
-        var firstInnerSpan = testNode.childNodes[3];
-        value_of(firstInnerSpan).should_contain_text("A1"); // It is the first span bound in the context of A1
-        value_of(ko.dataFor(firstInnerSpan)).should_be("A1");
-        value_of(ko.contextFor(firstInnerSpan).$parent.children()[2]).should_be("A3");
-        value_of(ko.contextFor(firstInnerSpan).$parents[1].items()[1].children()[1]).should_be("B2");
-        value_of(ko.contextFor(firstInnerSpan).$root.rootVal).should_be("ROOTVAL");        
-    },
+                };
+                ko.applyBindings(viewModel, testNode);
+
+                // Verify we can access binding contexts during binding
+                value_of(testNode).should_contain_text("(Val: A1, Parents: 2, Rootval: ROOTVAL)(Val: A2, Parents: 2, Rootval: ROOTVAL)(Val: A3, Parents: 2, Rootval: ROOTVAL)(Val: B1, Parents: 2, Rootval: ROOTVAL)(Val: B2, Parents: 2, Rootval: ROOTVAL)");
+
+                // Verify we can access them later
+                var firstInnerSpan = testNode.childNodes[3];
+                value_of(firstInnerSpan).should_contain_text("A1"); // It is the first span bound in the context of A1
+                value_of(ko.dataFor(firstInnerSpan)).should_be("A1");
+                value_of(ko.contextFor(firstInnerSpan).$parent.children()[2]).should_be("A3");
+                value_of(ko.contextFor(firstInnerSpan).$parents[1].items()[1].children()[1]).should_be("B2");
+                value_of(ko.contextFor(firstInnerSpan).$root.rootVal).should_be("ROOTVAL");
+            },
 
-    'Should be able to nest \'if\' inside \'foreach\' defined using containerless templates' : function() {
-        testNode.innerHTML = "<ul></ul>";
-        testNode.childNodes[0].appendChild(document.createComment("ko foreach: items"));
-        testNode.childNodes[0].appendChild(document.createElement("li"));        
-        testNode.childNodes[0].childNodes[1].innerHTML = "<span data-bind='text: childval.childprop'></span>";
-        testNode.childNodes[0].childNodes[1].insertBefore(document.createComment("ko if: childval"), testNode.childNodes[0].childNodes[1].firstChild);
-        testNode.childNodes[0].childNodes[1].appendChild(document.createComment("/ko"));
-        testNode.childNodes[0].appendChild(document.createComment("/ko"));
-
-        var viewModel = {
-            items: [
-                { childval: {childprop: 123 } },
+            'Should be able to nest \'if\' inside \'foreach\' defined using containerless templates': function () {
+                testNode.innerHTML = "<ul></ul>";
+                testNode.childNodes[0].appendChild(document.createComment(virtualElementTag + " foreach: items"));
+                testNode.childNodes[0].appendChild(document.createElement("li"));
+                testNode.childNodes[0].childNodes[1].innerHTML = "<span " + bindingAttribute + "='text: childval.childprop'></span>";
+                testNode.childNodes[0].childNodes[1].insertBefore(document.createComment(virtualElementTag + " if: childval"), testNode.childNodes[0].childNodes[1].firstChild);
+                testNode.childNodes[0].childNodes[1].appendChild(document.createComment("/" + virtualElementTag));
+                testNode.childNodes[0].appendChild(document.createComment("/" + virtualElementTag));
+
+                var viewModel = {
+                    items: [
+                { childval: { childprop: 123} },
                 { childval: null },
-                { childval: {childprop: 456 } }
+                { childval: { childprop: 456} }
             ]
-        };        
-        ko.applyBindings(viewModel, testNode);        
+                };
+                ko.applyBindings(viewModel, testNode);
 
-        value_of(testNode).should_contain_html('<ul>'
-                                                + '<!--ko foreach: items-->'
+                value_of(testNode).should_contain_html('<ul>'
+                                                + '<!--' + virtualElementTag + ' foreach: items-->'
                                                    + '<li>'
-                                                      + '<!--ko if: childval-->'
-                                                         + '<span data-bind="text: childval.childprop">123</span>'
-                                                      + '<!--/ko-->'
+                                                      + '<!--' + virtualElementTag + ' if: childval-->'
+                                                         + '<span ' + bindingAttribute + '="text: childval.childprop">123</span>'
+                                                      + '<!--/' + virtualElementTag + '-->'
                                                    + '</li>'
                                                    + '<li>'
-                                                      + '<!--ko if: childval-->'
-                                                      + '<!--/ko-->'
-                                                   + '</li>'                                                   
+                                                      + '<!--' + virtualElementTag + ' if: childval-->'
+                                                      + '<!--/' + virtualElementTag + '-->'
+                                                   + '</li>'
                                                    + '<li>'
-                                                      + '<!--ko if: childval-->'
-                                                         + '<span data-bind="text: childval.childprop">456</span>'
-                                                      + '<!--/ko-->'
+                                                      + '<!--' + virtualElementTag + ' if: childval-->'
+                                                         + '<span ' + bindingAttribute + '="text: childval.childprop">456</span>'
+                                                      + '<!--/' + virtualElementTag + '-->'
                                                    + '</li>'
-                                                + '<!--/ko-->'
+                                                + '<!--/' + virtualElementTag + '-->'
                                              + '</ul>');
-    },
+            },
 
-    'Should be able to use containerless templates directly inside UL elements even when closing LI tags are omitted' : function() {
-        // Represents issue https://github.com/SteveSanderson/knockout/issues/155
-        // Certain closing tags, including </li> are optional (http://www.w3.org/TR/html5/syntax.html#syntax-tag-omission)
-        // Most browsers respect your positioning of closing </li> tags, but IE <= 7 doesn't, and treats your markup
-        // as if it was written as below:
-
-        // Your actual markup: "<ul><li>Header item</li><!-- ko foreach: someitems --><li data-bind='text: $data'></li><!-- /ko --></ul>";
-        // How IE <= 8 treats it:
-        testNode.innerHTML =   "<ul><li>Header item<!-- ko foreach: someitems --><li data-bind='text: $data'><!-- /ko --></ul>";
-        var viewModel = {
-            someitems: [ 'Alpha', 'Beta' ]
-        };
-        ko.applyBindings(viewModel, testNode);
-
-        // Either of the following two results are acceptable.
-        try {
-            // Modern browsers implicitly re-add the closing </li> tags
-            value_of(testNode).should_contain_html('<ul><li>header item</li><!-- ko foreach: someitems --><li data-bind="text: $data">alpha</li><li data-bind="text: $data">beta</li><!-- /ko --></ul>');
-        } catch(ex) {
-            // ... but IE < 8 doesn't add ones that immediately precede a <li>
-            value_of(testNode).should_contain_html('<ul><li>header item</li><!-- ko foreach: someitems --><li data-bind="text: $data">alpha<li data-bind="text: $data">beta</li><!-- /ko --></ul>');
-        }
-    },
+            'Should be able to use containerless templates directly inside UL elements even when closing LI tags are omitted': function () {
+                // Represents issue https://github.com/SteveSanderson/knockout/issues/155
+                // Certain closing tags, including </li> are optional (http://www.w3.org/TR/html5/syntax.html#syntax-tag-omission)
+                // Most browsers respect your positioning of closing </li> tags, but IE <= 7 doesn't, and treats your markup
+                // as if it was written as below:
+
+                // Your actual markup: "<ul><li>Header item</li><!-- " + virtualElementTag  + " foreach: someitems --><li " + bindingAttribute + "='text: $data'></li><!--/" + virtualElementTag + " --></ul>";
+                // How IE <= 8 treats it:
+                testNode.innerHTML = "<ul><li>Header item<!-- " + virtualElementTag + " foreach: someitems --><li " + bindingAttribute + "='text: $data'><!--/" + virtualElementTag + " --></ul>";
+                var viewModel = {
+                    someitems: ['Alpha', 'Beta']
+                };
+                ko.applyBindings(viewModel, testNode);
+
+                // Either of the following two results are acceptable.
+                try {
+                    // Modern browsers implicitly re-add the closing </li> tags
+                    value_of(testNode).should_contain_html('<ul><li>header item</li><!-- ' + virtualElementTag + ' foreach: someitems --><li ' + bindingAttribute + '="text: $data">alpha</li><li ' + bindingAttribute + '="text: $data">beta</li><!--/' + virtualElementTag + ' --></ul>');
+                } catch (ex) {
+                    // ... but IE < 8 doesn't add ones that immediately precede a <li>
+                    value_of(testNode).should_contain_html('<ul><li>header item</li><!-- ' + virtualElementTag + ' foreach: someitems --><li ' + bindingAttribute + '="text: $data">alpha<li ' + bindingAttribute + '="text: $data">beta</li><!--/' + virtualElementTag + ' --></ul>');
+                }
+            },
 
-    'Should be able to nest containerless templates directly inside UL elements, even on IE < 8 with its bizarre HTML parsing/formatting' : function() {
-        // Represents https://github.com/SteveSanderson/knockout/issues/212
-        // This test starts with the following DOM structure:
-        //    <ul>
-        //        <!-- ko foreach: ['A', 'B'] -->
-        //        <!-- ko if: $data == 'B' -->
-        //        <li data-bind='text: $data'>
-        //            <!-- /ko -->
-        //            <!-- /ko -->
-        //        </li>
-        //    </ul>
-        // Note that:
-        //   1. The closing comments are inside the <li> to simulate IE<8's weird parsing
-        //   2. We have to build this with manual DOM operations, otherwise IE<8 will deform it in a different weird way
-        // It would be a more authentic test if we could set up the scenario using .innerHTML and then let the browser do whatever parsing it does normally,
-        // but unfortunately IE varies its weirdness according to whether it's really parsing an HTML doc, or whether you're using .innerHTML.
-
-        testNode.innerHTML = "";
-        testNode.appendChild(document.createElement("ul"));
-        testNode.firstChild.appendChild(document.createComment("ko foreach: ['A', 'B']"));
-        testNode.firstChild.appendChild(document.createComment("ko if: $data == 'B'"));
-        testNode.firstChild.appendChild(document.createElement("li"));
-        testNode.firstChild.lastChild.setAttribute("data-bind", "text: $data");
-        testNode.firstChild.lastChild.appendChild(document.createComment("/ko"));
-        testNode.firstChild.lastChild.appendChild(document.createComment("/ko"));
-
-        ko.applyBindings(null, testNode);        
-        value_of(testNode).should_contain_text("B");
-    },    
-
-    'Should be able to output HTML5 elements (even on IE<9, as long as you reference either innershiv.js or jQuery1.7+Modernizr)': function() {
-        // Represents https://github.com/SteveSanderson/knockout/issues/194
-        ko.utils.setHtml(testNode, "<div data-bind='foreach:someitems'><section data-bind='text: $data'></section></div>");
-        var viewModel = {
-            someitems: [ 'Alpha', 'Beta' ]
-        };
-        ko.applyBindings(viewModel, testNode);
-        value_of(testNode).should_contain_html('<div data-bind="foreach:someitems"><section data-bind="text: $data">alpha</section><section data-bind="text: $data">beta</section></div>');
-    },
+            'Should be able to nest containerless templates directly inside UL elements, even on IE < 8 with its bizarre HTML parsing/formatting': function () {
+                // Represents https://github.com/SteveSanderson/knockout/issues/212
+                // This test starts with the following DOM structure:
+                //    <ul>
+                //        <!-- " + virtualElementTag  + " foreach: ['A', 'B'] -->
+                //        <!-- " + virtualElementTag  + " if: $data == 'B' -->
+                //        <li " + bindingAttribute + "='text: $data'>
+                //            <!--/" + virtualElementTag + " -->
+                //            <!--/" + virtualElementTag + " -->
+                //        </li>
+                //    </ul>
+                // Note that:
+                //   1. The closing comments are inside the <li> to simulate IE<8's weird parsing
+                //   2. We have to build this with manual DOM operations, otherwise IE<8 will deform it in a different weird way
+                // It would be a more authentic test if we could set up the scenario using .innerHTML and then let the browser do whatever parsing it does normally,
+                // but unfortunately IE varies its weirdness according to whether it's really parsing an HTML doc, or whether you're using .innerHTML.
+
+                testNode.innerHTML = "";
+                testNode.appendChild(document.createElement("ul"));
+                testNode.firstChild.appendChild(document.createComment(virtualElementTag + " foreach: ['A', 'B']"));
+                testNode.firstChild.appendChild(document.createComment(virtualElementTag + " if: $data == 'B'"));
+                testNode.firstChild.appendChild(document.createElement("li"));
+                testNode.firstChild.lastChild.setAttribute(bindingAttribute, "text: $data");
+                testNode.firstChild.lastChild.appendChild(document.createComment("/" + virtualElementTag));
+                testNode.firstChild.lastChild.appendChild(document.createComment("/" + virtualElementTag));
+
+                ko.applyBindings(null, testNode);
+                value_of(testNode).should_contain_text("B");
+            },
+
+            'Should be able to output HTML5 elements (even on IE<9, as long as you reference either innershiv.js or jQuery1.7+Modernizr)': function () {
+                // Represents https://github.com/SteveSanderson/knockout/issues/194
+                ko.utils.setHtml(testNode, "<div " + bindingAttribute + "='foreach:someitems'><section " + bindingAttribute + "='text: $data'></section></div>");
+                var viewModel = {
+                    someitems: ['Alpha', 'Beta']
+                };
+                ko.applyBindings(viewModel, testNode);
+                value_of(testNode).should_contain_html('<div ' + bindingAttribute + '="foreach:someitems"><section ' + bindingAttribute + '="text: $data">alpha</section><section ' + bindingAttribute + '="text: $data">beta</section></div>');
+            },
 
-    'Should be able to output HTML5 elements within container-less templates (same as above)': function() {
-        // Represents https://github.com/SteveSanderson/knockout/issues/194
-        ko.utils.setHtml(testNode, "<!-- ko foreach:someitems --><div><section data-bind='text: $data'></section></div><!-- /ko -->");
-        var viewModel = {
-            someitems: [ 'Alpha', 'Beta' ]
-        };
-        ko.applyBindings(viewModel, testNode);
-        value_of(testNode).should_contain_html('<!-- ko foreach:someitems --><div><section data-bind="text: $data">alpha</section></div><div><section data-bind="text: $data">beta</section></div><!-- /ko -->');
+            'Should be able to output HTML5 elements within container-less templates (same as above)': function () {
+                // Represents https://github.com/SteveSanderson/knockout/issues/194
+                ko.utils.setHtml(testNode, "<!-- " + virtualElementTag + " foreach:someitems --><div><section " + bindingAttribute + "='text: $data'></section></div><!--/" + virtualElementTag + " -->");
+                var viewModel = {
+                    someitems: ['Alpha', 'Beta']
+                };
+                ko.applyBindings(viewModel, testNode);
+                value_of(testNode).should_contain_html('<!-- ' + virtualElementTag + ' foreach:someitems --><div><section ' + bindingAttribute + '="text: $data">alpha</section></div><div><section ' + bindingAttribute + '="text: $data">beta</section></div><!--/' + virtualElementTag + ' -->');
+            }
+        });
     }
-});
\ No newline at end of file
+    defaultBindingsBehaviors()
+    defaultBindingsBehaviors({ name: "alternative configuration", virtualElementTag: "ko1", bindingAttribute: "data-bind1" });
\ No newline at end of file
diff --git a/spec/templatingBehaviors.js b/spec/templatingBehaviors.js
index 7984e6ae6..b60261649 100644
--- a/spec/templatingBehaviors.js
+++ b/spec/templatingBehaviors.js
@@ -1,689 +1,723 @@
+var templatingBehaviors =
+    function (testConfiguration) {
+        var existingBindingProvider = ko.bindingProvider.instance;
+        var myConfiguration = testConfiguration;
 
-var dummyTemplateEngine = function (templates) {   
-    var inMemoryTemplates = templates || {};
-    var inMemoryTemplateData = {};
-
-    function dummyTemplateSource(id) {
-        this.id = id;
-    }
-    dummyTemplateSource.prototype = {
-        text: function(val) {
-            if (arguments.length >= 1)
-                inMemoryTemplates[this.id] = val;
-            return inMemoryTemplates[this.id];            
-        },
-        data: function(key, val) {
-            if (arguments.length >= 2) {
-                inMemoryTemplateData[this.id] = inMemoryTemplateData[this.id] || {};
-                inMemoryTemplateData[this.id][key] = val;
+
+        var dummyTemplateEngine = function (templates) {
+            var inMemoryTemplates = templates || {};
+            var inMemoryTemplateData = {};
+
+            function dummyTemplateSource(id) {
+                this.id = id;
             }
-            return (inMemoryTemplateData[this.id] || {})[key];
-        }
-    }
-
-    this.makeTemplateSource = function(template) {
-        if (typeof template == "string")
-            return new dummyTemplateSource(template); // Named template comes from the in-memory collection
-        else if ((template.nodeType == 1) || (template.nodeType == 8))
-            return new ko.templateSources.anonymousTemplate(template); // Anonymous template
-    };
 
-    this.renderTemplateSource = function (templateSource, bindingContext, options) {
-        var data = bindingContext['$data'];
-        options = options || {};
-        var templateText = templateSource.text();
-        if (typeof templateText == "function")
-            templateText = templateText(data, options);
-
-        templateText = options.showParams ? templateText + ", data=" + data + ", options=" + options : templateText;
-        var templateOptions = options.templateOptions; // Have templateOptions in scope to support [js:templateOptions.foo] syntax
-
-        var result;
-        with (bindingContext) {
-            with (data || {}) {
-                with (options.templateRenderingVariablesInScope || {}) {
-                    // Dummy [renderTemplate:...] syntax
-                    result = templateText.replace(/\[renderTemplate\:(.*?)\]/g, function (match, templateName) {
-                        return ko.renderTemplate(templateName, data, options);
-                    });
-
-                    
-                    var evalHandler = function (match, script) {
-                        try {
-                            var evalResult = eval(script);
-                            return (evalResult === null) || (evalResult === undefined) ? "" : evalResult.toString();
-                        } catch (ex) {
-                            throw new Error("Error evaluating script: [js: " + script + "]\n\nException: " + ex.toString());
+            dummyTemplateSource.prototype = {
+                text: function (val) {
+                    if (arguments.length >= 1)
+                        inMemoryTemplates[this.id] = val;
+                    return inMemoryTemplates[this.id];
+                },
+                data: function (key, val) {
+                    if (arguments.length >= 2) {
+                        inMemoryTemplateData[this.id] = inMemoryTemplateData[this.id] || {};
+                        inMemoryTemplateData[this.id][key] = val;
+                    }
+                    return (inMemoryTemplateData[this.id] || {})[key];
+                }
+            }
+
+            this.makeTemplateSource = function (template) {
+                if (typeof template == "string")
+                    return new dummyTemplateSource(template); // Named template comes from the in-memory collection
+                else if ((template.nodeType == 1) || (template.nodeType == 8))
+                    return new ko.templateSources.anonymousTemplate(template); // Anonymous template
+            };
+
+            this.renderTemplateSource = function (templateSource, bindingContext, options) {
+                var data = bindingContext['$data'];
+                options = options || {};
+                var templateText = templateSource.text();
+                if (typeof templateText == "function")
+                    templateText = templateText(data, options);
+
+                templateText = options.showParams ? templateText + ", data=" + data + ", options=" + options : templateText;
+                var templateOptions = options.templateOptions; // Have templateOptions in scope to support [js:templateOptions.foo] syntax
+
+                var result;
+                with (bindingContext) {
+                    with (data || {}) {
+                        with (options.templateRenderingVariablesInScope || {}) {
+                            // Dummy [renderTemplate:...] syntax
+                            result = templateText.replace(/\[renderTemplate\:(.*?)\]/g, function (match, templateName) {
+                                return ko.renderTemplate(templateName, data, options);
+                            });
+
+
+                            var evalHandler = function (match, script) {
+                                try {
+                                    var evalResult = eval(script);
+                                    return (evalResult === null) || (evalResult === undefined) ? "" : evalResult.toString();
+                                } catch (ex) {
+                                    throw new Error("Error evaluating script: [js: " + script + "]\n\nException: " + ex.toString());
+                                }
+                            }
+
+                            // Dummy [[js:...]] syntax (in case you need to use square brackets inside the expression)
+                            result = result.replace(/\[\[js\:([\s\S]*?)\]\]/g, evalHandler);
+
+                            // Dummy [js:...] syntax
+                            result = result.replace(/\[js\:([\s\S]*?)\]/g, evalHandler);
+                            var res = result;
                         }
                     }
+                }
+
+                if (options.bypassDomNodeWrap)
+                    return ko.utils.parseHtmlFragment(result);
+                else {
+                    var node = document.createElement("div");
 
-                    // Dummy [[js:...]] syntax (in case you need to use square brackets inside the expression)
-                    result = result.replace(/\[\[js\:([\s\S]*?)\]\]/g, evalHandler);
+                    // Annoyingly, IE strips out comment nodes unless they are contained between other nodes, so put some dummy nodes around the HTML, then remove them after parsing.
+                    node.innerHTML = "<div>a</div>" + result + "<div>a</div>";
+                    node.removeChild(node.firstChild);
+                    node.removeChild(node.lastChild);
 
-                    // Dummy [js:...] syntax
-                    result = result.replace(/\[js\:([\s\S]*?)\]/g, evalHandler);
+                    return [node];
                 }
-            }
-        }
+            };
+
+            this.rewriteTemplate = function (template, rewriterCallback) {
+                // Only rewrite if the template isn't a function (can't rewrite those)
+                var templateSource = this.makeTemplateSource(template);
+                if (typeof templateSource.text() != "function")
+                    return ko.templateEngine.prototype.rewriteTemplate.call(this, template, rewriterCallback);
+            };
+            this.createJavaScriptEvaluatorBlock = function (script) { return "[js:" + script + "]"; };
+        };
+        dummyTemplateEngine.prototype = new ko.templateEngine();
+
+        describe('Templating ' + (myConfiguration ? myConfiguration.name : "default provider settings"), {
+            before_each: function () {
+                ko.setTemplateEngine(new ko.nativeTemplateEngine());
+                var existingNode = document.getElementById("templatingTarget");
+                if (existingNode != null)
+                    existingNode.parentNode.removeChild(existingNode);
+                testNode = document.createElement("div");
+                testNode.id = "templatingTarget";
+                document.body.appendChild(testNode);
+                ko.bindingProvider["instance"] = new ko.bindingProvider(myConfiguration);
+                virtualElementTag = ko.bindingProvider["instance"].configuration.virtualElementTag;
+                bindingAttribute = ko.bindingProvider["instance"].configuration.bindingAttribute;
+            },
 
-        if (options.bypassDomNodeWrap)
-            return ko.utils.parseHtmlFragment(result);
-        else {
-            var node = document.createElement("div");
+            after_each: function () {
+                ko.bindingProvider.instance = existingBindingProvider;
 
-            // Annoyingly, IE strips out comment nodes unless they are contained between other nodes, so put some dummy nodes around the HTML, then remove them after parsing.
-            node.innerHTML = "<div>a</div>" + result + "<div>a</div>";
-            node.removeChild(node.firstChild);
-            node.removeChild(node.lastChild);
+            },
 
-            return [node];
-        }
-    };
+            'Template engines can return an array of DOM nodes': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ x: [document.createElement("div"), document.createElement("span")] }));
+                ko.renderTemplate("x", null, { bypassDomNodeWrap: true });
+            },
 
-    this.rewriteTemplate = function (template, rewriterCallback) {
-        // Only rewrite if the template isn't a function (can't rewrite those)
-        var templateSource = this.makeTemplateSource(template);
-        if (typeof templateSource.text() != "function")
-            return ko.templateEngine.prototype.rewriteTemplate.call(this, template, rewriterCallback);
-    };
-    this.createJavaScriptEvaluatorBlock = function (script) { return "[js:" + script + "]"; };
-};
-dummyTemplateEngine.prototype = new ko.templateEngine();
-
-describe('Templating', {
-    before_each: function () {
-        ko.setTemplateEngine(new ko.nativeTemplateEngine());
-        var existingNode = document.getElementById("templatingTarget");
-        if (existingNode != null)
-            existingNode.parentNode.removeChild(existingNode);
-        testNode = document.createElement("div");
-        testNode.id = "templatingTarget";
-        document.body.appendChild(testNode);
-    },   
-
-    'Template engines can return an array of DOM nodes': function () {
-        ko.setTemplateEngine(new dummyTemplateEngine({ x: [document.createElement("div"), document.createElement("span")] }));
-        ko.renderTemplate("x", null, { bypassDomNodeWrap: true });
-    },
-
-    'Should not be able to render a template until a template engine is provided': function () {
-        var threw = false;
-        ko.setTemplateEngine(undefined);
-        try { ko.renderTemplate("someTemplate", {}) }
-        catch (ex) { threw = true }
-        value_of(threw).should_be(true);
-    },
-
-    'Should be able to render a template into a given DOM element': function () {
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "ABC" }));
-        ko.renderTemplate("someTemplate", null, null, testNode);
-        value_of(testNode.childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].innerHTML).should_be("ABC");
-    },
-
-    'Should be able to access newly rendered/inserted elements in \'afterRender\' callaback': function () {
-        var passedElement, passedDataItem;
-        var myCallback = function(elementsArray, dataItem) { 
-            value_of(elementsArray.length).should_be(1);
-            passedElement = elementsArray[0]; 
-            passedDataItem = dataItem;     		
-        }
-        var myModel = {};
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "ABC" }));
-        ko.renderTemplate("someTemplate", myModel, { afterRender: myCallback }, testNode);
-        value_of(passedElement.innerHTML).should_be("ABC");
-        value_of(passedDataItem).should_be(myModel);
-    },
-
-    'Should automatically rerender into DOM element when dependencies change': function () {
-        var dependency = new ko.observable("A");
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: function () {
-            return "Value = " + dependency();
-        }
-        }));
-
-        ko.renderTemplate("someTemplate", null, null, testNode);
-        value_of(testNode.childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].innerHTML).should_be("Value = A");
-
-        dependency("B");
-        value_of(testNode.childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].innerHTML).should_be("Value = B");
-    },
-
-    'If the supplied data item is observable, evaluates it and has subscription on it': function () {
-        var observable = new ko.observable("A");
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: function (data) {
-            return "Value = " + data;
-        }
-        }));
-        ko.renderTemplate("someTemplate", observable, null, testNode);
-        value_of(testNode.childNodes[0].innerHTML).should_be("Value = A");
-
-        observable("B");
-        value_of(testNode.childNodes[0].innerHTML).should_be("Value = B");
-    },
-
-    'Should stop updating DOM nodes when the dependency next changes if the DOM node has been removed from the document': function () {
-        var dependency = new ko.observable("A");
-        var template = { someTemplate: function () { return "Value = " + dependency() } };
-        ko.setTemplateEngine(new dummyTemplateEngine(template));
-
-        ko.renderTemplate("someTemplate", null, null, testNode);
-        value_of(testNode.childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].innerHTML).should_be("Value = A");
-
-        testNode.parentNode.removeChild(testNode);
-        dependency("B");
-        value_of(testNode.childNodes.length).should_be(1);
-        value_of(testNode.childNodes[0].innerHTML).should_be("Value = A");
-    },
-    
-    'Should be able to render a template using data-bind syntax': function () {
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "template output" }));
-        testNode.innerHTML = "<div data-bind='template:\"someTemplate\"'></div>";
-        ko.applyBindings(null, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>template output</div>");
-    },
-
-    'Should be able to tell data-bind syntax which object to pass as data for the template (otherwise, uses viewModel)': function () {
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "result = [js: childProp]" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"someTemplate\", data: someProp }'></div>";
-        ko.applyBindings({ someProp: { childProp: 123} }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>result = 123</div>");
-    },
-
-    'Should stop tracking inner observables immediately when the container node is removed from the document': function() {
-        var innerObservable = ko.observable("some value");
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "result = [js: childProp()]" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"someTemplate\", data: someProp }'></div>";
-        ko.applyBindings({ someProp: { childProp: innerObservable} }, testNode);
-        
-        value_of(innerObservable.getSubscriptionsCount()).should_be(1);
-        ko.cleanAndRemoveNode(testNode.childNodes[0]);
-        value_of(innerObservable.getSubscriptionsCount()).should_be(0);
-    },
-
-    'Should be able to pick template as a function of the data item using data-bind syntax': function () {
-        var templatePicker = function(dataItem) {
-            return dataItem.myTemplate;	
-        };
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "result = [js: childProp]" }));
-        testNode.innerHTML = "<div data-bind='template: { name: templateSelectorFunction, data: someProp }'></div>";
-        ko.applyBindings({ someProp: { childProp: 123, myTemplate: "someTemplate" }, templateSelectorFunction: templatePicker }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>result = 123</div>");
-    },
-
-    'Should be able to chain templates, rendering one from inside another': function () {
-        ko.setTemplateEngine(new dummyTemplateEngine({
-            outerTemplate: "outer template output, [renderTemplate:innerTemplate]", // [renderTemplate:...] is special syntax supported by dummy template engine
-            innerTemplate: "inner template output <span data-bind='text: 123'></span>"
-        }));
-        testNode.innerHTML = "<div data-bind='template:\"outerTemplate\"'></div>";
-        ko.applyBindings(null, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>outer template output, <div>inner template output <span>123</span></div></div>");
-    },
-
-    'Should rerender chained templates when their dependencies change, without rerendering parent templates': function () {
-        var observable = new ko.observable("ABC");
-        var timesRenderedOuter = 0, timesRenderedInner = 0;
-        ko.setTemplateEngine(new dummyTemplateEngine({
-            outerTemplate: function () { timesRenderedOuter++; return "outer template output, [renderTemplate:innerTemplate]" }, // [renderTemplate:...] is special syntax supported by dummy template engine
-            innerTemplate: function () { timesRenderedInner++; return observable() }
-        }));
-        testNode.innerHTML = "<div data-bind='template:\"outerTemplate\"'></div>";
-        ko.applyBindings(null, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>outer template output, <div>abc</div></div>");
-        value_of(timesRenderedOuter).should_be(1);
-        value_of(timesRenderedInner).should_be(1);
-
-        observable("DEF");
-        value_of(testNode.childNodes[0]).should_contain_html("<div>outer template output, <div>def</div></div>");
-        value_of(timesRenderedOuter).should_be(1);
-        value_of(timesRenderedInner).should_be(2);
-    },
-    
-    'Should stop tracking inner observables referenced by a chained template as soon as the chained template output node is removed from the document': function() {
-        var innerObservable = ko.observable("some value");
-        ko.setTemplateEngine(new dummyTemplateEngine({
-            outerTemplate: "outer template output, <span id='innerTemplateOutput'>[renderTemplate:innerTemplate]</span>",
-            innerTemplate: "result = [js: childProp()]"
-        }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"outerTemplate\", data: someProp }'></div>";
-        ko.applyBindings({ someProp: { childProp: innerObservable} }, testNode);
-        
-        value_of(innerObservable.getSubscriptionsCount()).should_be(1);
-        ko.cleanAndRemoveNode(document.getElementById('innerTemplateOutput'));
-        value_of(innerObservable.getSubscriptionsCount()).should_be(0);
-    },
-
-    'Should handle data-bind attributes from inside templates, regardless of element and attribute casing': function () {
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "<INPUT Data-Bind='value:\"Hi\"' />" }));
-        ko.renderTemplate("someTemplate", null, null, testNode);
-        value_of(testNode.childNodes[0].childNodes[0].value).should_be("Hi");
-    },
-    
-    'Should handle data-bind attributes that include newlines from inside templates': function () {
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "<input data-bind='value:\n\"Hi\"' />" }));
-        ko.renderTemplate("someTemplate", null, null, testNode);
-        value_of(testNode.childNodes[0].childNodes[0].value).should_be("Hi");
-    },    
-
-    'Data binding syntax should be able to reference variables put into scope by the template engine': function () {
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "<input data-bind='value:message' />" }));
-        ko.renderTemplate("someTemplate", null, { templateRenderingVariablesInScope: { message: "hello"} }, testNode);
-        value_of(testNode.childNodes[0].childNodes[0].value).should_be("hello");
-    },
-
-    'Data binding syntax should defer evaluation of variables until the end of template rendering (so bindings can take independent subscriptions to them)': function () {
-        ko.setTemplateEngine(new dummyTemplateEngine({
-            someTemplate: "<input data-bind='value:message' />[js: message = 'goodbye'; undefined; ]"
-        }));
-        ko.renderTemplate("someTemplate", null, { templateRenderingVariablesInScope: { message: "hello"} }, testNode);
-        value_of(testNode.childNodes[0].childNodes[0].value).should_be("goodbye");
-    },
-    
-    'Data binding syntax should use the template\'s \'data\' object as the viewModel value (so \'this\' is set correctly when calling click handlers etc.)': function() {
-        ko.setTemplateEngine(new dummyTemplateEngine({
-            someTemplate: "<button data-bind='click: someFunctionOnModel'>click me</button>"
-        }));
-        var viewModel = {
-            didCallMyFunction : false,
-            someFunctionOnModel : function() { this.didCallMyFunction = true }
-        };
-        ko.renderTemplate("someTemplate", viewModel, null, testNode);
-        var buttonNode = testNode.childNodes[0].childNodes[0];
-        value_of(buttonNode.tagName).should_be("BUTTON"); // Be sure we're clicking the right thing
-        buttonNode.click();
-        value_of(viewModel.didCallMyFunction).should_be(true);
-    },
-
-    'Data binding syntax should permit nested templates, and only bind inner templates once': function() {
-        // Will verify that bindings are applied only once for both inline (rewritten) bindings,
-        // and external (non-rewritten) ones
-        var originalBindingProvider = ko.bindingProvider.instance;
-        ko.bindingProvider.instance = {
-            nodeHasBindings: function(node, bindingContext) {
-                return (node.tagName == 'EM') || originalBindingProvider.nodeHasBindings(node, bindingContext);
-            },
-            getBindings: function(node, bindingContext) {
-                if (node.tagName == 'EM')
-                    return { text: ++model.numBindings };
-                return originalBindingProvider.getBindings(node, bindingContext);
-            }
-        };
+            'Should not be able to render a template until a template engine is provided': function () {
+                var threw = false;
+                ko.setTemplateEngine(undefined);
+                try {
+                    ko.renderTemplate("someTemplate", {})
+                } catch (ex) {
+                    threw = true
+                }
+                value_of(threw).should_be(true);
+            },
 
-        ko.setTemplateEngine(new dummyTemplateEngine({ 
-            outerTemplate: "Outer <div data-bind='template: { name: \"innerTemplate\", bypassDomNodeWrap: true }'></div>", 
-            innerTemplate: "Inner via inline binding: <span data-bind='text: ++numBindings'></span>"
-                         + "Inner via external binding: <em></em>"
-        }));
-        var model = { numBindings: 0 };
-        testNode.innerHTML = "<div data-bind='template: { name: \"outerTemplate\", bypassDomNodeWrap: true }'></div>";
-        ko.applyBindings(model, testNode);
-        value_of(model.numBindings).should_be(2);
-        value_of(testNode.childNodes[0]).should_contain_html("outer <div>inner via inline binding: <span>2</span>inner via external binding: <em>1</em></div>");
-        
-        ko.bindingProvider.instance = originalBindingProvider;      
-    },
-
-    'Data binding syntax should support \'foreach\' option, whereby it renders for each item in an array but doesn\'t rerender everything if you push or splice': function () {
-        var myArray = new ko.observableArray([{ personName: "Bob" }, { personName: "Frank"}]);
-        ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is [js: personName]" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
-
-        ko.applyBindings({ myCollection: myArray }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>the item is bob</div><div>the item is frank</div>");
-        var originalBobNode = testNode.childNodes[0].childNodes[0];
-        var originalFrankNode = testNode.childNodes[0].childNodes[1];
-
-        myArray.push({ personName: "Steve" });
-        value_of(testNode.childNodes[0]).should_contain_html("<div>the item is bob</div><div>the item is frank</div><div>the item is steve</div>");
-        value_of(testNode.childNodes[0].childNodes[0]).should_be(originalBobNode);
-        value_of(testNode.childNodes[0].childNodes[1]).should_be(originalFrankNode);
-    },
-
-    'Data binding \'foreach\' option should apply bindings within the context of each item in the array': function () {
-        var myArray = new ko.observableArray([{ personName: "Bob" }, { personName: "Frank"}]);
-        ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is <span data-bind='text: personName'></span>" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
-
-        ko.applyBindings({ myCollection: myArray }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>the item is <span>bob</span></div><div>the item is <span>frank</span></div>");
-    },
-
-    'Data binding \'foreach\' options should only bind each group of output nodes once': function() {
-        var initCalls = 0;
-        ko.bindingHandlers.countInits = { init: function() { initCalls++ } };
-        ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "<span data-bind='countInits: true'></span>" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
-
-        ko.applyBindings({ myCollection: [1,2,3] }, testNode);
-        value_of(initCalls).should_be(3); // 3 because there were 3 items in myCollection
-    },
-    
-    'Data binding \'foreach\' option should accept array with "undefined" and "null" items': function () {
-        var myArray = new ko.observableArray([undefined, null]);
-        ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is <span data-bind='text: String($data)'></span>" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
-
-        ko.applyBindings({ myCollection: myArray }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>the item is <span>undefined</span></div><div>the item is <span>null</span></div>");
-    },
-    
-    'Data binding \'foreach\' option should update DOM nodes when a dependency of their mapping function changes': function() {
-        var myObservable = new ko.observable("Steve");
-        var myArray = new ko.observableArray([{ personName: "Bob" }, { personName: myObservable }, { personName: "Another" }]);
-        ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is [js: ko.utils.unwrapObservable(personName)]" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
-
-        ko.applyBindings({ myCollection: myArray }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>the item is bob</div><div>the item is steve</div><div>the item is another</div>");
-        var originalBobNode = testNode.childNodes[0].childNodes[0];
-        
-        myObservable("Steve2");
-        value_of(testNode.childNodes[0]).should_contain_html("<div>the item is bob</div><div>the item is steve2</div><div>the item is another</div>");
-        value_of(testNode.childNodes[0].childNodes[0]).should_be(originalBobNode);
-        
-        // Ensure we can still remove the corresponding nodes (even though they've changed), and that doing so causes the subscription to be disposed
-        value_of(myObservable.getSubscriptionsCount()).should_be(1);
-        myArray.splice(1, 1);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>the item is bob</div><div>the item is another</div>");
-        myObservable("Something else"); // Re-evaluating the observable causes the orphaned subscriptions to be disposed
-        value_of(myObservable.getSubscriptionsCount()).should_be(0);
-    },
-    
-    'Data binding \'foreach\' option should treat a null parameter as meaning \'no items\'': function() {
-        var myArray = new ko.observableArray(["A", "B"]);
-        ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "hello" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
-
-        ko.applyBindings({ myCollection: myArray }, testNode);    	
-        value_of(testNode.childNodes[0].childNodes.length).should_be(2);
-        
-        // Now set the observable to null and check it's treated like an empty array
-        // (because how else should null be interpreted?)
-        myArray(null);
-        value_of(testNode.childNodes[0].childNodes.length).should_be(0);
-    },
-    
-    'Data binding \'foreach\' option should stop tracking inner observables when the container node is removed': function() {
-        var innerObservable = ko.observable("some value");
-        var myArray = new ko.observableArray([{obsVal:innerObservable}, {obsVal:innerObservable}]);
-        ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is [js: ko.utils.unwrapObservable(obsVal)]" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
-
-        ko.applyBindings({ myCollection: myArray }, testNode);
-        value_of(innerObservable.getSubscriptionsCount()).should_be(2);    	
-        
-        ko.cleanAndRemoveNode(testNode.childNodes[0]);
-        value_of(innerObservable.getSubscriptionsCount()).should_be(0);    	
-    },
-    
-    'Data binding \'foreach\' option should stop tracking inner observables related to each array item when that array item is removed': function() {
-        var innerObservable = ko.observable("some value");
-        var myArray = new ko.observableArray([{obsVal:innerObservable}, {obsVal:innerObservable}]);
-        ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is [js: ko.utils.unwrapObservable(obsVal)]" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
-
-        ko.applyBindings({ myCollection: myArray }, testNode);
-        value_of(innerObservable.getSubscriptionsCount()).should_be(2);    	
-        
-        myArray.splice(1, 1);
-        value_of(innerObservable.getSubscriptionsCount()).should_be(1);    	
-        myArray([]);
-        value_of(innerObservable.getSubscriptionsCount()).should_be(0);    	
-    },    
-    
-    'Data binding syntax should omit any items whose \'_destroy\' flag is set (unwrapping the flag if it is observable)' : function() {
-        var myArray = new ko.observableArray([{ someProp: 1 }, { someProp: 2, _destroy: 'evals to true' }, { someProp : 3 }, { someProp: 4, _destroy: ko.observable(false) }]);
-        ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "someProp=[js: someProp]" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
-
-        ko.applyBindings({ myCollection: myArray }, testNode);    	
-        value_of(testNode.childNodes[0]).should_contain_html("<div>someprop=1</div><div>someprop=3</div><div>someprop=4</div>");
-    },
-    
-    'Data binding syntax should include any items whose \'_destroy\' flag is set if you use includeDestroyed' : function() {
-        var myArray = new ko.observableArray([{ someProp: 1 }, { someProp: 2, _destroy: 'evals to true' }, { someProp : 3 }]);
-        ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "someProp=[js: someProp]" }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"itemTemplate\", foreach: myCollection, includeDestroyed: true }'></div>";
-
-        ko.applyBindings({ myCollection: myArray }, testNode);    	
-        value_of(testNode.childNodes[0]).should_contain_html("<div>someprop=1</div><div>someprop=2</div><div>someprop=3</div>");
-    },
-    
-    'Data binding syntax should support \"if\" condition' : function() {
-        ko.setTemplateEngine(new dummyTemplateEngine({ myTemplate: "Value: [js: myProp().childProp]" }));        
-        testNode.innerHTML = "<div data-bind='template: { name: \"myTemplate\", \"if\": myProp }'></div>";
-        
-        var viewModel = { myProp: ko.observable({ childProp: 'abc' }) };
-        ko.applyBindings(viewModel, testNode);
-        
-        // Initially there is a value
-        value_of(testNode.childNodes[0]).should_contain_text("Value: abc");
-        
-        // Causing the condition to become false causes the output to be removed
-        viewModel.myProp(null);
-        value_of(testNode.childNodes[0]).should_contain_text("");
-        
-        // Causing the condition to become true causes the output to reappear
-        viewModel.myProp({ childProp: 'def' });
-        value_of(testNode.childNodes[0]).should_contain_text("Value: def");
-    },
-    
-    'Data binding syntax should support \"ifnot\" condition' : function() {
-        ko.setTemplateEngine(new dummyTemplateEngine({ myTemplate: "Hello" }));        
-        testNode.innerHTML = "<div data-bind='template: { name: \"myTemplate\", ifnot: shouldHide }'></div>";
-        
-        var viewModel = { shouldHide: ko.observable(true) };
-        ko.applyBindings(viewModel, testNode);
-        
-        // Initially there is no output (shouldHide=true)
-        value_of(testNode.childNodes[0]).should_contain_text("");
-        
-        // Causing the condition to become false causes the output to be displayed
-        viewModel.shouldHide(false);
-        value_of(testNode.childNodes[0]).should_contain_text("Hello");
-        
-        // Causing the condition to become true causes the output to disappear
-        viewModel.shouldHide(true);
-        value_of(testNode.childNodes[0]).should_contain_text("");
-    },    
-    
-    'Data binding syntax should support \"if\" condition in conjunction with foreach': function() {
-        ko.setTemplateEngine(new dummyTemplateEngine({ myTemplate: "Value: [js: myProp().childProp]" }));        
-        testNode.innerHTML = "<div data-bind='template: { name: \"myTemplate\", \"if\": myProp, foreach: [$data, $data, $data] }'></div>";
-        
-        var viewModel = { myProp: ko.observable({ childProp: 'abc' }) };
-        ko.applyBindings(viewModel, testNode);
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Value: abc");
-        value_of(testNode.childNodes[0].childNodes[1]).should_contain_text("Value: abc");
-        value_of(testNode.childNodes[0].childNodes[2]).should_contain_text("Value: abc");
-        
-        // Causing the condition to become false causes the output to be removed
-        viewModel.myProp(null);
-        value_of(testNode.childNodes[0]).should_contain_text("");
-        
-        // Causing the condition to become true causes the output to reappear
-        viewModel.myProp({ childProp: 'def' });
-        value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Value: def");
-        value_of(testNode.childNodes[0].childNodes[1]).should_contain_text("Value: def");
-        value_of(testNode.childNodes[0].childNodes[2]).should_contain_text("Value: def");
-    },
-    
-    'Should be able to populate checkboxes from inside templates, despite IE6 limitations': function () {    	
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "<input type='checkbox' data-bind='checked:isChecked' />" }));
-        ko.renderTemplate("someTemplate", null, { templateRenderingVariablesInScope: { isChecked: true } }, testNode);
-        value_of(testNode.childNodes[0].childNodes[0].checked).should_be(true);
-    },
-    
-    'Should be able to populate radio buttons from inside templates, despite IE6 limitations': function () {    	
-        ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "<input type='radio' name='somename' value='abc' data-bind='checked:someValue' />" }));
-        ko.renderTemplate("someTemplate", null, { templateRenderingVariablesInScope: { someValue: 'abc' } }, testNode);
-        value_of(testNode.childNodes[0].childNodes[0].checked).should_be(true);
-    },
-    
-    'Should be able to render a different template for each array entry by passing a function as template name': function() {
-        var myArray = new ko.observableArray([
-            { preferredTemplate: 1, someProperty: 'firstItemValue' }, 
-            { preferredTemplate: 2, someProperty: 'secondItemValue' }
-        ]);
-        ko.setTemplateEngine(new dummyTemplateEngine({
-            firstTemplate: "Template1Output, [js:someProperty]", 
-            secondTemplate: "Template2Output, [js:someProperty]"
-        }));
-        testNode.innerHTML = "<div data-bind='template: {name: getTemplateModelProperty, foreach: myCollection}'></div>";
-        
-        var getTemplate = function(dataItem) {
-            return dataItem.preferredTemplate == 1 ? 'firstTemplate' : 'secondTemplate';
-        };
-        ko.applyBindings({ myCollection: myArray, getTemplateModelProperty: getTemplate }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>template1output, firstitemvalue</div><div>template2output, seconditemvalue</div>");
-    },
-    
-    'Data binding \'templateOptions\' should be passed to template': function() {
-        var myModel = { 
-            someAdditionalData: { myAdditionalProp: "someAdditionalValue" },
-            people: new ko.observableArray([
-                { name: "Alpha" }, 
-                { name: "Beta" }
-            ])
-        };
-        ko.setTemplateEngine(new dummyTemplateEngine({myTemplate: "Person [js:name] has additional property [js:templateOptions.myAdditionalProp]"}));
-        testNode.innerHTML = "<div data-bind='template: {name: \"myTemplate\", foreach: people, templateOptions: someAdditionalData }'></div>";
+            'Should be able to render a template into a given DOM element': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "ABC" }));
+                ko.renderTemplate("someTemplate", null, null, testNode);
+                value_of(testNode.childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].innerHTML).should_be("ABC");
+            },
 
-        ko.applyBindings(myModel, testNode);
-        value_of(testNode.childNodes[0]).should_contain_html("<div>person alpha has additional property someadditionalvalue</div><div>person beta has additional property someadditionalvalue</div>");
-    },
-    
-    'If the template binding is updated, should dispose any template subscriptions previously associated with the element': function() {
-        var myModel = { 
-            myObservable: ko.observable("some value"),
-            unrelatedObservable: ko.observable()
-        };
-        ko.setTemplateEngine(new dummyTemplateEngine({myTemplate: "The value is [js:myObservable()]"}));
-        testNode.innerHTML = "<div data-bind='template: \"myTemplate\", unrelatedBindingHandler: unrelatedObservable()'></div>";
-        ko.applyBindings(myModel, testNode);
-        
-        // Right now the template references myObservable, so there should be exactly one subscription on it
-        value_of(testNode.childNodes[0]).should_contain_html("<div>the value is some value</div>");
-        value_of(myModel.myObservable.getSubscriptionsCount()).should_be(1);
-        
-        // By changing unrelatedObservable, we force the data-bind value to be re-evaluated, setting up a new template subscription,
-        // so there have now existed two subscriptions on myObservable...
-        myModel.unrelatedObservable("any value");
-        
-        // ...but, because the old subscription should have been disposed automatically, there should only be one left
-        value_of(myModel.myObservable.getSubscriptionsCount()).should_be(1);
-    },
-    
-    'Should be able to specify a template engine instance using data-bind syntax': function() {
-        ko.setTemplateEngine(new dummyTemplateEngine({ theTemplate: "Default output" })); // Not going to use this one
-        var alternativeTemplateEngine = new dummyTemplateEngine({ theTemplate: "Alternative output" });
-        
-        testNode.innerHTML = "<div data-bind='template: { name: \"theTemplate\", templateEngine: chosenEngine }'></div>";
-        ko.applyBindings({ chosenEngine: alternativeTemplateEngine }, testNode);
-        
-        value_of(testNode.childNodes[0]).should_contain_text("Alternative output");
-    },
-
-    'Data-bind syntax should expose parent binding context as $parent if binding with an explicit \"data\" value': function() {
-        ko.setTemplateEngine(new dummyTemplateEngine({
-            myTemplate: "ValueLiteral: [js:$parent.parentProp], ValueBound: <span data-bind='text: $parent.parentProp'></span>"
-        }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"myTemplate\", data: someItem }'></div>";
-        ko.applyBindings({ someItem: {}, parentProp: 'Hello' }, testNode);
-        value_of(testNode.childNodes[0]).should_contain_text("ValueLiteral: Hello, ValueBound: Hello");
-    },
-
-    'Data-bind syntax should expose all ancestor binding contexts as $parents': function() {
-        ko.setTemplateEngine(new dummyTemplateEngine({
-            outerTemplate:  "<div data-bind='template: { name:\"middleTemplate\", data: middleItem }'></div>",
-            middleTemplate: "<div data-bind='template: { name: \"innerTemplate\", data: innerItem }'></div>",
-            innerTemplate:  "(Data:[js:$data.val], Parent:[[js:$parents[0].val]], Grandparent:[[js:$parents[1].val]], Root:[js:$root.val], Depth:[js:$parents.length])"
-        }));
-        testNode.innerHTML = "<div data-bind='template: { name: \"outerTemplate\", data: outerItem }'></div>";   
-                           
-        ko.applyBindings({
-            val: "ROOT",
-            outerItem: {
-                val: "OUTER",
-                middleItem: {
-                    val: "MIDDLE",
-                    innerItem: { val: "INNER" }
+            'Should be able to access newly rendered/inserted elements in \'afterRender\' callaback': function () {
+                var passedElement, passedDataItem;
+                var myCallback = function (elementsArray, dataItem) {
+                    value_of(elementsArray.length).should_be(1);
+                    passedElement = elementsArray[0];
+                    passedDataItem = dataItem;
                 }
+                var myModel = {};
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "ABC" }));
+                ko.renderTemplate("someTemplate", myModel, { afterRender: myCallback }, testNode);
+                value_of(passedElement.innerHTML).should_be("ABC");
+                value_of(passedDataItem).should_be(myModel);
+            },
+
+            'Should automatically rerender into DOM element when dependencies change': function () {
+                var dependency = new ko.observable("A");
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    someTemplate: function () {
+                        return "Value = " + dependency();
+                    }
+                }));
+
+                ko.renderTemplate("someTemplate", null, null, testNode);
+                value_of(testNode.childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].innerHTML).should_be("Value = A");
+
+                dependency("B");
+                value_of(testNode.childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].innerHTML).should_be("Value = B");
+            },
+
+            'If the supplied data item is observable, evaluates it and has subscription on it': function () {
+                var observable = new ko.observable("A");
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    someTemplate: function (data) {
+                        return "Value = " + data;
+                    }
+                }));
+                ko.renderTemplate("someTemplate", observable, null, testNode);
+                value_of(testNode.childNodes[0].innerHTML).should_be("Value = A");
+
+                observable("B");
+                value_of(testNode.childNodes[0].innerHTML).should_be("Value = B");
+            },
+
+            'Should stop updating DOM nodes when the dependency next changes if the DOM node has been removed from the document': function () {
+                var dependency = new ko.observable("A");
+                var template = { someTemplate: function () { return "Value = " + dependency() } };
+                ko.setTemplateEngine(new dummyTemplateEngine(template));
+
+                ko.renderTemplate("someTemplate", null, null, testNode);
+                value_of(testNode.childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].innerHTML).should_be("Value = A");
+
+                testNode.parentNode.removeChild(testNode);
+                dependency("B");
+                value_of(testNode.childNodes.length).should_be(1);
+                value_of(testNode.childNodes[0].innerHTML).should_be("Value = A");
+            },
+
+            'Should be able to render a template using data-bind syntax': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "template output" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template:\"someTemplate\"'></div>";
+                ko.applyBindings(null, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>template output</div>");
+            },
+
+            'Should be able to tell data-bind syntax which object to pass as data for the template (otherwise, uses viewModel)': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "result = [js: childProp]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"someTemplate\", data: someProp }'></div>";
+                ko.applyBindings({ someProp: { childProp: 123} }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>result = 123</div>");
+            },
+
+            'Should stop tracking inner observables immediately when the container node is removed from the document': function () {
+                var innerObservable = ko.observable("some value");
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "result = [js: childProp()]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"someTemplate\", data: someProp }'></div>";
+                ko.applyBindings({ someProp: { childProp: innerObservable} }, testNode);
+
+                value_of(innerObservable.getSubscriptionsCount()).should_be(1);
+                ko.cleanAndRemoveNode(testNode.childNodes[0]);
+                value_of(innerObservable.getSubscriptionsCount()).should_be(0);
+            },
+
+            'Should be able to pick template as a function of the data item using data-bind syntax': function () {
+                var templatePicker = function (dataItem) {
+                    return dataItem.myTemplate;
+                };
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "result = [js: childProp]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: templateSelectorFunction, data: someProp }'></div>";
+                ko.applyBindings({ someProp: { childProp: 123, myTemplate: "someTemplate" }, templateSelectorFunction: templatePicker }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>result = 123</div>");
+            },
+
+            'Should be able to chain templates, rendering one from inside another': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    outerTemplate: "outer template output, [renderTemplate:innerTemplate]", // [renderTemplate:...] is special syntax supported by dummy template engine
+                    innerTemplate: "inner template output <span " + bindingAttribute + "='text: 123'></span>"
+                }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template:\"outerTemplate\"'></div>";
+                ko.applyBindings(null, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>outer template output, <div>inner template output <span>123</span></div></div>");
+            },
+
+            'Should rerender chained templates when their dependencies change, without rerendering parent templates': function () {
+                var observable = new ko.observable("ABC");
+                var timesRenderedOuter = 0, timesRenderedInner = 0;
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    outerTemplate: function () {
+                        timesRenderedOuter++;
+                        return "outer template output, [renderTemplate:innerTemplate]"
+                    }, // [renderTemplate:...] is special syntax supported by dummy template engine
+                    innerTemplate: function () {
+                        timesRenderedInner++;
+                        return observable()
+                    }
+                }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template:\"outerTemplate\"'></div>";
+                ko.applyBindings(null, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>outer template output, <div>abc</div></div>");
+                value_of(timesRenderedOuter).should_be(1);
+                value_of(timesRenderedInner).should_be(1);
+
+                observable("DEF");
+                value_of(testNode.childNodes[0]).should_contain_html("<div>outer template output, <div>def</div></div>");
+                value_of(timesRenderedOuter).should_be(1);
+                value_of(timesRenderedInner).should_be(2);
+            },
+
+            'Should stop tracking inner observables referenced by a chained template as soon as the chained template output node is removed from the document': function () {
+                var innerObservable = ko.observable("some value");
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    outerTemplate: "outer template output, <span id='innerTemplateOutput'>[renderTemplate:innerTemplate]</span>",
+                    innerTemplate: "result = [js: childProp()]"
+                }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"outerTemplate\", data: someProp }'></div>";
+                ko.applyBindings({ someProp: { childProp: innerObservable} }, testNode);
+
+                value_of(innerObservable.getSubscriptionsCount()).should_be(1);
+                ko.cleanAndRemoveNode(document.getElementById('innerTemplateOutput'));
+                value_of(innerObservable.getSubscriptionsCount()).should_be(0);
+            },
+
+            'Should handle data-bind attributes from inside templates, regardless of element and attribute casing': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "<INPUT " + bindingAttribute + "='value:\"Hi\"' />" }));
+                ko.renderTemplate("someTemplate", null, null, testNode);
+                value_of(testNode.childNodes[0].childNodes[0].value).should_be("Hi");
+            },
+
+            'Should handle data-bind attributes that include newlines from inside templates': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "<input " + bindingAttribute + "='value:\n\"Hi\"' />" }));
+                ko.renderTemplate("someTemplate", null, null, testNode);
+                value_of(testNode.childNodes[0].childNodes[0].value).should_be("Hi");
+            },
+
+            'Data binding syntax should be able to reference variables put into scope by the template engine': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "<input " + bindingAttribute + "='value:message' />" }));
+                ko.renderTemplate("someTemplate", null, { templateRenderingVariablesInScope: { message: "hello"} }, testNode);
+                value_of(testNode.childNodes[0].childNodes[0].value).should_be("hello");
+            },
+
+            'Data binding syntax should defer evaluation of variables until the end of template rendering (so bindings can take independent subscriptions to them)': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    someTemplate: "<input " + bindingAttribute + "='value:message' />[js: message = 'goodbye'; undefined; ]"
+                }));
+                ko.renderTemplate("someTemplate", null, { templateRenderingVariablesInScope: { message: "hello"} }, testNode);
+                value_of(testNode.childNodes[0].childNodes[0].value).should_be("goodbye");
+            },
+
+            'Data binding syntax should use the template\'s \'data\' object as the viewModel value (so \'this\' is set correctly when calling click handlers etc.)': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    someTemplate: "<button " + bindingAttribute + "='click: someFunctionOnModel'>click me</button>"
+                }));
+                var viewModel = {
+                    didCallMyFunction: false,
+                    someFunctionOnModel: function () { this.didCallMyFunction = true }
+                };
+                ko.renderTemplate("someTemplate", viewModel, null, testNode);
+                var buttonNode = testNode.childNodes[0].childNodes[0];
+                value_of(buttonNode.tagName).should_be("BUTTON"); // Be sure we're clicking the right thing
+                buttonNode.click();
+                value_of(viewModel.didCallMyFunction).should_be(true);
+            },
+
+            'Data binding syntax should permit nested templates, and only bind inner templates once': function () {
+                // Will verify that bindings are applied only once for both inline (rewritten) bindings,
+                // and external (non-rewritten) ones
+                var originalBindingProvider = ko.bindingProvider.instance;
+                ko.bindingProvider.instance = {
+                    nodeHasBindings: function (node, bindingContext) {
+                        return (node.tagName == 'EM') || originalBindingProvider.nodeHasBindings(node, bindingContext);
+                    },
+                    getBindings: function (node, bindingContext) {
+                        if (node.tagName == 'EM')
+                            return { text: ++model.numBindings };
+                        return originalBindingProvider.getBindings(node, bindingContext);
+                    },
+                    configuration : originalBindingProvider.configuration  //???!!!
+                };
+                
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    outerTemplate: "Outer <div " + ko.bindingProvider.configuration(originalBindingProvider).bindingAttribute + "='template: { name: \"innerTemplate\", bypassDomNodeWrap: true }'></div>",
+                    innerTemplate: "Inner via inline binding: <span " + ko.bindingProvider.configuration(originalBindingProvider).bindingAttribute + "='text: ++numBindings'></span>"
+                    + "Inner via external binding: <em></em>"
+                }));
+                var model = { numBindings: 0 };
+                testNode.innerHTML = "<div " + ko.bindingProvider.configuration(originalBindingProvider).bindingAttribute + "='template: { name: \"outerTemplate\", bypassDomNodeWrap: true }'></div>";
+                ko.applyBindings(model, testNode);
+                value_of(model.numBindings).should_be(2);
+                value_of(testNode.childNodes[0]).should_contain_html("outer <div>inner via inline binding: <span>2</span>inner via external binding: <em>1</em></div>");
+
+                ko.bindingProvider.instance = originalBindingProvider;
+            },
+
+            'Data binding syntax should support \'foreach\' option, whereby it renders for each item in an array but doesn\'t rerender everything if you push or splice': function () {
+                var myArray = new ko.observableArray([{ personName: "Bob" }, { personName: "Frank"}]);
+                ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is [js: personName]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
+
+                ko.applyBindings({ myCollection: myArray }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>the item is bob</div><div>the item is frank</div>");
+                var originalBobNode = testNode.childNodes[0].childNodes[0];
+                var originalFrankNode = testNode.childNodes[0].childNodes[1];
+
+                myArray.push({ personName: "Steve" });
+                value_of(testNode.childNodes[0]).should_contain_html("<div>the item is bob</div><div>the item is frank</div><div>the item is steve</div>");
+                value_of(testNode.childNodes[0].childNodes[0]).should_be(originalBobNode);
+                value_of(testNode.childNodes[0].childNodes[1]).should_be(originalFrankNode);
+            },
+
+            'Data binding \'foreach\' option should apply bindings within the context of each item in the array': function () {
+                var myArray = new ko.observableArray([{ personName: "Bob" }, { personName: "Frank"}]);
+                ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is <span " + bindingAttribute + "='text: personName'></span>" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
+
+                ko.applyBindings({ myCollection: myArray }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>the item is <span>bob</span></div><div>the item is <span>frank</span></div>");
+            },
+
+            'Data binding \'foreach\' options should only bind each group of output nodes once': function () {
+                var initCalls = 0;
+                ko.bindingHandlers.countInits = { init: function () { initCalls++ } };
+                ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "<span " + bindingAttribute + "='countInits: true'></span>" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
+
+                ko.applyBindings({ myCollection: [1, 2, 3] }, testNode);
+                value_of(initCalls).should_be(3); // 3 because there were 3 items in myCollection
+            },
+
+            'Data binding \'foreach\' option should accept array with "undefined" and "null" items': function () {
+                var myArray = new ko.observableArray([undefined, null]);
+                ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is <span " + bindingAttribute + "='text: String($data)'></span>" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
+
+                ko.applyBindings({ myCollection: myArray }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>the item is <span>undefined</span></div><div>the item is <span>null</span></div>");
+            },
+
+            'Data binding \'foreach\' option should update DOM nodes when a dependency of their mapping function changes': function () {
+                var myObservable = new ko.observable("Steve");
+                var myArray = new ko.observableArray([{ personName: "Bob" }, { personName: myObservable }, { personName: "Another"}]);
+                ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is [js: ko.utils.unwrapObservable(personName)]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
+
+                ko.applyBindings({ myCollection: myArray }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>the item is bob</div><div>the item is steve</div><div>the item is another</div>");
+                var originalBobNode = testNode.childNodes[0].childNodes[0];
+
+                myObservable("Steve2");
+                value_of(testNode.childNodes[0]).should_contain_html("<div>the item is bob</div><div>the item is steve2</div><div>the item is another</div>");
+                value_of(testNode.childNodes[0].childNodes[0]).should_be(originalBobNode);
+
+                // Ensure we can still remove the corresponding nodes (even though they've changed), and that doing so causes the subscription to be disposed
+                value_of(myObservable.getSubscriptionsCount()).should_be(1);
+                myArray.splice(1, 1);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>the item is bob</div><div>the item is another</div>");
+                myObservable("Something else"); // Re-evaluating the observable causes the orphaned subscriptions to be disposed
+                value_of(myObservable.getSubscriptionsCount()).should_be(0);
+            },
+
+            'Data binding \'foreach\' option should treat a null parameter as meaning \'no items\'': function () {
+                var myArray = new ko.observableArray(["A", "B"]);
+                ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "hello" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
+
+                ko.applyBindings({ myCollection: myArray }, testNode);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(2);
+
+                // Now set the observable to null and check it's treated like an empty array
+                // (because how else should null be interpreted?)
+                myArray(null);
+                value_of(testNode.childNodes[0].childNodes.length).should_be(0);
+            },
+
+            'Data binding \'foreach\' option should stop tracking inner observables when the container node is removed': function () {
+                var innerObservable = ko.observable("some value");
+                var myArray = new ko.observableArray([{ obsVal: innerObservable }, { obsVal: innerObservable}]);
+                ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is [js: ko.utils.unwrapObservable(obsVal)]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
+
+                ko.applyBindings({ myCollection: myArray }, testNode);
+                value_of(innerObservable.getSubscriptionsCount()).should_be(2);
+
+                ko.cleanAndRemoveNode(testNode.childNodes[0]);
+                value_of(innerObservable.getSubscriptionsCount()).should_be(0);
+            },
+
+            'Data binding \'foreach\' option should stop tracking inner observables related to each array item when that array item is removed': function () {
+                var innerObservable = ko.observable("some value");
+                var myArray = new ko.observableArray([{ obsVal: innerObservable }, { obsVal: innerObservable}]);
+                ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "The item is [js: ko.utils.unwrapObservable(obsVal)]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
+
+                ko.applyBindings({ myCollection: myArray }, testNode);
+                value_of(innerObservable.getSubscriptionsCount()).should_be(2);
+
+                myArray.splice(1, 1);
+                value_of(innerObservable.getSubscriptionsCount()).should_be(1);
+                myArray([]);
+                value_of(innerObservable.getSubscriptionsCount()).should_be(0);
+            },
+
+            'Data binding syntax should omit any items whose \'_destroy\' flag is set (unwrapping the flag if it is observable)': function () {
+                var myArray = new ko.observableArray([{ someProp: 1 }, { someProp: 2, _destroy: 'evals to true' }, { someProp: 3 }, { someProp: 4, _destroy: ko.observable(false)}]);
+                ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "someProp=[js: someProp]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"itemTemplate\", foreach: myCollection }'></div>";
+
+                ko.applyBindings({ myCollection: myArray }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>someprop=1</div><div>someprop=3</div><div>someprop=4</div>");
+            },
+
+            'Data binding syntax should include any items whose \'_destroy\' flag is set if you use includeDestroyed': function () {
+                var myArray = new ko.observableArray([{ someProp: 1 }, { someProp: 2, _destroy: 'evals to true' }, { someProp: 3}]);
+                ko.setTemplateEngine(new dummyTemplateEngine({ itemTemplate: "someProp=[js: someProp]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"itemTemplate\", foreach: myCollection, includeDestroyed: true }'></div>";
+
+                ko.applyBindings({ myCollection: myArray }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>someprop=1</div><div>someprop=2</div><div>someprop=3</div>");
+            },
+
+            'Data binding syntax should support \"if\" condition': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ myTemplate: "Value: [js: myProp().childProp]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"myTemplate\", \"if\": myProp }'></div>";
+
+                var viewModel = { myProp: ko.observable({ childProp: 'abc' }) };
+                ko.applyBindings(viewModel, testNode);
+
+                // Initially there is a value
+                value_of(testNode.childNodes[0]).should_contain_text("Value: abc");
+
+                // Causing the condition to become false causes the output to be removed
+                viewModel.myProp(null);
+                value_of(testNode.childNodes[0]).should_contain_text("");
+
+                // Causing the condition to become true causes the output to reappear
+                viewModel.myProp({ childProp: 'def' });
+                value_of(testNode.childNodes[0]).should_contain_text("Value: def");
+            },
+
+            'Data binding syntax should support \"ifnot\" condition': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ myTemplate: "Hello" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"myTemplate\", ifnot: shouldHide }'></div>";
+
+                var viewModel = { shouldHide: ko.observable(true) };
+                ko.applyBindings(viewModel, testNode);
+
+                // Initially there is no output (shouldHide=true)
+                value_of(testNode.childNodes[0]).should_contain_text("");
+
+                // Causing the condition to become false causes the output to be displayed
+                viewModel.shouldHide(false);
+                value_of(testNode.childNodes[0]).should_contain_text("Hello");
+
+                // Causing the condition to become true causes the output to disappear
+                viewModel.shouldHide(true);
+                value_of(testNode.childNodes[0]).should_contain_text("");
+            },
+
+            'Data binding syntax should support \"if\" condition in conjunction with foreach': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ myTemplate: "Value: [js: myProp().childProp]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"myTemplate\", \"if\": myProp, foreach: [$data, $data, $data] }'></div>";
+
+                var viewModel = { myProp: ko.observable({ childProp: 'abc' }) };
+                ko.applyBindings(viewModel, testNode);
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Value: abc");
+                value_of(testNode.childNodes[0].childNodes[1]).should_contain_text("Value: abc");
+                value_of(testNode.childNodes[0].childNodes[2]).should_contain_text("Value: abc");
+
+                // Causing the condition to become false causes the output to be removed
+                viewModel.myProp(null);
+                value_of(testNode.childNodes[0]).should_contain_text("");
+
+                // Causing the condition to become true causes the output to reappear
+                viewModel.myProp({ childProp: 'def' });
+                value_of(testNode.childNodes[0].childNodes[0]).should_contain_text("Value: def");
+                value_of(testNode.childNodes[0].childNodes[1]).should_contain_text("Value: def");
+                value_of(testNode.childNodes[0].childNodes[2]).should_contain_text("Value: def");
+            },
+
+            'Should be able to populate checkboxes from inside templates, despite IE6 limitations': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "<input type='checkbox' " + bindingAttribute + "='checked:isChecked' />" }));
+                ko.renderTemplate("someTemplate", null, { templateRenderingVariablesInScope: { isChecked: true} }, testNode);
+                value_of(testNode.childNodes[0].childNodes[0].checked).should_be(true);
+            },
+
+            'Should be able to populate radio buttons from inside templates, despite IE6 limitations': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ someTemplate: "<input type='radio' name='somename' value='abc' " + bindingAttribute + "='checked:someValue' />" }));
+                ko.renderTemplate("someTemplate", null, { templateRenderingVariablesInScope: { someValue: 'abc'} }, testNode);
+                value_of(testNode.childNodes[0].childNodes[0].checked).should_be(true);
+            },
+
+            'Should be able to render a different template for each array entry by passing a function as template name': function () {
+                var myArray = new ko.observableArray([
+                        { preferredTemplate: 1, someProperty: 'firstItemValue' },
+                        { preferredTemplate: 2, someProperty: 'secondItemValue' }
+                    ]);
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    firstTemplate: "Template1Output, [js:someProperty]",
+                    secondTemplate: "Template2Output, [js:someProperty]"
+                }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: {name: getTemplateModelProperty, foreach: myCollection}'></div>";
+
+                var getTemplate = function (dataItem) {
+                    return dataItem.preferredTemplate == 1 ? 'firstTemplate' : 'secondTemplate';
+                };
+                ko.applyBindings({ myCollection: myArray, getTemplateModelProperty: getTemplate }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>template1output, firstitemvalue</div><div>template2output, seconditemvalue</div>");
+            },
+
+            'Data binding \'templateOptions\' should be passed to template': function () {
+                var myModel = {
+                    someAdditionalData: { myAdditionalProp: "someAdditionalValue" },
+                    people: new ko.observableArray([
+                        { name: "Alpha" },
+                        { name: "Beta" }
+                    ])
+                };
+                ko.setTemplateEngine(new dummyTemplateEngine({ myTemplate: "Person [js:name] has additional property [js:templateOptions.myAdditionalProp]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: {name: \"myTemplate\", foreach: people, templateOptions: someAdditionalData }'></div>";
+
+                ko.applyBindings(myModel, testNode);
+                value_of(testNode.childNodes[0]).should_contain_html("<div>person alpha has additional property someadditionalvalue</div><div>person beta has additional property someadditionalvalue</div>");
+            },
+
+            'If the template binding is updated, should dispose any template subscriptions previously associated with the element': function () {
+                var myModel = {
+                    myObservable: ko.observable("some value"),
+                    unrelatedObservable: ko.observable()
+                };
+                ko.setTemplateEngine(new dummyTemplateEngine({ myTemplate: "The value is [js:myObservable()]" }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: \"myTemplate\", unrelatedBindingHandler: unrelatedObservable()'></div>";
+                ko.applyBindings(myModel, testNode);
+
+                // Right now the template references myObservable, so there should be exactly one subscription on it
+                value_of(testNode.childNodes[0]).should_contain_html("<div>the value is some value</div>");
+                value_of(myModel.myObservable.getSubscriptionsCount()).should_be(1);
+
+                // By changing unrelatedObservable, we force the data-bind value to be re-evaluated, setting up a new template subscription,
+                // so there have now existed two subscriptions on myObservable...
+                myModel.unrelatedObservable("any value");
+
+                // ...but, because the old subscription should have been disposed automatically, there should only be one left
+                value_of(myModel.myObservable.getSubscriptionsCount()).should_be(1);
+            },
+
+            'Should be able to specify a template engine instance using data-bind syntax': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({ theTemplate: "Default output" })); // Not going to use this one
+                var alternativeTemplateEngine = new dummyTemplateEngine({ theTemplate: "Alternative output" });
+
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"theTemplate\", templateEngine: chosenEngine }'></div>";
+                ko.applyBindings({ chosenEngine: alternativeTemplateEngine }, testNode);
+
+                value_of(testNode.childNodes[0]).should_contain_text("Alternative output");
+            },
+
+            'Data-bind syntax should expose parent binding context as $parent if binding with an explicit \"data\" value': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    myTemplate: "ValueLiteral: [js:$parent.parentProp], ValueBound: <span " + bindingAttribute + "='text: $parent.parentProp'></span>"
+                }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"myTemplate\", data: someItem }'></div>";
+                ko.applyBindings({ someItem: {}, parentProp: 'Hello' }, testNode);
+                value_of(testNode.childNodes[0]).should_contain_text("ValueLiteral: Hello, ValueBound: Hello");
+            },
+
+            'Data-bind syntax should expose all ancestor binding contexts as $parents': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    outerTemplate: "<div " + bindingAttribute + "='template: { name:\"middleTemplate\", data: middleItem }'></div>",
+                    middleTemplate: "<div " + bindingAttribute + "='template: { name: \"innerTemplate\", data: innerItem }'></div>",
+                    innerTemplate: "(Data:[js:$data.val], Parent:[[js:$parents[0].val]], Grandparent:[[js:$parents[1].val]], Root:[js:$root.val], Depth:[js:$parents.length])"
+                }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"outerTemplate\", data: outerItem }'></div>";
+
+                ko.applyBindings({
+                    val: "ROOT",
+                    outerItem: {
+                        val: "OUTER",
+                        middleItem: {
+                            val: "MIDDLE",
+                            innerItem: { val: "INNER" }
+                        }
+                    }
+                }, testNode);
+                value_of(testNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0].childNodes[0]).should_contain_text("(Data:INNER, Parent:MIDDLE, Grandparent:OUTER, Root:ROOT, Depth:3)");
+            },
+
+            'Should not be allowed to rewrite templates that embed anonymous templates': function () {
+                // The reason is that your template engine's native control flow and variable evaluation logic is going to run first, independently
+                // of any KO-native control flow, so variables would get evaluated in the wrong context. Example:
+                //
+                // <div " + bindingAttribute + "="foreach: someArray">
+                //     ${ somePropertyOfEachArrayItem }   <-- This gets evaluated *before* the foreach binds, so it can't reference array entries
+                // </div>
+                //
+                // It should be perfectly OK to fix this just by preventing anonymous templates within rewritten templates, because
+                // (1) The developer can always use their template engine's native control flow syntax instead of the KO-native ones - that will work
+                // (2) The developer can use KO's native templating instead, if they are keen on KO-native control flow or anonymous templates
+
+                ko.setTemplateEngine(new dummyTemplateEngine({
+                    myTemplate: "<div " + bindingAttribute + "='template: { data: someData }'>Childprop: [js: childProp]</div>"
+                }));
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"myTemplate\" }'></div>";
+
+                var didThrow = false;
+                try {
+                    ko.applyBindings({ someData: { childProp: 'abc'} }, testNode);
+                } catch (ex) {
+                    didThrow = true;
+                    value_of(ex.message).should_be("This template engine does not support anonymous templates nested within its templates");
+                }
+                value_of(didThrow).should_be(true);
+            },
+
+            'Should not be allowed to rewrite templates that embed control flow bindings': function () {
+                // Same reason as above
+                ko.utils.arrayForEach(['if', 'ifnot', 'with', 'foreach'], function (bindingName) {
+                    ko.setTemplateEngine(new dummyTemplateEngine({ myTemplate: "<div " + bindingAttribute + "='" + bindingName + ": \"SomeValue\"'>Hello</div>" }));
+                    testNode.innerHTML = "<div " + bindingAttribute + "='template: { name: \"myTemplate\" }'></div>";
+
+                    var didThrow = false;
+                    try {
+                        ko.applyBindings({ someData: { childProp: 'abc'} }, testNode)
+                    } catch (ex) {
+                        didThrow = true;
+                        value_of(ex.message).should_be("This template engine does not support the '" + bindingName + "' binding within its templates");
+                    }
+                    if (!didThrow)
+                        throw new Error("Did not prevent use of " + bindingName);
+                });
+            },
+
+            'Should be able to render anonymous templates using virtual containers': function () {
+                ko.setTemplateEngine(new dummyTemplateEngine());
+                testNode.innerHTML = "Start <!-- " + virtualElementTag + " template: { data: someData } -->Childprop: [js: childProp]<!-- /" + virtualElementTag + " --> End";
+                ko.applyBindings({ someData: { childProp: 'abc'} }, testNode);
+                value_of(testNode).should_contain_html("start <!-- " + virtualElementTag + " template: { data: somedata } --><div>childprop: abc</div><!-- /" + virtualElementTag + " -->end");
+            },
+
+            'Should be able to use anonymous templates that contain first-child comment nodes': function () {
+                // This represents issue https://github.com/SteveSanderson/knockout/issues/188
+                // (IE < 9 strips out leading comment nodes when you use .innerHTML)   
+                ko.setTemplateEngine(new dummyTemplateEngine({}));
+                testNode.innerHTML = "start <div " + bindingAttribute + "='foreach: [1,2]'><span><!-- leading comment -->hello</span></div>";
+                ko.applyBindings(null, testNode);
+                value_of(testNode).should_contain_html('start <div ' + bindingAttribute + '="foreach: [1,2]"><span><!-- leading comment -->hello</span><span><!-- leading comment -->hello</span></div>');
+            },
+
+            'Should allow anonymous templates output to include top-level virtual elements, and will bind their virtual children only once': function () {
+                delete ko.bindingHandlers.nonexistentHandler;
+                var initCalls = 0;
+                ko.bindingHandlers.countInits = { init: function () { initCalls++ } };
+                testNode.innerHTML = "<div " + bindingAttribute + "='template: {}'><!-- " + virtualElementTag + " nonexistentHandler: true --><span " + bindingAttribute + "='countInits: true'></span><!-- /" + virtualElementTag + " --></div>";
+                ko.applyBindings(null, testNode);
+                value_of(initCalls).should_be(1);
             }
-        }, testNode);
-        value_of(testNode.childNodes[0].childNodes[0].childNodes[0].childNodes[0].childNodes[0]).should_contain_text("(Data:INNER, Parent:MIDDLE, Grandparent:OUTER, Root:ROOT, Depth:3)");
-    },
-    
-    'Should not be allowed to rewrite templates that embed anonymous templates': function() {
-        // The reason is that your template engine's native control flow and variable evaluation logic is going to run first, independently
-        // of any KO-native control flow, so variables would get evaluated in the wrong context. Example:
-        //
-        // <div data-bind="foreach: someArray">
-        //     ${ somePropertyOfEachArrayItem }   <-- This gets evaluated *before* the foreach binds, so it can't reference array entries
-        // </div>
-        //
-        // It should be perfectly OK to fix this just by preventing anonymous templates within rewritten templates, because
-        // (1) The developer can always use their template engine's native control flow syntax instead of the KO-native ones - that will work
-        // (2) The developer can use KO's native templating instead, if they are keen on KO-native control flow or anonymous templates
-
-        ko.setTemplateEngine(new dummyTemplateEngine({
-            myTemplate: "<div data-bind='template: { data: someData }'>Childprop: [js: childProp]</div>"
-        }));        
-        testNode.innerHTML = "<div data-bind='template: { name: \"myTemplate\" }'></div>";   
-
-        var didThrow = false;
-        try {
-            ko.applyBindings({ someData: { childProp: 'abc' } }, testNode);
-        } catch(ex) {
-            didThrow = true;
-            value_of(ex.message).should_be("This template engine does not support anonymous templates nested within its templates");
-        }
-        value_of(didThrow).should_be(true);
-    },
-
-    'Should not be allowed to rewrite templates that embed control flow bindings': function() {
-        // Same reason as above
-        ko.utils.arrayForEach(['if', 'ifnot', 'with', 'foreach'], function(bindingName) {
-            ko.setTemplateEngine(new dummyTemplateEngine({ myTemplate: "<div data-bind='" + bindingName + ": \"SomeValue\"'>Hello</div>" }));
-            testNode.innerHTML = "<div data-bind='template: { name: \"myTemplate\" }'></div>";   
-
-            var didThrow = false;
-            try { ko.applyBindings({ someData: { childProp: 'abc' } }, testNode) } 
-            catch (ex) {
-                didThrow = true;
-                value_of(ex.message).should_be("This template engine does not support the '" + bindingName + "' binding within its templates");
-            }
-            if (!didThrow)
-                throw new Error("Did not prevent use of " + bindingName);            
-        });
-    },
+        })
+    };
+
+    templatingBehaviors();
+    templatingBehaviors({ name: "alternative configuration", virtualElementTag: "ko1", bindingAttribute: "data-bind1" });
     
-    'Should be able to render anonymous templates using virtual containers': function() {
-        ko.setTemplateEngine(new dummyTemplateEngine());    
-        testNode.innerHTML = "Start <!-- ko template: { data: someData } -->Childprop: [js: childProp]<!-- /ko --> End";
-        ko.applyBindings({ someData: { childProp: 'abc' } }, testNode);
-        value_of(testNode).should_contain_html("start <!-- ko template: { data: somedata } --><div>childprop: abc</div><!-- /ko -->end");
-    },
-
-    'Should be able to use anonymous templates that contain first-child comment nodes': function() {
-        // This represents issue https://github.com/SteveSanderson/knockout/issues/188
-        // (IE < 9 strips out leading comment nodes when you use .innerHTML)   
-        ko.setTemplateEngine(new dummyTemplateEngine({}));
-        testNode.innerHTML = "start <div data-bind='foreach: [1,2]'><span><!-- leading comment -->hello</span></div>";
-        ko.applyBindings(null, testNode);
-        value_of(testNode).should_contain_html('start <div data-bind="foreach: [1,2]"><span><!-- leading comment -->hello</span><span><!-- leading comment -->hello</span></div>');
-    },
-
-    'Should allow anonymous templates output to include top-level virtual elements, and will bind their virtual children only once': function() {
-        delete ko.bindingHandlers.nonexistentHandler;
-        var initCalls = 0;
-        ko.bindingHandlers.countInits = { init: function () { initCalls++ } };
-        testNode.innerHTML = "<div data-bind='template: {}'><!-- ko nonexistentHandler: true --><span data-bind='countInits: true'></span><!-- /ko --></div>";
-        ko.applyBindings(null, testNode);
-        value_of(initCalls).should_be(1);
-    }
-})
\ No newline at end of file
+    
\ No newline at end of file
diff --git a/src/binding/bindingProvider.js b/src/binding/bindingProvider.js
index 401ac599f..4e117033a 100644
--- a/src/binding/bindingProvider.js
+++ b/src/binding/bindingProvider.js
@@ -1,32 +1,32 @@
-(function() {
-    var defaultBindingAttributeName = "data-bind";
+(function () {
 
-    ko.bindingProvider = function() {
+    ko.bindingProvider = function (configuration) {
+        this.configuration = setDefaultConfiguration(configuration);
         this.bindingCache = {};
-        this['clearCache'] = function() {
+        this['clearCache'] = function () {
             this.bindingCache = {};
         };
     };
 
     ko.utils.extendInternal(ko.bindingProvider.prototype, {
-        'nodeHasBindings': function(node) {
+        'nodeHasBindings': function (node) {
             switch (node.nodeType) {
-                case 1: return node.getAttribute(defaultBindingAttributeName) != null;   // Element
+                case 1: return node.getAttribute(this.configuration.bindingAttribute) != null;   // Element
                 case 8: return ko.virtualElements.virtualNodeBindingValue(node) != null; // Comment node
                 default: return false;
             }
         },
 
-        'getBindings': function(node, bindingContext) {
+        'getBindings': function (node, bindingContext) {
             var bindingsString = this['getBindingsString'](node, bindingContext);
             return bindingsString ? this['parseBindingsString'](bindingsString, bindingContext) : 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) {
+        'getBindingsString': function (node, bindingContext) {
             switch (node.nodeType) {
-                case 1: return node.getAttribute(defaultBindingAttributeName);   // Element
+                case 1: return node.getAttribute(this.configuration.bindingAttribute);   // Element
                 case 8: return ko.virtualElements.virtualNodeBindingValue(node); // Comment node
                 default: return null;
             }
@@ -34,7 +34,7 @@
 
         // 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) {
+        'parseBindingsString': function (bindingsString, bindingContext) {
             try {
                 var viewModel = bindingContext['$data'],
                     scopes = (typeof viewModel == 'object' && viewModel != null) ? [viewModel, bindingContext] : [bindingContext],
@@ -42,22 +42,36 @@
                 return bindingFunction(scopes);
             } catch (ex) {
                 throw new Error("Unable to parse bindings.\nMessage: " + ex + ";\nBindings value: " + bindingsString);
-            }           
+            }
         }
     });
 
     ko.bindingProvider['instance'] = new ko.bindingProvider();
 
+    ko.bindingProvider.configuration = function (bindingProvider) {
+        bindingProvider = bindingProvider ? bindingProvider : ko.bindingProvider["instance"];
+        var configuration = bindingProvider.configuration ? bindingProvider.configuration : {};
+        return setDefaultConfiguration(configuration);
+    };
+
+    function setDefaultConfiguration(configuration) {
+        if (!configuration) configuration = {};
+        configuration.name = configuration.name ? configuration.name : 'default';
+        configuration.bindingAttribute = configuration.bindingAttribute ? configuration.bindingAttribute : 'data-bind';
+        configuration.virtualElementTag = configuration.virtualElementTag ? configuration.virtualElementTag : "ko";
+        return configuration;
+    }
+
     function createBindingsStringEvaluatorViaCache(bindingsString, bindingOptions, scopesCount, cache) {
         var cacheKey = scopesCount + '_' + bindingsString;
-        return cache[cacheKey] 
+        return cache[cacheKey]
             || (cache[cacheKey] = createBindingsStringEvaluator(bindingsString, bindingOptions, scopesCount));
     }
 
     function createBindingsStringEvaluator(bindingsString, bindingOptions, scopesCount) {
         var rewrittenBindings = " { " + ko.bindingExpressionRewriting.insertPropertyAccessors(bindingsString, bindingOptions) + " } ";
         return ko.utils.buildEvalWithinScopeFunction(rewrittenBindings, scopesCount);
-    }    
+    }
 })();
 
 ko.exportSymbol('bindingProvider', ko.bindingProvider);
diff --git a/src/templating/templateEngine.js b/src/templating/templateEngine.js
index f23d4e84e..de5a22341 100644
--- a/src/templating/templateEngine.js
+++ b/src/templating/templateEngine.js
@@ -8,7 +8,7 @@
 //            // - bindingContext.$data is the data you should pass into the template
 //            //   - you might also want to make bindingContext.$parent, bindingContext.$parents, 
 //            //     and bindingContext.$root available in the template too
-//            // - options gives you access to any other properties set on "data-bind: { template: options }"
+//            // - options gives you access to any other properties set on "data-bind: { template: options }  (where data-bind is the configured binding attribute)"
 //            //
 //            // Return value: an array of DOM nodes
 //        }
@@ -20,7 +20,7 @@
 //            //               For example, the jquery.tmpl template engine converts 'someScript' to '${ someScript }' 
 //        }
 //
-//     This is only necessary if you want to allow data-bind attributes to reference arbitrary template variables.
+//     This is only necessary if you want to allow binding attributes to reference arbitrary template variables.
 //     If you don't want to allow that, you can set the property 'allowTemplateRewriting' to false (like ko.nativeTemplateEngine does)
 //     and then you don't need to override 'createJavaScriptEvaluatorBlock'.
 
diff --git a/src/templating/templateRewriting.js b/src/templating/templateRewriting.js
index f931a40dc..37e71f7c9 100644
--- a/src/templating/templateRewriting.js
+++ b/src/templating/templateRewriting.js
@@ -1,7 +1,11 @@
 
 ko.templateRewriting = (function () {
-    var memoizeDataBindingAttributeSyntaxRegex = /(<[a-z]+\d*(\s+(?!data-bind=)[a-z0-9\-]+(=(\"[^\"]*\"|\'[^\']*\'))?)*\s+)data-bind=(["'])([\s\S]*?)\5/gi;
-    var memoizeVirtualContainerBindingSyntaxRegex = /<!--\s*ko\b\s*([\s\S]*?)\s*-->/g;
+    var memoizeDataBindingAttributeSyntaxRegex = function (bindingProvider) {
+        return new RegExp("(<[a-z]+\\d*(\\s+(?!" + ko.bindingProvider.configuration(bindingProvider).bindingAttribute + "=)[a-z0-9\\-]+(=(\\\"[^\\\"]*\\\"|\\'[^\\']*\\'))?)*\\s+)" + ko.bindingProvider.configuration(bindingProvider).bindingAttribute + "=([\"'])([\\s\\S]*?)\\5", "gi");
+    };
+    var memoizeVirtualContainerBindingSyntaxRegex = function (bindingProvider) {
+        return new RegExp("<!--\\s*" + ko.bindingProvider.configuration(bindingProvider).virtualElementTag + "\\b\\s*([\\s\\S]*?)\\s*-->", "g");
+    }
 
     function validateDataBindValuesForRewriting(keyValueArray) {
         var allValidators = ko.templateRewriting.bindingRewriteValidators;
@@ -44,10 +48,10 @@ ko.templateRewriting = (function () {
         },
 
         memoizeBindingAttributeSyntax: function (htmlString, templateEngine) {
-            return htmlString.replace(memoizeDataBindingAttributeSyntaxRegex, function () {
-                return constructMemoizedTagReplacement(/* dataBindAttributeValue: */ arguments[6], /* tagToRetain: */ arguments[1], templateEngine);
-            }).replace(memoizeVirtualContainerBindingSyntaxRegex, function() {
-                return constructMemoizedTagReplacement(/* dataBindAttributeValue: */ arguments[1], /* tagToRetain: */ "<!-- ko -->", templateEngine);              
+            return htmlString.replace(memoizeDataBindingAttributeSyntaxRegex(), function () {
+                return constructMemoizedTagReplacement(/* dataBindAttributeValue: */arguments[6], /* tagToRetain: */arguments[1], templateEngine);
+            }).replace(memoizeVirtualContainerBindingSyntaxRegex(), function () {
+                return constructMemoizedTagReplacement(/* dataBindAttributeValue: */arguments[1], /* tagToRetain: */"<!-- ko -->", templateEngine);
             });
         },
 
diff --git a/src/virtualElements.js b/src/virtualElements.js
index c02c411fc..803cba338 100644
--- a/src/virtualElements.js
+++ b/src/virtualElements.js
@@ -11,19 +11,25 @@ ko.virtualElements = (function() {
     // but it does give them a nonstandard alternative property called "text" that it can read reliably. Other browsers don't have that property.
     // So, use node.text where available, and node.nodeValue elsewhere
     var commentNodesHaveTextProperty = document.createComment("test").text === "<!--test-->";
+    var startCommentRegex = function (bindingProvider) {
+        return commentNodesHaveTextProperty ? new RegExp("^<!--\\s*" + ko.bindingProvider.configuration(bindingProvider).virtualElementTag + "\\s+(.*\\:.*)\\s*-->$") : new RegExp("^\\s*" + ko.bindingProvider.configuration(bindingProvider).virtualElementTag + "\\s+(.*\\:.*)\\s*$");
+    };
 
-    var startCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*ko\s+(.*\:.*)\s*-->$/ : /^\s*ko\s+(.*\:.*)\s*$/;
-    var endCommentRegex =   commentNodesHaveTextProperty ? /^<!--\s*\/ko\s*-->$/ : /^\s*\/ko\s*$/;
+    var endCommentRegex = function (bindingProvider) {
+        return commentNodesHaveTextProperty ? new RegExp("^<!--\\s*\\/" + ko.bindingProvider.configuration(bindingProvider).virtualElementTag + "\\s*-->$") : new RegExp("^\\s*\\/" + ko.bindingProvider.configuration(bindingProvider).virtualElementTag + "\\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) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex());
     }
 
     function isEndComment(node) {
-        return (node.nodeType == 8) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(endCommentRegex);
+        return (node.nodeType == 8) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(endCommentRegex());
     }
 
+
     function getVirtualChildren(startComment, allowUnbalanced) {
         var currentNode = startComment;
         var depth = 1;