https://www.reviewofoptometry.com/Scripts/knockout-3.3.0.debug.js

1/*!
2 * Knockout JavaScript library v3.3.0
3 * (c) Steven Sanderson - http://knockoutjs.com/
4 * License: MIT (http://www.opensource.org/licenses/mit-license.php)
5 */
6
7(function(){
8var DEBUG=true;
9(function(undefined){
10    // (0, eval)('this') is a robust way of getting a reference to the global object
11    // For details, see http://stackoverflow.com/questions/14119988/return-this-0-evalthis/14120023#14120023
12    var window = this || (0, eval)('this'),
13        document = window['document'],
14        navigator = window['navigator'],
15        jQueryInstance = window["jQuery"],
16        JSON = window["JSON"];
17(function(factory) {
18    // Support three module loading scenarios
19    if (typeof define === 'function' && define['amd']) {
20        // [1] AMD anonymous module
21        define(['exports', 'require'], factory);
22    } else if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
23        // [2] CommonJS/Node.js
24        factory(module['exports'] || exports);  // module.exports is for Node.js
25    } else {
26        // [3] No module loader (plain <script> tag) - put directly in global namespace
27        factory(window['ko'] = {});
28    }
29}(function(koExports, amdRequire){
30// Internally, all KO objects are attached to koExports (even the non-exported ones whose names will be minified by the closure compiler).
31// In the future, the following "ko" variable may be made distinct from "koExports" so that private objects are not externally reachable.
32var ko = typeof koExports !== 'undefined' ? koExports : {};
33// Google Closure Compiler helpers (used only to make the minified file smaller)
34ko.exportSymbol = function(koPath, object) {
35    var tokens = koPath.split(".");
36
37    // In the future, "ko" may become distinct from "koExports" (so that non-exported objects are not reachable)
38    // At that point, "target" would be set to: (typeof koExports !== "undefined" ? koExports : ko)
39    var target = ko;
40
41    for (var i = 0; i < tokens.length - 1; i++)
42        target = target[tokens[i]];
43    target[tokens[tokens.length - 1]] = object;
44};
45ko.exportProperty = function(owner, publicName, object) {
46    owner[publicName] = object;
47};
48ko.version = "3.3.0";
49
50ko.exportSymbol('version', ko.version);
51ko.utils = (function () {
52    function objectForEach(obj, action) {
53        for (var prop in obj) {
54            if (obj.hasOwnProperty(prop)) {
55                action(prop, obj[prop]);
56            }
57        }
58    }
59
60    function extend(target, source) {
61        if (source) {
62            for(var prop in source) {
63                if(source.hasOwnProperty(prop)) {
64                    target[prop] = source[prop];
65                }
66            }
67        }
68        return target;
69    }
70
71    function setPrototypeOf(obj, proto) {
72        obj.__proto__ = proto;
73        return obj;
74    }
75
76    var canSetPrototype = ({ __proto__: [] } instanceof Array);
77
78    // 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)
79    var knownEvents = {}, knownEventTypesByEventName = {};
80    var keyEventTypeName = (navigator && /Firefox\/2/i.test(navigator.userAgent)) ? 'KeyboardEvent' : 'UIEvents';
81    knownEvents[keyEventTypeName] = ['keyup', 'keydown', 'keypress'];
82    knownEvents['MouseEvents'] = ['click', 'dblclick', 'mousedown', 'mouseup', 'mousemove', 'mouseover', 'mouseout', 'mouseenter', 'mouseleave'];
83    objectForEach(knownEvents, function(eventType, knownEventsForType) {
84        if (knownEventsForType.length) {
85            for (var i = 0, j = knownEventsForType.length; i < j; i++)
86                knownEventTypesByEventName[knownEventsForType[i]] = eventType;
87        }
88    });
89    var eventsThatMustBeRegisteredUsingAttachEvent = { 'propertychange': true }; // Workaround for an IE9 issue - https://github.com/SteveSanderson/knockout/issues/406
90
91    // Detect IE versions for bug workarounds (uses IE conditionals, not UA string, for robustness)
92    // Note that, since IE 10 does not support conditional comments, the following logic only detects IE < 10.
93    // Currently this is by design, since IE 10+ behaves correctly when treated as a standard browser.
94    // If there is a future need to detect specific versions of IE10+, we will amend this.
95    var ieVersion = document && (function() {
96        var version = 3, div = document.createElement('div'), iElems = div.getElementsByTagName('i');
97
98        // Keep constructing conditional HTML blocks until we hit one that resolves to an empty fragment
99        while (
100            div.innerHTML = '<!--[if gt IE ' + (++version) + ']><i></i><![endif]-->',
101            iElems[0]
102        ) {}
103        return version > 4 ? version : undefined;
104    }());
105    var isIe6 = ieVersion === 6,
106        isIe7 = ieVersion === 7;
107
108    function isClickOnCheckableElement(element, eventType) {
109        if ((ko.utils.tagNameLower(element) !== "input") || !element.type) return false;
110        if (eventType.toLowerCase() != "click") return false;
111        var inputType = element.type;
112        return (inputType == "checkbox") || (inputType == "radio");
113    }
114
115    // For details on the pattern for changing node classes
116    // see: https://github.com/knockout/knockout/issues/1597
117    var cssClassNameRegex = /\S+/g;
118
119    function toggleDomNodeCssClass(node, classNames, shouldHaveClass) {
120        var addOrRemoveFn;
121        if (classNames) {
122            if (typeof node.classList === 'object') {
123                addOrRemoveFn = node.classList[shouldHaveClass ? 'add' : 'remove'];
124                ko.utils.arrayForEach(classNames.match(cssClassNameRegex), function(className) {
125                    addOrRemoveFn.call(node.classList, className);
126                });
127            } else if (typeof node.className['baseVal'] === 'string') {
128                // SVG tag .classNames is an SVGAnimatedString instance
129                toggleObjectClassPropertyString(node.className, 'baseVal', classNames, shouldHaveClass);
130            } else {
131                // node.className ought to be a string.
132                toggleObjectClassPropertyString(node, 'className', classNames, shouldHaveClass);
133            }
134        }
135    }
136
137    function toggleObjectClassPropertyString(obj, prop, classNames, shouldHaveClass) {
138        // obj/prop is either a node/'className' or a SVGAnimatedString/'baseVal'.
139        var currentClassNames = obj[prop].match(cssClassNameRegex) || [];
140        ko.utils.arrayForEach(classNames.match(cssClassNameRegex), function(className) {
141            ko.utils.addOrRemoveItem(currentClassNames, className, shouldHaveClass);
142        });
143        obj[prop] = currentClassNames.join(" ");
144    }
145
146    return {
147        fieldsIncludedWithJsonPost: ['authenticity_token', /^__RequestVerificationToken(_.*)?$/],
148
149        arrayForEach: function (array, action) {
150            for (var i = 0, j = array.length; i < j; i++)
151                action(array[i], i);
152        },
153
154        arrayIndexOf: function (array, item) {
155            if (typeof Array.prototype.indexOf == "function")
156                return Array.prototype.indexOf.call(array, item);
157            for (var i = 0, j = array.length; i < j; i++)
158                if (array[i] === item)
159                    return i;
160            return -1;
161        },
162
163        arrayFirst: function (array, predicate, predicateOwner) {
164            for (var i = 0, j = array.length; i < j; i++)
165                if (predicate.call(predicateOwner, array[i], i))
166                    return array[i];
167            return null;
168        },
169
170        arrayRemoveItem: function (array, itemToRemove) {
171            var index = ko.utils.arrayIndexOf(array, itemToRemove);
172            if (index > 0) {
173                array.splice(index, 1);
174            }
175            else if (index === 0) {
176                array.shift();
177            }
178        },
179
180        arrayGetDistinctValues: function (array) {
181            array = array || [];
182            var result = [];
183            for (var i = 0, j = array.length; i < j; i++) {
184                if (ko.utils.arrayIndexOf(result, array[i]) < 0)
185                    result.push(array[i]);
186            }
187            return result;
188        },
189
190        arrayMap: function (array, mapping) {
191            array = array || [];
192            var result = [];
193            for (var i = 0, j = array.length; i < j; i++)
194                result.push(mapping(array[i], i));
195            return result;
196        },
197
198        arrayFilter: function (array, predicate) {
199            array = array || [];
200            var result = [];
201            for (var i = 0, j = array.length; i < j; i++)
202                if (predicate(array[i], i))
203                    result.push(array[i]);
204            return result;
205        },
206
207        arrayPushAll: function (array, valuesToPush) {
208            if (valuesToPush instanceof Array)
209                array.push.apply(array, valuesToPush);
210            else
211                for (var i = 0, j = valuesToPush.length; i < j; i++)
212                    array.push(valuesToPush[i]);
213            return array;
214        },
215
216        addOrRemoveItem: function(array, value, included) {
217            var existingEntryIndex = ko.utils.arrayIndexOf(ko.utils.peekObservable(array), value);
218            if (existingEntryIndex < 0) {
219                if (included)
220                    array.push(value);
221            } else {
222                if (!included)
223                    array.splice(existingEntryIndex, 1);
224            }
225        },
226
227        canSetPrototype: canSetPrototype,
228
229        extend: extend,
230
231        setPrototypeOf: setPrototypeOf,
232
233        setPrototypeOfOrExtend: canSetPrototype ? setPrototypeOf : extend,
234
235        objectForEach: objectForEach,
236
237        objectMap: function(source, mapping) {
238            if (!source)
239                return source;
240            var target = {};
241            for (var prop in source) {
242                if (source.hasOwnProperty(prop)) {
243                    target[prop] = mapping(source[prop], prop, source);
244                }
245            }
246            return target;
247        },
248
249        emptyDomNode: function (domNode) {
250            while (domNode.firstChild) {
251                ko.removeNode(domNode.firstChild);
252            }
253        },
254
255        moveCleanedNodesToContainerElement: function(nodes) {
256            // Ensure it's a real array, as we're about to reparent the nodes and
257            // we don't want the underlying collection to change while we're doing that.
258            var nodesArray = ko.utils.makeArray(nodes);
259            var templateDocument = (nodesArray[0] && nodesArray[0].ownerDocument) || document;
260
261            var container = templateDocument.createElement('div');
262            for (var i = 0, j = nodesArray.length; i < j; i++) {
263                container.appendChild(ko.cleanNode(nodesArray[i]));
264            }
265            return container;
266        },
267
268        cloneNodes: function (nodesArray, shouldCleanNodes) {
269            for (var i = 0, j = nodesArray.length, newNodesArray = []; i < j; i++) {
270                var clonedNode = nodesArray[i].cloneNode(true);
271                newNodesArray.push(shouldCleanNodes ? ko.cleanNode(clonedNode) : clonedNode);
272            }
273            return newNodesArray;
274        },
275
276        setDomNodeChildren: function (domNode, childNodes) {
277            ko.utils.emptyDomNode(domNode);
278            if (childNodes) {
279                for (var i = 0, j = childNodes.length; i < j; i++)
280                    domNode.appendChild(childNodes[i]);
281            }
282        },
283
284        replaceDomNodes: function (nodeToReplaceOrNodeArray, newNodesArray) {
285            var nodesToReplaceArray = nodeToReplaceOrNodeArray.nodeType ? [nodeToReplaceOrNodeArray] : nodeToReplaceOrNodeArray;
286            if (nodesToReplaceArray.length > 0) {
287                var insertionPoint = nodesToReplaceArray[0];
288                var parent = insertionPoint.parentNode;
289                for (var i = 0, j = newNodesArray.length; i < j; i++)
290                    parent.insertBefore(newNodesArray[i], insertionPoint);
291                for (var i = 0, j = nodesToReplaceArray.length; i < j; i++) {
292                    ko.removeNode(nodesToReplaceArray[i]);
293                }
294            }
295        },
296
297        fixUpContinuousNodeArray: function(continuousNodeArray, parentNode) {
298            // Before acting on a set of nodes that were previously outputted by a template function, we have to reconcile
299            // them against what is in the DOM right now. It may be that some of the nodes have already been removed, or that
300            // new nodes might have been inserted in the middle, for example by a binding. Also, there may previously have been
301            // leading comment nodes (created by rewritten string-based templates) that have since been removed during binding.
302            // So, this function translates the old "map" output array into its best guess of the set of current DOM nodes.
303            //
304            // Rules:
305            //   [A] Any leading nodes that have been removed should be ignored
306            //       These most likely correspond to memoization nodes that were already removed during binding
307            //       See https://github.com/SteveSanderson/knockout/pull/440
308            //   [B] We want to output a continuous series of nodes. So, ignore any nodes that have already been removed,
309            //       and include any nodes that have been inserted among the previous collection
310
311            if (continuousNodeArray.length) {
312                // The parent node can be a virtual element; so get the real parent node
313                parentNode = (parentNode.nodeType === 8 && parentNode.parentNode) || parentNode;
314
315                // Rule [A]
316                while (continuousNodeArray.length && continuousNodeArray[0].parentNode !== parentNode)
317                    continuousNodeArray.splice(0, 1);
318
319                // Rule [B]
320                if (continuousNodeArray.length > 1) {
321                    var current = continuousNodeArray[0], last = continuousNodeArray[continuousNodeArray.length - 1];
322                    // Replace with the actual new continuous node set
323                    continuousNodeArray.length = 0;
324                    while (current !== last) {
325                        continuousNodeArray.push(current);
326                        current = current.nextSibling;
327                        if (!current) // Won't happen, except if the developer has manually removed some DOM elements (then we're in an undefined scenario)
328                            return;
329                    }
330                    continuousNodeArray.push(last);
331                }
332            }
333            return continuousNodeArray;
334        },
335
336        setOptionNodeSelectionState: function (optionNode, isSelected) {
337            // IE6 sometimes throws "unknown error" if you try to write to .selected directly, whereas Firefox struggles with setAttribute. Pick one based on browser.
338            if (ieVersion < 7)
339                optionNode.setAttribute("selected", isSelected);
340            else
341                optionNode.selected = isSelected;
342        },
343
344        stringTrim: function (string) {
345            return string === null || string === undefined ? '' :
346                string.trim ?
347                    string.trim() :
348                    string.toString().replace(/^[\s\xa0]+|[\s\xa0]+$/g, '');
349        },
350
351        stringStartsWith: function (string, startsWith) {
352            string = string || "";
353            if (startsWith.length > string.length)
354                return false;
355            return string.substring(0, startsWith.length) === startsWith;
356        },
357
358        domNodeIsContainedBy: function (node, containedByNode) {
359            if (node === containedByNode)
360                return true;
361            if (node.nodeType === 11)
362                return false; // Fixes issue #1162 - can't use node.contains for document fragments on IE8
363            if (containedByNode.contains)
364                return containedByNode.contains(node.nodeType === 3 ? node.parentNode : node);
365            if (containedByNode.compareDocumentPosition)
366                return (containedByNode.compareDocumentPosition(node) & 16) == 16;
367            while (node && node != containedByNode) {
368                node = node.parentNode;
369            }
370            return !!node;
371        },
372
373        domNodeIsAttachedToDocument: function (node) {
374            return ko.utils.domNodeIsContainedBy(node, node.ownerDocument.documentElement);
375        },
376
377        anyDomNodeIsAttachedToDocument: function(nodes) {
378            return !!ko.utils.arrayFirst(nodes, ko.utils.domNodeIsAttachedToDocument);
379        },
380
381        tagNameLower: function(element) {
382            // For HTML elements, tagName will always be upper case; for XHTML elements, it'll be lower case.
383            // Possible future optimization: If we know it's an element from an XHTML document (not HTML),
384            // we don't need to do the .toLowerCase() as it will always be lower case anyway.
385            return element && element.tagName && element.tagName.toLowerCase();
386        },
387
388        registerEventHandler: function (element, eventType, handler) {
389            var mustUseAttachEvent = ieVersion && eventsThatMustBeRegisteredUsingAttachEvent[eventType];
390            if (!mustUseAttachEvent && jQueryInstance) {
391                jQueryInstance(element)['bind'](eventType, handler);
392            } else if (!mustUseAttachEvent && typeof element.addEventListener == "function")
393                element.addEventListener(eventType, handler, false);
394            else if (typeof element.attachEvent != "undefined") {
395                var attachEventHandler = function (event) { handler.call(element, event); },
396                    attachEventName = "on" + eventType;
397                element.attachEvent(attachEventName, attachEventHandler);
398
399                // IE does not dispose attachEvent handlers automatically (unlike with addEventListener)
400                // so to avoid leaks, we have to remove them manually. See bug #856
401                ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
402                    element.detachEvent(attachEventName, attachEventHandler);
403                });
404            } else
405                throw new Error("Browser doesn't support addEventListener or attachEvent");
406        },
407
408        triggerEvent: function (element, eventType) {
409            if (!(element && element.nodeType))
410                throw new Error("element must be a DOM node when calling triggerEvent");
411
412            // For click events on checkboxes and radio buttons, jQuery toggles the element checked state *after* the
413            // event handler runs instead of *before*. (This was fixed in 1.9 for checkboxes but not for radio buttons.)
414            // IE doesn't change the checked state when you trigger the click event using "fireEvent".
415            // In both cases, we'll use the click method instead.
416            var useClickWorkaround = isClickOnCheckableElement(element, eventType);
417
418            if (jQueryInstance && !useClickWorkaround) {
419                jQueryInstance(element)['trigger'](eventType);
420            } else if (typeof document.createEvent == "function") {
421                if (typeof element.dispatchEvent == "function") {
422                    var eventCategory = knownEventTypesByEventName[eventType] || "HTMLEvents";
423                    var event = document.createEvent(eventCategory);
424                    event.initEvent(eventType, true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, element);
425                    element.dispatchEvent(event);
426                }
427                else
428                    throw new Error("The supplied element doesn't support dispatchEvent");
429            } else if (useClickWorkaround && element.click) {
430                element.click();
431            } else if (typeof element.fireEvent != "undefined") {
432                element.fireEvent("on" + eventType);
433            } else {
434                throw new Error("Browser doesn't support triggering events");
435            }
436        },
437
438        unwrapObservable: function (value) {
439            return ko.isObservable(value) ? value() : value;
440        },
441
442        peekObservable: function (value) {
443            return ko.isObservable(value) ? value.peek() : value;
444        },
445
446        toggleDomNodeCssClass: toggleDomNodeCssClass,
447
448        setTextContent: function(element, textContent) {
449            var value = ko.utils.unwrapObservable(textContent);
450            if ((value === null) || (value === undefined))
451                value = "";
452
453            // We need there to be exactly one child: a text node.
454            // If there are no children, more than one, or if it's not a text node,
455            // we'll clear everything and create a single text node.
456            var innerTextNode = ko.virtualElements.firstChild(element);
457            if (!innerTextNode || innerTextNode.nodeType != 3 || ko.virtualElements.nextSibling(innerTextNode)) {
458                ko.virtualElements.setDomNodeChildren(element, [element.ownerDocument.createTextNode(value)]);
459            } else {
460                innerTextNode.data = value;
461            }
462
463            ko.utils.forceRefresh(element);
464        },
465
466        setElementName: function(element, name) {
467            element.name = name;
468
469            // Workaround IE 6/7 issue
470            // - https://github.com/SteveSanderson/knockout/issues/197
471            // - http://www.matts411.com/post/setting_the_name_attribute_in_ie_dom/
472            if (ieVersion <= 7) {
473                try {
474                    element.mergeAttributes(document.createElement("<input name='" + element.name + "'/>"), false);
475                }
476                catch(e) {} // For IE9 with doc mode "IE9 Standards" and browser mode "IE9 Compatibility View"
477            }
478        },
479
480        forceRefresh: function(node) {
481            // Workaround for an IE9 rendering bug - https://github.com/SteveSanderson/knockout/issues/209
482            if (ieVersion >= 9) {
483                // For text nodes and comment nodes (most likely virtual elements), we will have to refresh the container
484                var elem = node.nodeType == 1 ? node : node.parentNode;
485                if (elem.style)
486                    elem.style.zoom = elem.style.zoom;
487            }
488        },
489
490        ensureSelectElementIsRenderedCorrectly: function(selectElement) {
491            // 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.
492            // (See https://github.com/SteveSanderson/knockout/issues/312, http://stackoverflow.com/questions/5908494/select-only-shows-first-char-of-selected-option)
493            // Also fixes IE7 and IE8 bug that causes selects to be zero width if enclosed by 'if' or 'with'. (See issue #839)
494            if (ieVersion) {
495                var originalWidth = selectElement.style.width;
496                selectElement.style.width = 0;
497                selectElement.style.width = originalWidth;
498            }
499        },
500
501        range: function (min, max) {
502            min = ko.utils.unwrapObservable(min);
503            max = ko.utils.unwrapObservable(max);
504            var result = [];
505            for (var i = min; i <= max; i++)
506                result.push(i);
507            return result;
508        },
509
510        makeArray: function(arrayLikeObject) {
511            var result = [];
512            for (var i = 0, j = arrayLikeObject.length; i < j; i++) {
513                result.push(arrayLikeObject[i]);
514            };
515            return result;
516        },
517
518        isIe6 : isIe6,
519        isIe7 : isIe7,
520        ieVersion : ieVersion,
521
522        getFormFields: function(form, fieldName) {
523            var fields = ko.utils.makeArray(form.getElementsByTagName("input")).concat(ko.utils.makeArray(form.getElementsByTagName("textarea")));
524            var isMatchingField = (typeof fieldName == 'string')
525                ? function(field) { return field.name === fieldName }
526                : function(field) { return fieldName.test(field.name) }; // Treat fieldName as regex or object containing predicate
527            var matches = [];
528            for (var i = fields.length - 1; i >= 0; i--) {
529                if (isMatchingField(fields[i]))
530                    matches.push(fields[i]);
531            };
532            return matches;
533        },
534
535        parseJson: function (jsonString) {
536            if (typeof jsonString == "string") {
537                jsonString = ko.utils.stringTrim(jsonString);
538                if (jsonString) {
539                    if (JSON && JSON.parse) // Use native parsing where available
540                        return JSON.parse(jsonString);
541                    return (new Function("return " + jsonString))(); // Fallback on less safe parsing for older browsers
542                }
543            }
544            return null;
545        },
546
547        stringifyJson: function (data, replacer, space) {   // replacer and space are optional
548            if (!JSON || !JSON.stringify)
549                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");
550            return JSON.stringify(ko.utils.unwrapObservable(data), replacer, space);
551        },
552
553        postJson: function (urlOrForm, data, options) {
554            options = options || {};
555            var params = options['params'] || {};
556            var includeFields = options['includeFields'] || this.fieldsIncludedWithJsonPost;
557            var url = urlOrForm;
558
559            // If we were given a form, use its 'action' URL and pick out any requested field values
560            if((typeof urlOrForm == 'object') && (ko.utils.tagNameLower(urlOrForm) === "form")) {
561                var originalForm = urlOrForm;
562                url = originalForm.action;
563                for (var i = includeFields.length - 1; i >= 0; i--) {
564                    var fields = ko.utils.getFormFields(originalForm, includeFields[i]);
565                    for (var j = fields.length - 1; j >= 0; j--)
566                        params[fields[j].name] = fields[j].value;
567                }
568            }
569
570            data = ko.utils.unwrapObservable(data);
571            var form = document.createElement("form");
572            form.style.display = "none";
573            form.action = url;
574            form.method = "post";
575            for (var key in data) {
576                // Since 'data' this is a model object, we include all properties including those inherited from its prototype
577                var input = document.createElement("input");
578                input.type = "hidden";
579                input.name = key;
580                input.value = ko.utils.stringifyJson(ko.utils.unwrapObservable(data[key]));
581                form.appendChild(input);
582            }
583            objectForEach(params, function(key, value) {
584                var input = document.createElement("input");
585                input.type = "hidden";
586                input.name = key;
587                input.value = value;
588                form.appendChild(input);
589            });
590            document.body.appendChild(form);
591            options['submitter'] ? options['submitter'](form) : form.submit();
592            setTimeout(function () { form.parentNode.removeChild(form); }, 0);
593        }
594    }
595}());
596
597ko.exportSymbol('utils', ko.utils);
598ko.exportSymbol('utils.arrayForEach', ko.utils.arrayForEach);
599ko.exportSymbol('utils.arrayFirst', ko.utils.arrayFirst);
600ko.exportSymbol('utils.arrayFilter', ko.utils.arrayFilter);
601ko.exportSymbol('utils.arrayGetDistinctValues', ko.utils.arrayGetDistinctValues);
602ko.exportSymbol('utils.arrayIndexOf', ko.utils.arrayIndexOf);
603ko.exportSymbol('utils.arrayMap', ko.utils.arrayMap);
604ko.exportSymbol('utils.arrayPushAll', ko.utils.arrayPushAll);
605ko.exportSymbol('utils.arrayRemoveItem', ko.utils.arrayRemoveItem);
606ko.exportSymbol('utils.extend', ko.utils.extend);
607ko.exportSymbol('utils.fieldsIncludedWithJsonPost', ko.utils.fieldsIncludedWithJsonPost);
608ko.exportSymbol('utils.getFormFields', ko.utils.getFormFields);
609ko.exportSymbol('utils.peekObservable', ko.utils.peekObservable);
610ko.exportSymbol('utils.postJson', ko.utils.postJson);
611ko.exportSymbol('utils.parseJson', ko.utils.parseJson);
612ko.exportSymbol('utils.registerEventHandler', ko.utils.registerEventHandler);
613ko.exportSymbol('utils.stringifyJson', ko.utils.stringifyJson);
614ko.exportSymbol('utils.range', ko.utils.range);
615ko.exportSymbol('utils.toggleDomNodeCssClass', ko.utils.toggleDomNodeCssClass);
616ko.exportSymbol('utils.triggerEvent', ko.utils.triggerEvent);
617ko.exportSymbol('utils.unwrapObservable', ko.utils.unwrapObservable);
618ko.exportSymbol('utils.objectForEach', ko.utils.objectForEach);
619ko.exportSymbol('utils.addOrRemoveItem', ko.utils.addOrRemoveItem);
620ko.exportSymbol('utils.setTextContent', ko.utils.setTextContent);
621ko.exportSymbol('unwrap', ko.utils.unwrapObservable); // Convenient shorthand, because this is used so commonly
622
623if (!Function.prototype['bind']) {
624    // 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)
625    // In case the browser doesn't implement it natively, provide a JavaScript implementation. This implementation is based on the one in prototype.js
626    Function.prototype['bind'] = function (object) {
627        var originalFunction = this;
628        if (arguments.length === 1) {
629            return function () {
630                return originalFunction.apply(object, arguments);
631            };
632        } else {
633            var partialArgs = Array.prototype.slice.call(arguments, 1);
634            return function () {
635                var args = partialArgs.slice(0);
636                args.push.apply(args, arguments);
637                return originalFunction.apply(object, args);
638            };
639        }
640    };
641}
642
643ko.utils.domData = new (function () {
644    var uniqueId = 0;
645    var dataStoreKeyExpandoPropertyName = "__ko__" + (new Date).getTime();
646    var dataStore = {};
647
648    function getAll(node, createIfNotFound) {
649        var dataStoreKey = node[dataStoreKeyExpandoPropertyName];
650        var hasExistingDataStore = dataStoreKey && (dataStoreKey !== "null") && dataStore[dataStoreKey];
651        if (!hasExistingDataStore) {
652            if (!createIfNotFound)
653                return undefined;
654            dataStoreKey = node[dataStoreKeyExpandoPropertyName] = "ko" + uniqueId++;
655            dataStore[dataStoreKey] = {};
656        }
657        return dataStore[dataStoreKey];
658    }
659
660    return {
661        get: function (node, key) {
662            var allDataForNode = getAll(node, false);
663            return allDataForNode === undefined ? undefined : allDataForNode[key];
664        },
665        set: function (node, key, value) {
666            if (value === undefined) {
667                // Make sure we don't actually create a new domData key if we are actually deleting a value
668                if (getAll(node, false) === undefined)
669                    return;
670            }
671            var allDataForNode = getAll(node, true);
672            allDataForNode[key] = value;
673        },
674        clear: function (node) {
675            var dataStoreKey = node[dataStoreKeyExpandoPropertyName];
676            if (dataStoreKey) {
677                delete dataStore[dataStoreKey];
678                node[dataStoreKeyExpandoPropertyName] = null;
679                return true; // Exposing "did clean" flag purely so specs can infer whether things have been cleaned up as intended
680            }
681            return false;
682        },
683
684        nextKey: function () {
685            return (uniqueId++) + dataStoreKeyExpandoPropertyName;
686        }
687    };
688})();
689
690ko.exportSymbol('utils.domData', ko.utils.domData);
691ko.exportSymbol('utils.domData.clear', ko.utils.domData.clear); // Exporting only so specs can clear up after themselves fully
692
693ko.utils.domNodeDisposal = new (function () {
694    var domDataKey = ko.utils.domData.nextKey();
695    var cleanableNodeTypes = { 1: true, 8: true, 9: true };       // Element, Comment, Document
696    var cleanableNodeTypesWithDescendants = { 1: true, 9: true }; // Element, Document
697
698    function getDisposeCallbacksCollection(node, createIfNotFound) {
699        var allDisposeCallbacks = ko.utils.domData.get(node, domDataKey);
700        if ((allDisposeCallbacks === undefined) && createIfNotFound) {
701            allDisposeCallbacks = [];
702            ko.utils.domData.set(node, domDataKey, allDisposeCallbacks);
703        }
704        return allDisposeCallbacks;
705    }
706    function destroyCallbacksCollection(node) {
707        ko.utils.domData.set(node, domDataKey, undefined);
708    }
709
710    function cleanSingleNode(node) {
711        // Run all the dispose callbacks
712        var callbacks = getDisposeCallbacksCollection(node, false);
713        if (callbacks) {
714            callbacks = callbacks.slice(0); // Clone, as the array may be modified during iteration (typically, callbacks will remove themselves)
715            for (var i = 0; i < callbacks.length; i++)
716                callbacks[i](node);
717        }
718
719        // Erase the DOM data
720        ko.utils.domData.clear(node);
721
722        // Perform cleanup needed by external libraries (currently only jQuery, but can be extended)
723        ko.utils.domNodeDisposal["cleanExternalData"](node);
724
725        // Clear any immediate-child comment nodes, as these wouldn't have been found by
726        // node.getElementsByTagName("*") in cleanNode() (comment nodes aren't elements)
727        if (cleanableNodeTypesWithDescendants[node.nodeType])
728            cleanImmediateCommentTypeChildren(node);
729    }
730
731    function cleanImmediateCommentTypeChildren(nodeWithChildren) {
732        var child, nextChild = nodeWithChildren.firstChild;
733        while (child = nextChild) {
734            nextChild = child.nextSibling;
735            if (child.nodeType === 8)
736                cleanSingleNode(child);
737        }
738    }
739
740    return {
741        addDisposeCallback : function(node, callback) {
742            if (typeof callback != "function")
743                throw new Error("Callback must be a function");
744            getDisposeCallbacksCollection(node, true).push(callback);
745        },
746
747        removeDisposeCallback : function(node, callback) {
748            var callbacksCollection = getDisposeCallbacksCollection(node, false);
749            if (callbacksCollection) {
750                ko.utils.arrayRemoveItem(callbacksCollection, callback);
751                if (callbacksCollection.length == 0)
752                    destroyCallbacksCollection(node);
753            }
754        },
755
756        cleanNode : function(node) {
757            // First clean this node, where applicable
758            if (cleanableNodeTypes[node.nodeType]) {
759                cleanSingleNode(node);
760
761                // ... then its descendants, where applicable
762                if (cleanableNodeTypesWithDescendants[node.nodeType]) {
763                    // Clone the descendants list in case it changes during iteration
764                    var descendants = [];
765                    ko.utils.arrayPushAll(descendants, node.getElementsByTagName("*"));
766                    for (var i = 0, j = descendants.length; i < j; i++)
767                        cleanSingleNode(descendants[i]);
768                }
769            }
770            return node;
771        },
772
773        removeNode : function(node) {
774            ko.cleanNode(node);
775            if (node.parentNode)
776                node.parentNode.removeChild(node);
777        },
778
779        "cleanExternalData" : function (node) {
780            // Special support for jQuery here because it's so commonly used.
781            // Many jQuery plugins (including jquery.tmpl) store data using jQuery's equivalent of domData
782            // so notify it to tear down any resources associated with the node & descendants here.
783            if (jQueryInstance && (typeof jQueryInstance['cleanData'] == "function"))
784                jQueryInstance['cleanData']([node]);
785        }
786    };
787})();
788ko.cleanNode = ko.utils.domNodeDisposal.cleanNode; // Shorthand name for convenience
789ko.removeNode = ko.utils.domNodeDisposal.removeNode; // Shorthand name for convenience
790ko.exportSymbol('cleanNode', ko.cleanNode);
791ko.exportSymbol('removeNode', ko.removeNode);
792ko.exportSymbol('utils.domNodeDisposal', ko.utils.domNodeDisposal);
793ko.exportSymbol('utils.domNodeDisposal.addDisposeCallback', ko.utils.domNodeDisposal.addDisposeCallback);
794ko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeDisposal.removeDisposeCallback);
795(function () {
796    var leadingCommentRegex = /^(\s*)<!--(.*?)-->/;
797
798    function simpleHtmlParse(html, documentContext) {
799        documentContext || (documentContext = document);
800        var windowContext = documentContext['parentWindow'] || documentContext['defaultView'] || window;
801
802        // Based on jQuery's "clean" function, but only accounting for table-related elements.
803        // If you have referenced jQuery, this won't be used anyway - KO will use jQuery's "clean" function directly
804
805        // Note that there's still an issue in IE < 9 whereby it will discard comment nodes that are the first child of
806        // a descendant node. For example: "<div><!-- mycomment -->abc</div>" will get parsed as "<div>abc</div>"
807        // This won't affect anyone who has referenced jQuery, and there's always the workaround of inserting a dummy node
808        // (possibly a text node) in front of the comment. So, KO does not attempt to workaround this IE issue automatically at present.
809
810        // Trim whitespace, otherwise indexOf won't work as expected
811        var tags = ko.utils.stringTrim(html).toLowerCase(), div = documentContext.createElement("div");
812
813        // Finds the first match from the left column, and returns the corresponding "wrap" data from the right column
814        var wrap = tags.match(/^<(thead|tbody|tfoot)/)              && [1, "<table>", "</table>"] ||
815                   !tags.indexOf("<tr")                             && [2, "<table><tbody>", "</tbody></table>"] ||
816                   (!tags.indexOf("<td") || !tags.indexOf("<th"))   && [3, "<table><tbody><tr>", "</tr></tbody></table>"] ||
817                   /* anything else */                                 [0, "", ""];
818
819        // Go to html and back, then peel off extra wrappers
820        // Note that we always prefix with some dummy text, because otherwise, IE<9 will strip out leading comment nodes in descendants. Total madness.
821        var markup = "ignored<div>" + wrap[1] + html + wrap[2] + "</div>";
822        if (typeof windowContext['innerShiv'] == "function") {
823            div.appendChild(windowContext['innerShiv'](markup));
824        } else {
825            div.innerHTML = markup;
826        }
827
828        // Move to the right depth
829        while (wrap[0]--)
830            div = div.lastChild;
831
832        return ko.utils.makeArray(div.lastChild.childNodes);
833    }
834
835    function jQueryHtmlParse(html, documentContext) {
836        // jQuery's "parseHTML" function was introduced in jQuery 1.8.0 and is a documented public API.
837        if (jQueryInstance['parseHTML']) {
838            return jQueryInstance['parseHTML'](html, documentContext) || []; // Ensure we always return an array and never null
839        } else {
840            // For jQuery < 1.8.0, we fall back on the undocumented internal "clean" function.
841            var elems = jQueryInstance['clean']([html], documentContext);
842
843            // 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.
844            // Unfortunately, it never clears the dummy parent nodes from the document fragment, so it leaks memory over time.
845            // Fix this by finding the top-most dummy parent element, and detaching it from its owner fragment.
846            if (elems && elems[0]) {
847                // Find the top-most parent element that's a direct child of a document fragment
848                var elem = elems[0];
849                while (elem.parentNode && elem.parentNode.nodeType !== 11 /* i.e., DocumentFragment */)
850                    elem = elem.parentNode;
851                // ... then detach it
852                if (elem.parentNode)
853                    elem.parentNode.removeChild(elem);
854            }
855
856            return elems;
857        }
858    }
859
860    ko.utils.parseHtmlFragment = function(html, documentContext) {
861        return jQueryInstance ? jQueryHtmlParse(html, documentContext)   // As below, benefit from jQuery's optimisations where possible
862                              : simpleHtmlParse(html, documentContext);  // ... otherwise, this simple logic will do in most common cases.
863    };
864
865    ko.utils.setHtml = function(node, html) {
866        ko.utils.emptyDomNode(node);
867
868        // There's no legitimate reason to display a stringified observable without unwrapping it, so we'll unwrap it
869        html = ko.utils.unwrapObservable(html);
870
871        if ((html !== null) && (html !== undefined)) {
872            if (typeof html != 'string')
873                html = html.toString();
874
875            // jQuery contains a lot of sophisticated code to parse arbitrary HTML fragments,
876            // for example <tr> elements which are not normally allowed to exist on their own.
877            // If you've referenced jQuery we'll use that rather than duplicating its code.
878            if (jQueryInstance) {
879                jQueryInstance(node)['html'](html);
880            } else {
881                // ... otherwise, use KO's own parsing logic.
882                var parsedNodes = ko.utils.parseHtmlFragment(html, node.ownerDocument);
883                for (var i = 0; i < parsedNodes.length; i++)
884                    node.appendChild(parsedNodes[i]);
885            }
886        }
887    };
888})();
889
890ko.exportSymbol('utils.parseHtmlFragment', ko.utils.parseHtmlFragment);
891ko.exportSymbol('utils.setHtml', ko.utils.setHtml);
892
893ko.memoization = (function () {
894    var memos = {};
895
896    function randomMax8HexChars() {
897        return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);
898    }
899    function generateRandomId() {
900        return randomMax8HexChars() + randomMax8HexChars();
901    }
902    function findMemoNodes(rootNode, appendToArray) {
903        if (!rootNode)
904            return;
905        if (rootNode.nodeType == 8) {
906            var memoId = ko.memoization.parseMemoText(rootNode.nodeValue);
907            if (memoId != null)
908                appendToArray.push({ domNode: rootNode, memoId: memoId });
909        } else if (rootNode.nodeType == 1) {
910            for (var i = 0, childNodes = rootNode.childNodes, j = childNodes.length; i < j; i++)
911                findMemoNodes(childNodes[i], appendToArray);
912        }
913    }
914
915    return {
916        memoize: function (callback) {
917            if (typeof callback != "function")
918                throw new Error("You can only pass a function to ko.memoization.memoize()");
919            var memoId = generateRandomId();
920            memos[memoId] = callback;
921            return "<!--[ko_memo:" + memoId + "]-->";
922        },
923
924        unmemoize: function (memoId, callbackParams) {
925            var callback = memos[memoId];
926            if (callback === undefined)
927                throw new Error("Couldn't find any memo with ID " + memoId + ". Perhaps it's already been unmemoized.");
928            try {
929                callback.apply(null, callbackParams || []);
930                return true;
931            }
932            finally { delete memos[memoId]; }
933        },
934
935        unmemoizeDomNodeAndDescendants: function (domNode, extraCallbackParamsArray) {
936            var memos = [];
937            findMemoNodes(domNode, memos);
938            for (var i = 0, j = memos.length; i < j; i++) {
939                var node = memos[i].domNode;
940                var combinedParams = [node];
941                if (extraCallbackParamsArray)
942                    ko.utils.arrayPushAll(combinedParams, extraCallbackParamsArray);
943                ko.memoization.unmemoize(memos[i].memoId, combinedParams);
944                node.nodeValue = ""; // Neuter this node so we don't try to unmemoize it again
945                if (node.parentNode)
946                    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)
947            }
948        },
949
950        parseMemoText: function (memoText) {
951            var match = memoText.match(/^\[ko_memo\:(.*?)\]$/);
952            return match ? match[1] : null;
953        }
954    };
955})();
956
957ko.exportSymbol('memoization', ko.memoization);
958ko.exportSymbol('memoization.memoize', ko.memoization.memoize);
959ko.exportSymbol('memoization.unmemoize', ko.memoization.unmemoize);
960ko.exportSymbol('memoization.parseMemoText', ko.memoization.parseMemoText);
961ko.exportSymbol('memoization.unmemoizeDomNodeAndDescendants', ko.memoization.unmemoizeDomNodeAndDescendants);
962ko.extenders = {
963    'throttle': function(target, timeout) {
964        // Throttling means two things:
965
966        // (1) For dependent observables, we throttle *evaluations* so that, no matter how fast its dependencies
967        //     notify updates, the target doesn't re-evaluate (and hence doesn't notify) faster than a certain rate
968        target['throttleEvaluation'] = timeout;
969
970        // (2) For writable targets (observables, or writable dependent observables), we throttle *writes*
971        //     so the target cannot change value synchronously or faster than a certain rate
972        var writeTimeoutInstance = null;
973        return ko.dependentObservable({
974            'read': target,
975            'write': function(value) {
976                clearTimeout(writeTimeoutInstance);
977                writeTimeoutInstance = setTimeout(function() {
978                    target(value);
979                }, timeout);
980            }
981        });
982    },
983
984    'rateLimit': function(target, options) {
985        var timeout, method, limitFunction;
986
987        if (typeof options == 'number') {
988            timeout = options;
989        } else {
990            timeout = options['timeout'];
991            method = options['method'];
992        }
993
994        limitFunction = method == 'notifyWhenChangesStop' ?  debounce : throttle;
995        target.limit(function(callback) {
996            return limitFunction(callback, timeout);
997        });
998    },
999
1000    'notify': function(target, notifyWhen) {
1001        target["equalityComparer"] = notifyWhen == "always" ?
1002            null :  // null equalityComparer means to always notify
1003            valuesArePrimitiveAndEqual;
1004    }
1005};
1006
1007var primitiveTypes = { 'undefined':1, 'boolean':1, 'number':1, 'string':1 };
1008function valuesArePrimitiveAndEqual(a, b) {
1009    var oldValueIsPrimitive = (a === null) || (typeof(a) in primitiveTypes);
1010    return oldValueIsPrimitive ? (a === b) : false;
1011}
1012
1013function throttle(callback, timeout) {
1014    var timeoutInstance;
1015    return function () {
1016        if (!timeoutInstance) {
1017            timeoutInstance = setTimeout(function() {
1018                timeoutInstance = undefined;
1019                callback();
1020            }, timeout);
1021        }
1022    };
1023}
1024
1025function debounce(callback, timeout) {
1026    var timeoutInstance;
1027    return function () {
1028        clearTimeout(timeoutInstance);
1029        timeoutInstance = setTimeout(callback, timeout);
1030    };
1031}
1032
1033function applyExtenders(requestedExtenders) {
1034    var target = this;
1035    if (requestedExtenders) {
1036        ko.utils.objectForEach(requestedExtenders, function(key, value) {
1037            var extenderHandler = ko.extenders[key];
1038            if (typeof extenderHandler == 'function') {
1039                target = extenderHandler(target, value) || target;
1040            }
1041        });
1042    }
1043    return target;
1044}
1045
1046ko.exportSymbol('extenders', ko.extenders);
1047
1048ko.subscription = function (target, callback, disposeCallback) {
1049    this._target = target;
1050    this.callback = callback;

1355    ko.utils.setPrototypeOfOrExtend(result, ko.observableArray['fn']);
1356    return result.extend({'trackArrayChanges':true});
1357};
1358
1359ko.observableArray['fn'] = {
1360    'remove': function (valueOrPredicate) {
1361        var underlyingArray = this.peek();
1362        var removedValues = [];
1363        var predicate = typeof valueOrPredicate == "function" && !ko.isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate; };
1364        for (var i = 0; i < underlyingArray.length; i++) {
1365            var value = underlyingArray[i];
1366            if (predicate(value)) {
1367                if (removedValues.length === 0) {
1368                    this.valueWillMutate();
1369                }
1370                removedValues.push(value);
1371                underlyingArray.splice(i, 1);
1372                i--;
1373            }
1374        }
1375        if (removedValues.length) {
1376            this.valueHasMutated();
1377        }
1378        return removedValues;
1379    },
1380
1381    'removeAll': function (arrayOfValues) {
1382        // If you passed zero args, we remove everything
1383        if (arrayOfValues === undefined) {
1384            var underlyingArray = this.peek();
1385            var allValues = underlyingArray.slice(0);
1386            this.valueWillMutate();
1387            underlyingArray.splice(0, underlyingArray.length);
1388            this.valueHasMutated();
1389            return allValues;
1390        }
1391        // If you passed an arg, we interpret it as an array of entries to remove
1392        if (!arrayOfValues)
1393            return [];
1394        return this['remove'](function (value) {
1395            return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0;
1396        });
1397    },
1398
1399    'destroy': function (valueOrPredicate) {
1400        var underlyingArray = this.peek();
1401        var predicate = typeof valueOrPredicate == "function" && !ko.isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate; };
1402        this.valueWillMutate();
1403        for (var i = underlyingArray.length - 1; i >= 0; i--) {
1404            var value = underlyingArray[i];
1405            if (predicate(value))
1406                underlyingArray[i]["_destroy"] = true;
1407        }
1408        this.valueHasMutated();
1409    },
1410
1411    'destroyAll': function (arrayOfValues) {
1412        // If you passed zero args, we destroy everything
1413        if (arrayOfValues === undefined)
1414            return this['destroy'](function() { return true });
1415
1416        // If you passed an arg, we interpret it as an array of entries to destroy
1417        if (!arrayOfValues)
1418            return [];
1419        return this['destroy'](function (value) {
1420            return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0;
1421        });
1422    },
1423
1424    'indexOf': function (item) {
1425        var underlyingArray = this();
1426        return ko.utils.arrayIndexOf(underlyingArray, item);
1427    },
1428
1429    'replace': function(oldItem, newItem) {
1430        var index = this['indexOf'](oldItem);
1431        if (index >= 0) {
1432            this.valueWillMutate();
1433            this.peek()[index] = newItem;
1434            this.valueHasMutated();
1435        }
1436    }
1437};
1438
1439// Populate ko.observableArray.fn with read/write functions from native arrays
1440// Important: Do not add any additional functions here that may reasonably be used to *read* data from the array
1441// because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale
1442ko.utils.arrayForEach(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function (methodName) {
1443    ko.observableArray['fn'][methodName] = function () {
1444        // Use "peek" to avoid creating a subscription in any computed that we're executing in the context of
1445        // (for consistency with mutating regular observables)
1446        var underlyingArray = this.peek();
1447        this.valueWillMutate();
1448        this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
1449        var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
1450        this.valueHasMutated();
1451        return methodCallResult;
1452    };
1453});
1454
1455// Populate ko.observableArray.fn with read-only functions from native arrays
1456ko.utils.arrayForEach(["slice"], function (methodName) {
1457    ko.observableArray['fn'][methodName] = function () {
1458        var underlyingArray = this();
1459        return underlyingArray[methodName].apply(underlyingArray, arguments);
1460    };
1461});
1462
1463// Note that for browsers that don't support proto assignment, the
1464// inheritance chain is created manually in the ko.observableArray constructor
1465if (ko.utils.canSetPrototype) {
1466    ko.utils.setPrototypeOf(ko.observableArray['fn'], ko.observable['fn']);
1467}
1468
1469ko.exportSymbol('observableArray', ko.observableArray);
1470var arrayChangeEventName = 'arrayChange';
1471ko.extenders['trackArrayChanges'] = function(target) {
1472    // Only modify the target observable once
1473    if (target.cacheDiffForKnownOperation) {
1474        return;
1475    }
1476    var trackingChanges = false,
1477        cachedDiff = null,
1478        arrayChangeSubscription,
1479        pendingNotifications = 0,
1480        underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd,
1481        underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
1482
1483    // Watch "subscribe" calls, and for array change events, ensure change tracking is enabled
1484    target.beforeSubscriptionAdd = function (event) {
1485        if (underlyingBeforeSubscriptionAddFunction)
1486            underlyingBeforeSubscriptionAddFunction.call(target, event);
1487        if (event === arrayChangeEventName) {
1488            trackChanges();
1489        }
1490    };
1491    // Watch "dispose" calls, and for array change events, ensure change tracking is disabled 

1889                            _target: dependency._target,
1890                            _order: dependency._order,
1891                            _version: dependency._version
1892                        };
1893                        dependency.dispose();
1894                    }
1895                });
1896                isSleeping = true;
1897                notify(undefined, "asleep");
1898            }
1899        };
1900
1901        // Because a pure computed is not automatically updated while it is sleeping, we can't
1902        // simply return the version number. Instead, we check if any of the dependencies have
1903        // changed and conditionally re-evaluate the computed observable.
1904        dependentObservable._originalGetVersion = dependentObservable.getVersion;
1905        dependentObservable.getVersion = function () {
1906            if (isSleeping && (_needsEvaluation || haveDependenciesChanged())) {
1907                evaluateImmediate();
1908            }
1909            return dependentObservable._originalGetVersion();
1910        };
1911    } else if (options['deferEvaluation']) {
1912        // This will force a computed with deferEvaluation to evaluate when the first subscriptions is registered.
1913        dependentObservable.beforeSubscriptionAdd = function (event) {
1914            if (event == 'change' || event == 'beforeChange') {
1915                peek();
1916            }
1917        }
1918    }
1919
1920    ko.exportProperty(dependentObservable, 'peek', dependentObservable.peek);
1921    ko.exportProperty(dependentObservable, 'dispose', dependentObservable.dispose);
1922    ko.exportProperty(dependentObservable, 'isActive', dependentObservable.isActive);
1923    ko.exportProperty(dependentObservable, 'getDependenciesCount', dependentObservable.getDependenciesCount);
1924
1925    // Add a "disposeWhen" callback that, on each evaluation, disposes if the node was removed without using ko.removeNode.
1926    if (disposeWhenNodeIsRemoved) {
1927        // Since this computed is associated with a DOM node, and we don't want to dispose the computed
1928        // until the DOM node is *removed* from the document (as opposed to never having been in the document),
1929        // we'll prevent disposal until "disposeWhen" first returns false.
1930        _suppressDisposalUntilDisposeWhenReturnsFalse = true;
1931
1932        // Only watch for the node's disposal if the value really is a node. It might not be,
1933        // e.g., { disposeWhenNodeIsRemoved: true } can be used to opt into the "only dispose
1934        // after first false result" behaviour even if there's no specific node to watch. This
1935        // technique is intended for KO's internal use only and shouldn't be documented or used
1936        // by application code, as it's likely to change in a future version of KO.
1937        if (disposeWhenNodeIsRemoved.nodeType) {
1938            disposeWhen = function () {
1939                return !ko.utils.domNodeIsAttachedToDocument(disposeWhenNodeIsRemoved) || (disposeWhenOption && disposeWhenOption());
1940            };
1941        }
1942    }
1943
1944    // Evaluate, unless sleeping or deferEvaluation is true
1945    if (!isSleeping && !options['deferEvaluation'])
1946        evaluateImmediate();
1947
1948    // Attach a DOM node disposal callback so that the computed will be proactively disposed as soon as the node is
1949    // removed using ko.removeNode. But skip if isActive is false (there will never be any dependencies to dispose).
1950    if (disposeWhenNodeIsRemoved && isActive() && disposeWhenNodeIsRemoved.nodeType) {
1951        dispose = function() {
1952            ko.utils.domNodeDisposal.removeDisposeCallback(disposeWhenNodeIsRemoved, dispose);
1953            disposeComputed();
1954        };
1955        ko.utils.domNodeDisposal.addDisposeCallback(disposeWhenNodeIsRemoved, dispose);
1956    }
1957
1958    return dependentObservable;
1959};
1960
1961ko.isComputed = function(instance) {
1962    return ko.hasPrototype(instance, ko.dependentObservable);
1963};
1964
1965var protoProp = ko.observable.protoProperty; // == "__ko_proto__"
1966ko.dependentObservable[protoProp] = ko.observable;
1967
1968ko.dependentObservable['fn'] = {
1969    "equalityComparer": valuesArePrimitiveAndEqual
1970};
1971ko.dependentObservable['fn'][protoProp] = ko.dependentObservable;
1972
1973// Note that for browsers that don't support proto assignment, the
1974// inheritance chain is created manually in the ko.dependentObservable constructor
1975if (ko.utils.canSetPrototype) {
1976    ko.utils.setPrototypeOf(ko.dependentObservable['fn'], ko.subscribable['fn']);
1977}
1978
1979ko.exportSymbol('dependentObservable', ko.dependentObservable);
1980ko.exportSymbol('computed', ko.dependentObservable); // Make "ko.computed" an alias for "ko.dependentObservable"
1981ko.exportSymbol('isComputed', ko.isComputed);
1982
1983ko.pureComputed = function (evaluatorFunctionOrOptions, evaluatorFunctionTarget) {
1984    if (typeof evaluatorFunctionOrOptions === 'function') {
1985        return ko.computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, {'pure':true});
1986    } else {
1987        evaluatorFunctionOrOptions = ko.utils.extend({}, evaluatorFunctionOrOptions);   // make a copy of the parameter object
1988        evaluatorFunctionOrOptions['pure'] = true;
1989        return ko.computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget);
1990    }
1991}
1992ko.exportSymbol('pureComputed', ko.pureComputed);
1993
1994(function() {
1995    var maxNestedObservableDepth = 10; // Escape the (unlikely) pathalogical case where an observable's current value is itself (or similar reference cycle)
1996
1997    ko.toJS = function(rootObject) {
1998        if (arguments.length == 0)
1999            throw new Error("When calling ko.toJS, pass the object you want to convert.");
2000
2001        // We just unwrap everything at every level in the object graph
2002        return mapJsObjectGraph(rootObject, function(valueToMap) {
2003            // Loop because an observable's value might in turn be another observable wrapper
2004            for (var i = 0; ko.isObservable(valueToMap) && (i < maxNestedObservableDepth); i++)
2005                valueToMap = valueToMap();
2006            return valueToMap;
2007        });
2008    };
2009
2010    ko.toJSON = function(rootObject, replacer, space) {     // replacer and space are optional
2011        var plainJavaScriptObject = ko.toJS(rootObject);
2012        return ko.utils.stringifyJson(plainJavaScriptObject, replacer, space);
2013    };
2014
2015    function mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects) {
2016        visitedObjects = visitedObjects || new objectLookup();
2017
2018        rootObject = mapInputCallback(rootObject);
2019        var canHaveProperties = (typeof rootObject == "object") && (rootObject !== null) && (rootObject !== undefined) && (!(rootObject instanceof Date)) && (!(rootObject instanceof String)) && (!(rootObject instanceof Number)) && (!(rootObject instanceof Boolean));
2020        if (!canHaveProperties)
2021            return rootObject;
2022
2023        var outputProperties = rootObject instanceof Array ? [] : {};
2024        visitedObjects.save(rootObject, outputProperties);
2025
2026        visitPropertiesOrArrayEntries(rootObject, function(indexer) {
2027            var propertyValue = mapInputCallback(rootObject[indexer]);
2028
2029            switch (typeof propertyValue) {
2030                case "boolean":
2031                case "number":
2032                case "string":
2033                case "function":
2034                    outputProperties[indexer] = propertyValue;
2035                    break;
2036                case "object":
2037                case "undefined":
2038                    var previouslyMappedValue = visitedObjects.get(propertyValue);
2039                    outputProperties[indexer] = (previouslyMappedValue !== undefined)
2040                        ? previouslyMappedValue
2041                        : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects);
2042                    break;
2043            }
2044        });
2045
2046        return outputProperties;
2047    }
2048
2049    function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {
2050        if (rootObject instanceof Array) {
2051            for (var i = 0; i < rootObject.length; i++)
2052                visitorCallback(i);
2053
2054            // For arrays, also respect toJSON property for custom mappings (fixes #278)
2055            if (typeof rootObject['toJSON'] == 'function')
2056                visitorCallback('toJSON');
2057        } else {
2058            for (var propertyName in rootObject) {
2059                visitorCallback(propertyName);
2060            }
2061        }
2062    };
2063
2064    function objectLookup() {
2065        this.keys = [];
2066        this.values = [];
2067    };
2068
2069    objectLookup.prototype = {
2070        constructor: objectLookup,
2071        save: function(key, value) {
2072            var existingIndex = ko.utils.arrayIndexOf(this.keys, key);
2073            if (existingIndex >= 0)
2074                this.values[existingIndex] = value;
2075            else {
2076                this.keys.push(key);
2077                this.values.push(value);
2078            }
2079        },
2080        get: function(key) {
2081            var existingIndex = ko.utils.arrayIndexOf(this.keys, key);
2082            return (existingIndex >= 0) ? this.values[existingIndex] : undefined;
2083        }
2084    };
2085})();
2086
2087ko.exportSymbol('toJS', ko.toJS);
2088ko.exportSymbol('toJSON', ko.toJSON);
2089(function () {
2090    var hasDomDataExpandoProperty = '__ko__hasDomDataOptionValue__';
2091
2092    // Normally, SELECT elements and their OPTIONs can only take value of type 'string' (because the values
2093    // are stored on DOM attributes). ko.selectExtensions provides a way for SELECTs/OPTIONs to have values
2094    // that are arbitrary objects. This is very convenient when implementing things like cascading dropdowns.
2095    ko.selectExtensions = {
2096        readValue : function(element) {
2097            switch (ko.utils.tagNameLower(element)) {
2098                case 'option':
2099                    if (element[hasDomDataExpandoProperty] === true)
2100                        return ko.utils.domData.get(element, ko.bindingHandlers.options.optionValueDomDataKey);
2101                    return ko.utils.ieVersion <= 7
2102                        ? (element.getAttributeNode('value') && element.getAttributeNode('value').specified ? element.value : element.text)
2103                        : element.value;
2104                case 'select':
2105                    return element.selectedIndex >= 0 ? ko.selectExtensions.readValue(element.options[element.selectedIndex]) : undefined;
2106                default:
2107                    return element.value;
2108            }
2109        },
2110
2111        writeValue: function(element, value, allowUnset) {
2112            switch (ko.utils.tagNameLower(element)) {
2113                case 'option':
2114                    switch(typeof value) {
2115                        case "string":
2116                            ko.utils.domData.set(element, ko.bindingHandlers.options.optionValueDomDataKey, undefined);
2117                            if (hasDomDataExpandoProperty in element) { // IE <= 8 throws errors if you delete non-existent properties from a DOM node
2118                                delete element[hasDomDataExpandoProperty];
2119                            }
2120                            element.value = value;
2121                            break;
2122                        default:
2123                            // Store arbitrary object using DomData
2124                            ko.utils.domData.set(element, ko.bindingHandlers.options.optionValueDomDataKey, value);
2125                            element[hasDomDataExpandoProperty] = true;
2126
2127                            // Special treatment of numbers is just for backward compatibility. KO 1.2.1 wrote numerical values to element.value.
2128                            element.value = typeof value === "number" ? value : "";
2129                            break;
2130                    }
2131                    break;
2132                case 'select':
2133                    if (value === "" || value === null)       // A blank string or null value will select the caption
2134                        value = undefined;
2135                    var selection = -1;
2136                    for (var i = 0, n = element.options.length, optionValue; i < n; ++i) {
2137                        optionValue = ko.selectExtensions.readValue(element.options[i]);
2138                        // Include special check to handle selecting a caption with a blank string value
2139                        if (optionValue == value || (optionValue == "" && value === undefined)) {
2140                            selection = i;
2141                            break;
2142                        }
2143                    }
2144                    if (allowUnset || selection >= 0 || (value === undefined && element.size > 1)) {
2145                        element.selectedIndex = selection;
2146                    }
2147                    break;
2148                default:
2149                    if ((value === null) || (value === undefined))
2150                        value = "";
2151                    element.value = value;
2152                    break;
2153            }
2154        }
2155    };
2156})();
2157
2158ko.exportSymbol('selectExtensions', ko.selectExtensions);
2159ko.exportSymbol('selectExtensions.readValue', ko.selectExtensions.readValue);
2160ko.exportSymbol('selectExtensions.writeValue', ko.selectExtensions.writeValue);
2161ko.expressionRewriting = (function () {
2162    var javaScriptReservedWords = ["true", "false", "null", "undefined"];
2163
2164    // Matches something that can be assigned to--either an isolated identifier or something ending with a property accessor
2165    // This is designed to be simple and avoid false negatives, but could produce false positives (e.g., a+b.c).
2166    // This also will not properly handle nested brackets (e.g., obj1[obj2['prop']]; see #911).
2167    var javaScriptAssignmentTarget = /^(?:[$_a-z][$\w]*|(.+)(\.\s*[$_a-z][$\w]*|\[.+\]))$/i;
2168
2169    function getWriteableValue(expression) {
2170        if (ko.utils.arrayIndexOf(javaScriptReservedWords, expression) >= 0)
2171            return false;
2172        var match = expression.match(javaScriptAssignmentTarget);
2173        return match === null ? false : match[1] ? ('Object(' + match[1] + ')' + match[2]) : expression;
2174    }
2175
2176    // The following regular expressions will be used to split an object-literal string into tokens
2177
2178        // These two match strings, either with double quotes or single quotes
2179    var stringDouble = '"(?:[^"\\\\]|\\\\.)*"',
2180        stringSingle = "'(?:[^'\\\\]|\\\\.)*'",
2181        // Matches a regular expression (text enclosed by slashes), but will also match sets of divisions
2182        // as a regular expression (this is handled by the parsing loop below).
2183        stringRegexp = '/(?:[^/\\\\]|\\\\.)*/\w*',
2184        // These characters have special meaning to the parser and must not appear in the middle of a
2185        // token, except as part of a string.
2186        specials = ',"\'{}()/:[\\]',
2187        // Match text (at least two characters) that does not contain any of the above special characters,
2188        // although some of the special characters are allowed to start it (all but the colon and comma).
2189        // The text can contain spaces, but leading or trailing spaces are skipped.
2190        everyThingElse = '[^\\s:,/][^' + specials + ']*[^\\s' + specials + ']',
2191        // Match any non-space character not matched already. This will match colons and commas, since they're
2192        // not matched by "everyThingElse", but will also match any other single character that wasn't already
2193        // matched (for example: in "a: 1, b: 2", each of the non-space characters will be matched by oneNotSpace).
2194        oneNotSpace = '[^\\s]',
2195
2196        // Create the actual regular expression by or-ing the above strings. The order is important.
2197        bindingToken = RegExp(stringDouble + '|' + stringSingle + '|' + stringRegexp + '|' + everyThingElse + '|' + oneNotSpace, 'g'),
2198
2199        // Match end of previous token to determine whether a slash is a division or regex.
2200        divisionLookBehind = /[\])"'A-Za-z0-9_$]+$/,
2201        keywordRegexLookBehind = {'in':1,'return':1,'typeof':1};
2202
2203    function parseObjectLiteral(objectLiteralString) {
2204        // Trim leading and trailing spaces from the string
2205        var str = ko.utils.stringTrim(objectLiteralString);
2206
2207        // Trim braces '{' surrounding the whole object literal
2208        if (str.charCodeAt(0) === 123) str = str.slice(1, -1);
2209
2210        // Split into tokens
2211        var result = [], toks = str.match(bindingToken), key, values = [], depth = 0;
2212
2213        if (toks) {
2214            // Append a comma so that we don't need a separate code block to deal with the last item
2215            toks.push(',');
2216
2217            for (var i = 0, tok; tok = toks[i]; ++i) {
2218                var c = tok.charCodeAt(0);
2219                // A comma signals the end of a key/value pair if depth is zero
2220                if (c === 44) { // ","
2221                    if (depth <= 0) {
2222                        result.push((key && values.length) ? {key: key, value: values.join('')} : {'unknown': key || values.join('')});
2223                        key = depth = 0;
2224                        values = [];
2225                        continue;
2226                    }
2227                // Simply skip the colon that separates the name and value
2228                } else if (c === 58) { // ":"
2229                    if (!depth && !key && values.length === 1) {
2230                        key = values.pop();
2231                        continue;
2232                    }
2233                // A set of slashes is initially matched as a regular expression, but could be division
2234                } else if (c === 47 && i && tok.length > 1) {  // "/"
2235                    // Look at the end of the previous token to determine if the slash is actually division
2236                    var match = toks[i-1].match(divisionLookBehind);
2237                    if (match && !keywordRegexLookBehind[match[0]]) {
2238                        // The slash is actually a division punctuator; re-parse the remainder of the string (not including the slash)
2239                        str = str.substr(str.indexOf(tok) + 1);
2240                        toks = str.match(bindingToken);
2241                        toks.push(',');
2242                        i = -1;
2243                        // Continue with just the slash
2244                        tok = '/';
2245                    }
2246                // Increment depth for parentheses, braces, and brackets so that interior commas are ignored
2247                } else if (c === 40 || c === 123 || c === 91) { // '(', '{', '['
2248                    ++depth;
2249                } else if (c === 41 || c === 125 || c === 93) { // ')', '}', ']'
2250                    --depth;
2251                // The key will be the first token; if it's a string, trim the quotes
2252                } else if (!key && !values.length && (c === 34 || c === 39)) { // '"', "'"
2253                    tok = tok.slice(1, -1);
2254                }
2255                values.push(tok);
2256            }
2257        }
2258        return result;
2259    }
2260
2261    // Two-way bindings include a write function that allow the handler to update the value even if it's not an observable.
2262    var twoWayBindings = {};
2263
2264    function preProcessBindings(bindingsStringOrKeyValueArray, bindingOptions) {
2265        bindingOptions = bindingOptions || {};
2266
2267        function processKeyValue(key, val) {
2268            var writableVal;
2269            function callPreprocessHook(obj) {
2270                return (obj && obj['preprocess']) ? (val = obj['preprocess'](val, key, processKeyValue)) : true;
2271            }
2272            if (!bindingParams) {
2273                if (!callPreprocessHook(ko['getBindingHandler'](key)))
2274                    return;
2275
2276                if (twoWayBindings[key] && (writableVal = getWriteableValue(val))) {
2277                    // For two-way bindings, provide a write method in case the value
2278                    // isn't a writable observable.
2279                    propertyAccessorResultStrings.push("'" + key + "':function(_z){" + writableVal + "=_z}");
2280                }
2281            }
2282            // Values are wrapped in a function so that each value can be accessed independently
2283            if (makeValueAccessors) {
2284                val = 'function(){return ' + val + ' }';
2285            }
2286            resultStrings.push("'" + key + "':" + val);
2287        }
2288
2289        var resultStrings = [],
2290            propertyAccessorResultStrings = [],
2291            makeValueAccessors = bindingOptions['valueAccessors'],
2292            bindingParams = bindingOptions['bindingParams'],
2293            keyValueArray = typeof bindingsStringOrKeyValueArray === "string" ?
2294                parseObjectLiteral(bindingsStringOrKeyValueArray) : bindingsStringOrKeyValueArray;
2295
2296        ko.utils.arrayForEach(keyValueArray, function(keyValue) {
2297            processKeyValue(keyValue.key || keyValue['unknown'], keyValue.value);
2298        });
2299
2300        if (propertyAccessorResultStrings.length)
2301            processKeyValue('_ko_property_writers', "{" + propertyAccessorResultStrings.join(",") + " }");
2302
2303        return resultStrings.join(",");
2304    }
2305
2306    return {
2307        bindingRewriteValidators: [],
2308
2309        twoWayBindings: twoWayBindings,
2310
2311        parseObjectLiteral: parseObjectLiteral,
2312
2313        preProcessBindings: preProcessBindings,
2314
2315        keyValueArrayContainsKey: function(keyValueArray, key) {
2316            for (var i = 0; i < keyValueArray.length; i++)
2317                if (keyValueArray[i]['key'] == key)
2318                    return true;
2319            return false;
2320        },
2321
2322        // Internal, private KO utility for updating model properties from within bindings
2323        // property:            If the property being updated is (or might be) an observable, pass it here
2324        //                      If it turns out to be a writable observable, it will be written to directly
2325        // allBindings:         An object with a get method to retrieve bindings in the current execution context.
2326        //                      This will be searched for a '_ko_property_writers' property in case you're writing to a non-observable
2327        // key:                 The key identifying the property to be written. Example: for { hasFocus: myValue }, write to 'myValue' by specifying the key 'hasFocus'
2328        // value:               The value to be written
2329        // checkIfDifferent:    If true, and if the property being written is a writable observable, the value will only be written if
2330        //                      it is !== existing value on that writable observable
2331        writeValueToProperty: function(property, allBindings, key, value, checkIfDifferent) {
2332            if (!property || !ko.isObservable(property)) {
2333                var propWriters = allBindings.get('_ko_property_writers');
2334                if (propWriters && propWriters[key])
2335                    propWriters[key](value);
2336            } else if (ko.isWriteableObservable(property) && (!checkIfDifferent || property.peek() !== value)) {
2337                property(value);
2338            }
2339        }
2340    };
2341})();
2342
2343ko.exportSymbol('expressionRewriting', ko.expressionRewriting);
2344ko.exportSymbol('expressionRewriting.bindingRewriteValidators', ko.expressionRewriting.bindingRewriteValidators);
2345ko.exportSymbol('expressionRewriting.parseObjectLiteral', ko.expressionRewriting.parseObjectLiteral);
2346ko.exportSymbol('expressionRewriting.preProcessBindings', ko.expressionRewriting.preProcessBindings);
2347
2348// Making bindings explicitly declare themselves as "two way" isn't ideal in the long term (it would be better if
2349// all bindings could use an official 'property writer' API without needing to declare that they might). However,
2350// since this is not, and has never been, a public API (_ko_property_writers was never documented), it's acceptable
2351// as an internal implementation detail in the short term.
2352// For those developers who rely on _ko_property_writers in their custom bindings, we expose _twoWayBindings as an
2353// undocumented feature that makes it relatively easy to upgrade to KO 3.0. However, this is still not an official
2354// public API, and we reserve the right to remove it at any time if we create a real public property writers API.
2355ko.exportSymbol('expressionRewriting._twoWayBindings', ko.expressionRewriting.twoWayBindings);
2356
2357// For backward compatibility, define the following aliases. (Previously, these function names were misleading because
2358// they referred to JSON specifically, even though they actually work with arbitrary JavaScript object literal expressions.)
2359ko.exportSymbol('jsonExpressionRewriting', ko.expressionRewriting);
2360ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.expressionRewriting.preProcessBindings);
2361(function() {
2362    // "Virtual elements" is an abstraction on top of the usual DOM API which understands the notion that comment nodes
2363    // may be used to represent hierarchy (in addition to the DOM's natural hierarchy).
2364    // If you call the DOM-manipulating functions on ko.virtualElements, you will be able to read and write the state
2365    // of that virtual hierarchy
2366    //
2367    // The point of all this is to support containerless templates (e.g., <!-- ko foreach:someCollection -->blah<!-- /ko -->)
2368    // without having to scatter special cases all over the binding and templating code.
2369
2370    // IE 9 cannot reliably read the "nodeValue" property of a comment node (see https://github.com/SteveSanderson/knockout/issues/186)
2371    // but it does give them a nonstandard alternative property called "text" that it can read reliably. Other browsers don't have that property.
2372    // So, use node.text where available, and node.nodeValue elsewhere
2373    var commentNodesHaveTextProperty = document && document.createComment("test").text === "<!--test-->";
2374
2375    var startCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*ko(?:\s+([\s\S]+))?\s*-->$/ : /^\s*ko(?:\s+([\s\S]+))?\s*$/;
2376    var endCommentRegex =   commentNodesHaveTextProperty ? /^<!--\s*\/ko\s*-->$/ : /^\s*\/ko\s*$/;
2377    var htmlTagsWithOptionallyClosingChildren = { 'ul': true, 'ol': true };
2378
2379    function isStartComment(node) {
2380        return (node.nodeType == 8) && startCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
2381    }
2382
2383    function isEndComment(node) {
2384        return (node.nodeType == 8) && endCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
2385    }
2386
2387    function getVirtualChildren(startComment, allowUnbalanced) {
2388        var currentNode = startComment;
2389        var depth = 1;
2390        var children = [];
2391        while (currentNode = currentNode.nextSibling) {
2392            if (isEndComment(currentNode)) {
2393                depth--;
2394                if (depth === 0)
2395                    return children;
2396            }
2397
2398            children.push(currentNode);
2399
2400            if (isStartComment(currentNode))
2401                depth++;
2402        }
2403        if (!allowUnbalanced)
2404            throw new Error("Cannot find closing comment tag to match: " + startComment.nodeValue);
2405        return null;
2406    }
2407
2408    function getMatchingEndComment(startComment, allowUnbalanced) {
2409        var allVirtualChildren = getVirtualChildren(startComment, allowUnbalanced);
2410        if (allVirtualChildren) {
2411            if (allVirtualChildren.length > 0)
2412                return allVirtualChildren[allVirtualChildren.length - 1].nextSibling;
2413            return startComment.nextSibling;
2414        } else
2415            return null; // Must have no matching end comment, and allowUnbalanced is true
2416    }
2417
2418    function getUnbalancedChildTags(node) {
2419        // e.g., from <div>OK</div><!-- ko blah --><span>Another</span>, returns: <!-- ko blah --><span>Another</span>
2420        //       from <div>OK</div><!-- /ko --><!-- /ko -->,             returns: <!-- /ko --><!-- /ko -->
2421        var childNode = node.firstChild, captureRemaining = null;
2422        if (childNode) {
2423            do {
2424                if (captureRemaining)                   // We already hit an unbalanced node and are now just scooping up all subsequent nodes
2425                    captureRemaining.push(childNode);
2426                else if (isStartComment(childNode)) {
2427                    var matchingEndComment = getMatchingEndComment(childNode, /* allowUnbalanced: */ true);
2428                    if (matchingEndComment)             // It's a balanced tag, so skip immediately to the end of this virtual set
2429                        childNode = matchingEndComment;
2430                    else
2431                        captureRemaining = [childNode]; // It's unbalanced, so start capturing from this point
2432                } else if (isEndComment(childNode)) {
2433                    captureRemaining = [childNode];     // It's unbalanced (if it wasn't, we'd have skipped over it already), so start capturing
2434                }
2435            } while (childNode = childNode.nextSibling);
2436        }
2437        return captureRemaining;
2438    }
2439
2440    ko.virtualElements = {
2441        allowedBindings: {},
2442
2443        childNodes: function(node) {
2444            return isStartComment(node) ? getVirtualChildren(node) : node.childNodes;
2445        },
2446
2447        emptyNode: function(node) {
2448            if (!isStartComment(node))
2449                ko.utils.emptyDomNode(node);
2450            else {
2451                var virtualChildren = ko.virtualElements.childNodes(node);
2452                for (var i = 0, j = virtualChildren.length; i < j; i++)
2453                    ko.removeNode(virtualChildren[i]);
2454            }
2455        },
2456
2457        setDomNodeChildren: function(node, childNodes) {
2458            if (!isStartComment(node))
2459                ko.utils.setDomNodeChildren(node, childNodes);
2460            else {
2461                ko.virtualElements.emptyNode(node);
2462                var endCommentNode = node.nextSibling; // Must be the next sibling, as we just emptied the children
2463                for (var i = 0, j = childNodes.length; i < j; i++)
2464                    endCommentNode.parentNode.insertBefore(childNodes[i], endCommentNode);
2465            }
2466        },
2467
2468        prepend: function(containerNode, nodeToPrepend) {
2469            if (!isStartComment(containerNode)) {
2470                if (containerNode.firstChild)
2471                    containerNode.insertBefore(nodeToPrepend, containerNode.firstChild);
2472                else
2473                    containerNode.appendChild(nodeToPrepend);
2474            } else {
2475                // Start comments must always have a parent and at least one following sibling (the end comment)
2476                containerNode.parentNode.insertBefore(nodeToPrepend, containerNode.nextSibling);
2477            }
2478        },
2479
2480        insertAfter: function(containerNode, nodeToInsert, insertAfterNode) {
2481            if (!insertAfterNode) {
2482                ko.virtualElements.prepend(containerNode, nodeToInsert);
2483            } else if (!isStartComment(containerNode)) {
2484                // Insert after insertion point
2485                if (insertAfterNode.nextSibling)
2486                    containerNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
2487                else
2488                    containerNode.appendChild(nodeToInsert);
2489            } else {
2490                // Children of start comments must always have a parent and at least one following sibling (the end comment)
2491                containerNode.parentNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
2492            }
2493        },
2494
2495        firstChild: function(node) {
2496            if (!isStartComment(node))
2497                return node.firstChild;
2498            if (!node.nextSibling || isEndComment(node.nextSibling))
2499                return null;
2500            return node.nextSibling;
2501        },
2502
2503        nextSibling: function(node) {
2504            if (isStartComment(node))
2505                node = getMatchingEndComment(node);
2506            if (node.nextSibling && isEndComment(node.nextSibling))
2507                return null;
2508            return node.nextSibling;
2509        },
2510
2511        hasBindingValue: isStartComment,
2512
2513        virtualNodeBindingValue: function(node) {
2514            var regexMatch = (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex);
2515            return regexMatch ? regexMatch[1] : null;
2516        },
2517
2518        normaliseVirtualElementDomStructure: function(elementVerified) {
2519            // Workaround for https://github.com/SteveSanderson/knockout/issues/155
2520            // (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
2521            // that are direct descendants of <ul> into the preceding <li>)
2522            if (!htmlTagsWithOptionallyClosingChildren[ko.utils.tagNameLower(elementVerified)])
2523                return;
2524
2525            // Scan immediate children to see if they contain unbalanced comment tags. If they do, those comment tags
2526            // must be intended to appear *after* that child, so move them there.
2527            var childNode = elementVerified.firstChild;
2528            if (childNode) {
2529                do {
2530                    if (childNode.nodeType === 1) {
2531                        var unbalancedTags = getUnbalancedChildTags(childNode);
2532                        if (unbalancedTags) {
2533                            // Fix up the DOM by moving the unbalanced tags to where they most likely were intended to be placed - *after* the child
2534                            var nodeToInsertBefore = childNode.nextSibling;
2535                            for (var i = 0; i < unbalancedTags.length; i++) {
2536                                if (nodeToInsertBefore)
2537                                    elementVerified.insertBefore(unbalancedTags[i], nodeToInsertBefore);
2538                                else
2539                                    elementVerified.appendChild(unbalancedTags[i]);
2540                            }
2541                        }
2542                    }
2543                } while (childNode = childNode.nextSibling);
2544            }
2545        }
2546    };
2547})();
2548ko.exportSymbol('virtualElements', ko.virtualElements);
2549ko.exportSymbol('virtualElements.allowedBindings', ko.virtualElements.allowedBindings);
2550ko.exportSymbol('virtualElements.emptyNode', ko.virtualElements.emptyNode);
2551//ko.exportSymbol('virtualElements.firstChild', ko.virtualElements.firstChild);     // firstChild is not minified
2552ko.exportSymbol('virtualElements.insertAfter', ko.virtualElements.insertAfter);
2553//ko.exportSymbol('virtualElements.nextSibling', ko.virtualElements.nextSibling);   // nextSibling is not minified
2554ko.exportSymbol('virtualElements.prepend', ko.virtualElements.prepend);
2555ko.exportSymbol('virtualElements.setDomNodeChildren', ko.virtualElements.setDomNodeChildren);
2556(function() {
2557    var defaultBindingAttributeName = "data-bind";
2558
2559    ko.bindingProvider = function() {
2560        this.bindingCache = {};
2561    };
2562
2563    ko.utils.extend(ko.bindingProvider.prototype, {
2564        'nodeHasBindings': function(node) {
2565            switch (node.nodeType) {
2566                case 1: // Element
2567                    return node.getAttribute(defaultBindingAttributeName) != null
2568                        || ko.components['getComponentNameForNode'](node);
2569                case 8: // Comment node
2570                    return ko.virtualElements.hasBindingValue(node);
2571                default: return false;
2572            }
2573        },
2574
2575        'getBindings': function(node, bindingContext) {
2576            var bindingsString = this['getBindingsString'](node, bindingContext),
2577                parsedBindings = bindingsString ? this['parseBindingsString'](bindingsString, bindingContext, node) : null;
2578            return ko.components.addBindingsForCustomElement(parsedBindings, node, bindingContext, /* valueAccessors */ false);
2579        },
2580
2581        'getBindingAccessors': function(node, bindingContext) {
2582            var bindingsString = this['getBindingsString'](node, bindingContext),
2583                parsedBindings = bindingsString ? this['parseBindingsString'](bindingsString, bindingContext, node, { 'valueAccessors': true }) : null;
2584            return ko.components.addBindingsForCustomElement(parsedBindings, node, bindingContext, /* valueAccessors */ true);
2585        },
2586
2587        // The following function is only used internally by this default provider.
2588        // It's not part of the interface definition for a general binding provider.
2589        'getBindingsString': function(node, bindingContext) {
2590            switch (node.nodeType) {
2591                case 1: return node.getAttribute(defaultBindingAttributeName);   // Element
2592                case 8: return ko.virtualElements.virtualNodeBindingValue(node); // Comment node
2593                default: return null;
2594            }
2595        },
2596
2597        // The following function is only used internally by this default provider.
2598        // It's not part of the interface definition for a general binding provider.
2599        'parseBindingsString': function(bindingsString, bindingContext, node, options) {
2600            try {
2601                var bindingFunction = createBindingsStringEvaluatorViaCache(bindingsString, this.bindingCache, options);
2602                return bindingFunction(bindingContext, node);
2603            } catch (ex) {
2604                ex.message = "Unable to parse bindings.\nBindings value: " + bindingsString + "\nMessage: " + ex.message;
2605                throw ex;
2606            }
2607        }
2608    });
2609
2610    ko.bindingProvider['instance'] = new ko.bindingProvider();
2611
2612    function createBindingsStringEvaluatorViaCache(bindingsString, cache, options) {
2613        var cacheKey = bindingsString + (options && options['valueAccessors'] || '');
2614        return cache[cacheKey]
2615            || (cache[cacheKey] = createBindingsStringEvaluator(bindingsString, options));
2616    }
2617
2618    function createBindingsStringEvaluator(bindingsString, options) {
2619        // Build the source for a function that evaluates "expression"
2620        // For each scope variable, add an extra level of "with" nesting
2621        // Example result: with(sc1) { with(sc0) { return (expression) } }
2622        var rewrittenBindings = ko.expressionRewriting.preProcessBindings(bindingsString, options),
2623            functionBody = "with($context){with($data||{}){return{" + rewrittenBindings + "}}}";
2624        return new Function("$context", "$element", functionBody);
2625    }
2626})();
2627
2628ko.exportSymbol('bindingProvider', ko.bindingProvider);
2629(function () {
2630    ko.bindingHandlers = {};
2631
2632    // The following element types will not be recursed into during binding. In the future, we
2633    // may consider adding <template> to this list, because such elements' contents are always
2634    // intended to be bound in a different context from where they appear in the document.
2635    var bindingDoesNotRecurseIntoElementTypes = {
2636        // Don't want bindings that operate on text nodes to mutate <script> and <textarea> contents,
2637        // because it's unexpected and a potential XSS issue
2638        'script': true,
2639        'textarea': true
2640    };
2641
2642    // Use an overridable method for retrieving binding handlers so that a plugins may support dynamically created handlers
2643    ko['getBindingHandler'] = function(bindingKey) {
2644        return ko.bindingHandlers[bindingKey];
2645    };
2646
2647    // The ko.bindingContext constructor is only called directly to create the root context. For child
2648    // contexts, use bindingContext.createChildContext or bindingContext.extend.
2649    ko.bindingContext = function(dataItemOrAccessor, parentContext, dataItemAlias, extendCallback) {
2650
2651        // The binding context object includes static properties for the current, parent, and root view models.
2652        // If a view model is actually stored in an observable, the corresponding binding context object, and
2653        // any child contexts, must be updated when the view model is changed.
2654        function updateContext() {
2655            // Most of the time, the context will directly get a view model object, but if a function is given,
2656            // we call the function to retrieve the view model. If the function accesses any obsevables or returns
2657            // an observable, the dependency is tracked, and those observables can later cause the binding
2658            // context to be updated.
2659            var dataItemOrObservable = isFunc ? dataItemOrAccessor() : dataItemOrAccessor,
2660                dataItem = ko.utils.unwrapObservable(dataItemOrObservable);
2661
2662            if (parentContext) {