diff -r d043dac9f34e -r d8fa1e55acfa Resources/Web/js/knockout.mapping-latest.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Resources/Web/js/knockout.mapping-latest.js	Sun May 27 20:15:32 2012 +0000
@@ -0,0 +1,687 @@
+// Knockout Mapping plugin v2.1.2
+// (c) 2012 Steven Sanderson, Roy Jacobs - http://knockoutjs.com/
+// License: MIT (http://www.opensource.org/licenses/mit-license.php)
+
+(function (factory) {
+	// Module systems magic dance.
+
+	if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
+		// CommonJS or Node: hard-coded dependency on "knockout"
+		factory(require("knockout"), exports);
+	} else if (typeof define === "function" && define["amd"]) {
+		// AMD anonymous module with hard-coded dependency on "knockout"
+		define(["knockout", "exports"], factory);
+	} else {
+		// <script> tag: use the global `ko` object, attaching a `mapping` property
+		factory(ko, ko.mapping = {});
+	}
+}(function (ko, exports) {
+	var DEBUG=true;
+	var mappingProperty = "__ko_mapping__";
+	var realKoDependentObservable = ko.dependentObservable;
+	var mappingNesting = 0;
+	var dependentObservables;
+	var visitedObjects;
+
+	var _defaultOptions = {
+		include: ["_destroy"],
+		ignore: [],
+		copy: []
+	};
+	var defaultOptions = _defaultOptions;
+
+	exports.isMapped = function (viewModel) {
+		var unwrapped = ko.utils.unwrapObservable(viewModel);
+		return unwrapped && unwrapped[mappingProperty];
+	}
+
+	exports.fromJS = function (jsObject /*, inputOptions, target*/ ) {
+		if (arguments.length == 0) throw new Error("When calling ko.fromJS, pass the object you want to convert.");
+
+		// When mapping is completed, even with an exception, reset the nesting level
+		window.setTimeout(function () {
+			mappingNesting = 0;
+		}, 0);
+
+		if (!mappingNesting++) {
+			dependentObservables = [];
+			visitedObjects = new objectLookup();
+		}
+
+		var options;
+		var target;
+
+		if (arguments.length == 2) {
+			if (arguments[1][mappingProperty]) {
+				target = arguments[1];
+			} else {
+				options = arguments[1];
+			}
+		}
+		if (arguments.length == 3) {
+			options = arguments[1];
+			target = arguments[2];
+		}
+
+		if (target) {
+			options = mergeOptions(target[mappingProperty], options);
+		} else {
+			options = mergeOptions(options);
+		}
+		options.mappedProperties = options.mappedProperties || {};
+
+		var result = updateViewModel(target, jsObject, options);
+		if (target) {
+			result = target;
+		}
+
+		// Evaluate any dependent observables that were proxied.
+		// Do this in a timeout to defer execution. Basically, any user code that explicitly looks up the DO will perform the first evaluation. Otherwise,
+		// it will be done by this code.
+		if (!--mappingNesting) {
+			window.setTimeout(function () {
+				while (dependentObservables.length) {
+					var DO = dependentObservables.pop();
+					if (DO) DO();
+				}
+			}, 0);
+		}
+
+		// Save any new mapping options in the view model, so that updateFromJS can use them later.
+		result[mappingProperty] = mergeOptions(result[mappingProperty], options);
+
+		return result;
+	};
+
+	exports.fromJSON = function (jsonString /*, options, target*/ ) {
+		var parsed = ko.utils.parseJson(jsonString);
+		arguments[0] = parsed;
+		return exports.fromJS.apply(this, arguments);
+	};
+
+	exports.updateFromJS = function (viewModel) {
+		throw new Error("ko.mapping.updateFromJS, use ko.mapping.fromJS instead. Please note that the order of parameters is different!");
+	};
+
+	exports.updateFromJSON = function (viewModel) {
+		throw new Error("ko.mapping.updateFromJSON, use ko.mapping.fromJSON instead. Please note that the order of parameters is different!");
+	};
+
+	exports.toJS = function (rootObject, options) {
+		if (arguments.length == 0) throw new Error("When calling ko.mapping.toJS, pass the object you want to convert.");
+		// Merge in the options used in fromJS
+		options = mergeOptions(rootObject[mappingProperty], options);
+
+		// We just unwrap everything at every level in the object graph
+		return visitModel(rootObject, function (x) {
+			return ko.utils.unwrapObservable(x)
+		}, options);
+	};
+
+	exports.toJSON = function (rootObject, options) {
+		var plainJavaScriptObject = exports.toJS(rootObject, options);
+		return ko.utils.stringifyJson(plainJavaScriptObject);
+	};
+
+	exports.visitModel = function (rootObject, callback, options) {
+		if (arguments.length == 0) throw new Error("When calling ko.mapping.visitModel, pass the object you want to visit.");
+		// Merge in the options used in fromJS
+		options = mergeOptions(rootObject[mappingProperty], options);
+
+		return visitModel(rootObject, callback, options);
+	};
+
+	exports.defaultOptions = function () {
+		if (arguments.length > 0) {
+			defaultOptions = arguments[0];
+		} else {
+			return defaultOptions;
+		}
+	};
+
+	exports.resetDefaultOptions = function () {
+		defaultOptions = {
+			include: _defaultOptions.include.slice(0),
+			ignore: _defaultOptions.ignore.slice(0),
+			copy: _defaultOptions.copy.slice(0)
+		};
+	};
+
+	exports.getType = function(x) {
+		if ((x) && (typeof (x) === "object")) {
+			if (x.constructor == (new Date).constructor) return "date";
+			if (x.constructor == (new Array).constructor) return "array";
+		}
+		return typeof x;
+	}
+
+	function extendOptionsArray(distArray, sourceArray) {
+		return ko.utils.arrayGetDistinctValues(
+			ko.utils.arrayPushAll(distArray, sourceArray)
+		);
+	}
+
+	function extendOptionsObject(target, options) {
+		var type = exports.getType,
+			name, special = { "include": true, "ignore": true, "copy": true },
+			t, o, i = 1, l = arguments.length;
+		if (type(target) !== "object") {
+			target = {};
+		}
+		for (; i < l; i++) {
+			options = arguments[i];
+			if (type(options) !== "object") {
+				options = {};
+			}
+			for (name in options) {
+				t = target[name]; o = options[name];
+				if (name !== "constructor" && special[name] && type(o) !== "array") {
+					if (type(o) !== "string") {
+						throw new Error("ko.mapping.defaultOptions()." + name + " should be an array or string.");
+					}
+					o = [o];
+				}
+				switch (type(o)) {
+				case "object": // Recurse
+					t = type(t) === "object" ? t : {};
+					target[name] = extendOptionsObject(t, o);
+					break;
+				case "array":
+					t = type(t) === "array" ? t : [];
+					target[name] = extendOptionsArray(t, o);
+					break;
+				default:
+					target[name] = o;
+				}
+			}
+		}
+		return target;
+	}
+
+	function mergeOptions() {
+		var options = ko.utils.arrayPushAll([{}, defaultOptions], arguments); // Always use empty object as target to avoid changing default options
+		options = extendOptionsObject.apply(this, options);
+		return options;
+	}
+
+	// When using a 'create' callback, we proxy the dependent observable so that it doesn't immediately evaluate on creation.
+	// The reason is that the dependent observables in the user-specified callback may contain references to properties that have not been mapped yet.
+	function withProxyDependentObservable(dependentObservables, callback) {
+		var localDO = ko.dependentObservable;
+		ko.dependentObservable = function (read, owner, options) {
+			options = options || {};
+
+			if (read && typeof read == "object") { // mirrors condition in knockout implementation of DO's
+				options = read;
+			}
+
+			var realDeferEvaluation = options.deferEvaluation;
+
+			var isRemoved = false;
+
+			// We wrap the original dependent observable so that we can remove it from the 'dependentObservables' list we need to evaluate after mapping has
+			// completed if the user already evaluated the DO themselves in the meantime.
+			var wrap = function (DO) {
+				var wrapped = realKoDependentObservable({
+					read: function () {
+						if (!isRemoved) {
+							ko.utils.arrayRemoveItem(dependentObservables, DO);
+							isRemoved = true;
+						}
+						return DO.apply(DO, arguments);
+					},
+					write: function (val) {
+						return DO(val);
+					},
+					deferEvaluation: true
+				});
+				if(DEBUG) wrapped._wrapper = true;
+				return wrapped;
+			};
+			
+			options.deferEvaluation = true; // will either set for just options, or both read/options.
+			var realDependentObservable = new realKoDependentObservable(read, owner, options);
+
+			if (!realDeferEvaluation) {
+				realDependentObservable = wrap(realDependentObservable);
+				dependentObservables.push(realDependentObservable);
+			}
+
+			return realDependentObservable;
+		}
+		ko.dependentObservable.fn = realKoDependentObservable.fn;
+		ko.computed = ko.dependentObservable;
+		var result = callback();
+		ko.dependentObservable = localDO;
+		ko.computed = ko.dependentObservable;
+		return result;
+	}
+
+	function updateViewModel(mappedRootObject, rootObject, options, parentName, parent, parentPropertyName) {
+		var isArray = ko.utils.unwrapObservable(rootObject) instanceof Array;
+
+		// If nested object was already mapped previously, take the options from it
+		if (parentName !== undefined && exports.isMapped(mappedRootObject)) {
+			options = ko.utils.unwrapObservable(mappedRootObject)[mappingProperty];
+			parentName = "";
+			parentPropertyName = "";
+		}
+
+		parentName = parentName || "";
+		parentPropertyName = parentPropertyName || "";
+
+		var callbackParams = {
+			data: rootObject,
+			parent: parent
+		};
+
+		var getCallback = function (name) {
+			var callback;
+			if (parentName === "") {
+				callback = options[name];
+			} else if (callback = options[parentName]) {
+				callback = callback[name]
+			}
+			return callback;
+		};
+
+		var hasCreateCallback = function () {
+			return getCallback("create") instanceof Function;
+		};
+
+		var createCallback = function (data) {
+			return withProxyDependentObservable(dependentObservables, function () {
+				return getCallback("create")({
+					data: data || callbackParams.data,
+					parent: callbackParams.parent
+				});
+			});
+		};
+
+		var hasUpdateCallback = function () {
+			return getCallback("update") instanceof Function;
+		};
+
+		var updateCallback = function (obj, data) {
+			var params = {
+				data: data || callbackParams.data,
+				parent: callbackParams.parent,
+				target: ko.utils.unwrapObservable(obj)
+			};
+
+			if (ko.isWriteableObservable(obj)) {
+				params.observable = obj;
+			}
+
+			return getCallback("update")(params);
+		}
+
+		var alreadyMapped = visitedObjects.get(rootObject);
+		if (alreadyMapped) {
+			return alreadyMapped;
+		}
+
+		if (!isArray) {
+			// For atomic types, do a direct update on the observable
+			if (!canHaveProperties(rootObject)) {
+				switch (exports.getType(rootObject)) {
+				case "function":
+					if (hasUpdateCallback()) {
+						if (ko.isWriteableObservable(rootObject)) {
+							rootObject(updateCallback(rootObject));
+							mappedRootObject = rootObject;
+						} else {
+							mappedRootObject = updateCallback(rootObject);
+						}
+					} else {
+						mappedRootObject = rootObject;
+					}
+					break;
+				default:
+					if (ko.isWriteableObservable(mappedRootObject)) {
+						if (hasUpdateCallback()) {
+							mappedRootObject(updateCallback(mappedRootObject));
+						} else {
+							mappedRootObject(ko.utils.unwrapObservable(rootObject));
+						}
+					} else {
+						if (hasCreateCallback()) {
+							mappedRootObject = createCallback();
+						} else {
+							mappedRootObject = ko.observable(ko.utils.unwrapObservable(rootObject));
+						}
+
+						if (hasUpdateCallback()) {
+							mappedRootObject(updateCallback(mappedRootObject));
+						}
+					}
+					break;
+				}
+
+			} else {
+				mappedRootObject = ko.utils.unwrapObservable(mappedRootObject);
+				if (!mappedRootObject) {
+					if (hasCreateCallback()) {
+						var result = createCallback();
+
+						if (hasUpdateCallback()) {
+							result = updateCallback(result);
+						}
+
+						return result;
+					} else {
+						if (hasUpdateCallback()) {
+							return updateCallback(result);
+						}
+
+						mappedRootObject = {};
+					}
+				}
+
+				if (hasUpdateCallback()) {
+					mappedRootObject = updateCallback(mappedRootObject);
+				}
+
+				visitedObjects.save(rootObject, mappedRootObject);
+
+				// For non-atomic types, visit all properties and update recursively
+				visitPropertiesOrArrayEntries(rootObject, function (indexer) {
+					var fullPropertyName = getPropertyName(parentPropertyName, rootObject, indexer);
+
+					if (ko.utils.arrayIndexOf(options.ignore, fullPropertyName) != -1) {
+						return;
+					}
+
+					if (ko.utils.arrayIndexOf(options.copy, fullPropertyName) != -1) {
+						mappedRootObject[indexer] = rootObject[indexer];
+						return;
+					}
+
+					// In case we are adding an already mapped property, fill it with the previously mapped property value to prevent recursion.
+					// If this is a property that was generated by fromJS, we should use the options specified there
+					var prevMappedProperty = visitedObjects.get(rootObject[indexer]);
+					var value = prevMappedProperty || updateViewModel(mappedRootObject[indexer], rootObject[indexer], options, indexer, mappedRootObject, fullPropertyName);
+
+					if (ko.isWriteableObservable(mappedRootObject[indexer])) {
+						mappedRootObject[indexer](ko.utils.unwrapObservable(value));
+					} else {
+						mappedRootObject[indexer] = value;
+					}
+
+					options.mappedProperties[fullPropertyName] = true;
+				});
+			}
+		} else {
+			var changes = [];
+
+			var hasKeyCallback = getCallback("key") instanceof Function;
+			var keyCallback = hasKeyCallback ? getCallback("key") : function (x) {
+				return x;
+			};
+			if (!ko.isObservable(mappedRootObject)) {
+				// When creating the new observable array, also add a bunch of utility functions that take the 'key' of the array items into account.
+				mappedRootObject = ko.observableArray([]);
+
+				mappedRootObject.mappedRemove = function (valueOrPredicate) {
+					var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) {
+							return value === keyCallback(valueOrPredicate);
+						};
+					return mappedRootObject.remove(function (item) {
+						return predicate(keyCallback(item));
+					});
+				}
+
+				mappedRootObject.mappedRemoveAll = function (arrayOfValues) {
+					var arrayOfKeys = filterArrayByKey(arrayOfValues, keyCallback);
+					return mappedRootObject.remove(function (item) {
+						return ko.utils.arrayIndexOf(arrayOfKeys, keyCallback(item)) != -1;
+					});
+				}
+
+				mappedRootObject.mappedDestroy = function (valueOrPredicate) {
+					var predicate = typeof valueOrPredicate == "function" ? valueOrPredicate : function (value) {
+							return value === keyCallback(valueOrPredicate);
+						};
+					return mappedRootObject.destroy(function (item) {
+						return predicate(keyCallback(item));
+					});
+				}
+
+				mappedRootObject.mappedDestroyAll = function (arrayOfValues) {
+					var arrayOfKeys = filterArrayByKey(arrayOfValues, keyCallback);
+					return mappedRootObject.destroy(function (item) {
+						return ko.utils.arrayIndexOf(arrayOfKeys, keyCallback(item)) != -1;
+					});
+				}
+
+				mappedRootObject.mappedIndexOf = function (item) {
+					var keys = filterArrayByKey(mappedRootObject(), keyCallback);
+					var key = keyCallback(item);
+					return ko.utils.arrayIndexOf(keys, key);
+				}
+
+				mappedRootObject.mappedCreate = function (value) {
+					if (mappedRootObject.mappedIndexOf(value) !== -1) {
+						throw new Error("There already is an object with the key that you specified.");
+					}
+
+					var item = hasCreateCallback() ? createCallback(value) : value;
+					if (hasUpdateCallback()) {
+						var newValue = updateCallback(item, value);
+						if (ko.isWriteableObservable(item)) {
+							item(newValue);
+						} else {
+							item = newValue;
+						}
+					}
+					mappedRootObject.push(item);
+					return item;
+				}
+			}
+
+			var currentArrayKeys = filterArrayByKey(ko.utils.unwrapObservable(mappedRootObject), keyCallback).sort();
+			var newArrayKeys = filterArrayByKey(rootObject, keyCallback);
+			if (hasKeyCallback) newArrayKeys.sort();
+			var editScript = ko.utils.compareArrays(currentArrayKeys, newArrayKeys);
+
+			var ignoreIndexOf = {};
+
+			var newContents = [];
+			for (var i = 0, j = editScript.length; i < j; i++) {
+				var key = editScript[i];
+				var mappedItem;
+				var fullPropertyName = getPropertyName(parentPropertyName, rootObject, i);
+				switch (key.status) {
+				case "added":
+					var item = getItemByKey(ko.utils.unwrapObservable(rootObject), key.value, keyCallback);
+					mappedItem = updateViewModel(undefined, item, options, parentName, mappedRootObject, fullPropertyName);
+					if(!hasCreateCallback()) {
+						mappedItem = ko.utils.unwrapObservable(mappedItem);
+					}
+
+					var index = ignorableIndexOf(ko.utils.unwrapObservable(rootObject), item, ignoreIndexOf);
+					newContents[index] = mappedItem;
+					ignoreIndexOf[index] = true;
+					break;
+				case "retained":
+					var item = getItemByKey(ko.utils.unwrapObservable(rootObject), key.value, keyCallback);
+					mappedItem = getItemByKey(mappedRootObject, key.value, keyCallback);
+					updateViewModel(mappedItem, item, options, parentName, mappedRootObject, fullPropertyName);
+
+					var index = ignorableIndexOf(ko.utils.unwrapObservable(rootObject), item, ignoreIndexOf);
+					newContents[index] = mappedItem;
+					ignoreIndexOf[index] = true;
+					break;
+				case "deleted":
+					mappedItem = getItemByKey(mappedRootObject, key.value, keyCallback);
+					break;
+				}
+
+				changes.push({
+					event: key.status,
+					item: mappedItem
+				});
+			}
+
+			mappedRootObject(newContents);
+
+			var arrayChangedCallback = getCallback("arrayChanged");
+			if (arrayChangedCallback instanceof Function) {
+				ko.utils.arrayForEach(changes, function (change) {
+					arrayChangedCallback(change.event, change.item);
+				});
+			}
+		}
+
+		return mappedRootObject;
+	}
+
+	function ignorableIndexOf(array, item, ignoreIndices) {
+		for (var i = 0, j = array.length; i < j; i++) {
+			if (ignoreIndices[i] === true) continue;
+			if (array[i] === item) return i;
+		}
+		return null;
+	}
+
+	function mapKey(item, callback) {
+		var mappedItem;
+		if (callback) mappedItem = callback(item);
+		if (exports.getType(mappedItem) === "undefined") mappedItem = item;
+
+		return ko.utils.unwrapObservable(mappedItem);
+	}
+
+	function getItemByKey(array, key, callback) {
+		var filtered = ko.utils.arrayFilter(ko.utils.unwrapObservable(array), function (item) {
+			return mapKey(item, callback) === key;
+		});
+
+		if (filtered.length == 0) throw new Error("When calling ko.update*, the key '" + key + "' was not found!");
+		if ((filtered.length > 1) && (canHaveProperties(filtered[0]))) throw new Error("When calling ko.update*, the key '" + key + "' was not unique!");
+
+		return filtered[0];
+	}
+
+	function filterArrayByKey(array, callback) {
+		return ko.utils.arrayMap(ko.utils.unwrapObservable(array), function (item) {
+			if (callback) {
+				return mapKey(item, callback);
+			} else {
+				return item;
+			}
+		});
+	}
+
+	function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {
+		if (rootObject instanceof Array) {
+			for (var i = 0; i < rootObject.length; i++)
+			visitorCallback(i);
+		} else {
+			for (var propertyName in rootObject)
+			visitorCallback(propertyName);
+		}
+	};
+
+	function canHaveProperties(object) {
+		var type = exports.getType(object);
+		return (type === "object" || type === "array") && (object !== null) && (type !== "undefined");
+	}
+
+	// Based on the parentName, this creates a fully classified name of a property
+
+	function getPropertyName(parentName, parent, indexer) {
+		var propertyName = parentName || "";
+		if (parent instanceof Array) {
+			if (parentName) {
+				propertyName += "[" + indexer + "]";
+			}
+		} else {
+			if (parentName) {
+				propertyName += ".";
+			}
+			propertyName += indexer;
+		}
+		return propertyName;
+	}
+
+	function visitModel(rootObject, callback, options, parentName, fullParentName) {
+		// If nested object was already mapped previously, take the options from it
+		if (parentName !== undefined && exports.isMapped(rootObject)) {
+			//options = ko.utils.unwrapObservable(rootObject)[mappingProperty];
+			options = mergeOptions(ko.utils.unwrapObservable(rootObject)[mappingProperty], options);
+			parentName = "";
+		}
+
+		if (parentName === undefined) { // the first call
+			visitedObjects = new objectLookup();
+		}
+
+		parentName = parentName || "";
+
+		var mappedRootObject;
+		var unwrappedRootObject = ko.utils.unwrapObservable(rootObject);
+		if (!canHaveProperties(unwrappedRootObject)) {
+			return callback(rootObject, fullParentName);
+		} else {
+			// Only do a callback, but ignore the results
+			callback(rootObject, fullParentName);
+			mappedRootObject = unwrappedRootObject instanceof Array ? [] : {};
+		}
+
+		visitedObjects.save(rootObject, mappedRootObject);
+
+		var origFullParentName = fullParentName;
+		visitPropertiesOrArrayEntries(unwrappedRootObject, function (indexer) {
+			if (options.ignore && ko.utils.arrayIndexOf(options.ignore, indexer) != -1) return;
+
+			var propertyValue = unwrappedRootObject[indexer];
+			var fullPropertyName = getPropertyName(parentName, unwrappedRootObject, indexer);
+			
+			// If we don't want to explicitly copy the unmapped property...
+			if (ko.utils.arrayIndexOf(options.copy, indexer) === -1) {
+				// ...find out if it's a property we want to explicitly include
+				if (ko.utils.arrayIndexOf(options.include, indexer) === -1) {
+					// Options contains all the properties that were part of the original object.
+					// If a property does not exist, and it is not because it is part of an array (e.g. "myProp[3]"), then it should not be unmapped.
+					if (options.mappedProperties && !options.mappedProperties[fullPropertyName] && !(unwrappedRootObject instanceof Array)) {
+						return;
+					}
+				}
+			}
+
+			fullParentName = getPropertyName(origFullParentName, unwrappedRootObject, indexer);
+			
+			var propertyType = exports.getType(ko.utils.unwrapObservable(propertyValue));
+			switch (propertyType) {
+			case "object":
+			case "array":
+			case "undefined":
+				var previouslyMappedValue = visitedObjects.get(propertyValue);
+				mappedRootObject[indexer] = (exports.getType(previouslyMappedValue) !== "undefined") ? previouslyMappedValue : visitModel(propertyValue, callback, options, fullPropertyName, fullParentName);
+				break;
+			default:
+				mappedRootObject[indexer] = callback(propertyValue, fullParentName);
+			}
+		});
+
+		return mappedRootObject;
+	}
+
+	function objectLookup() {
+		var keys = [];
+		var values = [];
+		this.save = function (key, value) {
+			var existingIndex = ko.utils.arrayIndexOf(keys, key);
+			if (existingIndex >= 0) values[existingIndex] = value;
+			else {
+				keys.push(key);
+				values.push(value);
+			}
+		};
+		this.get = function (key) {
+			var existingIndex = ko.utils.arrayIndexOf(keys, key);
+			return (existingIndex >= 0) ? values[existingIndex] : undefined;
+		};
+	};
+}));
\ No newline at end of file