", "
"] ||
+ /* 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" + wrap[1] + html + wrap[2] + "
";
+ if (typeof window['innerShiv'] == "function") {
+ div.appendChild(window['innerShiv'](markup));
+ } else {
+ div.innerHTML = markup;
+ }
+
+ // Move to the right depth
+ while (wrap[0]--)
+ div = div.lastChild;
+
+ return ko.utils.makeArray(div.lastChild.childNodes);
+ }
+
+ function jQueryHtmlParse(html) {
+ // jQuery's "parseHTML" function was introduced in jQuery 1.8.0 and is a documented public API.
+ if (jQuery['parseHTML']) {
+ return jQuery['parseHTML'](html) || []; // 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 = jQuery['clean']([html]);
+
+ // As of jQuery 1.7.1, jQuery parses the HTML by appending it to some dummy parent nodes held in an in-memory document fragment.
+ // Unfortunately, it never clears the dummy parent nodes from the document fragment, so it leaks memory over time.
+ // Fix this by finding the top-most dummy parent element, and detaching it from its owner fragment.
+ if (elems && elems[0]) {
+ // Find the top-most parent element that's a direct child of a document fragment
+ var elem = elems[0];
+ while (elem.parentNode && elem.parentNode.nodeType !== 11 /* i.e., DocumentFragment */)
+ elem = elem.parentNode;
+ // ... then detach it
+ if (elem.parentNode)
+ elem.parentNode.removeChild(elem);
+ }
+
+ return elems;
+ }
+ }
+
+ ko.utils.parseHtmlFragment = function(html) {
+ return jQuery ? 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 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 (jQuery) {
+ jQuery(node)['html'](html);
+ } else {
+ // ... otherwise, use KO's own parsing logic.
+ var parsedNodes = ko.utils.parseHtmlFragment(html);
+ for (var i = 0; i < parsedNodes.length; i++)
+ node.appendChild(parsedNodes[i]);
+ }
+ }
+ };
+})();
+
+ko.exportSymbol('utils.parseHtmlFragment', ko.utils.parseHtmlFragment);
+ko.exportSymbol('utils.setHtml', ko.utils.setHtml);
+
+ko.memoization = (function () {
+ var memos = {};
+
+ function randomMax8HexChars() {
+ return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);
+ }
+ function generateRandomId() {
+ return randomMax8HexChars() + randomMax8HexChars();
+ }
+ function findMemoNodes(rootNode, appendToArray) {
+ if (!rootNode)
+ return;
+ if (rootNode.nodeType == 8) {
+ var memoId = ko.memoization.parseMemoText(rootNode.nodeValue);
+ if (memoId != null)
+ appendToArray.push({ domNode: rootNode, memoId: memoId });
+ } else if (rootNode.nodeType == 1) {
+ for (var i = 0, childNodes = rootNode.childNodes, j = childNodes.length; i < j; i++)
+ findMemoNodes(childNodes[i], appendToArray);
+ }
+ }
+
+ return {
+ memoize: function (callback) {
+ if (typeof callback != "function")
+ throw new Error("You can only pass a function to ko.memoization.memoize()");
+ var memoId = generateRandomId();
+ memos[memoId] = callback;
+ return "";
+ },
+
+ 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;
+
+ if (typeof options == 'number') {
+ timeout = options;
+ } else {
+ timeout = options['timeout'];
+ method = options['method'];
+ }
+
+ limitFunction = method == 'notifyWhenChangesStop' ? debounce : throttle;
+ target.limit(function(callback) {
+ return limitFunction(callback, timeout);
+ });
+ },
+
+ 'notify': function(target, notifyWhen) {
+ target["equalityComparer"] = notifyWhen == "always" ?
+ null : // null equalityComparer means to always notify
+ valuesArePrimitiveAndEqual;
+ }
+};
+
+var primitiveTypes = { 'undefined':1, 'boolean':1, 'number':1, 'string':1 };
+function valuesArePrimitiveAndEqual(a, b) {
+ var oldValueIsPrimitive = (a === null) || (typeof(a) in primitiveTypes);
+ return oldValueIsPrimitive ? (a === b) : false;
+}
+
+function throttle(callback, timeout) {
+ var timeoutInstance;
+ return function () {
+ if (!timeoutInstance) {
+ timeoutInstance = setTimeout(function() {
+ timeoutInstance = undefined;
+ callback();
+ }, timeout);
+ }
+ };
+}
+
+function debounce(callback, timeout) {
+ var timeoutInstance;
+ return function () {
+ clearTimeout(timeoutInstance);
+ timeoutInstance = setTimeout(callback, timeout);
+ };
+}
+
+function applyExtenders(requestedExtenders) {
+ var target = this;
+ if (requestedExtenders) {
+ ko.utils.objectForEach(requestedExtenders, function(key, value) {
+ var extenderHandler = ko.extenders[key];
+ if (typeof extenderHandler == 'function') {
+ target = extenderHandler(target, value) || target;
+ }
+ });
+ }
+ return target;
+}
+
+ko.exportSymbol('extenders', ko.extenders);
+
+ko.subscription = function (target, callback, disposeCallback) {
+ this.target = target;
+ this.callback = callback;
+ this.disposeCallback = disposeCallback;
+ this.isDisposed = false;
+ ko.exportProperty(this, 'dispose', this.dispose);
+};
+ko.subscription.prototype.dispose = function () {
+ this.isDisposed = true;
+ this.disposeCallback();
+};
+
+ko.subscribable = function () {
+ ko.utils.setPrototypeOfOrExtend(this, ko.subscribable['fn']);
+ this._subscriptions = {};
+}
+
+var defaultEvent = "change";
+
+var ko_subscribable_fn = {
+ subscribe: function (callback, callbackTarget, event) {
+ var self = this;
+
+ event = event || defaultEvent;
+ var boundCallback = callbackTarget ? callback.bind(callbackTarget) : callback;
+
+ var subscription = new ko.subscription(self, boundCallback, function () {
+ ko.utils.arrayRemoveItem(self._subscriptions[event], subscription);
+ });
+
+ // This will force a computed with deferEvaluation to evaluate before any subscriptions
+ // are registered.
+ if (self.peek) {
+ self.peek();
+ }
+
+ if (!self._subscriptions[event])
+ self._subscriptions[event] = [];
+ self._subscriptions[event].push(subscription);
+ return subscription;
+ },
+
+ "notifySubscribers": function (valueToNotify, event) {
+ event = event || defaultEvent;
+ if (this.hasSubscriptionsForEvent(event)) {
+ try {
+ ko.dependencyDetection.begin(); // Begin suppressing dependency detection (by setting the top frame to undefined)
+ for (var a = this._subscriptions[event].slice(0), i = 0, subscription; subscription = a[i]; ++i) {
+ // In case a subscription was disposed during the arrayForEach cycle, check
+ // for isDisposed on each subscription before invoking its callback
+ if (!subscription.isDisposed)
+ subscription.callback(valueToNotify);
+ }
+ } finally {
+ ko.dependencyDetection.end(); // End suppressing dependency detection
+ }
+ }
+ },
+
+ limit: function(limitFunction) {
+ var self = this, selfIsObservable = ko.isObservable(self),
+ isPending, previousValue, pendingValue, beforeChange = 'beforeChange';
+
+ if (!self._origNotifySubscribers) {
+ self._origNotifySubscribers = self["notifySubscribers"];
+ self["notifySubscribers"] = function(value, event) {
+ if (!event || event === defaultEvent) {
+ self._rateLimitedChange(value);
+ } else if (event === beforeChange) {
+ self._rateLimitedBeforeChange(value);
+ } else {
+ self._origNotifySubscribers(value, event);
+ }
+ };
+ }
+
+ var finish = limitFunction(function() {
+ // If an observable provided a reference to itself, access it to get the latest value.
+ // This allows computed observables to delay calculating their value until needed.
+ if (selfIsObservable && pendingValue === self) {
+ pendingValue = self();
+ }
+ isPending = false;
+ if (self.isDifferent(previousValue, pendingValue)) {
+ self._origNotifySubscribers(previousValue = pendingValue);
+ }
+ });
+
+ self._rateLimitedChange = function(value) {
+ isPending = true;
+ pendingValue = value;
+ finish();
+ };
+ self._rateLimitedBeforeChange = function(value) {
+ if (!isPending) {
+ previousValue = value;
+ self._origNotifySubscribers(value, beforeChange);
+ }
+ };
+ },
+
+ hasSubscriptionsForEvent: function(event) {
+ return this._subscriptions[event] && this._subscriptions[event].length;
+ },
+
+ getSubscriptionsCount: function () {
+ var total = 0;
+ ko.utils.objectForEach(this._subscriptions, function(eventName, subscriptions) {
+ total += subscriptions.length;
+ });
+ return total;
+ },
+
+ isDifferent: function(oldValue, newValue) {
+ return !this['equalityComparer'] || !this['equalityComparer'](oldValue, newValue);
+ },
+
+ extend: applyExtenders
+};
+
+ko.exportProperty(ko_subscribable_fn, 'subscribe', ko_subscribable_fn.subscribe);
+ko.exportProperty(ko_subscribable_fn, 'extend', ko_subscribable_fn.extend);
+ko.exportProperty(ko_subscribable_fn, 'getSubscriptionsCount', ko_subscribable_fn.getSubscriptionsCount);
+
+// For browsers that support proto assignment, we overwrite the prototype of each
+// observable instance. Since observables are functions, we need Function.prototype
+// to still be in the prototype chain.
+if (ko.utils.canSetPrototype) {
+ ko.utils.setPrototypeOf(ko_subscribable_fn, Function.prototype);
+}
+
+ko.subscribable['fn'] = ko_subscribable_fn;
+
+
+ko.isSubscribable = function (instance) {
+ return instance != null && typeof instance.subscribe == "function" && typeof instance["notifySubscribers"] == "function";
+};
+
+ko.exportSymbol('subscribable', ko.subscribable);
+ko.exportSymbol('isSubscribable', ko.isSubscribable);
+
+ko.computedContext = ko.dependencyDetection = (function () {
+ var outerFrames = [],
+ currentFrame,
+ lastId = 0;
+
+ // Return a unique ID that can be assigned to an observable for dependency tracking.
+ // Theoretically, you could eventually overflow the number storage size, resulting
+ // in duplicate IDs. But in JavaScript, the largest exact integral value is 2^53
+ // or 9,007,199,254,740,992. If you created 1,000,000 IDs per second, it would
+ // take over 285 years to reach that number.
+ // Reference http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html
+ function getId() {
+ return ++lastId;
+ }
+
+ function begin(options) {
+ outerFrames.push(currentFrame);
+ currentFrame = options;
+ }
+
+ function end() {
+ currentFrame = outerFrames.pop();
+ }
+
+ return {
+ begin: begin,
+
+ end: end,
+
+ registerDependency: function (subscribable) {
+ if (currentFrame) {
+ if (!ko.isSubscribable(subscribable))
+ throw new Error("Only subscribable things can act as dependencies");
+ currentFrame.callback(subscribable, subscribable._id || (subscribable._id = getId()));
+ }
+ },
+
+ ignore: function (callback, callbackTarget, callbackArgs) {
+ try {
+ begin();
+ return callback.apply(callbackTarget, callbackArgs || []);
+ } finally {
+ end();
+ }
+ },
+
+ getDependenciesCount: function () {
+ if (currentFrame)
+ return currentFrame.computed.getDependenciesCount();
+ },
+
+ isInitial: function() {
+ if (currentFrame)
+ return currentFrame.isInitial;
+ }
+ };
+})();
+
+ko.exportSymbol('computedContext', ko.computedContext);
+ko.exportSymbol('computedContext.getDependenciesCount', ko.computedContext.getDependenciesCount);
+ko.exportSymbol('computedContext.isInitial', ko.computedContext.isInitial);
+ko.observable = function (initialValue) {
+ var _latestValue = initialValue;
+
+ function observable() {
+ if (arguments.length > 0) {
+ // Write
+
+ // Ignore writes if the value hasn't changed
+ if (observable.isDifferent(_latestValue, arguments[0])) {
+ observable.valueWillMutate();
+ _latestValue = arguments[0];
+ if (DEBUG) observable._latestValue = _latestValue;
+ observable.valueHasMutated();
+ }
+ return this; // Permits chained assignments
+ }
+ else {
+ // Read
+ ko.dependencyDetection.registerDependency(observable); // The caller only needs to be notified of changes if they did a "read" operation
+ return _latestValue;
+ }
+ }
+ ko.subscribable.call(observable);
+ ko.utils.setPrototypeOfOrExtend(observable, ko.observable['fn']);
+
+ if (DEBUG) observable._latestValue = _latestValue;
+ observable.peek = function() { return _latestValue };
+ observable.valueHasMutated = function () { observable["notifySubscribers"](_latestValue); }
+ observable.valueWillMutate = function () { observable["notifySubscribers"](_latestValue, "beforeChange"); }
+
+ ko.exportProperty(observable, 'peek', observable.peek);
+ ko.exportProperty(observable, "valueHasMutated", observable.valueHasMutated);
+ ko.exportProperty(observable, "valueWillMutate", observable.valueWillMutate);
+
+ return observable;
+}
+
+ko.observable['fn'] = {
+ "equalityComparer": valuesArePrimitiveAndEqual
+};
+
+var protoProperty = ko.observable.protoProperty = "__ko_proto__";
+ko.observable['fn'][protoProperty] = ko.observable;
+
+// Note that for browsers that don't support proto assignment, the
+// inheritance chain is created manually in the ko.observable constructor
+if (ko.utils.canSetPrototype) {
+ ko.utils.setPrototypeOf(ko.observable['fn'], ko.subscribable['fn']);
+}
+
+ko.hasPrototype = function(instance, prototype) {
+ if ((instance === null) || (instance === undefined) || (instance[protoProperty] === undefined)) return false;
+ if (instance[protoProperty] === prototype) return true;
+ return ko.hasPrototype(instance[protoProperty], prototype); // Walk the prototype chain
+};
+
+ko.isObservable = function (instance) {
+ return ko.hasPrototype(instance, ko.observable);
+}
+ko.isWriteableObservable = function (instance) {
+ // Observable
+ if ((typeof instance == "function") && instance[protoProperty] === ko.observable)
+ return true;
+ // Writeable dependent observable
+ if ((typeof instance == "function") && (instance[protoProperty] === ko.dependentObservable) && (instance.hasWriteFunction))
+ return true;
+ // Anything else
+ return false;
+}
+
+
+ko.exportSymbol('observable', ko.observable);
+ko.exportSymbol('isObservable', ko.isObservable);
+ko.exportSymbol('isWriteableObservable', ko.isWriteableObservable);
+ko.observableArray = function (initialValues) {
+ initialValues = initialValues || [];
+
+ if (typeof initialValues != 'object' || !('length' in initialValues))
+ throw new Error("The argument passed when initializing an observable array must be an array, or null, or undefined.");
+
+ var result = ko.observable(initialValues);
+ ko.utils.setPrototypeOfOrExtend(result, ko.observableArray['fn']);
+ return result.extend({'trackArrayChanges':true});
+};
+
+ko.observableArray['fn'] = {
+ 'remove': function (valueOrPredicate) {
+ var underlyingArray = this.peek();
+ var removedValues = [];
+ var predicate = typeof valueOrPredicate == "function" && !ko.isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate; };
+ for (var i = 0; i < underlyingArray.length; i++) {
+ var value = underlyingArray[i];
+ if (predicate(value)) {
+ if (removedValues.length === 0) {
+ this.valueWillMutate();
+ }
+ removedValues.push(value);
+ underlyingArray.splice(i, 1);
+ i--;
+ }
+ }
+ if (removedValues.length) {
+ this.valueHasMutated();
+ }
+ return removedValues;
+ },
+
+ 'removeAll': function (arrayOfValues) {
+ // If you passed zero args, we remove everything
+ if (arrayOfValues === undefined) {
+ var underlyingArray = this.peek();
+ var allValues = underlyingArray.slice(0);
+ this.valueWillMutate();
+ underlyingArray.splice(0, underlyingArray.length);
+ this.valueHasMutated();
+ return allValues;
+ }
+ // If you passed an arg, we interpret it as an array of entries to remove
+ if (!arrayOfValues)
+ return [];
+ return this['remove'](function (value) {
+ return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0;
+ });
+ },
+
+ 'destroy': function (valueOrPredicate) {
+ var underlyingArray = this.peek();
+ var predicate = typeof valueOrPredicate == "function" && !ko.isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate; };
+ this.valueWillMutate();
+ for (var i = underlyingArray.length - 1; i >= 0; i--) {
+ var value = underlyingArray[i];
+ if (predicate(value))
+ underlyingArray[i]["_destroy"] = true;
+ }
+ this.valueHasMutated();
+ },
+
+ 'destroyAll': function (arrayOfValues) {
+ // If you passed zero args, we destroy everything
+ if (arrayOfValues === undefined)
+ return this['destroy'](function() { return true });
+
+ // If you passed an arg, we interpret it as an array of entries to destroy
+ if (!arrayOfValues)
+ return [];
+ return this['destroy'](function (value) {
+ return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0;
+ });
+ },
+
+ 'indexOf': function (item) {
+ var underlyingArray = this();
+ return ko.utils.arrayIndexOf(underlyingArray, item);
+ },
+
+ 'replace': function(oldItem, newItem) {
+ var index = this['indexOf'](oldItem);
+ if (index >= 0) {
+ this.valueWillMutate();
+ this.peek()[index] = newItem;
+ this.valueHasMutated();
+ }
+ }
+};
+
+// Populate ko.observableArray.fn with read/write functions from native arrays
+// Important: Do not add any additional functions here that may reasonably be used to *read* data from the array
+// because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale
+ko.utils.arrayForEach(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function (methodName) {
+ ko.observableArray['fn'][methodName] = function () {
+ // Use "peek" to avoid creating a subscription in any computed that we're executing in the context of
+ // (for consistency with mutating regular observables)
+ var underlyingArray = this.peek();
+ this.valueWillMutate();
+ this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
+ var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
+ this.valueHasMutated();
+ return methodCallResult;
+ };
+});
+
+// Populate ko.observableArray.fn with read-only functions from native arrays
+ko.utils.arrayForEach(["slice"], function (methodName) {
+ ko.observableArray['fn'][methodName] = function () {
+ var underlyingArray = this();
+ return underlyingArray[methodName].apply(underlyingArray, arguments);
+ };
+});
+
+// Note that for browsers that don't support proto assignment, the
+// inheritance chain is created manually in the ko.observableArray constructor
+if (ko.utils.canSetPrototype) {
+ ko.utils.setPrototypeOf(ko.observableArray['fn'], ko.observable['fn']);
+}
+
+ko.exportSymbol('observableArray', ko.observableArray);
+var arrayChangeEventName = 'arrayChange';
+ko.extenders['trackArrayChanges'] = function(target) {
+ // Only modify the target observable once
+ if (target.cacheDiffForKnownOperation) {
+ return;
+ }
+ var trackingChanges = false,
+ cachedDiff = null,
+ pendingNotifications = 0,
+ underlyingSubscribeFunction = target.subscribe;
+
+ // Intercept "subscribe" calls, and for array change events, ensure change tracking is enabled
+ target.subscribe = target['subscribe'] = function(callback, callbackTarget, event) {
+ if (event === arrayChangeEventName) {
+ trackChanges();
+ }
+ return underlyingSubscribeFunction.apply(this, arguments);
+ };
+
+ function trackChanges() {
+ // Calling 'trackChanges' multiple times is the same as calling it once
+ if (trackingChanges) {
+ return;
+ }
+
+ trackingChanges = true;
+
+ // Intercept "notifySubscribers" to track how many times it was called.
+ var underlyingNotifySubscribersFunction = target['notifySubscribers'];
+ target['notifySubscribers'] = function(valueToNotify, event) {
+ if (!event || event === defaultEvent) {
+ ++pendingNotifications;
+ }
+ return underlyingNotifySubscribersFunction.apply(this, arguments);
+ };
+
+ // Each time the array changes value, capture a clone so that on the next
+ // change it's possible to produce a diff
+ var previousContents = [].concat(target.peek() || []);
+ cachedDiff = null;
+ target.subscribe(function(currentContents) {
+ // Make a copy of the current contents and ensure it's an array
+ currentContents = [].concat(currentContents || []);
+
+ // Compute the diff and issue notifications, but only if someone is listening
+ if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
+ var changes = getChanges(previousContents, currentContents);
+ if (changes.length) {
+ target['notifySubscribers'](changes, arrayChangeEventName);
+ }
+ }
+
+ // Eliminate references to the old, removed items, so they can be GCed
+ previousContents = currentContents;
+ cachedDiff = null;
+ pendingNotifications = 0;
+ });
+ }
+
+ function getChanges(previousContents, currentContents) {
+ // We try to re-use cached diffs.
+ // The scenarios where pendingNotifications > 1 are when using rate-limiting or the Deferred Updates
+ // plugin, which without this check would not be compatible with arrayChange notifications. Normally,
+ // notifications are issued immediately so we wouldn't be queueing up more than one.
+ if (!cachedDiff || pendingNotifications > 1) {
+ cachedDiff = ko.utils.compareArrays(previousContents, currentContents, { 'sparse': true });
+ }
+
+ return cachedDiff;
+ }
+
+ target.cacheDiffForKnownOperation = function(rawArray, operationName, args) {
+ // Only run if we're currently tracking changes for this observable array
+ // and there aren't any pending deferred notifications.
+ if (!trackingChanges || pendingNotifications) {
+ return;
+ }
+ var diff = [],
+ arrayLength = rawArray.length,
+ argsLength = args.length,
+ offset = 0;
+
+ function pushDiff(status, value, index) {
+ return diff[diff.length] = { 'status': status, 'value': value, 'index': index };
+ }
+ switch (operationName) {
+ case 'push':
+ offset = arrayLength;
+ case 'unshift':
+ for (var index = 0; index < argsLength; index++) {
+ pushDiff('added', args[index], offset + index);
+ }
+ break;
+
+ case 'pop':
+ offset = arrayLength - 1;
+ case 'shift':
+ if (arrayLength) {
+ pushDiff('deleted', rawArray[offset], offset);
+ }
+ break;
+
+ case 'splice':
+ // Negative start index means 'from end of array'. After that we clamp to [0...arrayLength].
+ // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice
+ var startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength),
+ endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength),
+ endAddIndex = startIndex + argsLength - 2,
+ endIndex = Math.max(endDeleteIndex, endAddIndex),
+ additions = [], deletions = [];
+ for (var index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {
+ if (index < endDeleteIndex)
+ deletions.push(pushDiff('deleted', rawArray[index], index));
+ if (index < endAddIndex)
+ additions.push(pushDiff('added', args[argsIndex], index));
+ }
+ ko.utils.findMovesInArrayComparison(deletions, additions);
+ break;
+
+ default:
+ return;
+ }
+ cachedDiff = diff;
+ };
+};
+ko.computed = ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunctionTarget, options) {
+ var _latestValue,
+ _needsEvaluation = true,
+ _isBeingEvaluated = false,
+ _suppressDisposalUntilDisposeWhenReturnsFalse = false,
+ _isDisposed = false,
+ readFunction = evaluatorFunctionOrOptions;
+
+ if (readFunction && typeof readFunction == "object") {
+ // Single-parameter syntax - everything is on this "options" param
+ options = readFunction;
+ readFunction = options["read"];
+ } else {
+ // Multi-parameter syntax - construct the options according to the params passed
+ options = options || {};
+ if (!readFunction)
+ readFunction = options["read"];
+ }
+ if (typeof readFunction != "function")
+ throw new Error("Pass a function that returns the value of the ko.computed");
+
+ function addSubscriptionToDependency(subscribable, id) {
+ if (!_subscriptionsToDependencies[id]) {
+ _subscriptionsToDependencies[id] = subscribable.subscribe(evaluatePossiblyAsync);
+ ++_dependenciesCount;
+ }
+ }
+
+ function disposeAllSubscriptionsToDependencies() {
+ _isDisposed = true;
+ ko.utils.objectForEach(_subscriptionsToDependencies, function (id, subscription) {
+ subscription.dispose();
+ });
+ _subscriptionsToDependencies = {};
+ _dependenciesCount = 0;
+ _needsEvaluation = false;
+ }
+
+ function evaluatePossiblyAsync() {
+ var throttleEvaluationTimeout = dependentObservable['throttleEvaluation'];
+ if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {
+ clearTimeout(evaluationTimeoutInstance);
+ evaluationTimeoutInstance = setTimeout(evaluateImmediate, throttleEvaluationTimeout);
+ } else if (dependentObservable._evalRateLimited) {
+ dependentObservable._evalRateLimited();
+ } else {
+ evaluateImmediate();
+ }
+ }
+
+ function evaluateImmediate() {
+ if (_isBeingEvaluated) {
+ // If the evaluation of a ko.computed causes side effects, it's possible that it will trigger its own re-evaluation.
+ // This is not desirable (it's hard for a developer to realise a chain of dependencies might cause this, and they almost
+ // certainly didn't intend infinite re-evaluations). So, for predictability, we simply prevent ko.computeds from causing
+ // their own re-evaluation. Further discussion at https://github.com/SteveSanderson/knockout/pull/387
+ return;
+ }
+
+ // Do not evaluate (and possibly capture new dependencies) if disposed
+ if (_isDisposed) {
+ return;
+ }
+
+ if (disposeWhen && disposeWhen()) {
+ // See comment below about _suppressDisposalUntilDisposeWhenReturnsFalse
+ if (!_suppressDisposalUntilDisposeWhenReturnsFalse) {
+ dispose();
+ return;
+ }
+ } else {
+ // It just did return false, so we can stop suppressing now
+ _suppressDisposalUntilDisposeWhenReturnsFalse = false;
+ }
+
+ _isBeingEvaluated = true;
+ try {
+ // Initially, we assume that none of the subscriptions are still being used (i.e., all are candidates for disposal).
+ // Then, during evaluation, we cross off any that are in fact still being used.
+ var disposalCandidates = _subscriptionsToDependencies, disposalCount = _dependenciesCount;
+ ko.dependencyDetection.begin({
+ callback: function(subscribable, id) {
+ if (!_isDisposed) {
+ if (disposalCount && disposalCandidates[id]) {
+ // Don't want to dispose this subscription, as it's still being used
+ _subscriptionsToDependencies[id] = disposalCandidates[id];
+ ++_dependenciesCount;
+ delete disposalCandidates[id];
+ --disposalCount;
+ } else {
+ // Brand new subscription - add it
+ addSubscriptionToDependency(subscribable, id);
+ }
+ }
+ },
+ computed: dependentObservable,
+ isInitial: !_dependenciesCount // If we're evaluating when there are no previous dependencies, it must be the first time
+ });
+
+ _subscriptionsToDependencies = {};
+ _dependenciesCount = 0;
+
+ try {
+ var newValue = evaluatorFunctionTarget ? readFunction.call(evaluatorFunctionTarget) : readFunction();
+
+ } finally {
+ ko.dependencyDetection.end();
+
+ // For each subscription no longer being used, remove it from the active subscriptions list and dispose it
+ if (disposalCount) {
+ ko.utils.objectForEach(disposalCandidates, function(id, toDispose) {
+ toDispose.dispose();
+ });
+ }
+
+ _needsEvaluation = false;
+ }
+
+ if (dependentObservable.isDifferent(_latestValue, newValue)) {
+ dependentObservable["notifySubscribers"](_latestValue, "beforeChange");
+
+ _latestValue = newValue;
+ if (DEBUG) dependentObservable._latestValue = _latestValue;
+
+ // If rate-limited, the notification will happen within the limit function. Otherwise,
+ // notify as soon as the value changes. Check specifically for the throttle setting since
+ // it overrides rateLimit.
+ if (!dependentObservable._evalRateLimited || dependentObservable['throttleEvaluation']) {
+ dependentObservable["notifySubscribers"](_latestValue);
+ }
+ }
+ } finally {
+ _isBeingEvaluated = false;
+ }
+
+ if (!_dependenciesCount)
+ dispose();
+ }
+
+ function dependentObservable() {
+ if (arguments.length > 0) {
+ if (typeof writeFunction === "function") {
+ // Writing a value
+ writeFunction.apply(evaluatorFunctionTarget, arguments);
+ } else {
+ throw new Error("Cannot write a value to a ko.computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.");
+ }
+ return this; // Permits chained assignments
+ } else {
+ // Reading the value
+ if (_needsEvaluation)
+ evaluateImmediate();
+ ko.dependencyDetection.registerDependency(dependentObservable);
+ return _latestValue;
+ }
+ }
+
+ function peek() {
+ // Peek won't re-evaluate, except to get the initial value when "deferEvaluation" is set.
+ // That's the only time that both of these conditions will be satisfied.
+ if (_needsEvaluation && !_dependenciesCount)
+ evaluateImmediate();
+ return _latestValue;
+ }
+
+ function isActive() {
+ return _needsEvaluation || _dependenciesCount > 0;
+ }
+
+ // By here, "options" is always non-null
+ var writeFunction = options["write"],
+ disposeWhenNodeIsRemoved = options["disposeWhenNodeIsRemoved"] || options.disposeWhenNodeIsRemoved || null,
+ disposeWhenOption = options["disposeWhen"] || options.disposeWhen,
+ disposeWhen = disposeWhenOption,
+ dispose = disposeAllSubscriptionsToDependencies,
+ _subscriptionsToDependencies = {},
+ _dependenciesCount = 0,
+ evaluationTimeoutInstance = null;
+
+ if (!evaluatorFunctionTarget)
+ evaluatorFunctionTarget = options["owner"];
+
+ ko.subscribable.call(dependentObservable);
+ ko.utils.setPrototypeOfOrExtend(dependentObservable, ko.dependentObservable['fn']);
+
+ dependentObservable.peek = peek;
+ dependentObservable.getDependenciesCount = function () { return _dependenciesCount; };
+ dependentObservable.hasWriteFunction = typeof options["write"] === "function";
+ dependentObservable.dispose = function () { dispose(); };
+ dependentObservable.isActive = isActive;
+
+ // Replace the limit function with one that delays evaluation as well.
+ var originalLimit = dependentObservable.limit;
+ dependentObservable.limit = function(limitFunction) {
+ originalLimit.call(dependentObservable, limitFunction);
+ dependentObservable._evalRateLimited = function() {
+ dependentObservable._rateLimitedBeforeChange(_latestValue);
+
+ _needsEvaluation = true; // Mark as dirty
+
+ // Pass the observable to the rate-limit code, which will access it when
+ // it's time to do the notification.
+ dependentObservable._rateLimitedChange(dependentObservable);
+ }
+ };
+
+ ko.exportProperty(dependentObservable, 'peek', dependentObservable.peek);
+ ko.exportProperty(dependentObservable, 'dispose', dependentObservable.dispose);
+ ko.exportProperty(dependentObservable, 'isActive', dependentObservable.isActive);
+ ko.exportProperty(dependentObservable, 'getDependenciesCount', dependentObservable.getDependenciesCount);
+
+ // Add a "disposeWhen" callback that, on each evaluation, disposes if the node was removed without using ko.removeNode.
+ if (disposeWhenNodeIsRemoved) {
+ // Since this computed is associated with a DOM node, and we don't want to dispose the computed
+ // until the DOM node is *removed* from the document (as opposed to never having been in the document),
+ // we'll prevent disposal until "disposeWhen" first returns false.
+ _suppressDisposalUntilDisposeWhenReturnsFalse = true;
+
+ // Only watch for the node's disposal if the value really is a node. It might not be,
+ // e.g., { disposeWhenNodeIsRemoved: true } can be used to opt into the "only dispose
+ // after first false result" behaviour even if there's no specific node to watch. This
+ // technique is intended for KO's internal use only and shouldn't be documented or used
+ // by application code, as it's likely to change in a future version of KO.
+ if (disposeWhenNodeIsRemoved.nodeType) {
+ disposeWhen = function () {
+ return !ko.utils.domNodeIsAttachedToDocument(disposeWhenNodeIsRemoved) || (disposeWhenOption && disposeWhenOption());
+ };
+ }
+ }
+
+ // Evaluate, unless deferEvaluation is true
+ if (options['deferEvaluation'] !== true)
+ evaluateImmediate();
+
+ // Attach a DOM node disposal callback so that the computed will be proactively disposed as soon as the node is
+ // removed using ko.removeNode. But skip if isActive is false (there will never be any dependencies to dispose).
+ if (disposeWhenNodeIsRemoved && isActive() && disposeWhenNodeIsRemoved.nodeType) {
+ dispose = function() {
+ ko.utils.domNodeDisposal.removeDisposeCallback(disposeWhenNodeIsRemoved, dispose);
+ disposeAllSubscriptionsToDependencies();
+ };
+ ko.utils.domNodeDisposal.addDisposeCallback(disposeWhenNodeIsRemoved, dispose);
+ }
+
+ return dependentObservable;
+};
+
+ko.isComputed = function(instance) {
+ return ko.hasPrototype(instance, ko.dependentObservable);
+};
+
+var protoProp = ko.observable.protoProperty; // == "__ko_proto__"
+ko.dependentObservable[protoProp] = ko.observable;
+
+ko.dependentObservable['fn'] = {
+ "equalityComparer": valuesArePrimitiveAndEqual
+};
+ko.dependentObservable['fn'][protoProp] = ko.dependentObservable;
+
+// Note that for browsers that don't support proto assignment, the
+// inheritance chain is created manually in the ko.dependentObservable constructor
+if (ko.utils.canSetPrototype) {
+ ko.utils.setPrototypeOf(ko.dependentObservable['fn'], ko.subscribable['fn']);
+}
+
+ko.exportSymbol('dependentObservable', ko.dependentObservable);
+ko.exportSymbol('computed', ko.dependentObservable); // Make "ko.computed" an alias for "ko.dependentObservable"
+ko.exportSymbol('isComputed', ko.isComputed);
+
+(function() {
+ var maxNestedObservableDepth = 10; // Escape the (unlikely) pathalogical case where an observable's current value is itself (or similar reference cycle)
+
+ ko.toJS = function(rootObject) {
+ if (arguments.length == 0)
+ throw new Error("When calling ko.toJS, pass the object you want to convert.");
+
+ // We just unwrap everything at every level in the object graph
+ return mapJsObjectGraph(rootObject, function(valueToMap) {
+ // Loop because an observable's value might in turn be another observable wrapper
+ for (var i = 0; ko.isObservable(valueToMap) && (i < maxNestedObservableDepth); i++)
+ valueToMap = valueToMap();
+ return valueToMap;
+ });
+ };
+
+ ko.toJSON = function(rootObject, replacer, space) { // replacer and space are optional
+ var plainJavaScriptObject = ko.toJS(rootObject);
+ return ko.utils.stringifyJson(plainJavaScriptObject, replacer, space);
+ };
+
+ function mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects) {
+ visitedObjects = visitedObjects || new objectLookup();
+
+ rootObject = mapInputCallback(rootObject);
+ var canHaveProperties = (typeof rootObject == "object") && (rootObject !== null) && (rootObject !== undefined) && (!(rootObject instanceof Date)) && (!(rootObject instanceof String)) && (!(rootObject instanceof Number)) && (!(rootObject instanceof Boolean));
+ if (!canHaveProperties)
+ return rootObject;
+
+ var outputProperties = rootObject instanceof Array ? [] : {};
+ visitedObjects.save(rootObject, outputProperties);
+
+ visitPropertiesOrArrayEntries(rootObject, function(indexer) {
+ var propertyValue = mapInputCallback(rootObject[indexer]);
+
+ switch (typeof propertyValue) {
+ case "boolean":
+ case "number":
+ case "string":
+ case "function":
+ outputProperties[indexer] = propertyValue;
+ break;
+ case "object":
+ case "undefined":
+ var previouslyMappedValue = visitedObjects.get(propertyValue);
+ outputProperties[indexer] = (previouslyMappedValue !== undefined)
+ ? previouslyMappedValue
+ : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects);
+ break;
+ }
+ });
+
+ return outputProperties;
+ }
+
+ function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {
+ if (rootObject instanceof Array) {
+ for (var i = 0; i < rootObject.length; i++)
+ visitorCallback(i);
+
+ // For arrays, also respect toJSON property for custom mappings (fixes #278)
+ if (typeof rootObject['toJSON'] == 'function')
+ visitorCallback('toJSON');
+ } else {
+ for (var propertyName in rootObject) {
+ visitorCallback(propertyName);
+ }
+ }
+ };
+
+ function objectLookup() {
+ this.keys = [];
+ this.values = [];
+ };
+
+ objectLookup.prototype = {
+ constructor: objectLookup,
+ save: function(key, value) {
+ var existingIndex = ko.utils.arrayIndexOf(this.keys, key);
+ if (existingIndex >= 0)
+ this.values[existingIndex] = value;
+ else {
+ this.keys.push(key);
+ this.values.push(value);
+ }
+ },
+ get: function(key) {
+ var existingIndex = ko.utils.arrayIndexOf(this.keys, key);
+ return (existingIndex >= 0) ? this.values[existingIndex] : undefined;
+ }
+ };
+})();
+
+ko.exportSymbol('toJS', ko.toJS);
+ko.exportSymbol('toJSON', ko.toJSON);
+(function () {
+ var hasDomDataExpandoProperty = '__ko__hasDomDataOptionValue__';
+
+ // Normally, SELECT elements and their OPTIONs can only take value of type 'string' (because the values
+ // are stored on DOM attributes). ko.selectExtensions provides a way for SELECTs/OPTIONs to have values
+ // that are arbitrary objects. This is very convenient when implementing things like cascading dropdowns.
+ ko.selectExtensions = {
+ readValue : function(element) {
+ switch (ko.utils.tagNameLower(element)) {
+ case 'option':
+ if (element[hasDomDataExpandoProperty] === true)
+ return ko.utils.domData.get(element, ko.bindingHandlers.options.optionValueDomDataKey);
+ return ko.utils.ieVersion <= 7
+ ? (element.getAttributeNode('value') && element.getAttributeNode('value').specified ? element.value : element.text)
+ : element.value;
+ case 'select':
+ return element.selectedIndex >= 0 ? ko.selectExtensions.readValue(element.options[element.selectedIndex]) : undefined;
+ default:
+ return element.value;
+ }
+ },
+
+ writeValue: function(element, value, allowUnset) {
+ switch (ko.utils.tagNameLower(element)) {
+ case 'option':
+ switch(typeof value) {
+ case "string":
+ ko.utils.domData.set(element, ko.bindingHandlers.options.optionValueDomDataKey, undefined);
+ if (hasDomDataExpandoProperty in element) { // IE <= 8 throws errors if you delete non-existent properties from a DOM node
+ delete element[hasDomDataExpandoProperty];
+ }
+ element.value = value;
+ break;
+ default:
+ // Store arbitrary object using DomData
+ ko.utils.domData.set(element, ko.bindingHandlers.options.optionValueDomDataKey, value);
+ element[hasDomDataExpandoProperty] = true;
+
+ // Special treatment of numbers is just for backward compatibility. KO 1.2.1 wrote numerical values to element.value.
+ element.value = typeof value === "number" ? value : "";
+ break;
+ }
+ break;
+ case 'select':
+ if (value === "" || value === null) // A blank string or null value will select the caption
+ value = undefined;
+ var selection = -1;
+ for (var i = 0, n = element.options.length, optionValue; i < n; ++i) {
+ optionValue = ko.selectExtensions.readValue(element.options[i]);
+ // Include special check to handle selecting a caption with a blank string value
+ if (optionValue == value || (optionValue == "" && value === undefined)) {
+ selection = i;
+ break;
+ }
+ }
+ if (allowUnset || selection >= 0 || (value === undefined && element.size > 1)) {
+ element.selectedIndex = selection;
+ }
+ break;
+ default:
+ if ((value === null) || (value === undefined))
+ value = "";
+ element.value = value;
+ break;
+ }
+ }
+ };
+})();
+
+ko.exportSymbol('selectExtensions', ko.selectExtensions);
+ko.exportSymbol('selectExtensions.readValue', ko.selectExtensions.readValue);
+ko.exportSymbol('selectExtensions.writeValue', ko.selectExtensions.writeValue);
+ko.expressionRewriting = (function () {
+ var javaScriptReservedWords = ["true", "false", "null", "undefined"];
+
+ // Matches something that can be assigned to--either an isolated identifier or something ending with a property accessor
+ // This is designed to be simple and avoid false negatives, but could produce false positives (e.g., a+b.c).
+ // This also will not properly handle nested brackets (e.g., obj1[obj2['prop']]; see #911).
+ var javaScriptAssignmentTarget = /^(?:[$_a-z][$\w]*|(.+)(\.\s*[$_a-z][$\w]*|\[.+\]))$/i;
+
+ function getWriteableValue(expression) {
+ if (ko.utils.arrayIndexOf(javaScriptReservedWords, expression) >= 0)
+ return false;
+ var match = expression.match(javaScriptAssignmentTarget);
+ return match === null ? false : match[1] ? ('Object(' + match[1] + ')' + match[2]) : expression;
+ }
+
+ // The following regular expressions will be used to split an object-literal string into tokens
+
+ // These two match strings, either with double quotes or single quotes
+ var stringDouble = '"(?:[^"\\\\]|\\\\.)*"',
+ stringSingle = "'(?:[^'\\\\]|\\\\.)*'",
+ // Matches a regular expression (text enclosed by slashes), but will also match sets of divisions
+ // as a regular expression (this is handled by the parsing loop below).
+ stringRegexp = '/(?:[^/\\\\]|\\\\.)*/\w*',
+ // These characters have special meaning to the parser and must not appear in the middle of a
+ // token, except as part of a string.
+ specials = ',"\'{}()/:[\\]',
+ // Match text (at least two characters) that does not contain any of the above special characters,
+ // although some of the special characters are allowed to start it (all but the colon and comma).
+ // The text can contain spaces, but leading or trailing spaces are skipped.
+ everyThingElse = '[^\\s:,/][^' + specials + ']*[^\\s' + specials + ']',
+ // Match any non-space character not matched already. This will match colons and commas, since they're
+ // not matched by "everyThingElse", but will also match any other single character that wasn't already
+ // matched (for example: in "a: 1, b: 2", each of the non-space characters will be matched by oneNotSpace).
+ oneNotSpace = '[^\\s]',
+
+ // Create the actual regular expression by or-ing the above strings. The order is important.
+ bindingToken = RegExp(stringDouble + '|' + stringSingle + '|' + stringRegexp + '|' + everyThingElse + '|' + oneNotSpace, 'g'),
+
+ // Match end of previous token to determine whether a slash is a division or regex.
+ divisionLookBehind = /[\])"'A-Za-z0-9_$]+$/,
+ keywordRegexLookBehind = {'in':1,'return':1,'typeof':1};
+
+ function parseObjectLiteral(objectLiteralString) {
+ // Trim leading and trailing spaces from the string
+ var str = ko.utils.stringTrim(objectLiteralString);
+
+ // Trim braces '{' surrounding the whole object literal
+ if (str.charCodeAt(0) === 123) str = str.slice(1, -1);
+
+ // Split into tokens
+ var result = [], toks = str.match(bindingToken), key, values, depth = 0;
+
+ if (toks) {
+ // Append a comma so that we don't need a separate code block to deal with the last item
+ toks.push(',');
+
+ for (var i = 0, tok; tok = toks[i]; ++i) {
+ var c = tok.charCodeAt(0);
+ // A comma signals the end of a key/value pair if depth is zero
+ if (c === 44) { // ","
+ if (depth <= 0) {
+ if (key)
+ result.push(values ? {key: key, value: values.join('')} : {'unknown': key});
+ key = values = depth = 0;
+ continue;
+ }
+ // Simply skip the colon that separates the name and value
+ } else if (c === 58) { // ":"
+ if (!values)
+ continue;
+ // A set of slashes is initially matched as a regular expression, but could be division
+ } else if (c === 47 && i && tok.length > 1) { // "/"
+ // Look at the end of the previous token to determine if the slash is actually division
+ var match = toks[i-1].match(divisionLookBehind);
+ if (match && !keywordRegexLookBehind[match[0]]) {
+ // The slash is actually a division punctuator; re-parse the remainder of the string (not including the slash)
+ str = str.substr(str.indexOf(tok) + 1);
+ toks = str.match(bindingToken);
+ toks.push(',');
+ i = -1;
+ // Continue with just the slash
+ tok = '/';
+ }
+ // Increment depth for parentheses, braces, and brackets so that interior commas are ignored
+ } else if (c === 40 || c === 123 || c === 91) { // '(', '{', '['
+ ++depth;
+ } else if (c === 41 || c === 125 || c === 93) { // ')', '}', ']'
+ --depth;
+ // The key must be a single token; if it's a string, trim the quotes
+ } else if (!key && !values) {
+ key = (c === 34 || c === 39) /* '"', "'" */ ? tok.slice(1, -1) : tok;
+ continue;
+ }
+ if (values)
+ values.push(tok);
+ else
+ values = [tok];
+ }
+ }
+ return result;
+ }
+
+ // Two-way bindings include a write function that allow the handler to update the value even if it's not an observable.
+ var twoWayBindings = {};
+
+ function preProcessBindings(bindingsStringOrKeyValueArray, bindingOptions) {
+ bindingOptions = bindingOptions || {};
+
+ function processKeyValue(key, val) {
+ var writableVal;
+ function callPreprocessHook(obj) {
+ return (obj && obj['preprocess']) ? (val = obj['preprocess'](val, key, processKeyValue)) : true;
+ }
+ if (!callPreprocessHook(ko['getBindingHandler'](key)))
+ return;
+
+ if (twoWayBindings[key] && (writableVal = getWriteableValue(val))) {
+ // For two-way bindings, provide a write method in case the value
+ // isn't a writable observable.
+ propertyAccessorResultStrings.push("'" + key + "':function(_z){" + writableVal + "=_z}");
+ }
+
+ // Values are wrapped in a function so that each value can be accessed independently
+ if (makeValueAccessors) {
+ val = 'function(){return ' + val + ' }';
+ }
+ resultStrings.push("'" + key + "':" + val);
+ }
+
+ var resultStrings = [],
+ propertyAccessorResultStrings = [],
+ makeValueAccessors = bindingOptions['valueAccessors'],
+ keyValueArray = typeof bindingsStringOrKeyValueArray === "string" ?
+ parseObjectLiteral(bindingsStringOrKeyValueArray) : bindingsStringOrKeyValueArray;
+
+ ko.utils.arrayForEach(keyValueArray, function(keyValue) {
+ processKeyValue(keyValue.key || keyValue['unknown'], keyValue.value);
+ });
+
+ if (propertyAccessorResultStrings.length)
+ processKeyValue('_ko_property_writers', "{" + propertyAccessorResultStrings.join(",") + " }");
+
+ return resultStrings.join(",");
+ }
+
+ return {
+ bindingRewriteValidators: [],
+
+ twoWayBindings: twoWayBindings,
+
+ parseObjectLiteral: parseObjectLiteral,
+
+ preProcessBindings: preProcessBindings,
+
+ keyValueArrayContainsKey: function(keyValueArray, key) {
+ for (var i = 0; i < keyValueArray.length; i++)
+ if (keyValueArray[i]['key'] == key)
+ return true;
+ return false;
+ },
+
+ // Internal, private KO utility for updating model properties from within bindings
+ // property: If the property being updated is (or might be) an observable, pass it here
+ // If it turns out to be a writable observable, it will be written to directly
+ // allBindings: An object with a get method to retrieve bindings in the current execution context.
+ // This will be searched for a '_ko_property_writers' property in case you're writing to a non-observable
+ // key: The key identifying the property to be written. Example: for { hasFocus: myValue }, write to 'myValue' by specifying the key 'hasFocus'
+ // value: The value to be written
+ // checkIfDifferent: If true, and if the property being written is a writable observable, the value will only be written if
+ // it is !== existing value on that writable observable
+ writeValueToProperty: function(property, allBindings, key, value, checkIfDifferent) {
+ if (!property || !ko.isObservable(property)) {
+ var propWriters = allBindings.get('_ko_property_writers');
+ if (propWriters && propWriters[key])
+ propWriters[key](value);
+ } else if (ko.isWriteableObservable(property) && (!checkIfDifferent || property.peek() !== value)) {
+ property(value);
+ }
+ }
+ };
+})();
+
+ko.exportSymbol('expressionRewriting', ko.expressionRewriting);
+ko.exportSymbol('expressionRewriting.bindingRewriteValidators', ko.expressionRewriting.bindingRewriteValidators);
+ko.exportSymbol('expressionRewriting.parseObjectLiteral', ko.expressionRewriting.parseObjectLiteral);
+ko.exportSymbol('expressionRewriting.preProcessBindings', ko.expressionRewriting.preProcessBindings);
+
+// Making bindings explicitly declare themselves as "two way" isn't ideal in the long term (it would be better if
+// all bindings could use an official 'property writer' API without needing to declare that they might). However,
+// since this is not, and has never been, a public API (_ko_property_writers was never documented), it's acceptable
+// as an internal implementation detail in the short term.
+// For those developers who rely on _ko_property_writers in their custom bindings, we expose _twoWayBindings as an
+// undocumented feature that makes it relatively easy to upgrade to KO 3.0. However, this is still not an official
+// public API, and we reserve the right to remove it at any time if we create a real public property writers API.
+ko.exportSymbol('expressionRewriting._twoWayBindings', ko.expressionRewriting.twoWayBindings);
+
+// For backward compatibility, define the following aliases. (Previously, these function names were misleading because
+// they referred to JSON specifically, even though they actually work with arbitrary JavaScript object literal expressions.)
+ko.exportSymbol('jsonExpressionRewriting', ko.expressionRewriting);
+ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.expressionRewriting.preProcessBindings);
+(function() {
+ // "Virtual elements" is an abstraction on top of the usual DOM API which understands the notion that comment nodes
+ // may be used to represent hierarchy (in addition to the DOM's natural hierarchy).
+ // If you call the DOM-manipulating functions on ko.virtualElements, you will be able to read and write the state
+ // of that virtual hierarchy
+ //
+ // The point of all this is to support containerless templates (e.g., blah)
+ // without having to scatter special cases all over the binding and templating code.
+
+ // IE 9 cannot reliably read the "nodeValue" property of a comment node (see https://github.com/SteveSanderson/knockout/issues/186)
+ // but it does give them a nonstandard alternative property called "text" that it can read reliably. Other browsers don't have that property.
+ // So, use node.text where available, and node.nodeValue elsewhere
+ var commentNodesHaveTextProperty = document && document.createComment("test").text === "";
+
+ var startCommentRegex = commentNodesHaveTextProperty ? /^$/ : /^\s*ko(?:\s+([\s\S]+))?\s*$/;
+ var endCommentRegex = commentNodesHaveTextProperty ? /^$/ : /^\s*\/ko\s*$/;
+ var htmlTagsWithOptionallyClosingChildren = { 'ul': true, 'ol': true };
+
+ function isStartComment(node) {
+ return (node.nodeType == 8) && startCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
+ }
+
+ function isEndComment(node) {
+ return (node.nodeType == 8) && endCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
+ }
+
+ function getVirtualChildren(startComment, allowUnbalanced) {
+ var currentNode = startComment;
+ var depth = 1;
+ var children = [];
+ while (currentNode = currentNode.nextSibling) {
+ if (isEndComment(currentNode)) {
+ depth--;
+ if (depth === 0)
+ return children;
+ }
+
+ children.push(currentNode);
+
+ if (isStartComment(currentNode))
+ depth++;
+ }
+ if (!allowUnbalanced)
+ throw new Error("Cannot find closing comment tag to match: " + startComment.nodeValue);
+ return null;
+ }
+
+ function getMatchingEndComment(startComment, allowUnbalanced) {
+ var allVirtualChildren = getVirtualChildren(startComment, allowUnbalanced);
+ if (allVirtualChildren) {
+ if (allVirtualChildren.length > 0)
+ return allVirtualChildren[allVirtualChildren.length - 1].nextSibling;
+ return startComment.nextSibling;
+ } else
+ return null; // Must have no matching end comment, and allowUnbalanced is true
+ }
+
+ function getUnbalancedChildTags(node) {
+ // e.g., from OK
Another, returns: Another
+ // from OK
, returns:
+ var childNode = node.firstChild, captureRemaining = null;
+ if (childNode) {
+ do {
+ if (captureRemaining) // We already hit an unbalanced node and are now just scooping up all subsequent nodes
+ captureRemaining.push(childNode);
+ else if (isStartComment(childNode)) {
+ var matchingEndComment = getMatchingEndComment(childNode, /* allowUnbalanced: */ true);
+ if (matchingEndComment) // It's a balanced tag, so skip immediately to the end of this virtual set
+ childNode = matchingEndComment;
+ else
+ captureRemaining = [childNode]; // It's unbalanced, so start capturing from this point
+ } else if (isEndComment(childNode)) {
+ captureRemaining = [childNode]; // It's unbalanced (if it wasn't, we'd have skipped over it already), so start capturing
+ }
+ } while (childNode = childNode.nextSibling);
+ }
+ return captureRemaining;
+ }
+
+ ko.virtualElements = {
+ allowedBindings: {},
+
+ childNodes: function(node) {
+ return isStartComment(node) ? getVirtualChildren(node) : node.childNodes;
+ },
+
+ emptyNode: function(node) {
+ if (!isStartComment(node))
+ ko.utils.emptyDomNode(node);
+ else {
+ var virtualChildren = ko.virtualElements.childNodes(node);
+ for (var i = 0, j = virtualChildren.length; i < j; i++)
+ ko.removeNode(virtualChildren[i]);
+ }
+ },
+
+ setDomNodeChildren: function(node, childNodes) {
+ if (!isStartComment(node))
+ ko.utils.setDomNodeChildren(node, childNodes);
+ else {
+ ko.virtualElements.emptyNode(node);
+ var endCommentNode = node.nextSibling; // Must be the next sibling, as we just emptied the children
+ for (var i = 0, j = childNodes.length; i < j; i++)
+ endCommentNode.parentNode.insertBefore(childNodes[i], endCommentNode);
+ }
+ },
+
+ prepend: function(containerNode, nodeToPrepend) {
+ if (!isStartComment(containerNode)) {
+ if (containerNode.firstChild)
+ containerNode.insertBefore(nodeToPrepend, containerNode.firstChild);
+ else
+ containerNode.appendChild(nodeToPrepend);
+ } else {
+ // Start comments must always have a parent and at least one following sibling (the end comment)
+ containerNode.parentNode.insertBefore(nodeToPrepend, containerNode.nextSibling);
+ }
+ },
+
+ insertAfter: function(containerNode, nodeToInsert, insertAfterNode) {
+ if (!insertAfterNode) {
+ ko.virtualElements.prepend(containerNode, nodeToInsert);
+ } else if (!isStartComment(containerNode)) {
+ // Insert after insertion point
+ if (insertAfterNode.nextSibling)
+ containerNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
+ else
+ containerNode.appendChild(nodeToInsert);
+ } else {
+ // Children of start comments must always have a parent and at least one following sibling (the end comment)
+ containerNode.parentNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
+ }
+ },
+
+ firstChild: function(node) {
+ if (!isStartComment(node))
+ return node.firstChild;
+ if (!node.nextSibling || isEndComment(node.nextSibling))
+ return null;
+ return node.nextSibling;
+ },
+
+ nextSibling: function(node) {
+ if (isStartComment(node))
+ node = getMatchingEndComment(node);
+ if (node.nextSibling && isEndComment(node.nextSibling))
+ return null;
+ return node.nextSibling;
+ },
+
+ hasBindingValue: isStartComment,
+
+ virtualNodeBindingValue: function(node) {
+ var regexMatch = (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex);
+ return regexMatch ? regexMatch[1] : null;
+ },
+
+ normaliseVirtualElementDomStructure: function(elementVerified) {
+ // Workaround for https://github.com/SteveSanderson/knockout/issues/155
+ // (IE <= 8 or IE 9 quirks mode parses your HTML weirdly, treating closing tags as if they don't exist, thereby moving comment nodes
+ // that are direct descendants of into the preceding - )
+ if (!htmlTagsWithOptionallyClosingChildren[ko.utils.tagNameLower(elementVerified)])
+ return;
+
+ // Scan immediate children to see if they contain unbalanced comment tags. If they do, those comment tags
+ // must be intended to appear *after* that child, so move them there.
+ var childNode = elementVerified.firstChild;
+ if (childNode) {
+ do {
+ if (childNode.nodeType === 1) {
+ var unbalancedTags = getUnbalancedChildTags(childNode);
+ if (unbalancedTags) {
+ // Fix up the DOM by moving the unbalanced tags to where they most likely were intended to be placed - *after* the child
+ var nodeToInsertBefore = childNode.nextSibling;
+ for (var i = 0; i < unbalancedTags.length; i++) {
+ if (nodeToInsertBefore)
+ elementVerified.insertBefore(unbalancedTags[i], nodeToInsertBefore);
+ else
+ elementVerified.appendChild(unbalancedTags[i]);
+ }
+ }
+ }
+ } while (childNode = childNode.nextSibling);
+ }
+ }
+ };
+})();
+ko.exportSymbol('virtualElements', ko.virtualElements);
+ko.exportSymbol('virtualElements.allowedBindings', ko.virtualElements.allowedBindings);
+ko.exportSymbol('virtualElements.emptyNode', ko.virtualElements.emptyNode);
+//ko.exportSymbol('virtualElements.firstChild', ko.virtualElements.firstChild); // firstChild is not minified
+ko.exportSymbol('virtualElements.insertAfter', ko.virtualElements.insertAfter);
+//ko.exportSymbol('virtualElements.nextSibling', ko.virtualElements.nextSibling); // nextSibling is not minified
+ko.exportSymbol('virtualElements.prepend', ko.virtualElements.prepend);
+ko.exportSymbol('virtualElements.setDomNodeChildren', ko.virtualElements.setDomNodeChildren);
+(function() {
+ var defaultBindingAttributeName = "data-bind";
+
+ ko.bindingProvider = function() {
+ this.bindingCache = {};
+ };
+
+ ko.utils.extend(ko.bindingProvider.prototype, {
+ 'nodeHasBindings': function(node) {
+ switch (node.nodeType) {
+ case 1: return node.getAttribute(defaultBindingAttributeName) != null; // Element
+ case 8: return ko.virtualElements.hasBindingValue(node); // Comment node
+ default: return false;
+ }
+ },
+
+ 'getBindings': function(node, bindingContext) {
+ var bindingsString = this['getBindingsString'](node, bindingContext);
+ return bindingsString ? this['parseBindingsString'](bindingsString, bindingContext, node) : null;
+ },
+
+ 'getBindingAccessors': function(node, bindingContext) {
+ var bindingsString = this['getBindingsString'](node, bindingContext);
+ return bindingsString ? this['parseBindingsString'](bindingsString, bindingContext, node, {'valueAccessors':true}) : null;
+ },
+
+ // The following function is only used internally by this default provider.
+ // It's not part of the interface definition for a general binding provider.
+ 'getBindingsString': function(node, bindingContext) {
+ switch (node.nodeType) {
+ case 1: return node.getAttribute(defaultBindingAttributeName); // Element
+ case 8: return ko.virtualElements.virtualNodeBindingValue(node); // Comment node
+ default: return null;
+ }
+ },
+
+ // The following function is only used internally by this default provider.
+ // It's not part of the interface definition for a general binding provider.
+ 'parseBindingsString': function(bindingsString, bindingContext, node, options) {
+ try {
+ var bindingFunction = createBindingsStringEvaluatorViaCache(bindingsString, this.bindingCache, options);
+ return bindingFunction(bindingContext, node);
+ } catch (ex) {
+ ex.message = "Unable to parse bindings.\nBindings value: " + bindingsString + "\nMessage: " + ex.message;
+ throw ex;
+ }
+ }
+ });
+
+ ko.bindingProvider['instance'] = new ko.bindingProvider();
+
+ function createBindingsStringEvaluatorViaCache(bindingsString, cache, options) {
+ var cacheKey = bindingsString + (options && options['valueAccessors'] || '');
+ return cache[cacheKey]
+ || (cache[cacheKey] = createBindingsStringEvaluator(bindingsString, options));
+ }
+
+ function createBindingsStringEvaluator(bindingsString, options) {
+ // Build the source for a function that evaluates "expression"
+ // For each scope variable, add an extra level of "with" nesting
+ // Example result: with(sc1) { with(sc0) { return (expression) } }
+ var rewrittenBindings = ko.expressionRewriting.preProcessBindings(bindingsString, options),
+ functionBody = "with($context){with($data||{}){return{" + rewrittenBindings + "}}}";
+ return new Function("$context", "$element", functionBody);
+ }
+})();
+
+ko.exportSymbol('bindingProvider', ko.bindingProvider);
+(function () {
+ ko.bindingHandlers = {};
+
+ // The following element types will not be recursed into during binding. In the future, we
+ // may consider adding to this list, because such elements' contents are always
+ // intended to be bound in a different context from where they appear in the document.
+ var bindingDoesNotRecurseIntoElementTypes = {
+ // Don't want bindings that operate on text nodes to mutate