/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2013-2014 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Oracle. Portions Copyright 2013-2014 Oracle. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

/*!

 * Knockout JavaScript library v3.2.0

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

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

 */

(function(){

var DEBUG=true;

(function(undefined){

    // (0, eval)('this') is a robust way of getting a reference to the global object

    // For details, see http://stackoverflow.com/questions/14119988/return-this-0-evalthis/14120023#14120023

    var window = this || (0, eval)('this'),

        document = window['document'],

        navigator = window['navigator'],

        jQueryInstance = window["jQuery"],

        JSON = window["JSON"];

(function(factory) {

    // Support three module loading scenarios

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

        // [1] CommonJS/Node.js

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

        factory(target, require);

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

        // [2] AMD anonymous module

        define(['exports', 'require'], factory);

    } else {

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

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

    }

}(function(koExports, require){

// Internally, all KO objects are attached to koExports (even the non-exported ones whose names will be minified by the closure compiler).

// In the future, the following "ko" variable may be made distinct from "koExports" so that private objects are not externally reachable.

var ko = typeof koExports !== 'undefined' ? koExports : {};

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

ko.exportSymbol = function(koPath, object) {

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

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

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

    var target = ko;

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

        target = target[tokens[i]];

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

};

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

    owner[publicName] = object;

};

ko.version = "3.2.0";

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

ko.utils = (function () {

    function objectForEach(obj, action) {

        for (var prop in obj) {

            if (obj.hasOwnProperty(prop)) {

                action(prop, obj[prop]);

            }

        }

    }

    function extend(target, source) {

        if (source) {

            for(var prop in source) {

                if(source.hasOwnProperty(prop)) {

                    target[prop] = source[prop];

                }

            }

        }

        return target;

    }

    function setPrototypeOf(obj, proto) {

        obj.__proto__ = proto;

        return obj;

    }

    var canSetPrototype = ({ __proto__: [] } instanceof Array);

    // Represent the known event types in a compact way, then at runtime transform it into a hash with event name as key (for fast lookup)

    var knownEvents = {}, knownEventTypesByEventName = {};

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

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

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

    objectForEach(knownEvents, function(eventType, knownEventsForType) {

        if (knownEventsForType.length) {

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

                knownEventTypesByEventName[knownEventsForType[i]] = eventType;

        }

    });

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

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

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

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

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

    var ieVersion = document && (function() {

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

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

        while (

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

            iElems[0]

        ) {}

        return version > 4 ? version : undefined;

    }());

    var isIe6 = ieVersion === 6,

        isIe7 = ieVersion === 7;

    function isClickOnCheckableElement(element, eventType) {

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

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

        var inputType = element.type;

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

    }

    return {

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

        arrayForEach: function (array, action) {

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

                action(array[i], i);

        },

        arrayIndexOf: function (array, item) {

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

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

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

                if (array[i] === item)

                    return i;

            return -1;

        },

        arrayFirst: function (array, predicate, predicateOwner) {

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

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

                    return array[i];

            return null;

        },

        arrayRemoveItem: function (array, itemToRemove) {

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

            if (index > 0) {

                array.splice(index, 1);

            }

            else if (index === 0) {

                array.shift();

            }

        },

        arrayGetDistinctValues: function (array) {

            array = array || [];

            var result = [];

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

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

                    result.push(array[i]);

            }

            return result;

        },

        arrayMap: function (array, mapping) {

            array = array || [];

            var result = [];

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

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

            return result;

        },

        arrayFilter: function (array, predicate) {

            array = array || [];

            var result = [];

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

                if (predicate(array[i], i))

                    result.push(array[i]);

            return result;

        },

        arrayPushAll: function (array, valuesToPush) {

            if (valuesToPush instanceof Array)

                array.push.apply(array, valuesToPush);

            else

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

                    array.push(valuesToPush[i]);

            return array;

        },

        addOrRemoveItem: function(array, value, included) {

            var existingEntryIndex = ko.utils.arrayIndexOf(ko.utils.peekObservable(array), value);

            if (existingEntryIndex < 0) {

                if (included)

                    array.push(value);

            } else {

                if (!included)

                    array.splice(existingEntryIndex, 1);

            }

        },

        canSetPrototype: canSetPrototype,

        extend: extend,

        setPrototypeOf: setPrototypeOf,

        setPrototypeOfOrExtend: canSetPrototype ? setPrototypeOf : extend,

        objectForEach: objectForEach,

        objectMap: function(source, mapping) {

            if (!source)

                return source;

            var target = {};

            for (var prop in source) {

                if (source.hasOwnProperty(prop)) {

                    target[prop] = mapping(source[prop], prop, source);

                }

            }

            return target;

        },

        emptyDomNode: function (domNode) {

            while (domNode.firstChild) {

                ko.removeNode(domNode.firstChild);

            }

        },

        moveCleanedNodesToContainerElement: function(nodes) {

            // Ensure it's a real array, as we're about to reparent the nodes and

            // we don't want the underlying collection to change while we're doing that.

            var nodesArray = ko.utils.makeArray(nodes);

            var container = document.createElement('div');

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

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

            }

            return container;

        },

        cloneNodes: function (nodesArray, shouldCleanNodes) {

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

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

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

            }

            return newNodesArray;

        },

        setDomNodeChildren: function (domNode, childNodes) {

            ko.utils.emptyDomNode(domNode);

            if (childNodes) {

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

                    domNode.appendChild(childNodes[i]);

            }

        },

        replaceDomNodes: function (nodeToReplaceOrNodeArray, newNodesArray) {

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

            if (nodesToReplaceArray.length > 0) {

                var insertionPoint = nodesToReplaceArray[0];

                var parent = insertionPoint.parentNode;

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

                    parent.insertBefore(newNodesArray[i], insertionPoint);

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

                    ko.removeNode(nodesToReplaceArray[i]);

                }

            }

        },

        fixUpContinuousNodeArray: function(continuousNodeArray, parentNode) {

            // Before acting on a set of nodes that were previously outputted by a template function, we have to reconcile

            // them against what is in the DOM right now. It may be that some of the nodes have already been removed, or that

            // new nodes might have been inserted in the middle, for example by a binding. Also, there may previously have been

            // leading comment nodes (created by rewritten string-based templates) that have since been removed during binding.

            // So, this function translates the old "map" output array into its best guess of the set of current DOM nodes.

            //

            // Rules:

            //   [A] Any leading nodes that have been removed should be ignored

            //       These most likely correspond to memoization nodes that were already removed during binding

            //       See https://github.com/SteveSanderson/knockout/pull/440

            //   [B] We want to output a continuous series of nodes. So, ignore any nodes that have already been removed,

            //       and include any nodes that have been inserted among the previous collection

            if (continuousNodeArray.length) {

                // The parent node can be a virtual element; so get the real parent node

                parentNode = (parentNode.nodeType === 8 && parentNode.parentNode) || parentNode;

                // Rule [A]

                while (continuousNodeArray.length && continuousNodeArray[0].parentNode !== parentNode)

                    continuousNodeArray.shift();

                // Rule [B]

                if (continuousNodeArray.length > 1) {

                    var current = continuousNodeArray[0], last = continuousNodeArray[continuousNodeArray.length - 1];

                    // Replace with the actual new continuous node set

                    continuousNodeArray.length = 0;

                    while (current !== last) {

                        continuousNodeArray.push(current);

                        current = current.nextSibling;

                        if (!current) // Won't happen, except if the developer has manually removed some DOM elements (then we're in an undefined scenario)

                            return;

                    }

                    continuousNodeArray.push(last);

                }

            }

            return continuousNodeArray;

        },

        setOptionNodeSelectionState: function (optionNode, isSelected) {

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

            if (ieVersion < 7)

                optionNode.setAttribute("selected", isSelected);

            else

                optionNode.selected = isSelected;

        },

        stringTrim: function (string) {

            return string === null || string === undefined ? '' :

                string.trim ?

                    string.trim() :

                    string.toString().replace(/^[\s\xa0]+|[\s\xa0]+$/g, '');

        },

        stringStartsWith: function (string, startsWith) {

            string = string || "";

            if (startsWith.length > string.length)

                return false;

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

        },

        domNodeIsContainedBy: function (node, containedByNode) {

            if (node === containedByNode)

                return true;

            if (node.nodeType === 11)

                return false; // Fixes issue #1162 - can't use node.contains for document fragments on IE8

            if (containedByNode.contains)

                return containedByNode.contains(node.nodeType === 3 ? node.parentNode : node);

            if (containedByNode.compareDocumentPosition)

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

            while (node && node != containedByNode) {

                node = node.parentNode;

            }

            return !!node;

        },

        domNodeIsAttachedToDocument: function (node) {

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

        },

        anyDomNodeIsAttachedToDocument: function(nodes) {

            return !!ko.utils.arrayFirst(nodes, ko.utils.domNodeIsAttachedToDocument);

        },

        tagNameLower: function(element) {

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

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

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

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

        },

        registerEventHandler: function (element, eventType, handler) {

            var mustUseAttachEvent = ieVersion && eventsThatMustBeRegisteredUsingAttachEvent[eventType];

            if (!mustUseAttachEvent && jQueryInstance) {

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

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

                element.addEventListener(eventType, handler, false);

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

                var attachEventHandler = function (event) { handler.call(element, event); },

                    attachEventName = "on" + eventType;

                element.attachEvent(attachEventName, attachEventHandler);

                // IE does not dispose attachEvent handlers automatically (unlike with addEventListener)

                // so to avoid leaks, we have to remove them manually. See bug #856

                ko.utils.domNodeDisposal.addDisposeCallback(element, function() {

                    element.detachEvent(attachEventName, attachEventHandler);

                });

            } else

                throw new Error("Browser doesn't support addEventListener or attachEvent");

        },

        triggerEvent: function (element, eventType) {

            if (!(element && element.nodeType))

                throw new Error("element must be a DOM node when calling triggerEvent");

            // For click events on checkboxes and radio buttons, jQuery toggles the element checked state *after* the

            // event handler runs instead of *before*. (This was fixed in 1.9 for checkboxes but not for radio buttons.)

            // IE doesn't change the checked state when you trigger the click event using "fireEvent".

            // In both cases, we'll use the click method instead.

            var useClickWorkaround = isClickOnCheckableElement(element, eventType);

            if (jQueryInstance && !useClickWorkaround) {

                jQueryInstance(element)['trigger'](eventType);

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

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

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

                    var event = document.createEvent(eventCategory);

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

                    element.dispatchEvent(event);

                }

                else

                    throw new Error("The supplied element doesn't support dispatchEvent");

            } else if (useClickWorkaround && element.click) {

                element.click();

            } else if (typeof element.fireEvent != "undefined") {

                element.fireEvent("on" + eventType);

            } else {

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

            }

        },

        unwrapObservable: function (value) {

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

        },

        peekObservable: function (value) {

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

        },

        toggleDomNodeCssClass: function (node, classNames, shouldHaveClass) {

            if (classNames) {

                var cssClassNameRegex = /\S+/g,

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

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

                    ko.utils.addOrRemoveItem(currentClassNames, className, shouldHaveClass);

                });

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

            }

        },

        setTextContent: function(element, textContent) {

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

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

                value = "";

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

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

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

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

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

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

            } else {

                innerTextNode.data = value;

            }

            ko.utils.forceRefresh(element);

        },

        setElementName: function(element, name) {

            element.name = name;

            // Workaround IE 6/7 issue

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

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

            if (ieVersion <= 7) {

                try {

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

                }

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

            }

        },

        forceRefresh: function(node) {

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

            if (ieVersion >= 9) {

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

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

                if (elem.style)

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

            }

        },

        ensureSelectElementIsRenderedCorrectly: function(selectElement) {

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

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

            // Also fixes IE7 and IE8 bug that causes selects to be zero width if enclosed by 'if' or 'with'. (See issue #839)

            if (ieVersion) {

                var originalWidth = selectElement.style.width;

                selectElement.style.width = 0;

                selectElement.style.width = originalWidth;

            }

        },

        range: function (min, max) {

            min = ko.utils.unwrapObservable(min);

            max = ko.utils.unwrapObservable(max);

            var result = [];

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

                result.push(i);

            return result;

        },

        makeArray: function(arrayLikeObject) {

            var result = [];

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

                result.push(arrayLikeObject[i]);

            };

            return result;

        },

        isIe6 : isIe6,

        isIe7 : isIe7,

        ieVersion : ieVersion,

        getFormFields: function(form, fieldName) {

            var fields = ko.utils.makeArray(form.getElementsByTagName("input")).concat(ko.utils.makeArray(form.getElementsByTagName("textarea")));

            var isMatchingField = (typeof fieldName == 'string')

                ? function(field) { return field.name === fieldName }

                : function(field) { return fieldName.test(field.name) }; // Treat fieldName as regex or object containing predicate

            var matches = [];

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

                if (isMatchingField(fields[i]))

                    matches.push(fields[i]);

            };

            return matches;

        },

        parseJson: function (jsonString) {

            if (typeof jsonString == "string") {

                jsonString = ko.utils.stringTrim(jsonString);

                if (jsonString) {

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

                        return JSON.parse(jsonString);

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

                }

            }

            return null;

        },

        stringifyJson: function (data, replacer, space) {   // replacer and space are optional

            if (!JSON || !JSON.stringify)

                throw new Error("Cannot find JSON.stringify(). Some browsers (e.g., IE < 8) don't support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js");

            return JSON.stringify(ko.utils.unwrapObservable(data), replacer, space);

        },

        postJson: function (urlOrForm, data, options) {

            options = options || {};

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

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

            var url = urlOrForm;

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

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

                var originalForm = urlOrForm;

                url = originalForm.action;

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

                    var fields = ko.utils.getFormFields(originalForm, includeFields[i]);

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

                        params[fields[j].name] = fields[j].value;

                }

            }

            data = ko.utils.unwrapObservable(data);

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

            form.style.display = "none";

            form.action = url;

            form.method = "post";

            for (var key in data) {

                // Since 'data' this is a model object, we include all properties including those inherited from its prototype

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

                input.type = "hidden";

                input.name = key;

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

                form.appendChild(input);

            }

            objectForEach(params, function(key, value) {

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

                input.type = "hidden";

                input.name = key;

                input.value = value;

                form.appendChild(input);

            });

            document.body.appendChild(form);

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

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

        }

    }

}());

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ko.exportSymbol('unwrap', ko.utils.unwrapObservable); // Convenient shorthand, because this is used so commonly

if (!Function.prototype['bind']) {

    // Function.prototype.bind is a standard part of ECMAScript 5th Edition (December 2009, http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf)

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

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

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

        return function () {

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

        };

    };

}

ko.utils.domData = new (function () {

    var uniqueId = 0;

    var dataStoreKeyExpandoPropertyName = "__ko__" + (new Date).getTime();

    var dataStore = {};

    function getAll(node, createIfNotFound) {

        var dataStoreKey = node[dataStoreKeyExpandoPropertyName];

        var hasExistingDataStore = dataStoreKey && (dataStoreKey !== "null") && dataStore[dataStoreKey];

        if (!hasExistingDataStore) {

            if (!createIfNotFound)

                return undefined;

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

            dataStore[dataStoreKey] = {};

        }

        return dataStore[dataStoreKey];

    }

    return {

        get: function (node, key) {

            var allDataForNode = getAll(node, false);

            return allDataForNode === undefined ? undefined : allDataForNode[key];

        },

        set: function (node, key, value) {

            if (value === undefined) {

                // Make sure we don't actually create a new domData key if we are actually deleting a value

                if (getAll(node, false) === undefined)

                    return;

            }

            var allDataForNode = getAll(node, true);

            allDataForNode[key] = value;

        },

        clear: function (node) {

            var dataStoreKey = node[dataStoreKeyExpandoPropertyName];

            if (dataStoreKey) {

                delete dataStore[dataStoreKey];

                node[dataStoreKeyExpandoPropertyName] = null;

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

            }

            return false;

        },

        nextKey: function () {

            return (uniqueId++) + dataStoreKeyExpandoPropertyName;

        }

    };

})();

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

ko.exportSymbol('utils.domData.clear', ko.utils.domData.clear); // Exporting only so specs can clear up after themselves fully

ko.utils.domNodeDisposal = new (function () {

    var domDataKey = ko.utils.domData.nextKey();

    var cleanableNodeTypes = { 1: true, 8: true, 9: true };       // Element, Comment, Document

    var cleanableNodeTypesWithDescendants = { 1: true, 9: true }; // Element, Document

    function getDisposeCallbacksCollection(node, createIfNotFound) {

        var allDisposeCallbacks = ko.utils.domData.get(node, domDataKey);

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

            allDisposeCallbacks = [];

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

        }

        return allDisposeCallbacks;

    }

    function destroyCallbacksCollection(node) {

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

    }

    function cleanSingleNode(node) {

        // Run all the dispose callbacks

        var callbacks = getDisposeCallbacksCollection(node, false);

        if (callbacks) {

            callbacks = callbacks.slice(0); // Clone, as the array may be modified during iteration (typically, callbacks will remove themselves)

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

                callbacks[i](node);

        }

        // Erase the DOM data

        ko.utils.domData.clear(node);

        // Perform cleanup needed by external libraries (currently only jQuery, but can be extended)

        ko.utils.domNodeDisposal["cleanExternalData"](node);

        // Clear any immediate-child comment nodes, as these wouldn't have been found by

        // node.getElementsByTagName("*") in cleanNode() (comment nodes aren't elements)

        if (cleanableNodeTypesWithDescendants[node.nodeType])

            cleanImmediateCommentTypeChildren(node);

    }

    function cleanImmediateCommentTypeChildren(nodeWithChildren) {

        var child, nextChild = nodeWithChildren.firstChild;

        while (child = nextChild) {

            nextChild = child.nextSibling;

            if (child.nodeType === 8)

                cleanSingleNode(child);

        }

    }

    return {

        addDisposeCallback : function(node, callback) {

            if (typeof callback != "function")

                throw new Error("Callback must be a function");

            getDisposeCallbacksCollection(node, true).push(callback);

        },

        removeDisposeCallback : function(node, callback) {

            var callbacksCollection = getDisposeCallbacksCollection(node, false);

            if (callbacksCollection) {

                ko.utils.arrayRemoveItem(callbacksCollection, callback);

                if (callbacksCollection.length == 0)

                    destroyCallbacksCollection(node);

            }

        },

        cleanNode : function(node) {

            // First clean this node, where applicable

            if (cleanableNodeTypes[node.nodeType]) {

                cleanSingleNode(node);

                // ... then its descendants, where applicable

                if (cleanableNodeTypesWithDescendants[node.nodeType]) {

                    // Clone the descendants list in case it changes during iteration

                    var descendants = [];

                    ko.utils.arrayPushAll(descendants, node.getElementsByTagName("*"));

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

                        cleanSingleNode(descendants[i]);

                }

            }

            return node;

        },

        removeNode : function(node) {

            ko.cleanNode(node);

            if (node.parentNode)

                node.parentNode.removeChild(node);

        },

        "cleanExternalData" : function (node) {

            // Special support for jQuery here because it's so commonly used.

            // Many jQuery plugins (including jquery.tmpl) store data using jQuery's equivalent of domData

            // so notify it to tear down any resources associated with the node & descendants here.

            if (jQueryInstance && (typeof jQueryInstance['cleanData'] == "function"))

                jQueryInstance['cleanData']([node]);

        }

    }

})();

ko.cleanNode = ko.utils.domNodeDisposal.cleanNode; // Shorthand name for convenience

ko.removeNode = ko.utils.domNodeDisposal.removeNode; // Shorthand name for convenience

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

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

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

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

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

(function () {

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

    function simpleHtmlParse(html) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        } else {

            div.innerHTML = markup;

        }

        // Move to the right depth

        while (wrap[0]--)

            div = div.lastChild;

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

    }

    function jQueryHtmlParse(html) {

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

        if (jQueryInstance['parseHTML']) {

            return jQueryInstance['parseHTML'](html) || []; // Ensure we always return an array and never null

        } else {

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

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

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

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

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

            if (elems && elems[0]) {

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

                var elem = elems[0];

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

                    elem = elem.parentNode;

                // ... then detach it

                if (elem.parentNode)

                    elem.parentNode.removeChild(elem);

            }

            return elems;

        }

    }

    ko.utils.parseHtmlFragment = function(html) {

        return jQueryInstance ? jQueryHtmlParse(html)   // As below, benefit from jQuery's optimisations where possible

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

    };

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

        ko.utils.emptyDomNode(node);

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

        html = ko.utils.unwrapObservable(html);

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

            if (typeof html != 'string')

                html = html.toString();

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

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

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

            if (jQueryInstance) {

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

            } else {

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

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

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

                    node.appendChild(parsedNodes[i]);

            }

        }

    };

})();

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

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

ko.memoization = (function () {

    var memos = {};

    function randomMax8HexChars() {

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

    }

    function generateRandomId() {

        return randomMax8HexChars() + randomMax8HexChars();

    }

    function findMemoNodes(rootNode, appendToArray) {

        if (!rootNode)

            return;

        if (rootNode.nodeType == 8) {

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

            if (memoId != null)

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

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

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

                findMemoNodes(childNodes[i], appendToArray);

        }

    }

    return {

        memoize: function (callback) {

            if (typeof callback != "function")

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

            var memoId = generateRandomId();

            memos[memoId] = callback;

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

        },

        unmemoize: function (memoId, callbackParams) {

            var callback = memos[memoId];

            if (callback === undefined)

                throw new Error("Couldn't find any memo with ID " + memoId + ". Perhaps it's already been unmemoized.");

            try {

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

                return true;

            }

            finally { delete memos[memoId]; }

        },

        unmemoizeDomNodeAndDescendants: function (domNode, extraCallbackParamsArray) {

            var memos = [];

            findMemoNodes(domNode, memos);

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

                var node = memos[i].domNode;

                var combinedParams = [node];

                if (extraCallbackParamsArray)

                    ko.utils.arrayPushAll(combinedParams, extraCallbackParamsArray);

                ko.memoization.unmemoize(memos[i].memoId, combinedParams);

                node.nodeValue = ""; // Neuter this node so we don't try to unmemoize it again

                if (node.parentNode)

                    node.parentNode.removeChild(node); // If possible, erase it totally (not always possible - someone else might just hold a reference to it then call unmemoizeDomNodeAndDescendants again)

            }

        },

        parseMemoText: function (memoText) {

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

            return match ? match[1] : null;

        }

    };

})();

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

ko.exportSymbol('memoization.memoize', ko.memoization.memoize);

ko.exportSymbol('memoization.unmemoize', ko.memoization.unmemoize);

ko.exportSymbol('memoization.parseMemoText', ko.memoization.parseMemoText);

ko.exportSymbol('memoization.unmemoizeDomNodeAndDescendants', ko.memoization.unmemoizeDomNodeAndDescendants);

ko.extenders = {

    'throttle': function(target, timeout) {

        // Throttling means two things:

        // (1) For dependent observables, we throttle *evaluations* so that, no matter how fast its dependencies

        //     notify updates, the target doesn't re-evaluate (and hence doesn't notify) faster than a certain rate

        target['throttleEvaluation'] = timeout;

        // (2) For writable targets (observables, or writable dependent observables), we throttle *writes*

        //     so the target cannot change value synchronously or faster than a certain rate

        var writeTimeoutInstance = null;

        return ko.dependentObservable({

            'read': target,

            'write': function(value) {

                clearTimeout(writeTimeoutInstance);

                writeTimeoutInstance = setTimeout(function() {

                    target(value);

                }, timeout);

            }

        });

    },

    'rateLimit': function(target, options) {

        var timeout, method, limitFunction;