/*

  * HTML via Java(tm) Language Bindings

  * Copyright (C) 2013 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

  *

  * This program is free software: you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation, version 2 of the License.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details. apidesign.org

  * designates this particular file as subject to the

  * "Classpath" exception as provided by apidesign.org

  * in the License file that accompanied this code.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program. Look for COPYING file in the top folder.

  * If not, see http://wiki.apidesign.org/wiki/GPLwithClassPathException

  */

 // Knockout JavaScript library v2.2.1

 // (c) Steven Sanderson - http://knockoutjs.com/

 // License: MIT (http://www.opensource.org/licenses/mit-license.php)

 (function(){

 var DEBUG=true;

 (function(window,document,navigator,jQuery,undefined){

 !function(factory) {

     // Support three module loading scenarios

     if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {

         // [1] CommonJS/Node.js

         var target = module['exports'] || exports; // module.exports is for Node.js

         factory(target);

     } else if (typeof define === 'function' && define['amd']) {

         // [2] AMD anonymous module

         define(['exports'], factory);

     } else {

         // [3] No module loader (plain <script> tag) - put directly in global namespace

         factory(window['ko'] = {});

     }

 }(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 : {};

 // Google Closure Compiler helpers (used only to make the minified file smaller)

 ko.exportSymbol = function(koPath, object) {

 	var tokens = koPath.split(".");

 	// In the future, "ko" may become distinct from "koExports" (so that non-exported objects are not reachable)

 	// At that point, "target" would be set to: (typeof koExports !== "undefined" ? koExports : ko)

 	var target = ko;

 	for (var i = 0; i < tokens.length - 1; i++)

 		target = target[tokens[i]];

 	target[tokens[tokens.length - 1]] = object;

 };

 ko.exportProperty = function(owner, publicName, object) {

   owner[publicName] = object;

 };

 ko.version = "2.2.1";

 ko.exportSymbol('version', ko.version);

 ko.utils = new (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)

     var knownEvents = {}, knownEventTypesByEventName = {};

     var keyEventTypeName = /Firefox\/2/i.test(navigator.userAgent) ? 'KeyboardEvent' : 'UIEvents';

     knownEvents[keyEventTypeName] = ['keyup', 'keydown', 'keypress'];

     knownEvents['MouseEvents'] = ['click', 'dblclick', 'mousedown', 'mouseup', 'mousemove', 'mouseover', 'mouseout', 'mouseenter', 'mouseleave'];

     for (var eventType in knownEvents) {

         var knownEventsForType = knownEvents[eventType];

         if (knownEventsForType.length) {

             for (var i = 0, j = knownEventsForType.length; i < j; i++)

                 knownEventTypesByEventName[knownEventsForType[i]] = eventType;

         }

     }

     var eventsThatMustBeRegisteredUsingAttachEvent = { 'propertychange': true }; // Workaround for an IE9 issue - https://github.com/SteveSanderson/knockout/issues/406

     // Detect IE versions for bug workarounds (uses IE conditionals, not UA string, for robustness)

     // Note that, since IE 10 does not support conditional comments, the following logic only detects IE < 10.

     // Currently this is by design, since IE 10+ behaves correctly when treated as a standard browser.

     // If there is a future need to detect specific versions of IE10+, we will amend this.

     var ieVersion = (function() {

         var version = 3, div = document.createElement('div'), iElems = div.getElementsByTagName('i');

         // Keep constructing conditional HTML blocks until we hit one that resolves to an empty fragment

         while (

             div.innerHTML = '<!--[if gt IE ' + (++version) + ']><i></i><![endif]-->',

             iElems[0]

         );

         return version > 4 ? version : undefined;

     }());

     var isIe6 = ieVersion === 6,

         isIe7 = ieVersion === 7;

     function isClickOnCheckableElement(element, eventType) {

         if ((ko.utils.tagNameLower(element) !== "input") || !element.type) return false;

         if (eventType.toLowerCase() != "click") return false;

         var inputType = element.type;

         return (inputType == "checkbox") || (inputType == "radio");

     }

     return {

         fieldsIncludedWithJsonPost: ['authenticity_token', /^__RequestVerificationToken(_.*)?$/],

         arrayForEach: function (array, action) {

             for (var i = 0, j = array.length; i < j; i++)

                 action(array[i]);

         },

         arrayIndexOf: function (array, item) {

             if (typeof Array.prototype.indexOf == "function")

                 return Array.prototype.indexOf.call(array, item);

             for (var i = 0, j = array.length; i < j; i++)

                 if (array[i] === item)

                     return i;

             return -1;

         },

         arrayFirst: function (array, predicate, predicateOwner) {

             for (var i = 0, j = array.length; i < j; i++)

                 if (predicate.call(predicateOwner, array[i]))

                     return array[i];

             return null;

         },

         arrayRemoveItem: function (array, itemToRemove) {

             var index = ko.utils.arrayIndexOf(array, itemToRemove);

             if (index >= 0)

                 array.splice(index, 1);

         },

         arrayGetDistinctValues: function (array) {

             array = array || [];

             var result = [];

             for (var i = 0, j = array.length; i < j; i++) {

                 if (ko.utils.arrayIndexOf(result, array[i]) < 0)

                     result.push(array[i]);

             }

             return result;

         },

         arrayMap: function (array, mapping) {

             array = array || [];

             var result = [];

             for (var i = 0, j = array.length; i < j; i++)

                 result.push(mapping(array[i]));

             return result;

         },

         arrayFilter: function (array, predicate) {

             array = array || [];

             var result = [];

             for (var i = 0, j = array.length; i < j; i++)

                 if (predicate(array[i]))

                     result.push(array[i]);

             return result;

         },

         arrayPushAll: function (array, valuesToPush) {

             if (valuesToPush instanceof Array)

                 array.push.apply(array, valuesToPush);

             else

                 for (var i = 0, j = valuesToPush.length; i < j; i++)

                     array.push(valuesToPush[i]);

             return array;

         },

         extend: function (target, source) {

             if (source) {

                 for(var prop in source) {

                     if(source.hasOwnProperty(prop)) {

                         target[prop] = source[prop];

                     }

                 }

             }

             return target;

         },

         emptyDomNode: function (domNode) {

             while (domNode.firstChild) {

                 ko.removeNode(domNode.firstChild);

             }

         },

         moveCleanedNodesToContainerElement: 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 container = document.createElement('div');

             for (var i = 0, j = nodesArray.length; i < j; i++) {

                 container.appendChild(ko.cleanNode(nodesArray[i]));

             }

             return container;

         },

         cloneNodes: function (nodesArray, shouldCleanNodes) {

             for (var i = 0, j = nodesArray.length, newNodesArray = []; i < j; i++) {

                 var clonedNode = nodesArray[i].cloneNode(true);

                 newNodesArray.push(shouldCleanNodes ? ko.cleanNode(clonedNode) : clonedNode);

             }

             return newNodesArray;

         },

         setDomNodeChildren: function (domNode, childNodes) {

             ko.utils.emptyDomNode(domNode);

             if (childNodes) {

                 for (var i = 0, j = childNodes.length; i < j; i++)

                     domNode.appendChild(childNodes[i]);

             }

         },

         replaceDomNodes: function (nodeToReplaceOrNodeArray, newNodesArray) {

             var nodesToReplaceArray = nodeToReplaceOrNodeArray.nodeType ? [nodeToReplaceOrNodeArray] : nodeToReplaceOrNodeArray;

             if (nodesToReplaceArray.length > 0) {

                 var insertionPoint = nodesToReplaceArray[0];

                 var parent = insertionPoint.parentNode;

                 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]);

                 }

             }

         },

         setOptionNodeSelectionState: function (optionNode, isSelected) {

             // IE6 sometimes throws "unknown error" if you try to write to .selected directly, whereas Firefox struggles with setAttribute. Pick one based on browser.

             if (ieVersion < 7)

                 optionNode.setAttribute("selected", isSelected);

             else

                 optionNode.selected = isSelected;

         },

         stringTrim: function (string) {

             return (string || "").replace(stringTrimRegex, "");

         },

         stringTokenize: function (string, delimiter) {

             var result = [];

             var tokens = (string || "").split(delimiter);

             for (var i = 0, j = tokens.length; i < j; i++) {

                 var trimmed = ko.utils.stringTrim(tokens[i]);

                 if (trimmed !== "")

                     result.push(trimmed);

             }

             return result;

         },

         stringStartsWith: function (string, startsWith) {

             string = string || "";

             if (startsWith.length > string.length)

                 return false;

             return string.substring(0, startsWith.length) === startsWith;

         },

         domNodeIsContainedBy: function (node, containedByNode) {

             if (containedByNode.compareDocumentPosition)

                 return (containedByNode.compareDocumentPosition(node) & 16) == 16;

             while (node != null) {

                 if (node == containedByNode)

                     return true;

                 node = node.parentNode;

             }

             return false;

         },

         domNodeIsAttachedToDocument: function (node) {

             return ko.utils.domNodeIsContainedBy(node, node.ownerDocument);

         },

         tagNameLower: function(element) {

             // For HTML elements, tagName will always be upper case; for XHTML elements, it'll be lower case.

             // Possible future optimization: If we know it's an element from an XHTML document (not HTML),

             // we don't need to do the .toLowerCase() as it will always be lower case anyway.

             return element && element.tagName && element.tagName.toLowerCase();

         },

         registerEventHandler: function (element, eventType, handler) {

             var mustUseAttachEvent = ieVersion && eventsThatMustBeRegisteredUsingAttachEvent[eventType];

             if (!mustUseAttachEvent && typeof jQuery != "undefined") {

                 if (isClickOnCheckableElement(element, eventType)) {

                     // For click events on checkboxes, jQuery interferes with the event handling in an awkward way:

                     // it toggles the element checked state *after* the click event handlers run, whereas native

                     // click events toggle the checked state *before* the event handler.

                     // Fix this by intecepting the handler and applying the correct checkedness before it runs.

                     var originalHandler = handler;

                     handler = function(event, eventData) {

                         var jQuerySuppliedCheckedState = this.checked;

                         if (eventData)

                             this.checked = eventData.checkedStateBeforeEvent !== true;

                         originalHandler.call(this, event);

                         this.checked = jQuerySuppliedCheckedState; // Restore the state jQuery applied

                     };

                 }

                 jQuery(element)['bind'](eventType, handler);

             } else if (!mustUseAttachEvent && typeof element.addEventListener == "function")

                 element.addEventListener(eventType, handler, false);

             else if (typeof element.attachEvent != "undefined")

                 element.attachEvent("on" + eventType, function (event) {

                     handler.call(element, event);

                 });

             else

                 throw new Error("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");

             if (typeof jQuery != "undefined") {

                 var eventData = [];

                 if (isClickOnCheckableElement(element, eventType)) {

                     // Work around the jQuery "click events on checkboxes" issue described above by storing the original checked state before triggering the handler

                     eventData.push({ checkedStateBeforeEvent: element.checked });

                 }

                 jQuery(element)['trigger'](eventType, eventData);

             } else if (typeof document.createEvent == "function") {

                 if (typeof element.dispatchEvent == "function") {

                     var eventCategory = knownEventTypesByEventName[eventType] || "HTMLEvents";

                     var event = document.createEvent(eventCategory);

                     event.initEvent(eventType, true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, element);

                     element.dispatchEvent(event);

                 }

                 else

                     throw new Error("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

                 if (isClickOnCheckableElement(element, eventType))

                     element.checked = element.checked !== true;

                 element.fireEvent("on" + eventType);

             }

             else

                 throw new Error("Browser doesn't support triggering events");

         },

         unwrapObservable: function (value) {

             return ko.isObservable(value) ? value() : value;

         },

         peekObservable: function (value) {

             return ko.isObservable(value) ? value.peek() : value;

         },

         toggleDomNodeCssClass: function (node, classNames, shouldHaveClass) {

             if (classNames) {

                 var cssClassNameRegex = /[\w-]+/g,

                     currentClassNames = node.className.match(cssClassNameRegex) || [];

                 ko.utils.arrayForEach(classNames.match(cssClassNameRegex), function(className) {

                     var indexOfClass = ko.utils.arrayIndexOf(currentClassNames, className);

                     if (indexOfClass >= 0) {

                         if (!shouldHaveClass)

                             currentClassNames.splice(indexOfClass, 1);

                     } else {

                         if (shouldHaveClass)

                             currentClassNames.push(className);

                     }

                 });

                 node.className = currentClassNames.join(" ");

             }

         },

         setTextContent: function(element, textContent) {

             var value = ko.utils.unwrapObservable(textContent);

             if ((value === null) || (value === undefined))

                 value = "";

             if (element.nodeType === 3) {

                 element.data = value;

             } else {

                 // We need there to be exactly one child: a text node.

                 // If there are no children, more than one, or if it's not a text node,

                 // we'll clear everything and create a single text node.

                 var innerTextNode = ko.virtualElements.firstChild(element);

                 if (!innerTextNode || innerTextNode.nodeType != 3 || ko.virtualElements.nextSibling(innerTextNode)) {

                     ko.virtualElements.setDomNodeChildren(element, [document.createTextNode(value)]);

                 } else {

                     innerTextNode.data = value;

                 }

                 ko.utils.forceRefresh(element);

             }

         },

         setElementName: function(element, name) {

             element.name = name;

             // Workaround IE 6/7 issue

             // - https://github.com/SteveSanderson/knockout/issues/197

             // - http://www.matts411.com/post/setting_the_name_attribute_in_ie_dom/

             if (ieVersion <= 7) {

                 try {

                     element.mergeAttributes(document.createElement("<input name='" + element.name + "'/>"), false);

                 }

                 catch(e) {} // For IE9 with doc mode "IE9 Standards" and browser mode "IE9 Compatibility View"

             }

         },

         forceRefresh: function(node) {

             // Workaround for an IE9 rendering bug - https://github.com/SteveSanderson/knockout/issues/209

             if (ieVersion >= 9) {

                 // For text nodes and comment nodes (most likely virtual elements), we will have to refresh the container

                 var elem = node.nodeType == 1 ? node : node.parentNode;

                 if (elem.style)

                     elem.style.zoom = elem.style.zoom;

             }

         },

         ensureSelectElementIsRenderedCorrectly: function(selectElement) {

             // Workaround for IE9 rendering bug - it doesn't reliably display all the text in dynamically-added select boxes unless you force it to re-render by updating the width.

             // (See https://github.com/SteveSanderson/knockout/issues/312, http://stackoverflow.com/questions/5908494/select-only-shows-first-char-of-selected-option)

             if (ieVersion >= 9) {

                 var originalWidth = selectElement.style.width;

                 selectElement.style.width = 0;

                 selectElement.style.width = originalWidth;

             }

         },

         range: function (min, max) {

             min = ko.utils.unwrapObservable(min);

             max = ko.utils.unwrapObservable(max);

             var result = [];

             for (var i = min; i <= max; i++)

                 result.push(i);

             return result;

         },

         makeArray: function(arrayLikeObject) {

             var result = [];

             for (var i = 0, j = arrayLikeObject.length; i < j; i++) {

                 result.push(arrayLikeObject[i]);

             };

             return result;

         },

         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 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

             var matches = [];

             for (var i = fields.length - 1; i >= 0; i--) {

                 if (isMatchingField(fields[i]))

                     matches.push(fields[i]);

             };

             return matches;

         },

         parseJson: function (jsonString) {

             if (typeof jsonString == "string") {

                 jsonString = ko.utils.stringTrim(jsonString);

                 if (jsonString) {

                     if (window.JSON && window.JSON.parse) // Use native parsing where available

                         return window.JSON.parse(jsonString);

                     return (new Function("return " + jsonString))(); // Fallback on less safe parsing for older browsers

                 }

             }

             return null;

         },

         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), replacer, space);

         },

         postJson: function (urlOrForm, data, options) {

             options = options || {};

             var params = options['params'] || {};

             var includeFields = options['includeFields'] || this.fieldsIncludedWithJsonPost;

             var url = urlOrForm;

             // If we were given a form, use its 'action' URL and pick out any requested field values

             if((typeof urlOrForm == 'object') && (ko.utils.tagNameLower(urlOrForm) === "form")) {

                 var originalForm = urlOrForm;

                 url = originalForm.action;

                 for (var i = includeFields.length - 1; i >= 0; i--) {

                     var fields = ko.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);

             var form = document.createElement("form");

             form.style.display = "none";

             form.action = url;

             form.method = "post";

             for (var key in data) {

                 var input = document.createElement("input");

                 input.name = key;

                 input.value = ko.utils.stringifyJson(ko.utils.unwrapObservable(data[key]));

                 form.appendChild(input);

             }

             for (var key in params) {

                 var input = document.createElement("input");

                 input.name = key;

                 input.value = params[key];

                 form.appendChild(input);

             }

             document.body.appendChild(form);

             options['submitter'] ? options['submitter'](form) : form.submit();

             setTimeout(function () { form.parentNode.removeChild(form); }, 0);

         }

     }

 })();

 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.peekObservable', ko.utils.peekObservable);

 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)

     // In case the browser doesn't implement it natively, provide a JavaScript implementation. This implementation is based on the one in prototype.js

     Function.prototype['bind'] = function (object) {

         var originalFunction = this, args = Array.prototype.slice.call(arguments), object = args.shift();

         return function () {

             return originalFunction.apply(object, args.concat(Array.prototype.slice.call(arguments)));

         };

     };

 }

 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") && dataStore[dataStoreKey];

             if (!hasExistingDataStore) {

                 if (!createIfNotFound)

                     return undefined;

                 dataStoreKey = node[dataStoreKeyExpandoPropertyName] = "ko" + uniqueId++;

                 dataStore[dataStoreKey] = {};

             }

             return dataStore[dataStoreKey];

         },

         clear: function (node) {

             var dataStoreKey = node[dataStoreKeyExpandoPropertyName];

             if (dataStoreKey) {

                 delete dataStore[dataStoreKey];

                 node[dataStoreKeyExpandoPropertyName] = null;

                 return true; // Exposing "did clean" flag purely so specs can infer whether things have been cleaned up as intended

             }

             return false;

         }

     }

 })();

 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 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);

         if ((allDisposeCallbacks === undefined) && createIfNotFound) {

             allDisposeCallbacks = [];

             ko.utils.domData.set(node, domDataKey, allDisposeCallbacks);

         }

         return allDisposeCallbacks;

     }

     function destroyCallbacksCollection(node) {

         ko.utils.domData.set(node, domDataKey, undefined);

     }

     function cleanSingleNode(node) {

         // 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);

         }

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

         // 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);

     }

     function cleanImmediateCommentTypeChildren(nodeWithChildren) {

         var child, nextChild = nodeWithChildren.firstChild;

         while (child = nextChild) {

             nextChild = child.nextSibling;

             if (child.nodeType === 8)

                 cleanSingleNode(child);

         }

     }

     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) {

             var callbacksCollection = getDisposeCallbacksCollection(node, false);

             if (callbacksCollection) {

                 ko.utils.arrayRemoveItem(callbacksCollection, callback);

                 if (callbacksCollection.length == 0)

                     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]);

                 }

             }

             return node;

         },

         removeNode : function(node) {

             ko.cleanNode(node);

             if (node.parentNode)

                 node.parentNode.removeChild(node);

         }

     }

 })();

 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('utils.domNodeDisposal', ko.utils.domNodeDisposal);

 ko.exportSymbol('utils.domNodeDisposal.addDisposeCallback', ko.utils.domNodeDisposal.addDisposeCallback);

 ko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeDisposal.removeDisposeCallback);

 (function () {

     var leadingCommentRegex = /^(\s*)<!--(.*?)-->/;

     function simpleHtmlParse(html) {

         // Based on jQuery's "clean" function, but only accounting for table-related elements.

         // If you have referenced jQuery, this won't be used anyway - KO will use jQuery's "clean" function directly

         // Note that there's still an issue in IE < 9 whereby it will discard comment nodes that are the first child of

         // a descendant node. For example: "<div><!-- mycomment -->abc</div>" will get parsed as "<div>abc</div>"

         // This won't affect anyone who has referenced jQuery, and there's always the workaround of inserting a dummy node

         // (possibly a text node) in front of the comment. So, KO does not attempt to workaround this IE issue automatically at present.

         // Trim whitespace, otherwise indexOf won't work as expected

         var tags = ko.utils.stringTrim(html).toLowerCase(), div = document.createElement("div");

         // Finds the first match from the left column, and returns the corresponding "wrap" data from the right column

         var wrap = tags.match(/^<(thead|tbody|tfoot)/)              && [1, "<table>", "</table>"] ||

                    !tags.indexOf("<tr")                             && [2, "<table><tbody>", "</tbody></table>"] ||

                    (!tags.indexOf("<td") || !tags.indexOf("<th"))   && [3, "<table><tbody><tr>", "</tr></tbody></table>"] ||

                    /* anything else */                                 [0, "", ""];

         // Go to html and back, then peel off extra wrappers

         // Note that we always prefix with some dummy text, because otherwise, IE<9 will strip out leading comment nodes in descendants. Total madness.

         var markup = "ignored<div>" + wrap[1] + html + wrap[2] + "</div>";

         if (typeof window['innerShiv'] == "function") {

             div.appendChild(window['innerShiv'](markup));

         } else {

             div.innerHTML = markup;

         }

         // Move to the right depth

         while (wrap[0]--)

             div = div.lastChild;

         return ko.utils.makeArray(div.lastChild.childNodes);

     }

     function jQueryHtmlParse(html) {

         // jQuery's "parseHTML" function was introduced in jQuery 1.8.0 and is a documented public API.

         if (jQuery['parseHTML']) {

             return jQuery['parseHTML'](html);

         } else {

             // For jQuery < 1.8.0, we fall back on the undocumented internal "clean" function.

             var elems = jQuery['clean']([html]);

             // As of jQuery 1.7.1, jQuery parses the HTML by appending it to some dummy parent nodes held in an in-memory document fragment.

             // Unfortunately, it never clears the dummy parent nodes from the document fragment, so it leaks memory over time.

             // Fix this by finding the top-most dummy parent element, and detaching it from its owner fragment.

             if (elems && elems[0]) {

                 // Find the top-most parent element that's a direct child of a document fragment

                 var elem = elems[0];

                 while (elem.parentNode && elem.parentNode.nodeType !== 11 /* i.e., DocumentFragment */)

                     elem = elem.parentNode;

                 // ... then detach it

                 if (elem.parentNode)

                     elem.parentNode.removeChild(elem);

             }

             return elems;

         }

     }

     ko.utils.parseHtmlFragment = function(html) {

         return typeof jQuery != 'undefined' ? jQueryHtmlParse(html)   // As below, benefit from jQuery's optimisations where possible

                                             : simpleHtmlParse(html);  // ... otherwise, this simple logic will do in most common cases.

     };

     ko.utils.setHtml = function(node, html) {

         ko.utils.emptyDomNode(node);

         // There's no legitimate reason to display a stringified observable without unwrapping it, so we'll unwrap it

         html = ko.utils.unwrapObservable(html);

         if ((html !== null) && (html !== undefined)) {

             if (typeof html != 'string')

                 html = html.toString();

             // jQuery contains a lot of sophisticated code to parse arbitrary HTML fragments,

             // for example <tr> elements which are not normally allowed to exist on their own.

             // If you've referenced jQuery we'll use that rather than duplicating its code.

             if (typeof jQuery != 'undefined') {

                 jQuery(node)['html'](html);

             } else {

                 // ... otherwise, use KO's own parsing logic.

                 var parsedNodes = ko.utils.parseHtmlFragment(html);

                 for (var i = 0; i < parsedNodes.length; i++)

                     node.appendChild(parsedNodes[i]);

             }

         }

     };

 })();

 ko.exportSymbol('utils.parseHtmlFragment', ko.utils.parseHtmlFragment);

 ko.exportSymbol('utils.setHtml', ko.utils.setHtml);

 ko.memoization = (function () {

     var memos = {};

     function randomMax8HexChars() {

         return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);

     }

     function generateRandomId() {

         return randomMax8HexChars() + randomMax8HexChars();

     }

     function findMemoNodes(rootNode, appendToArray) {

         if (!rootNode)

             return;

         if (rootNode.nodeType == 8) {

             var memoId = ko.memoization.parseMemoText(rootNode.nodeValue);

             if (memoId != null)

                 appendToArray.push({ domNode: rootNode, memoId: memoId });

         } else if (rootNode.nodeType == 1) {

             for (var i = 0, childNodes = rootNode.childNodes, j = childNodes.length; i < j; i++)

                 findMemoNodes(childNodes[i], appendToArray);

         }

     }

     return {

         memoize: function (callback) {

             if (typeof callback != "function")

                 throw new Error("You can only pass a function to ko.memoization.memoize()");

             var memoId = generateRandomId();

             memos[memoId] = callback;

             return "<!--[ko_memo:" + memoId + "]-->";

         },

         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.");

             try {

                 callback.apply(null, callbackParams || []);

                 return true;

             }

             finally { delete memos[memoId]; }

         },

         unmemoizeDomNodeAndDescendants: function (domNode, extraCallbackParamsArray) {

             var memos = [];

             findMemoNodes(domNode, memos);

             for (var i = 0, j = memos.length; i < j; i++) {

                 var node = memos[i].domNode;

                 var combinedParams = [node];

                 if (extraCallbackParamsArray)

                     ko.utils.arrayPushAll(combinedParams, extraCallbackParamsArray);

                 ko.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)

             }

         },

         parseMemoText: function (memoText) {

             var match = memoText.match(/^\[ko_memo\:(.*?)\]$/);

             return match ? match[1] : null;

         }

     };

 })();

 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);

             }

         });

     },

     'notify': function(target, notifyWhen) {

         target["equalityComparer"] = notifyWhen == "always"

             ? function() { return false } // Treat all values as not equal

             : ko.observable["fn"]["equalityComparer"];

         return target;

     }

 };

 function applyExtenders(requestedExtenders) {

     var target = this;

     if (requestedExtenders) {

         for (var key in requestedExtenders) {

             var extenderHandler = ko.extenders[key];

             if (typeof extenderHandler == 'function') {

                 target = extenderHandler(target, requestedExtenders[key]);

             }

         }

     }

     return target;

 }

 ko.exportSymbol('extenders', ko.extenders);

 ko.subscription = function (target, callback, disposeCallback) {

     this.target = target;

     this.callback = callback;

     this.disposeCallback = disposeCallback;

     ko.exportProperty(this, 'dispose', this.dispose);

 };

 ko.subscription.prototype.dispose = function () {

     this.isDisposed = true;

     this.disposeCallback();

 };

 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);

 }

 var defaultEvent = "change";

 ko.subscribable['fn'] = {

     subscribe: function (callback, callbackTarget, event) {

         event = event || defaultEvent;

         var boundCallback = callbackTarget ? callback.bind(callbackTarget) : callback;

         var subscription = new ko.subscription(this, boundCallback, function () {

             ko.utils.arrayRemoveItem(this._subscriptions[event], subscription);

         }.bind(this));

         if (!this._subscriptions[event])

             this._subscriptions[event] = [];

         this._subscriptions[event].push(subscription);

         return subscription;

     },

     "notifySubscribers": function (valueToNotify, event) {

         event = event || defaultEvent;

         if (this._subscriptions[event]) {

             ko.dependencyDetection.ignore(function() {

                 ko.utils.arrayForEach(this._subscriptions[event].slice(0), function (subscription) {

                     // In case a subscription was disposed during the arrayForEach cycle, check

                     // for isDisposed on each subscription before invoking its callback

                     if (subscription && (subscription.isDisposed !== true))

                         subscription.callback(valueToNotify);

                 });

             }, this);

         }

     },

     getSubscriptionsCount: function () {

         var total = 0;

         for (var eventName in this._subscriptions) {

             if (this._subscriptions.hasOwnProperty(eventName))

                 total += this._subscriptions[eventName].length;

         }

         return total;

     },

     extend: applyExtenders

 };

 ko.isSubscribable = function (instance) {

     return typeof instance.subscribe == "function" && typeof instance["notifySubscribers"] == "function";

 };

 ko.exportSymbol('subscribable', ko.subscribable);

 ko.exportSymbol('isSubscribable', ko.isSubscribable);

 ko.dependencyDetection = (function () {

     var _frames = [];

     return {

         begin: function (callback) {

             _frames.push({ callback: callback, distinctDependencies:[] });

         },

         end: function () {

             _frames.pop();

         },

         registerDependency: function (subscribable) {

             if (!ko.isSubscribable(subscribable))

                 throw new Error("Only subscribable things can act as dependencies");

             if (_frames.length > 0) {

                 var topFrame = _frames[_frames.length - 1];

                 if (!topFrame || ko.utils.arrayIndexOf(topFrame.distinctDependencies, subscribable) >= 0)

                     return;

                 topFrame.distinctDependencies.push(subscribable);

                 topFrame.callback(subscribable);

             }

         },

         ignore: function(callback, callbackTarget, callbackArgs) {

             try {

                 _frames.push(null);

                 return callback.apply(callbackTarget, callbackArgs || []);

             } finally {

                 _frames.pop();

             }

         }

     };

 })();

 var primitiveTypes = { 'undefined':true, 'boolean':true, 'number':true, 'string':true };

 ko.observable = function (initialValue) {

     var _latestValue = initialValue;

     function observable() {

         if (arguments.length > 0) {

             // Write

             // Ignore writes if the value hasn't changed

             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

         }

         else {

             // Read

             ko.dependencyDetection.registerDependency(observable); // The caller only needs to be notified of changes if they did a "read" operation

             return _latestValue;

         }

     }

     if (DEBUG) observable._latestValue = _latestValue;

     ko.subscribable.call(observable);

     observable.peek = function() { return _latestValue };

     observable.valueHasMutated = function () { observable["notifySubscribers"](_latestValue); }

     observable.valueWillMutate = function () { observable["notifySubscribers"](_latestValue, "beforeChange"); }

     ko.utils.extend(observable, ko.observable['fn']);

     ko.exportProperty(observable, 'peek', observable.peek);

     ko.exportProperty(observable, "valueHasMutated", observable.valueHasMutated);

     ko.exportProperty(observable, "valueWillMutate", observable.valueWillMutate);

     return observable;

 }

 ko.observable['fn'] = {

     "equalityComparer": function valuesArePrimitiveAndEqual(a, b) {

         var oldValueIsPrimitive = (a === null) || (typeof(a) in primitiveTypes);

         return oldValueIsPrimitive ? (a === b) : false;

     }

 };

 var protoProperty = ko.observable.protoProperty = "__ko_proto__";

 ko.observable['fn'][protoProperty] = ko.observable;

 ko.hasPrototype = function(instance, prototype) {

     if ((instance === null) || (instance === undefined) || (instance[protoProperty] === undefined)) return false;

     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

     if ((typeof instance == "function") && instance[protoProperty] === ko.observable)

         return true;

     // Writeable dependent observable

     if ((typeof instance == "function") && (instance[protoProperty] === ko.dependentObservable) && (instance.hasWriteFunction))

         return true;

     // Anything else

     return false;

 }

 ko.exportSymbol('observable', ko.observable);

 ko.exportSymbol('isObservable', ko.isObservable);

 ko.exportSymbol('isWriteableObservable', ko.isWriteableObservable);

 ko.observableArray = function (initialValues) {

     if (arguments.length == 0) {

         // Zero-parameter constructor initializes to empty array

         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.");

     var result = ko.observable(initialValues);

     ko.utils.extend(result, ko.observableArray['fn']);

     return result;

 }

 ko.observableArray['fn'] = {

     'remove': function (valueOrPredicate) {

         var underlyingArray = this.peek();

         var removedValues = [];

         var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) { return value === valueOrPredicate; };

         for (var i = 0; i < underlyingArray.length; i++) {

             var value = underlyingArray[i];

             if (predicate(value)) {

                 if (removedValues.length === 0) {

                     this.valueWillMutate();

                 }

                 removedValues.push(value);

                 underlyingArray.splice(i, 1);

                 i--;

             }

         }

         if (removedValues.length) {

             this.valueHasMutated();

         }

         return removedValues;

     },

     'removeAll': function (arrayOfValues) {

         // If you passed zero args, we remove everything

         if (arrayOfValues === undefined) {

             var underlyingArray = this.peek();

             var allValues = underlyingArray.slice(0);

             this.valueWillMutate();

             underlyingArray.splice(0, underlyingArray.length);

             this.valueHasMutated();

             return allValues;

         }

         // If you passed an arg, we interpret it as an array of entries to remove

         if (!arrayOfValues)

             return [];

         return this['remove'](function (value) {

             return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0;

         });

     },

     'destroy': function (valueOrPredicate) {

         var underlyingArray = this.peek();

         var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) { return value === valueOrPredicate; };

         this.valueWillMutate();

         for (var i = underlyingArray.length - 1; i >= 0; i--) {

             var value = underlyingArray[i];

             if (predicate(value))

                 underlyingArray[i]["_destroy"] = true;

         }

         this.valueHasMutated();

     },

     'destroyAll': function (arrayOfValues) {

         // If you passed zero args, we destroy everything

         if (arrayOfValues === undefined)

             return this['destroy'](function() { return true });

         // If you passed an arg, we interpret it as an array of entries to destroy

         if (!arrayOfValues)

             return [];

         return this['destroy'](function (value) {

             return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0;

         });

     },

     'indexOf': function (item) {

         var underlyingArray = this();

         return ko.utils.arrayIndexOf(underlyingArray, item);

     },

     'replace': function(oldItem, newItem) {

         var index = this['indexOf'](oldItem);

         if (index >= 0) {

             this.valueWillMutate();

             this.peek()[index] = newItem;

             this.valueHasMutated();

         }

     }

 }

 // Populate ko.observableArray.fn with read/write functions from native arrays

 // Important: Do not add any additional functions here that may reasonably be used to *read* data from the array

 // because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale

 ko.utils.arrayForEach(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function (methodName) {

     ko.observableArray['fn'][methodName] = function () {

         // Use "peek" to avoid creating a subscription in any computed that we're executing in the context of

         // (for consistency with mutating regular observables)

         var underlyingArray = this.peek();

         this.valueWillMutate();

         var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);

         this.valueHasMutated();

         return methodCallResult;

     };

 });

 // Populate ko.observableArray.fn with read-only functions from native arrays

 ko.utils.arrayForEach(["slice"], function (methodName) {

     ko.observableArray['fn'][methodName] = function () {

         var underlyingArray = this();

         return underlyingArray[methodName].apply(underlyingArray, arguments);

     };

 });

 ko.exportSymbol('observableArray', ko.observableArray);

 ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunctionTarget, options) {

     var _latestValue,

         _hasBeenEvaluated = false,

         _isBeingEvaluated = false,

         readFunction = evaluatorFunctionOrOptions;

     if (readFunction && typeof readFunction == "object") {

         // Single-parameter syntax - everything is on this "options" param

         options = readFunction;

         readFunction = options["read"];

     } else {

         // Multi-parameter syntax - construct the options according to the params passed

         options = options || {};

         if (!readFunction)

             readFunction = options["read"];

     }

     if (typeof readFunction != "function")

         throw new Error("Pass a function that returns the value of the ko.computed");

     function addSubscriptionToDependency(subscribable) {

         _subscriptionsToDependencies.push(subscribable.subscribe(evaluatePossiblyAsync));

     }

     function disposeAllSubscriptionsToDependencies() {

         ko.utils.arrayForEach(_subscriptionsToDependencies, function (subscription) {

             subscription.dispose();

         });

         _subscriptionsToDependencies = [];

     }

     function evaluatePossiblyAsync() {

         var throttleEvaluationTimeout = dependentObservable['throttleEvaluation'];

         if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {

             clearTimeout(evaluationTimeoutInstance);

             evaluationTimeoutInstance = setTimeout(evaluateImmediate, throttleEvaluationTimeout);

         } else

             evaluateImmediate();

     }

     function evaluateImmediate() {

         if (_isBeingEvaluated) {

             // If the evaluation of a ko.computed causes side effects, it's possible that it will trigger its own re-evaluation.

             // This is not desirable (it's hard for a developer to realise a chain of dependencies might cause this, and they almost

             // certainly didn't intend infinite re-evaluations). So, for predictability, we simply prevent ko.computeds from causing

             // their own re-evaluation. Further discussion at https://github.com/SteveSanderson/knockout/pull/387

             return;

         }

         // Don't dispose on first evaluation, because the "disposeWhen" callback might

         // e.g., dispose when the associated DOM element isn't in the doc, and it's not

         // going to be in the doc until *after* the first evaluation

         if (_hasBeenEvaluated && disposeWhen()) {

             dispose();

             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.

             var disposalCandidates = ko.utils.arrayMap(_subscriptionsToDependencies, function(item) {return item.target;});

             ko.dependencyDetection.begin(function(subscribable) {

                 var inOld;

                 if ((inOld = ko.utils.arrayIndexOf(disposalCandidates, subscribable)) >= 0)

                     disposalCandidates[inOld] = undefined; // Don't want to dispose this subscription, as it's still being used

                 else

                     addSubscriptionToDependency(subscribable); // Brand new subscription - add it

             });

             var newValue = readFunction.call(evaluatorFunctionTarget);

             // For each subscription no longer being used, remove it from the active subscriptions list and dispose it

             for (var i = disposalCandidates.length - 1; i >= 0; i--) {

                 if (disposalCandidates[i])

                     _subscriptionsToDependencies.splice(i, 1)[0].dispose();

             }

             _hasBeenEvaluated = true;

             dependentObservable["notifySubscribers"](_latestValue, "beforeChange");

             _latestValue = newValue;

             if (DEBUG) dependentObservable._latestValue = _latestValue;

         } finally {

             ko.dependencyDetection.end();

         }

         dependentObservable["notifySubscribers"](_latestValue);

         _isBeingEvaluated = false;

         if (!_subscriptionsToDependencies.length)

             dispose();

     }

     function dependentObservable() {

         if (arguments.length > 0) {

             if (typeof writeFunction === "function") {

                 // 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.");

             }

             return this; // Permits chained assignments

         } else {

             // Reading the value

             if (!_hasBeenEvaluated)

                 evaluateImmediate();

             ko.dependencyDetection.registerDependency(dependentObservable);

             return _latestValue;

         }

     }

     function peek() {

         if (!_hasBeenEvaluated)

             evaluateImmediate();

         return _latestValue;

     }

     function isActive() {

         return !_hasBeenEvaluated || _subscriptionsToDependencies.length > 0;

     }

     // By here, "options" is always non-null

     var writeFunction = options["write"],

         disposeWhenNodeIsRemoved = options["disposeWhenNodeIsRemoved"] || options.disposeWhenNodeIsRemoved || null,

         disposeWhen = options["disposeWhen"] || options.disposeWhen || function() { return false; },

         dispose = disposeAllSubscriptionsToDependencies,

         _subscriptionsToDependencies = [],

         evaluationTimeoutInstance = null;

     if (!evaluatorFunctionTarget)

         evaluatorFunctionTarget = options["owner"];

     dependentObservable.peek = peek;

     dependentObservable.getDependenciesCount = function () { return _subscriptionsToDependencies.length; };

     dependentObservable.hasWriteFunction = typeof options["write"] === "function";

     dependentObservable.dispose = function () { dispose(); };

     dependentObservable.isActive = isActive;

     dependentObservable.valueHasMutated = function() {

         _hasBeenEvaluated = false;

         evaluateImmediate();

     };

     ko.subscribable.call(dependentObservable);

     ko.utils.extend(dependentObservable, ko.dependentObservable['fn']);

     ko.exportProperty(dependentObservable, 'peek', dependentObservable.peek);

     ko.exportProperty(dependentObservable, 'dispose', dependentObservable.dispose);

     ko.exportProperty(dependentObservable, 'isActive', dependentObservable.isActive);

     ko.exportProperty(dependentObservable, 'getDependenciesCount', dependentObservable.getDependenciesCount);

     // Evaluate, unless deferEvaluation is true

     if (options['deferEvaluation'] !== true)

         evaluateImmediate();

     // Build "disposeWhenNodeIsRemoved" and "disposeWhenNodeIsRemovedCallback" option values.

     // But skip if isActive is false (there will never be any dependencies to dispose).

     // (Note: "disposeWhenNodeIsRemoved" option both proactively disposes as soon as the node is removed using ko.removeNode(),

     // plus adds a "disposeWhen" callback that, on each evaluation, disposes if the node was removed by some other means.)

     if (disposeWhenNodeIsRemoved && isActive()) {

         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();

         }

     }

     return dependentObservable;

 };

 ko.isComputed = function(instance) {

     return ko.hasPrototype(instance, ko.dependentObservable);

 };

 var protoProp = ko.observable.protoProperty; // == "__ko_proto__"

 ko.dependentObservable[protoProp] = ko.observable;

 ko.dependentObservable['fn'] = {};

 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.");

         // We just unwrap everything at every level in the object graph

         return mapJsObjectGraph(rootObject, function(valueToMap) {

             // Loop because an observable's value might in turn be another observable wrapper

             for (var i = 0; ko.isObservable(valueToMap) && (i < maxNestedObservableDepth); i++)

                 valueToMap = valueToMap();

             return valueToMap;

         });

     };

     ko.toJSON = function(rootObject, replacer, space) {     // replacer and space are optional

         var plainJavaScriptObject = ko.toJS(rootObject);

         return ko.utils.stringifyJson(plainJavaScriptObject, replacer, space);

     };

     function mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects) {

         visitedObjects = visitedObjects || new objectLookup();

         rootObject = mapInputCallback(rootObject);

         var canHaveProperties = (typeof rootObject == "object") && (rootObject !== null) && (rootObject !== undefined) && (!(rootObject instanceof Date));

         if (!canHaveProperties)

             return rootObject;

         var outputProperties = rootObject instanceof Array ? [] : {};

         visitedObjects.save(rootObject, outputProperties);

         visitPropertiesOrArrayEntries(rootObject, function(indexer) {

             var propertyValue = mapInputCallback(rootObject[indexer]);

             switch (typeof propertyValue) {

                 case "boolean":

                 case "number":

                 case "string":

                 case "function":

                     outputProperties[indexer] = propertyValue;

                     break;

                 case "object":

                 case "undefined":

                     var previouslyMappedValue = visitedObjects.get(propertyValue);

                     outputProperties[indexer] = (previouslyMappedValue !== undefined)

                         ? previouslyMappedValue

                         : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects);

                     break;

             }

         });

         return outputProperties;

     }

     function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {

         if (rootObject instanceof Array) {

             for (var i = 0; i < rootObject.length; i++)

                 visitorCallback(i);

             // For arrays, also respect toJSON property for custom mappings (fixes #278)

             if (typeof rootObject['toJSON'] == 'function')

                 visitorCallback('toJSON');

         } else {

             for (var propertyName in rootObject)

                 visitorCallback(propertyName);

         }

     };

     function objectLookup() {

         var keys = [];

         var values = [];

         this.save = function(key, value) {

             var existingIndex = ko.utils.arrayIndexOf(keys, key);

             if (existingIndex >= 0)

                 values[existingIndex] = value;

             else {

                 keys.push(key);

                 values.push(value);

             }

         };

         this.get = function(key) {

             var existingIndex = ko.utils.arrayIndexOf(keys, key);

             return (existingIndex >= 0) ? values[existingIndex] : undefined;

         };

     };

 })();

 ko.exportSymbol('toJS', ko.toJS);

 ko.exportSymbol('toJSON', ko.toJSON);

 (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 = {

         readValue : function(element) {

             switch (ko.utils.tagNameLower(element)) {

                 case 'option':

                     if (element[hasDomDataExpandoProperty] === true)

                         return ko.utils.domData.get(element, ko.bindingHandlers.options.optionValueDomDataKey);

                     return ko.utils.ieVersion <= 7

                         ? (element.getAttributeNode('value').specified ? element.value : element.text)

                         : element.value;

                 case 'select':

                     return element.selectedIndex >= 0 ? ko.selectExtensions.readValue(element.options[element.selectedIndex]) : undefined;

                 default:

                     return element.value;

             }

         },

         writeValue: function(element, value) {

             switch (ko.utils.tagNameLower(element)) {

                 case 'option':

                     switch(typeof value) {

                         case "string":

                             ko.utils.domData.set(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];

                             }

                             element.value = value;

                             break;

                         default:

                             // Store arbitrary object using DomData

                             ko.utils.domData.set(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.

                             element.value = typeof value === "number" ? value : "";

                             break;

                     }

                     break;

                 case 'select':

                     for (var i = element.options.length - 1; i >= 0; i--) {

                         if (ko.selectExtensions.readValue(element.options[i]) == value) {

                             element.selectedIndex = i;

                             break;

                         }

                     }

                     break;

                 default:

                     if ((value === null) || (value === undefined))

                         value = "";

                     element.value = value;

                     break;

             }

         }

     };

 })();

 ko.exportSymbol('selectExtensions', ko.selectExtensions);

 ko.exportSymbol('selectExtensions.readValue', ko.selectExtensions.readValue);

 ko.exportSymbol('selectExtensions.writeValue', ko.selectExtensions.writeValue);

 ko.expressionRewriting = (function () {

     var restoreCapturedTokensRegex = /\@ko_token_(\d+)\@/g;

     var javaScriptReservedWords = ["true", "false"];

     // Matches something that can be assigned to--either an isolated identifier or something ending with a property accessor

     // This is designed to be simple and avoid false negatives, but could produce false positives (e.g., a+b.c).

     var javaScriptAssignmentTarget = /^(?:[$_a-z][$\w]*|(.+)(\.\s*[$_a-z][$\w]*|\[.+\]))$/i;

     function restoreTokens(string, tokens) {

         var prevValue = null;

         while (string != prevValue) { // Keep restoring tokens until it no longer makes a difference (they may be nested)

             prevValue = string;

             string = string.replace(restoreCapturedTokensRegex, function (match, tokenIndex) {

                 return tokens[tokenIndex];

             });

         }

         return string;

     }

     function getWriteableValue(expression) {

         if (ko.utils.arrayIndexOf(javaScriptReservedWords, ko.utils.stringTrim(expression).toLowerCase()) >= 0)

             return false;

         var match = expression.match(javaScriptAssignmentTarget);

         return match === null ? false : match[1] ? ('Object(' + match[1] + ')' + match[2]) : expression;

     }

     function ensureQuoted(key) {

         var trimmedKey = ko.utils.stringTrim(key);

         switch (trimmedKey.length && trimmedKey.charAt(0)) {

             case "'":

             case '"':

                 return key;

             default:

                 return "'" + trimmedKey + "'";

         }

     }

     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

             var str = ko.utils.stringTrim(objectLiteralString);

             if (str.length < 3)

                 return [];

             if (str.charAt(0) === "{")// Ignore any braces surrounding the whole object literal

                 str = str.substring(1, str.length - 1);

             // Pull out any string literals and regex literals

             var tokens = [];

             var tokenStart = null, tokenEndChar;

             for (var position = 0; position < str.length; position++) {

                 var c = str.charAt(position);

                 if (tokenStart === null) {

                     switch (c) {

                         case '"':

                         case "'":

                         case "/":

                             tokenStart = position;

                             tokenEndChar = c;

                             break;

                     }

                 } else if ((c == tokenEndChar) && (str.charAt(position - 1) !== "\\")) {

                     var token = str.substring(tokenStart, position + 1);

                     tokens.push(token);

                     var replacement = "@ko_token_" + (tokens.length - 1) + "@";

                     str = str.substring(0, tokenStart) + replacement + str.substring(position + 1);

                     position -= (token.length - replacement.length);

                     tokenStart = null;

                 }

             }

             // Next pull out balanced paren, brace, and bracket blocks

             tokenStart = null;

             tokenEndChar = null;

             var tokenDepth = 0, tokenStartChar = null;

             for (var position = 0; position < str.length; position++) {

                 var c = str.charAt(position);

                 if (tokenStart === null) {

                     switch (c) {

                         case "{": tokenStart = position; tokenStartChar = c;

                                   tokenEndChar = "}";

                                   break;

                         case "(": tokenStart = position; tokenStartChar = c;

                                   tokenEndChar = ")";

                                   break;

                         case "[": tokenStart = position; tokenStartChar = c;

                                   tokenEndChar = "]";

                                   break;

                     }

                 }

                 if (c === tokenStartChar)

                     tokenDepth++;

                 else if (c === tokenEndChar) {

                     tokenDepth--;

                     if (tokenDepth === 0) {

                         var token = str.substring(tokenStart, position + 1);

                         tokens.push(token);

                         var replacement = "@ko_token_" + (tokens.length - 1) + "@";

                         str = str.substring(0, tokenStart) + replacement + str.substring(position + 1);

                         position -= (token.length - replacement.length);

                         tokenStart = null;

                     }

                 }

             }

             // Now we can safely split on commas to get the key/value pairs

             var result = [];

             var keyValuePairs = str.split(",");

             for (var i = 0, j = keyValuePairs.length; i < j; i++) {

                 var pair = keyValuePairs[i];

                 var colonPos = pair.indexOf(":");

                 if ((colonPos > 0) && (colonPos < pair.length - 1)) {

                     var key = pair.substring(0, colonPos);

                     var value = pair.substring(colonPos + 1);

                     result.push({ 'key': restoreTokens(key, tokens), 'value': restoreTokens(value, tokens) });

                 } else {

                     result.push({ 'unknown': restoreTokens(pair, tokens) });

                 }

             }

             return result;

         },

         preProcessBindings: function (objectLiteralStringOrKeyValueArray) {

             var keyValueArray = typeof objectLiteralStringOrKeyValueArray === "string"

                 ? ko.expressionRewriting.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 (val = getWriteableValue(ko.utils.stringTrim(val))) {

                         if (propertyAccessorResultStrings.length > 0)

                             propertyAccessorResultStrings.push(", ");

                         propertyAccessorResultStrings.push(quotedKey + " : function(__ko_value) { " + val + " = __ko_value; }");

                     }

                 } else if (keyValueEntry['unknown']) {

                     resultStrings.push(keyValueEntry['unknown']);

                 }

             }

             var combinedResult = resultStrings.join("");

             if (propertyAccessorResultStrings.length > 0) {

                 var allPropertyAccessors = propertyAccessorResultStrings.join("");

                 combinedResult = combinedResult + ", '_ko_property_writers' : { " + allPropertyAccessors + " } ";

             }

             return combinedResult;

         },

         keyValueArrayContainsKey: function(keyValueArray, key) {

             for (var i = 0; i < keyValueArray.length; i++)

                 if (ko.utils.stringTrim(keyValueArray[i]['key']) == key)

                     return true;

             return false;

         },

         // Internal, private KO utility for updating model properties from within bindings

         // property:            If the property being updated is (or might be) an observable, pass it here

         //                      If it turns out to be a writable observable, it will be written to directly

         // allBindingsAccessor: All bindings in the current execution context.

         //                      This will be searched for a '_ko_property_writers' property in case you're writing to a non-observable

         // key:                 The key identifying the property to be written. Example: for { hasFocus: myValue }, write to 'myValue' by specifying the key 'hasFocus'

         // value:               The value to be written

         // checkIfDifferent:    If true, and if the property being written is a writable observable, the value will only be written if

         //                      it is !== existing value on that writable observable

         writeValueToProperty: function(property, allBindingsAccessor, key, value, checkIfDifferent) {

             if (!property || !ko.isWriteableObservable(property)) {

                 var propWriters = allBindingsAccessor()['_ko_property_writers'];

                 if (propWriters && propWriters[key])

                     propWriters[key](value);

             } else if (!checkIfDifferent || property.peek() !== value) {

                 property(value);

             }

         }

     };

 })();

 ko.exportSymbol('expressionRewriting', ko.expressionRewriting);

 ko.exportSymbol('expressionRewriting.bindingRewriteValidators', ko.expressionRewriting.bindingRewriteValidators);

 ko.exportSymbol('expressionRewriting.parseObjectLiteral', ko.expressionRewriting.parseObjectLiteral);

 ko.exportSymbol('expressionRewriting.preProcessBindings', ko.expressionRewriting.preProcessBindings);

 // For backward compatibility, define the following aliases. (Previously, these function names were misleading because

 // they referred to JSON specifically, even though they actually work with arbitrary JavaScript object literal expressions.)

 ko.exportSymbol('jsonExpressionRewriting', ko.expressionRewriting);

 ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.expressionRewriting.preProcessBindings);(function() {

     // "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

     // of that virtual hierarchy

     //

     // The point of all this is to support containerless templates (e.g., <!-- ko foreach:someCollection -->blah<!-- /ko -->)

     // without having to scatter special cases all over the binding and templating code.

     // IE 9 cannot reliably read the "nodeValue" property of a comment node (see https://github.com/SteveSanderson/knockout/issues/186)

     // 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 = commentNodesHaveTextProperty ? /^<!--\s*ko(?:\s+(.+\s*\:[\s\S]*))?\s*-->$/ : /^\s*ko(?:\s+(.+\s*\:[\s\S]*))?\s*$/;

     var endCommentRegex =   commentNodesHaveTextProperty ? /^<!--\s*\/ko\s*-->$/ : /^\s*\/ko\s*$/;

     var htmlTagsWithOptionallyClosingChildren = { 'ul': true, 'ol': true };

     function isStartComment(node) {

         return (node.nodeType == 8) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex);

     }

     function isEndComment(node) {

         return (node.nodeType == 8) && (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(endCommentRegex);

     }

     function getVirtualChildren(startComment, allowUnbalanced) {

         var currentNode = startComment;

         var depth = 1;

         var children = [];

         while (currentNode = currentNode.nextSibling) {

             if (isEndComment(currentNode)) {

                 depth--;

                 if (depth === 0)

                     return children;

             }

             children.push(currentNode);

             if (isStartComment(currentNode))

                 depth++;

         }

         if (!allowUnbalanced)

             throw new Error("Cannot find closing comment tag to match: " + startComment.nodeValue);

         return null;

     }

     function getMatchingEndComment(startComment, allowUnbalanced) {

         var allVirtualChildren = getVirtualChildren(startComment, allowUnbalanced);

         if (allVirtualChildren) {

             if (allVirtualChildren.length > 0)

                 return allVirtualChildren[allVirtualChildren.length - 1].nextSibling;

             return startComment.nextSibling;

         } else

             return null; // Must have no matching end comment, and allowUnbalanced is true

     }

     function getUnbalancedChildTags(node) {

         // e.g., from <div>OK</div><!-- ko blah --><span>Another</span>, returns: <!-- ko blah --><span>Another</span>

         //       from <div>OK</div><!-- /ko --><!-- /ko -->,             returns: <!-- /ko --><!-- /ko -->

         var childNode = node.firstChild, captureRemaining = null;

         if (childNode) {

             do {

                 if (captureRemaining)                   // We already hit an unbalanced node and are now just scooping up all subsequent nodes

                     captureRemaining.push(childNode);

                 else if (isStartComment(childNode)) {

                     var matchingEndComment = getMatchingEndComment(childNode, /* allowUnbalanced: */ true);

                     if (matchingEndComment)             // It's a balanced tag, so skip immediately to the end of this virtual set

                         childNode = matchingEndComment;

                     else

                         captureRemaining = [childNode]; // It's unbalanced, so start capturing from this point

                 } else if (isEndComment(childNode)) {

                     captureRemaining = [childNode];     // It's unbalanced (if it wasn't, we'd have skipped over it already), so start capturing

                 }

             } while (childNode = childNode.nextSibling);

         }

         return captureRemaining;

     }

     ko.virtualElements = {

         allowedBindings: {},

         childNodes: function(node) {

             return isStartComment(node) ? getVirtualChildren(node) : node.childNodes;

         },

         emptyNode: function(node) {

             if (!isStartComment(node))

                 ko.utils.emptyDomNode(node);

             else {

                 var virtualChildren = ko.virtualElements.childNodes(node);

                 for (var i = 0, j = virtualChildren.length; i < j; i++)

                     ko.removeNode(virtualChildren[i]);

             }

         },

         setDomNodeChildren: function(node, childNodes) {

             if (!isStartComment(node))

                 ko.utils.setDomNodeChildren(node, childNodes);

             else {

                 ko.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);

             }

         },

         prepend: function(containerNode, nodeToPrepend) {

             if (!isStartComment(containerNode)) {

                 if (containerNode.firstChild)

                     containerNode.insertBefore(nodeToPrepend, containerNode.firstChild);

                 else

                     containerNode.appendChild(nodeToPrepend);

             } else {

                 // Start comments must always have a parent and at least one following sibling (the end comment)

                 containerNode.parentNode.insertBefore(nodeToPrepend, containerNode.nextSibling);

             }

         },

         insertAfter: function(containerNode, nodeToInsert, insertAfterNode) {

             if (!insertAfterNode) {

                 ko.virtualElements.prepend(containerNode, nodeToInsert);

             } else if (!isStartComment(containerNode)) {

                 // Insert after insertion point

                 if (insertAfterNode.nextSibling)

                     containerNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);

                 else

                     containerNode.appendChild(nodeToInsert);

             } else {

                 // Children of start comments must always have a parent and at least one following sibling (the end comment)

                 containerNode.parentNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);

             }

         },

         firstChild: function(node) {

             if (!isStartComment(node))

                 return node.firstChild;

             if (!node.nextSibling || isEndComment(node.nextSibling))

                 return null;

             return node.nextSibling;

         },

         nextSibling: function(node) {

             if (isStartComment(node))

                 node = getMatchingEndComment(node);

             if (node.nextSibling && isEndComment(node.nextSibling))

                 return null;

             return node.nextSibling;

         },

         virtualNodeBindingValue: function(node) {

             var regexMatch = isStartComment(node);

             return regexMatch ? regexMatch[1] : null;

         },

         normaliseVirtualElementDomStructure: function(elementVerified) {

             // Workaround for https://github.com/SteveSanderson/knockout/issues/155

             // (IE <= 8 or IE 9 quirks mode parses your HTML weirdly, treating closing </li> tags as if they don't exist, thereby moving comment nodes

             // that are direct descendants of <ul> into the preceding <li>)

             if (!htmlTagsWithOptionallyClosingChildren[ko.utils.tagNameLower(elementVerified)])

                 return;

             // Scan immediate children to see if they contain unbalanced comment tags. If they do, those comment tags

             // must be intended to appear *after* that child, so move them there.

             var childNode = elementVerified.firstChild;

             if (childNode) {

                 do {

                     if (childNode.nodeType === 1) {

                         var unbalancedTags = getUnbalancedChildTags(childNode);

                         if (unbalancedTags) {

                             // Fix up the DOM by moving the unbalanced tags to where they most likely were intended to be placed - *after* the child

                             var nodeToInsertBefore = childNode.nextSibling;

                             for (var i = 0; i < unbalancedTags.length; i++) {

                                 if (nodeToInsertBefore)

                                     elementVerified.insertBefore(unbalancedTags[i], nodeToInsertBefore);

                                 else

                                     elementVerified.appendChild(unbalancedTags[i]);

                             }

                         }

                     }

                 } while (childNode = childNode.nextSibling);

             }

         }

     };

 })();

 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";

     ko.bindingProvider = function() {

         this.bindingCache = {};

     };

     ko.utils.extend(ko.bindingProvider.prototype, {

         'nodeHasBindings': function(node) {

             switch (node.nodeType) {

                 case 1: return node.getAttribute(defaultBindingAttributeName) != null;   // Element

                 case 8: return ko.virtualElements.virtualNodeBindingValue(node) != null; // Comment node

                 default: return false;

             }

         },

         'getBindings': function(node, bindingContext) {

             var bindingsString = this['getBindingsString'](node, bindingContext);

             return bindingsString ? this['parseBindingsString'](bindingsString, bindingContext, node) : 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) {

             switch (node.nodeType) {

                 case 1: return node.getAttribute(defaultBindingAttributeName);   // Element

                 case 8: return ko.virtualElements.virtualNodeBindingValue(node); // Comment node

                 default: return 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.

         'parseBindingsString': function(bindingsString, bindingContext, node) {

             try {

                 var bindingFunction = createBindingsStringEvaluatorViaCache(bindingsString, this.bindingCache);

                 return bindingFunction(bindingContext, node);

             } catch (ex) {

                 throw new Error("Unable to parse bindings.\nMessage: " + ex + ";\nBindings value: " + bindingsString);

             }

         }

     });

     ko.bindingProvider['instance'] = new ko.bindingProvider();

     function createBindingsStringEvaluatorViaCache(bindingsString, cache) {

         var cacheKey = bindingsString;

         return cache[cacheKey]

             || (cache[cacheKey] = createBindingsStringEvaluator(bindingsString));

     }

     function createBindingsStringEvaluator(bindingsString) {

         // Build the source for a function that evaluates "expression"

         // For each scope variable, add an extra level of "with" nesting

         // Example result: with(sc1) { with(sc0) { return (expression) } }

         var rewrittenBindings = ko.expressionRewriting.preProcessBindings(bindingsString),

             functionBody = "with($context){with($data||{}){return{" + rewrittenBindings + "}}}";

         return new Function("$context", "$element", functionBody);

     }

 })();

 ko.exportSymbol('bindingProvider', ko.bindingProvider);

 (function () {

     ko.bindingHandlers = {};

     ko.bindingContext = function(dataItem, parentBindingContext, dataItemAlias) {

         if (parentBindingContext) {

             ko.utils.extend(this, parentBindingContext); // Inherit $root and any custom properties

             this['$parentContext'] = parentBindingContext;

             this['$parent'] = parentBindingContext['$data'];

             this['$parents'] = (parentBindingContext['$parents'] || []).slice(0);

             this['$parents'].unshift(this['$parent']);

         } else {

             this['$parents'] = [];

             this['$root'] = dataItem;

             // Export 'ko' in the binding context so it will be available in bindings and templates

             // even if 'ko' isn't exported as a global, such as when using an AMD loader.

             // See https://github.com/SteveSanderson/knockout/issues/490

             this['ko'] = ko;

         }

         this['$data'] = dataItem;

         if (dataItemAlias)

             this[dataItemAlias] = dataItem;

     }

     ko.bindingContext.prototype['createChildContext'] = function (dataItem, dataItemAlias) {

         return new ko.bindingContext(dataItem, this, dataItemAlias);

     };

     ko.bindingContext.prototype['extend'] = function(properties) {

         var clone = ko.utils.extend(new ko.bindingContext(), this);

         return ko.utils.extend(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 applyBindingsToDescendantsInternal (viewModel, 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);

         }

     }

     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);

         if (isElement) // Workaround IE <= 8 HTML parsing weirdness

             ko.virtualElements.normaliseVirtualElementDomStructure(nodeVerified);

         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);

         }

     }

     function applyBindingsToNodeInternal (node, bindings, viewModelOrBindingContext, bindingContextMayDifferFromDomParentElement) {

         // Need to be sure that inits are only run once, and updates never run until all the inits have been run

         var initPhase = 0; // 0 = before all inits, 1 = during inits, 2 = after all inits

         // Each time the dependentObservable is evaluated (after data changes),

         // the binding attribute is reparsed so that it can pick out the correct

         // model properties in the context of the changed data.

         // DOM event callbacks need to be able to access this changed data,

         // so we need a single parsedBindings variable (shared by all callbacks

         // associated with this node's bindings) that all the closures can access.

         var parsedBindings;

         function makeValueAccessor(bindingKey) {

             return function () { return parsedBindings[bindingKey] }

         }

         function parsedBindingsAccessor() {

             return parsedBindings;

         }

         var 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(bindingContextInstance, node) : bindings;

                 parsedBindings = evaluatedBindings || ko.bindingProvider['instance']['getBindings'](node, bindingContextInstance);

                 if (parsedBindings) {

                     // First run all the inits, so bindings can register for notification on changes

                     if (initPhase === 0) {

                         initPhase = 1;

                         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;

                                 }

                             }

                         }

                         initPhase = 2;

                     }

                     // ... 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);

                             }

                         }

                     }

                 }

             },

             null,

             { disposeWhenNodeIsRemoved : node }

         );

         return {

             shouldBindDescendants: bindingHandlerThatControlsDescendantBindings === undefined

         };

     };

     var storedBindingContextDomDataKey = "__ko_bindingContext__";

     ko.storedBindingContextForNode = function (node, bindingContext) {

         if (arguments.length == 2)

             ko.utils.domData.set(node, storedBindingContextDomDataKey, bindingContext);

         else

             return ko.utils.domData.get(node, storedBindingContextDomDataKey);

     }

     ko.applyBindingsToNode = function (node, bindings, viewModel) {

         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.applyBindingsToDescendants = function(viewModel, rootNode) {

         if (rootNode.nodeType === 1 || rootNode.nodeType === 8)

             applyBindingsToDescendantsInternal(viewModel, rootNode, true);

     };

     ko.applyBindings = function (viewModel, rootNode) {

         if (rootNode && (rootNode.nodeType !== 1) && (rootNode.nodeType !== 8))

             throw new Error("ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node");

         rootNode = rootNode || window.document.body; // Make "rootNode" parameter optional

         applyBindingsToNodeAndDescendantsInternal(viewModel, rootNode, true);

     };

     // Retrieving binding context from arbitrary nodes

     ko.contextFor = function(node) {

         // We can only do something meaningful for elements and comment nodes (in particular, not text nodes, as IE can't store domdata for them)

         switch (node.nodeType) {

             case 1:

             case 8:

                 var context = ko.storedBindingContextForNode(node);

                 if (context) return context;

                 if (node.parentNode) return ko.contextFor(node.parentNode);

                 break;

         }

         return undefined;

     };

     ko.dataFor = function(node) {

         var context = ko.contextFor(node);

         return context ? context['$data'] : undefined;

     };

     ko.exportSymbol('bindingHandlers', ko.bindingHandlers);

     ko.exportSymbol('applyBindings', ko.applyBindings);

     ko.exportSymbol('applyBindingsToDescendants', ko.applyBindingsToDescendants);

     ko.exportSymbol('applyBindingsToNode', ko.applyBindingsToNode);

     ko.exportSymbol('contextFor', ko.contextFor);

     ko.exportSymbol('dataFor', ko.dataFor);

 })();

 var attrHtmlToJavascriptMap = { 'class': 'className', 'for': 'htmlFor' };

 ko.bindingHandlers['attr'] = {

     'update': function(element, valueAccessor, allBindingsAccessor) {

         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.)

                 var toRemove = (attrValue === false) || (attrValue === null) || (attrValue === undefined);

                 if (toRemove)

                     element.removeAttribute(attrName);

                 // 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) {

                     try {

                         element.setAttribute(attrName, attrValue.toString());

                     } catch (err) {

                         // ignore for now

                         if (console) {

                             console.log("Can't set attribute " + attrName + " to " + attrValue + " error: " + err);

                         }

                     }

                 }

                 // Treat "name" specially - although you can think of it as an attribute, it also needs

                 // special handling on older versions of IE (https://github.com/SteveSanderson/knockout/pull/333)

                 // Deliberately being case-sensitive here because XHTML would regard "Name" as a different thing

                 // entirely, and there's no strong reason to allow for such casing in HTML.

                 if (attrName === "name") {

                     ko.utils.setElementName(element, toRemove ? "" : attrValue.toString());

                 }

             }

         }

     }

 };

 ko.bindingHandlers['checked'] = {

     'init': function (element, valueAccessor, allBindingsAccessor) {

         var updateHandler = function() {

             var valueToWrite;

             if (element.type == "checkbox") {

                 valueToWrite = element.checked;

             } else if ((element.type == "radio") && (element.checked)) {

                 valueToWrite = element.value;

             } else {

                 return; // "checked" binding only responds to checkboxes and selected radio buttons

             }

             var modelValue = valueAccessor(), unwrappedValue = ko.utils.unwrapObservable(modelValue);

             if ((element.type == "checkbox") && (unwrappedValue instanceof Array)) {

                 // For checkboxes bound to an array, we add/remove the checkbox value to that array

                 // This works for both observable and non-observable arrays

                 var existingEntryIndex = ko.utils.arrayIndexOf(unwrappedValue, element.value);

                 if (element.checked && (existingEntryIndex < 0))

                     modelValue.push(element.value);

                 else if ((!element.checked) && (existingEntryIndex >= 0))

                     modelValue.splice(existingEntryIndex, 1);

             } else {

                 ko.expressionRewriting.writeValueToProperty(modelValue, allBindingsAccessor, 'checked', valueToWrite, true);

             }

         };

         ko.utils.registerEventHandler(element, "click", updateHandler);

         // IE 6 won't allow radio buttons to be selected unless they have a name

         if ((element.type == "radio") && !element.name)

             ko.bindingHandlers['uniqueName']['init'](element, function() { return true });

     },

     'update': function (element, valueAccessor) {

         var value = ko.utils.unwrapObservable(valueAccessor());

         if (element.type == "checkbox") {

             if (value instanceof Array) {

                 // When bound to an array, the checkbox being checked represents its value being present in that array

                 element.checked = ko.utils.arrayIndexOf(value, element.value) >= 0;

             } else {

                 // When bound to anything other value (not an array), the checkbox being checked represents the value being trueish

                 element.checked = value;

             }

         } else if (element.type == "radio") {

             element.checked = (element.value == value);

         }

     }

 };

 var classesWrittenByBindingKey = '__ko__cssValue';

 ko.bindingHandlers['css'] = {

     'update': function (element, valueAccessor) {

         var value = ko.utils.unwrapObservable(valueAccessor());

         if (typeof value == "object") {

             for (var className in value) {

                 var shouldHaveClass = ko.utils.unwrapObservable(value[className]);

                 ko.utils.toggleDomNodeCssClass(element, className, shouldHaveClass);

             }

         } else {

             value = String(value || ''); // Make sure we don't try to store or set a non-string value

             ko.utils.toggleDomNodeCssClass(element, element[classesWrittenByBindingKey], false);

             element[classesWrittenByBindingKey] = value;

             ko.utils.toggleDomNodeCssClass(element, value, true);

         }

     }

 };

 ko.bindingHandlers['enable'] = {

     'update': function (element, valueAccessor) {

         var value = ko.utils.unwrapObservable(valueAccessor());

         if (value && element.disabled)

             element.removeAttribute("disabled");

         else if ((!value) && (!element.disabled))

             element.disabled = true;

     }

 };

 ko.bindingHandlers['disable'] = {

     'update': function (element, valueAccessor) {

         ko.bindingHandlers['enable']['update'](element, function() { return !ko.utils.unwrapObservable(valueAccessor()) });

     }

 };

 // For certain common events (currently just 'click'), allow a simplified data-binding syntax

 // e.g. click:handler instead of the usual full-length event:{click:handler}

 function makeEventHandlerShortcut(eventName) {

     ko.bindingHandlers[eventName] = {

         'init': function(element, valueAccessor, allBindingsAccessor, viewModel) {

             var newValueAccessor = function () {

                 var result = {};

                 result[eventName] = valueAccessor();

                 return result;

             };

             return ko.bindingHandlers['event']['init'].call(this, element, newValueAccessor, allBindingsAccessor, viewModel);

         }

     }

 }

 ko.bindingHandlers['event'] = {

     'init' : function (element, valueAccessor, allBindingsAccessor, viewModel) {

         var eventsToHandle = valueAccessor() || {};

         for(var eventNameOutsideClosure in eventsToHandle) {

             (function() {

                 var eventName = eventNameOutsideClosure; // Separate variable to be captured by event handler closure

                 if (typeof eventName == "string") {

                     ko.utils.registerEventHandler(element, eventName, function (event) {

                         var handlerReturnValue;

                         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);

                             argsForHandler.unshift(viewModel);

                             handlerReturnValue = handlerFunction.apply(viewModel, argsForHandler);

                         } finally {

                             if (handlerReturnValue !== true) { // Normally we want to prevent default action. Developer can override this be explicitly returning true.

                                 if (event.preventDefault)

                                     event.preventDefault();

                                 else

                                     event.returnValue = false;

                             }

                         }

                         var bubble = allBindings[eventName + 'Bubble'] !== false;

                         if (!bubble) {

                             event.cancelBubble = true;

                             if (event.stopPropagation)

                                 event.stopPropagation();

                         }

                     });

                 }

             })();

         }

     }

 };

 // "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 modelValue = valueAccessor(),

                 unwrappedValue = ko.utils.peekObservable(modelValue);    // Unwrap without setting a dependency here

             // If unwrappedValue is the array, pass in the wrapped value on its own

             // The value will be unwrapped and tracked within the template binding

             // (See https://github.com/SteveSanderson/knockout/issues/523)

             if ((!unwrappedValue) || typeof unwrappedValue.length == "number")

                 return { 'foreach': modelValue, 'templateEngine': ko.nativeTemplateEngine.instance };

             // If unwrappedValue.data is the array, preserve all relevant options and unwrap again value so we get updates

             ko.utils.unwrapObservable(modelValue);

             return {

                 'foreach': unwrappedValue['data'],

                 'as': unwrappedValue['as'],

                 'includeDestroyed': unwrappedValue['includeDestroyed'],

                 'afterAdd': unwrappedValue['afterAdd'],

                 'beforeRemove': unwrappedValue['beforeRemove'],

                 'afterRender': unwrappedValue['afterRender'],

                 'beforeMove': unwrappedValue['beforeMove'],

                 'afterMove': unwrappedValue['afterMove'],

                 '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.expressionRewriting.bindingRewriteValidators['foreach'] = false; // Can't rewrite control flow bindings

 ko.virtualElements.allowedBindings['foreach'] = true;

 var hasfocusUpdatingProperty = '__ko_hasfocusUpdating';

 ko.bindingHandlers['hasfocus'] = {

     'init': function(element, valueAccessor, allBindingsAccessor) {

         var handleElementFocusChange = function(isFocused) {

             // Where possible, ignore which event was raised and determine focus state using activeElement,

             // as this avoids phantom focus/blur events raised when changing tabs in modern browsers.

             // However, not all KO-targeted browsers (Firefox 2) support activeElement. For those browsers,

             // prevent a loss of focus when changing tabs/windows by setting a flag that prevents hasfocus

             // from calling 'blur()' on the element when it loses focus.

             // Discussion at https://github.com/SteveSanderson/knockout/pull/352

             element[hasfocusUpdatingProperty] = true;

             var ownerDoc = element.ownerDocument;

             if ("activeElement" in ownerDoc) {

                 isFocused = (ownerDoc.activeElement === element);

             }

             var modelValue = valueAccessor();

             ko.expressionRewriting.writeValueToProperty(modelValue, allBindingsAccessor, 'hasfocus', isFocused, true);

             element[hasfocusUpdatingProperty] = false;

         };

         var handleElementFocusIn = handleElementFocusChange.bind(null, true);

         var handleElementFocusOut = handleElementFocusChange.bind(null, false);

         ko.utils.registerEventHandler(element, "focus", handleElementFocusIn);

         ko.utils.registerEventHandler(element, "focusin", handleElementFocusIn); // For IE

         ko.utils.registerEventHandler(element, "blur",  handleElementFocusOut);

         ko.utils.registerEventHandler(element, "focusout",  handleElementFocusOut); // For IE

     },

     'update': function(element, valueAccessor) {

         var value = ko.utils.unwrapObservable(valueAccessor());

         if (!element[hasfocusUpdatingProperty]) {

             value ? element.focus() : element.blur();

             ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, value ? "focusin" : "focusout"]); // For IE, which doesn't reliably fire "focus" or "blur" events synchronously

         }

     }

 };

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

     },

     'update': function (element, valueAccessor) {

         // setHtml will unwrap the value if needed

         ko.utils.setHtml(element, valueAccessor());

     }

 };

 var withIfDomDataKey = '__ko_withIfBindingData';

 // Makes a binding like with or if

 function makeWithIfBinding(bindingKey, isWith, isNot, makeContextCallback) {

     ko.bindingHandlers[bindingKey] = {

         'init': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {

             ko.utils.domData.set(element, withIfDomDataKey, {});

             return { 'controlsDescendantBindings': true };

         },

         'update': function(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {

             var withIfData = ko.utils.domData.get(element, withIfDomDataKey),

                 dataValue = ko.utils.unwrapObservable(valueAccessor()),

                 shouldDisplay = !isNot !== !dataValue, // equivalent to isNot ? !dataValue : !!dataValue

                 isFirstRender = !withIfData.savedNodes,

                 needsRefresh = isFirstRender || isWith || (shouldDisplay !== withIfData.didDisplayOnLastUpdate);

             if (needsRefresh) {

                 if (isFirstRender) {

                     withIfData.savedNodes = ko.utils.cloneNodes(ko.virtualElements.childNodes(element), true /* shouldCleanNodes */);

                 }

                 if (shouldDisplay) {

                     if (!isFirstRender) {

                         ko.virtualElements.setDomNodeChildren(element, ko.utils.cloneNodes(withIfData.savedNodes));

                     }

                     ko.applyBindingsToDescendants(makeContextCallback ? makeContextCallback(bindingContext, dataValue) : bindingContext, element);

                 } else {

                     ko.virtualElements.emptyNode(element);

                 }

                 withIfData.didDisplayOnLastUpdate = shouldDisplay;

             }

         }

     };

     ko.expressionRewriting.bindingRewriteValidators[bindingKey] = false; // Can't rewrite control flow bindings

     ko.virtualElements.allowedBindings[bindingKey] = true;

 }

 // Construct the actual binding handlers

 makeWithIfBinding('if');

 makeWithIfBinding('ifnot', false /* isWith */, true /* isNot */);

 makeWithIfBinding('with', true /* isWith */, false /* isNot */,

     function(bindingContext, dataValue) {

         return bindingContext['createChildContext'](dataValue);

     }

 );

 function ensureDropdownSelectionIsConsistentWithModelValue(element, modelValue, preferModelValue) {

     if (preferModelValue) {

         if (modelValue !== ko.selectExtensions.readValue(element))

             ko.selectExtensions.writeValue(element, modelValue);

     }

     // No matter which direction we're syncing in, we want the end result to be equality between dropdown value and model value.

     // If they aren't equal, either we prefer the dropdown value, or the model value couldn't be represented, so either way,

     // change the model value to match the dropdown.

     if (modelValue !== ko.selectExtensions.readValue(element))

         ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, "change"]);

 };

 ko.bindingHandlers['options'] = {

     'update': function (element, valueAccessor, allBindingsAccessor) {

         if (ko.utils.tagNameLower(element) !== "select")

             throw new Error("options binding applies only to SELECT elements");

         var selectWasPreviouslyEmpty = element.length == 0;

         var previousSelectedValues = ko.utils.arrayMap(ko.utils.arrayFilter(element.childNodes, function (node) {

             return node.tagName && (ko.utils.tagNameLower(node) === "option") && node.selected;

         }), function (node) {

             return ko.selectExtensions.readValue(node) || node.innerText || node.textContent;

         });

         var previousScrollTop = element.scrollTop;

         var value = ko.utils.unwrapObservable(valueAccessor());

         var selectedValue = element.value;

         // Remove all existing <option>s.

         // Need to use .remove() rather than .removeChild() for <option>s otherwise IE behaves oddly (https://github.com/SteveSanderson/knockout/issues/134)

         while (element.length > 0) {

             ko.cleanNode(element.options[0]);

             element.remove(0);

         }

         if (value) {

             var allBindings = allBindingsAccessor(),

                 includeDestroyed = allBindings['optionsIncludeDestroyed'];

             if (typeof value.length != "number")

                 value = [value];

             if (allBindings['optionsCaption']) {

                 var option = document.createElement("option");

                 ko.utils.setHtml(option, allBindings['optionsCaption']);

                 ko.selectExtensions.writeValue(option, undefined);

                 element.appendChild(option);

             }

             for (var i = 0, j = value.length; i < j; i++) {

                 // Skip destroyed items

                 var arrayEntry = value[i];

                 if (arrayEntry && arrayEntry['_destroy'] && !includeDestroyed)

                     continue;

                 var option = document.createElement("option");

                 function applyToObject(object, predicate, defaultValue) {

                     var predicateType = typeof predicate;

                     if (predicateType == "function")    // Given a function; run it against the data value

                         return predicate(object);

                     else if (predicateType == "string") // Given a string; treat it as a property name on the data value

                         return object[predicate];

                     else                                // Given no optionsText arg; use the data value itself

                         return defaultValue;

                 }

                 // Apply a value to the option element

                 var optionValue = applyToObject(arrayEntry, allBindings['optionsValue'], arrayEntry);

                 ko.selectExtensions.writeValue(option, ko.utils.unwrapObservable(optionValue));

                 // Apply some text to the option element

                 var optionText = applyToObject(arrayEntry, allBindings['optionsText'], optionValue);

                 ko.utils.setTextContent(option, optionText);

                 element.appendChild(option);

             }

             // IE6 doesn't like us to assign selection to OPTION nodes before they're added to the document.

             // That's why we first added them without selection. Now it's time to set the selection.

             var newOptions = element.getElementsByTagName("option");

             var countSelectionsRetained = 0;

             for (var i = 0, j = newOptions.length; i < j; i++) {

                 if (ko.utils.arrayIndexOf(previousSelectedValues, ko.selectExtensions.readValue(newOptions[i])) >= 0) {

                     ko.utils.setOptionNodeSelectionState(newOptions[i], true);

                     countSelectionsRetained++;

                 }

             }

             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.peekObservable(allBindings['value']), /* preferModelValue */ true);

             }

             // Workaround for IE9 bug

             ko.utils.ensureSelectElementIsRenderedCorrectly(element);

         }

     }

 };

 ko.bindingHandlers['options'].optionValueDomDataKey = '__ko.optionValueDomData__';

 ko.bindingHandlers['selectedOptions'] = {

     'init': function (element, valueAccessor, allBindingsAccessor) {

         ko.utils.registerEventHandler(element, "change", function () {

             var value = valueAccessor(), valueToWrite = [];

             ko.utils.arrayForEach(element.getElementsByTagName("option"), function(node) {

                 if (node.selected)

                     valueToWrite.push(ko.selectExtensions.readValue(node));

             });

             ko.expressionRewriting.writeValueToProperty(value, allBindingsAccessor, 'value', valueToWrite);

         });

     },

     'update': function (element, valueAccessor) {

         if (ko.utils.tagNameLower(element) != "select")

             throw new Error("values binding applies only to SELECT elements");

         var newValue = ko.utils.unwrapObservable(valueAccessor());

         if (newValue && typeof newValue.length == "number") {

             ko.utils.arrayForEach(element.getElementsByTagName("option"), function(node) {

                 var isSelected = ko.utils.arrayIndexOf(newValue, ko.selectExtensions.readValue(node)) >= 0;

                 ko.utils.setOptionNodeSelectionState(node, isSelected);

             });

         }

     }

 };

 ko.bindingHandlers['style'] = {

     'update': function (element, valueAccessor) {

         var value = ko.utils.unwrapObservable(valueAccessor() || {});

         for (var styleName in value) {

             if (typeof styleName == "string") {

                 var styleValue = ko.utils.unwrapObservable(value[styleName]);

                 element.style[styleName] = styleValue || ""; // Empty string removes the value, whereas null/undefined have no effect

             }

         }

     }

 };

 ko.bindingHandlers['submit'] = {

     'init': function (element, valueAccessor, allBindingsAccessor, viewModel) {

         if (typeof valueAccessor() != "function")

             throw new Error("The value for a submit binding must be a function");

         ko.utils.registerEventHandler(element, "submit", function (event) {

             var handlerReturnValue;

             var value = valueAccessor();

             try { handlerReturnValue = value.call(viewModel, element); }

             finally {

                 if (handlerReturnValue !== true) { // Normally we want to prevent default action. Developer can override this be explicitly returning true.

                     if (event.preventDefault)

                         event.preventDefault();

                     else

                         event.returnValue = false;