Initial commit of intern.ccwn.org contentsHEADmaster

316 files changed, 67014 insertions, 0 deletions

diff --git a/js/dojo-1.7.2/dojo/AdapterRegistry.js b/js/dojo-1.7.2/dojo/AdapterRegistry.js
new file mode 100644
index 0000000..eace876
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/AdapterRegistry.js
@@ -0,0 +1,114 @@
+//>>built
+define("dojo/AdapterRegistry", ["./_base/kernel", "./_base/lang"], function(dojo, lang) {
+	// module:
+	//		dojo/AdapterRegistry
+	// summary:
+	//		TODOC
+
+var AdapterRegistry = dojo.AdapterRegistry = function(/*Boolean?*/ returnWrappers){
+	//	summary:
+	//		A registry to make contextual calling/searching easier.
+	//	description:
+	//		Objects of this class keep list of arrays in the form [name, check,
+	//		wrap, directReturn] that are used to determine what the contextual
+	//		result of a set of checked arguments is. All check/wrap functions
+	//		in this registry should be of the same arity.
+	//	example:
+	//	|	// create a new registry
+	//	|	var reg = new dojo.AdapterRegistry();
+	//	|	reg.register("handleString",
+	//	|		dojo.isString,
+	//	|		function(str){
+	//	|			// do something with the string here
+	//	|		}
+	//	|	);
+	//	|	reg.register("handleArr",
+	//	|		dojo.isArray,
+	//	|		function(arr){
+	//	|			// do something with the array here
+	//	|		}
+	//	|	);
+	//	|
+	//	|	// now we can pass reg.match() *either* an array or a string and
+	//	|	// the value we pass will get handled by the right function
+	//	|	reg.match("someValue"); // will call the first function
+	//	|	reg.match(["someValue"]); // will call the second
+
+	this.pairs = [];
+	this.returnWrappers = returnWrappers || false; // Boolean
+};
+
+/*=====
+// doc alias helpers:
+AdapterRegistry = dojo.AdapterRegistry;
+=====*/
+
+lang.extend(AdapterRegistry, {
+	register: function(/*String*/ name, /*Function*/ check, /*Function*/ wrap, /*Boolean?*/ directReturn, /*Boolean?*/ override){
+		//	summary:
+		//		register a check function to determine if the wrap function or
+		//		object gets selected
+		//	name:
+		//		a way to identify this matcher.
+		//	check:
+		//		a function that arguments are passed to from the adapter's
+		//		match() function.  The check function should return true if the
+		//		given arguments are appropriate for the wrap function.
+		//	directReturn:
+		//		If directReturn is true, the value passed in for wrap will be
+		//		returned instead of being called. Alternately, the
+		//		AdapterRegistry can be set globally to "return not call" using
+		//		the returnWrappers property. Either way, this behavior allows
+		//		the registry to act as a "search" function instead of a
+		//		function interception library.
+		//	override:
+		//		If override is given and true, the check function will be given
+		//		highest priority. Otherwise, it will be the lowest priority
+		//		adapter.
+		this.pairs[((override) ? "unshift" : "push")]([name, check, wrap, directReturn]);
+	},
+
+	match: function(/* ... */){
+		// summary:
+		//		Find an adapter for the given arguments. If no suitable adapter
+		//		is found, throws an exception. match() accepts any number of
+		//		arguments, all of which are passed to all matching functions
+		//		from the registered pairs.
+		for(var i = 0; i < this.pairs.length; i++){
+			var pair = this.pairs[i];
+			if(pair[1].apply(this, arguments)){
+				if((pair[3])||(this.returnWrappers)){
+					return pair[2];
+				}else{
+					return pair[2].apply(this, arguments);
+				}
+			}
+		}
+		throw new Error("No match found");
+	},
+
+	unregister: function(name){
+		// summary:
+		//		Remove a named adapter from the registry
+		// name: String
+		//		The name of the adapter.
+		// returns: Boolean
+		//		Returns true if operation is successful.
+		//		Returns false if operation fails.
+	
+		// FIXME: this is kind of a dumb way to handle this. On a large
+		// registry this will be slow-ish and we can use the name as a lookup
+		// should we choose to trade memory for speed.
+		for(var i = 0; i < this.pairs.length; i++){
+			var pair = this.pairs[i];
+			if(pair[0] == name){
+				this.pairs.splice(i, 1);
+				return true;
+			}
+		}
+		return false;
+	}
+});
+
+return AdapterRegistry;
+});
diff --git a/js/dojo-1.7.2/dojo/DeferredList.js b/js/dojo-1.7.2/dojo/DeferredList.js
new file mode 100644
index 0000000..52ba47e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/DeferredList.js
@@ -0,0 +1,87 @@
+//>>built
+define("dojo/DeferredList", ["./_base/kernel", "./_base/Deferred", "./_base/array"], function(dojo, Deferred, darray) {
+	// module:
+	//		dojo/DeferredList
+	// summary:
+	//		TODOC
+
+
+dojo.DeferredList = function(/*Array*/ list, /*Boolean?*/ fireOnOneCallback, /*Boolean?*/ fireOnOneErrback, /*Boolean?*/ consumeErrors, /*Function?*/ canceller){
+	// summary:
+	//		Provides event handling for a group of Deferred objects.
+	// description:
+	//		DeferredList takes an array of existing deferreds and returns a new deferred of its own
+	//		this new deferred will typically have its callback fired when all of the deferreds in
+	//		the given list have fired their own deferreds.  The parameters `fireOnOneCallback` and
+	//		fireOnOneErrback, will fire before all the deferreds as appropriate
+	//
+	// list:
+	//		The list of deferreds to be synchronizied with this DeferredList
+	// fireOnOneCallback:
+	//		Will cause the DeferredLists callback to be fired as soon as any
+	//		of the deferreds in its list have been fired instead of waiting until
+	//		the entire list has finished
+	// fireonOneErrback:
+	//		Will cause the errback to fire upon any of the deferreds errback
+	// canceller:
+	//		A deferred canceller function, see dojo.Deferred
+	var resultList = [];
+	Deferred.call(this);
+	var self = this;
+	if(list.length === 0 && !fireOnOneCallback){
+		this.resolve([0, []]);
+	}
+	var finished = 0;
+	darray.forEach(list, function(item, i){
+		item.then(function(result){
+			if(fireOnOneCallback){
+				self.resolve([i, result]);
+			}else{
+				addResult(true, result);
+			}
+		},function(error){
+			if(fireOnOneErrback){
+				self.reject(error);
+			}else{
+				addResult(false, error);
+			}
+			if(consumeErrors){
+				return null;
+			}
+			throw error;
+		});
+		function addResult(succeeded, result){
+			resultList[i] = [succeeded, result];
+			finished++;
+			if(finished === list.length){
+				self.resolve(resultList);
+			}
+
+		}
+	});
+};
+dojo.DeferredList.prototype = new Deferred();
+
+dojo.DeferredList.prototype.gatherResults = function(deferredList){
+	// summary:
+	//		Gathers the results of the deferreds for packaging
+	//		as the parameters to the Deferred Lists' callback
+	// deferredList: dojo.DeferredList
+	//		The deferred list from which this function gathers results.
+	// returns: dojo.DeferredList
+	//		The newly created deferred list which packs results as
+	//		parameters to its callback.
+
+	var d = new dojo.DeferredList(deferredList, false, true, false);
+	d.addCallback(function(results){
+		var ret = [];
+		darray.forEach(results, function(result){
+			ret.push(result[1]);
+		});
+		return ret;
+	});
+	return d;
+};
+
+return dojo.DeferredList;
+});
diff --git a/js/dojo-1.7.2/dojo/Evented.js b/js/dojo-1.7.2/dojo/Evented.js
new file mode 100644
index 0000000..6e65365
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/Evented.js
@@ -0,0 +1,33 @@
+//>>built
+define("dojo/Evented", ["./aspect", "./on"], function(aspect, on){
+	// summary:
+	//		The export of this module is a class that can be used as a mixin or base class, 
+	// 		to add on() and emit() methods to a class
+	// 		for listening for events and emiting events:
+	// 		|define(["dojo/Evented"], function(Evented){
+	// 		|	var EventedWidget = dojo.declare([Evented, dijit._Widget], {...});
+	//		|	widget = new EventedWidget();
+	//		|	widget.on("open", function(event){
+	//		|	... do something with event
+	//		|	 });
+	//		|
+	//		|	widget.emit("open", {name:"some event", ...});
+
+ 	"use strict";
+ 	var after = aspect.after;
+	function Evented(){
+	}
+	Evented.prototype = {
+		on: function(type, listener){
+			return on.parse(this, type, listener, function(target, type){
+				return after(target, 'on' + type, listener, true);
+			});
+		},
+		emit: function(type, event){
+			var args = [this];
+			args.push.apply(args, arguments);
+			return on.emit.apply(on, args);
+		}
+	};
+	return Evented;
+});
diff --git a/js/dojo-1.7.2/dojo/LICENSE b/js/dojo-1.7.2/dojo/LICENSE
new file mode 100644
index 0000000..aa6b39f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/LICENSE
@@ -0,0 +1,195 @@
+Dojo is available under *either* the terms of the modified BSD license *or* the
+Academic Free License version 2.1. As a recipient of Dojo, you may choose which
+license to receive this code under (except as noted in per-module LICENSE
+files). Some modules may not be the copyright of the Dojo Foundation. These
+modules contain explicit declarations of copyright in both the LICENSE files in
+the directories in which they reside and in the code itself. No external
+contributions are allowed under licenses which are fundamentally incompatible
+with the AFL or BSD licenses that Dojo is distributed under.
+
+The text of the AFL and BSD licenses is reproduced below. 
+
+-------------------------------------------------------------------------------
+The "New" BSD License:
+**********************
+
+Copyright (c) 2005-2011, The Dojo Foundation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the name of the Dojo Foundation nor the names of its contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-------------------------------------------------------------------------------
+The Academic Free License, v. 2.1:
+**********************************
+
+This Academic Free License (the "License") applies to any original work of
+authorship (the "Original Work") whose owner (the "Licensor") has placed the
+following notice immediately following the copyright notice for the Original
+Work:
+
+Licensed under the Academic Free License version 2.1
+
+1) Grant of Copyright License. Licensor hereby grants You a world-wide,
+royalty-free, non-exclusive, perpetual, sublicenseable license to do the
+following:
+
+a) to reproduce the Original Work in copies;
+
+b) to prepare derivative works ("Derivative Works") based upon the Original
+Work;
+
+c) to distribute copies of the Original Work and Derivative Works to the
+public;
+
+d) to perform the Original Work publicly; and
+
+e) to display the Original Work publicly.
+
+2) Grant of Patent License. Licensor hereby grants You a world-wide,
+royalty-free, non-exclusive, perpetual, sublicenseable license, under patent
+claims owned or controlled by the Licensor that are embodied in the Original
+Work as furnished by the Licensor, to make, use, sell and offer for sale the
+Original Work and Derivative Works.
+
+3) Grant of Source Code License. The term "Source Code" means the preferred
+form of the Original Work for making modifications to it and all available
+documentation describing how to modify the Original Work. Licensor hereby
+agrees to provide a machine-readable copy of the Source Code of the Original
+Work along with each copy of the Original Work that Licensor distributes.
+Licensor reserves the right to satisfy this obligation by placing a
+machine-readable copy of the Source Code in an information repository
+reasonably calculated to permit inexpensive and convenient access by You for as
+long as Licensor continues to distribute the Original Work, and by publishing
+the address of that information repository in a notice immediately following
+the copyright notice that applies to the Original Work.
+
+4) Exclusions From License Grant. Neither the names of Licensor, nor the names
+of any contributors to the Original Work, nor any of their trademarks or
+service marks, may be used to endorse or promote products derived from this
+Original Work without express prior written permission of the Licensor. Nothing
+in this License shall be deemed to grant any rights to trademarks, copyrights,
+patents, trade secrets or any other intellectual property of Licensor except as
+expressly stated herein. No patent license is granted to make, use, sell or
+offer to sell embodiments of any patent claims other than the licensed claims
+defined in Section 2. No right is granted to the trademarks of Licensor even if
+such marks are included in the Original Work. Nothing in this License shall be
+interpreted to prohibit Licensor from licensing under different terms from this
+License any Original Work that Licensor otherwise would have a right to
+license.
+
+5) This section intentionally omitted.
+
+6) Attribution Rights. You must retain, in the Source Code of any Derivative
+Works that You create, all copyright, patent or trademark notices from the
+Source Code of the Original Work, as well as any notices of licensing and any
+descriptive text identified therein as an "Attribution Notice." You must cause
+the Source Code for any Derivative Works that You create to carry a prominent
+Attribution Notice reasonably calculated to inform recipients that You have
+modified the Original Work.
+
+7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that
+the copyright in and to the Original Work and the patent rights granted herein
+by Licensor are owned by the Licensor or are sublicensed to You under the terms
+of this License with the permission of the contributor(s) of those copyrights
+and patent rights. Except as expressly stated in the immediately proceeding
+sentence, the Original Work is provided under this License on an "AS IS" BASIS
+and WITHOUT WARRANTY, either express or implied, including, without limitation,
+the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU.
+This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No
+license to Original Work is granted hereunder except under this disclaimer.
+
+8) Limitation of Liability. Under no circumstances and under no legal theory,
+whether in tort (including negligence), contract, or otherwise, shall the
+Licensor be liable to any person for any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License
+or the use of the Original Work including, without limitation, damages for loss
+of goodwill, work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses. This limitation of liability shall not
+apply to liability for death or personal injury resulting from Licensor's
+negligence to the extent applicable law prohibits such limitation. Some
+jurisdictions do not allow the exclusion or limitation of incidental or
+consequential damages, so this exclusion and limitation may not apply to You.
+
+9) Acceptance and Termination. If You distribute copies of the Original Work or
+a Derivative Work, You must make a reasonable effort under the circumstances to
+obtain the express assent of recipients to the terms of this License. Nothing
+else but this License (or another written agreement between Licensor and You)
+grants You permission to create Derivative Works based upon the Original Work
+or to exercise any of the rights granted in Section 1 herein, and any attempt
+to do so except under the terms of this License (or another written agreement
+between Licensor and You) is expressly prohibited by U.S. copyright law, the
+equivalent laws of other countries, and by international treaty. Therefore, by
+exercising any of the rights granted to You in Section 1 herein, You indicate
+Your acceptance of this License and all of its terms and conditions.
+
+10) Termination for Patent Action. This License shall terminate automatically
+and You may no longer exercise any of the rights granted to You by this License
+as of the date You commence an action, including a cross-claim or counterclaim,
+against Licensor or any licensee alleging that the Original Work infringes a
+patent. This termination provision shall not apply for an action alleging
+patent infringement by combinations of the Original Work with other software or
+hardware.
+
+11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this
+License may be brought only in the courts of a jurisdiction wherein the
+Licensor resides or in which Licensor conducts its primary business, and under
+the laws of that jurisdiction excluding its conflict-of-law provisions. The
+application of the United Nations Convention on Contracts for the International
+Sale of Goods is expressly excluded. Any use of the Original Work outside the
+scope of this License or after its termination shall be subject to the
+requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et
+seq., the equivalent laws of other countries, and international treaty. This
+section shall survive the termination of this License.
+
+12) Attorneys Fees. In any action to enforce the terms of this License or
+seeking damages relating thereto, the prevailing party shall be entitled to
+recover its costs and expenses, including, without limitation, reasonable
+attorneys' fees and costs incurred in connection with such action, including
+any appeal of such action. This section shall survive the termination of this
+License.
+
+13) Miscellaneous. This License represents the complete agreement concerning
+the subject matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent necessary to
+make it enforceable.
+
+14) Definition of "You" in This License. "You" throughout this License, whether
+in upper or lower case, means an individual or a legal entity exercising rights
+under, and complying with all of the terms of, this License. For legal
+entities, "You" includes any entity that controls, is controlled by, or is
+under common control with you. For purposes of this definition, "control" means
+(i) the power, direct or indirect, to cause the direction or management of such
+entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+(50%) or more of the outstanding shares, or (iii) beneficial ownership of such
+entity.
+
+15) Right to Use. You may use the Original Work in all ways not otherwise
+restricted or conditioned by this License or by law, and Licensor promises not
+to interfere with or be responsible for such uses by You.
+
+This license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights reserved.
+Permission is hereby granted to copy and distribute this license without
+modification. This license may not be modified without the express written
+permission of its copyright owner.
diff --git a/js/dojo-1.7.2/dojo/NodeList-data.js b/js/dojo-1.7.2/dojo/NodeList-data.js
new file mode 100644
index 0000000..8e524d9
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/NodeList-data.js
@@ -0,0 +1,182 @@
+//>>built
+define("dojo/NodeList-data", [
+	"./_base/kernel", "./query", "./_base/lang", "./_base/array", "./dom-attr"
+], function(dojo, query, lang, array, attr) {
+	// module:
+	//		dojo/NodeList-data
+	// summary:
+	//		TODOC
+
+var NodeList = query.NodeList;
+/*=====
+// doc alias helpers:
+var NodeList = dojo.NodeList;
+
+	dojo.NodeList.prototype.data = function(key, value){
+		// summary: stash or get some arbitrary data on/from these nodes.
+		//
+		// description:
+		//		Stash or get some arbirtrary data on/from these nodes. This private _data function is
+		//		exposed publicly on `dojo.NodeList`, eg: as the result of a `dojo.query` call.
+		//		DIFFERS from jQuery.data in that when used as a getter, the entire list is ALWAYS
+		//		returned. EVEN WHEN THE LIST IS length == 1.
+		//
+		//		A single-node version of this function is provided as `dojo._nodeData`, which follows
+		//		the same signature, though expects a String ID or DomNode reference in the first
+		//		position, before key/value arguments.
+		//
+		// node: String|DomNode
+		//		The node to associate data with
+		//
+		// key: Object?|String?
+		//		If an object, act as a setter and iterate over said object setting data items as defined.
+		//		If a string, and `value` present, set the data for defined `key` to `value`
+		//		If a string, and `value` absent, act as a getter, returning the data associated with said `key`
+		//
+		// value: Anything?
+		//		The value to set for said `key`, provided `key` is a string (and not an object)
+		//
+		// example:
+		//		Set a key `bar` to some data, then retrieve it.
+		//	|	dojo.query(".foo").data("bar", "touched");
+		//	|	var touched = dojo.query(".foo").data("bar");
+		//	|	if(touched[0] == "touched"){ alert('win'); }
+		//
+		// example:
+		//		Get all the data items for a given node.
+		//	|	var list = dojo.query(".foo").data();
+		//	|	var first = list[0];
+		//
+		// example:
+		//		Set the data to a complex hash. Overwrites existing keys with new value
+		//	|	dojo.query(".foo").data({ bar:"baz", foo:"bar" });
+		//		Then get some random key:
+		//	|	dojo.query(".foo").data("foo"); // returns [`bar`]
+		//
+		//	returns: Object|Anything|Nothing
+		//		When used as a setter via `dojo.NodeList`, a NodeList instance is returned
+		//		for further chaning. When used as a getter via `dojo.NodeList` an ARRAY
+		//		of items is returned. The items in the array correspond to the elements
+		//		in the original list. This is true even when the list length is 1, eg:
+		//		when looking up a node by ID (#foo)
+	};
+
+	dojo.NodeList.prototype.removeData = function(key){
+		// summary: Remove the data associated with these nodes.
+		// key: String?
+		//		If ommitted, clean all data for this node.
+		//		If passed, remove the data item found at `key`
+	};
+
+=====*/
+
+	var dataCache = {}, x = 0, dataattr = "data-dojo-dataid",
+		dopid = function(node){
+			// summary: Return a uniqueish ID for the passed node reference
+			var pid = attr.get(node, dataattr);
+			if(!pid){
+				pid = "pid" + (x++);
+				attr.set(node, dataattr, pid);
+			}
+			return pid;
+		}
+	;
+
+	
+	var dodata = dojo._nodeData = function(node, key, value){
+		// summary: Private helper for dojo.NodeList.data for single node data access. Refer to NodeList.data 
+		//		documentation for more information.
+		//
+		// node: String|DomNode
+		//		The node to associate data with
+		//
+		// key: Object?|String?
+		//		If an object, act as a setter and iterate over said object setting data items as defined.
+		//		If a string, and `value` present, set the data for defined `key` to `value`
+		//		If a string, and `value` absent, act as a getter, returning the data associated with said `key`
+		//
+		// value: Anything?
+		//		The value to set for said `key`, provided `key` is a string (and not an object)
+		//
+		var pid = dopid(node), r;
+		if(!dataCache[pid]){ dataCache[pid] = {}; }
+
+		// API discrepency: calling with only a node returns the whole object. $.data throws
+		if(arguments.length == 1){ r = dataCache[pid]; }
+		if(typeof key == "string"){
+			// either getter or setter, based on `value` presence
+			if(arguments.length > 2){
+				dataCache[pid][key] = value;
+			}else{
+				r = dataCache[pid][key];
+			}
+		}else{
+			// must be a setter, mix `value` into data hash
+			// API discrepency: using object as setter works here
+			r = lang.mixin(dataCache[pid], key);
+		}
+
+		return r; // Object|Anything|Nothing
+	};
+
+	var removeData = dojo._removeNodeData = function(node, key){
+		// summary: Remove some data from this node
+		// node: String|DomNode
+		//		The node reference to remove data from
+		// key: String?
+		//		If omitted, remove all data in this dataset.
+		//		If passed, remove only the passed `key` in the associated dataset
+		var pid = dopid(node);
+		if(dataCache[pid]){
+			if(key){
+				delete dataCache[pid][key];
+			}else{
+				delete dataCache[pid];
+			}
+		}
+	};
+
+	dojo._gcNodeData = function(){
+		// summary: super expensive: GC all data in the data for nodes that no longer exist in the dom.
+		// description:
+		//		super expensive: GC all data in the data for nodes that no longer exist in the dom.
+		//		MUCH safer to do this yourself, manually, on a per-node basis (via `NodeList.removeData()`)
+		//		provided as a stop-gap for exceptionally large/complex applications with constantly changing
+		//		content regions (eg: a dijit.layout.ContentPane with replacing data)
+		//		There is NO automatic GC going on. If you dojo.destroy() a node, you should _removeNodeData
+		//		prior to destruction.
+		var livePids = query("[" + dataattr + "]").map(dopid);
+		for(var i in dataCache){
+			if(array.indexOf(livePids, i) < 0){ delete dataCache[i]; }
+		}
+	};
+
+	// make nodeData and removeNodeData public on dojo.NodeList:
+	lang.extend(NodeList, {
+		data: NodeList._adaptWithCondition(dodata, function(a){
+			return a.length === 0 || a.length == 1 && (typeof a[0] == "string");
+		}),
+		removeData: NodeList._adaptAsForEach(removeData)
+	});
+
+// TODO: this is the basic implemetation of adaptWithCondtionAndWhenMappedConsiderLength, for lack of a better API name
+// it conflicts with the the `dojo.NodeList` way: always always return an arrayLike thinger. Consider for 2.0:
+//
+//	NodeList.prototype.data = function(key, value){
+//		var a = arguments, r;
+//		if(a.length === 0 || a.length == 1 && (typeof a[0] == "string")){
+//			r = this.map(function(node){
+//				return d._data(node, key);
+//			});
+//			if(r.length == 1){ r = r[0]; } // the offending line, and the diff on adaptWithCondition
+//		}else{
+//			r = this.forEach(function(node){
+//				d._data(node, key, value);
+//			});
+//		}
+//		return r; // dojo.NodeList|Array|SingleItem
+//	};
+
+	return NodeList;
+
+});
diff --git a/js/dojo-1.7.2/dojo/NodeList-dom.js b/js/dojo-1.7.2/dojo/NodeList-dom.js
new file mode 100644
index 0000000..0596c0c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/NodeList-dom.js
@@ -0,0 +1,455 @@
+//>>built
+define("dojo/NodeList-dom", ["./_base/kernel", "./query", "./_base/array", "./_base/lang", "./dom-class", "./dom-construct", "./dom-geometry", "./dom-attr", "./dom-style"], function(dojo, query, array, lang, domCls, domCtr, domGeom, domAttr, domStyle){
+	/*===== var NodeList = dojo.NodeList; =====*/
+	var magicGuard = function(a){
+		// summary:
+		//		the guard function for dojo.attr() and dojo.style()
+		return a.length == 1 && (typeof a[0] == "string"); // inline'd type check
+	};
+
+	var orphan = function(node){
+		// summary:
+		//		function to orphan nodes
+		var p = node.parentNode;
+		if(p){
+			p.removeChild(node);
+		}
+	};
+	// FIXME: should we move orphan() to dojo.html?
+
+	var NodeList = query.NodeList,
+		awc = NodeList._adaptWithCondition,
+		aafe = NodeList._adaptAsForEach,
+		aam = NodeList._adaptAsMap;
+
+	function getSet(module){
+		return function(node, name, value){
+			if(arguments.length == 2){
+				return module[typeof name == "string" ? "get" : "set"](node, name);
+			}
+			// setter
+			return module.set(node, name, value);
+		};
+	}
+
+	lang.extend(NodeList, {
+		_normalize: function(/*String||Element||Object||NodeList*/content, /*DOMNode?*/refNode){
+			// summary:
+			//		normalizes data to an array of items to insert.
+			// description:
+			//		If content is an object, it can have special properties "template" and
+			//		"parse". If "template" is defined, then the template value is run through
+			//		dojo.string.substitute (if dojo.string.substitute has been dojo.required elsewhere),
+			//		or if templateFunc is a function on the content, that function will be used to
+			//		transform the template into a final string to be used for for passing to dojo._toDom.
+			//		If content.parse is true, then it is remembered for later, for when the content
+			//		nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets
+			//		(if dojo.parser has been dojo.required elsewhere).
+
+			//Wanted to just use a DocumentFragment, but for the array/NodeList
+			//case that meant using cloneNode, but we may not want that.
+			//Cloning should only happen if the node operations span
+			//multiple refNodes. Also, need a real array, not a NodeList from the
+			//DOM since the node movements could change those NodeLists.
+
+			var parse = content.parse === true;
+
+			//Do we have an object that needs to be run through a template?
+			if(typeof content.template == "string"){
+				var templateFunc = content.templateFunc || (dojo.string && dojo.string.substitute);
+				content = templateFunc ? templateFunc(content.template, content) : content;
+			}
+
+			var type = (typeof content);
+			if(type == "string" || type == "number"){
+				content = domCtr.toDom(content, (refNode && refNode.ownerDocument));
+				if(content.nodeType == 11){
+					//DocumentFragment. It cannot handle cloneNode calls, so pull out the children.
+					content = lang._toArray(content.childNodes);
+				}else{
+					content = [content];
+				}
+			}else if(!lang.isArrayLike(content)){
+				content = [content];
+			}else if(!lang.isArray(content)){
+				//To get to this point, content is array-like, but
+				//not an array, which likely means a DOM NodeList. Convert it now.
+				content = lang._toArray(content);
+			}
+
+			//Pass around the parse info
+			if(parse){
+				content._runParse = true;
+			}
+			return content; //Array
+		},
+
+		_cloneNode: function(/*DOMNode*/ node){
+			// summary:
+			//		private utility to clone a node. Not very interesting in the vanilla
+			//		dojo.NodeList case, but delegates could do interesting things like
+			//		clone event handlers if that is derivable from the node.
+			return node.cloneNode(true);
+		},
+
+		_place: function(/*Array*/ary, /*DOMNode*/refNode, /*String*/position, /*Boolean*/useClone){
+			// summary:
+			//		private utility to handle placing an array of nodes relative to another node.
+			// description:
+			//		Allows for cloning the nodes in the array, and for
+			//		optionally parsing widgets, if ary._runParse is true.
+
+			//Avoid a disallowed operation if trying to do an innerHTML on a non-element node.
+			if(refNode.nodeType != 1 && position == "only"){
+				return;
+			}
+			var rNode = refNode, tempNode;
+
+			//Always cycle backwards in case the array is really a
+			//DOM NodeList and the DOM operations take it out of the live collection.
+			var length = ary.length;
+			for(var i = length - 1; i >= 0; i--){
+				var node = (useClone ? this._cloneNode(ary[i]) : ary[i]);
+
+				//If need widget parsing, use a temp node, instead of waiting after inserting into
+				//real DOM because we need to start widget parsing at one node up from current node,
+				//which could cause some already parsed widgets to be parsed again.
+				if(ary._runParse && dojo.parser && dojo.parser.parse){
+					if(!tempNode){
+						tempNode = rNode.ownerDocument.createElement("div");
+					}
+					tempNode.appendChild(node);
+					dojo.parser.parse(tempNode);
+					node = tempNode.firstChild;
+					while(tempNode.firstChild){
+						tempNode.removeChild(tempNode.firstChild);
+					}
+				}
+
+				if(i == length - 1){
+					domCtr.place(node, rNode, position);
+				}else{
+					rNode.parentNode.insertBefore(node, rNode);
+				}
+				rNode = node;
+			}
+		},
+
+		/*=====
+		position: function(){
+			// summary:
+			//		Returns border-box objects (x/y/w/h) of all elements in a node list
+			//		as an Array (*not* a NodeList). Acts like `dojo.position`, though
+			//		assumes the node passed is each node in this list.
+
+			return dojo.map(this, dojo.position); // Array
+		},
+
+		attr: function(property, value){
+			// summary:
+			//		gets or sets the DOM attribute for every element in the
+			//		NodeList. See also `dojo.attr`
+			// property: String
+			//		the attribute to get/set
+			// value: String?
+			//		optional. The value to set the property to
+			// returns:
+			//		if no value is passed, the result is an array of attribute values
+			//		If a value is passed, the return is this NodeList
+			// example:
+			//		Make all nodes with a particular class focusable:
+			//	|	dojo.query(".focusable").attr("tabIndex", -1);
+			// example:
+			//		Disable a group of buttons:
+			//	|	dojo.query("button.group").attr("disabled", true);
+			// example:
+			//		innerHTML can be assigned or retrieved as well:
+			//	|	// get the innerHTML (as an array) for each list item
+			//	|	var ih = dojo.query("li.replaceable").attr("innerHTML");
+			return; // dojo.NodeList
+			return; // Array
+		},
+
+		style: function(property, value){
+			// summary:
+			//		gets or sets the CSS property for every element in the NodeList
+			// property: String
+			//		the CSS property to get/set, in JavaScript notation
+			//		("lineHieght" instead of "line-height")
+			// value: String?
+			//		optional. The value to set the property to
+			// returns:
+			//		if no value is passed, the result is an array of strings.
+			//		If a value is passed, the return is this NodeList
+			return; // dojo.NodeList
+			return; // Array
+		},
+
+		addClass: function(className){
+			// summary:
+			//		adds the specified class to every node in the list
+			// className: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			return; // dojo.NodeList
+		},
+
+		removeClass: function(className){
+			// summary:
+			//		removes the specified class from every node in the list
+			// className: String|Array?
+			//		An optional String class name to remove, or several space-separated
+			//		class names, or an array of class names. If omitted, all class names
+			//		will be deleted.
+			// returns:
+			//		dojo.NodeList, this list
+			return; // dojo.NodeList
+		},
+
+		toggleClass: function(className, condition){
+			// summary:
+			//		Adds a class to node if not present, or removes if present.
+			//		Pass a boolean condition if you want to explicitly add or remove.
+			// condition: Boolean?
+			//		If passed, true means to add the class, false means to remove.
+			// className: String
+			//		the CSS class to add
+			return; // dojo.NodeList
+		},
+
+		empty: function(){
+			// summary:
+			//		clears all content from each node in the list. Effectively
+			//		equivalent to removing all child nodes from every item in
+			//		the list.
+			return this.forEach("item.innerHTML='';"); // dojo.NodeList
+			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
+		},
+		=====*/
+
+		// useful html methods
+		attr: awc(getSet(domAttr), magicGuard),
+		style: awc(getSet(domStyle), magicGuard),
+
+		addClass: aafe(domCls.add),
+		removeClass: aafe(domCls.remove),
+		replaceClass: aafe(domCls.replace),
+		toggleClass: aafe(domCls.toggle),
+
+		empty: aafe(domCtr.empty),
+		removeAttr: aafe(domAttr.remove),
+
+		position: aam(domGeom.position),
+		marginBox: aam(domGeom.getMarginBox),
+
+		// FIXME: connectPublisher()? connectRunOnce()?
+
+		/*
+		destroy: function(){
+			// summary:
+			//		destroys every item in the list.
+			this.forEach(d.destroy);
+			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
+		},
+		*/
+
+		place: function(/*String||Node*/ queryOrNode, /*String*/ position){
+			// summary:
+			//		places elements of this node list relative to the first element matched
+			//		by queryOrNode. Returns the original NodeList. See: `dojo.place`
+			// queryOrNode:
+			//		may be a string representing any valid CSS3 selector or a DOM node.
+			//		In the selector case, only the first matching element will be used
+			//		for relative positioning.
+			// position:
+			//		can be one of:
+			//		|	"last" (default)
+			//		|	"first"
+			//		|	"before"
+			//		|	"after"
+			//		|	"only"
+			//		|	"replace"
+			//		or an offset in the childNodes property
+			var item = query(queryOrNode)[0];
+			return this.forEach(function(node){ domCtr.place(node, item, position); }); // dojo.NodeList
+		},
+
+		orphan: function(/*String?*/ filter){
+			// summary:
+			//		removes elements in this list that match the filter
+			//		from their parents and returns them as a new NodeList.
+			// filter:
+			//		CSS selector like ".foo" or "div > span"
+			// returns:
+			//		`dojo.NodeList` containing the orphaned elements
+			return (filter ? query._filterResult(this, filter) : this).forEach(orphan); // dojo.NodeList
+		},
+
+		adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){
+			// summary:
+			//		places any/all elements in queryOrListOrNode at a
+			//		position relative to the first element in this list.
+			//		Returns a dojo.NodeList of the adopted elements.
+			// queryOrListOrNode:
+			//		a DOM node or a query string or a query result.
+			//		Represents the nodes to be adopted relative to the
+			//		first element of this NodeList.
+			// position:
+			//		can be one of:
+			//		|	"last" (default)
+			//		|	"first"
+			//		|	"before"
+			//		|	"after"
+			//		|	"only"
+			//		|	"replace"
+			//		or an offset in the childNodes property
+			return query(queryOrListOrNode).place(this[0], position)._stash(this);	// dojo.NodeList
+		},
+
+		// FIXME: do we need this?
+		query: function(/*String*/ queryStr){
+			// summary:
+			//		Returns a new list whose members match the passed query,
+			//		assuming elements of the current NodeList as the root for
+			//		each search.
+			// example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo">
+			//	|		<p>
+			//	|			bacon is tasty, <span>dontcha think?</span>
+			//	|		</p>
+			//	|	</div>
+			//	|	<div id="bar">
+			//	|		<p>great comedians may not be funny <span>in person</span></p>
+			//	|	</div>
+			//		If we are presented with the following definition for a NodeList:
+			//	|	var l = new dojo.NodeList(dojo.byId("foo"), dojo.byId("bar"));
+			//		it's possible to find all span elements under paragraphs
+			//		contained by these elements with this sub-query:
+			//	|	var spans = l.query("p span");
+
+			// FIXME: probably slow
+			if(!queryStr){ return this; }
+			var ret = new NodeList;
+			this.map(function(node){
+				// FIXME: why would we ever get undefined here?
+				query(queryStr, node).forEach(function(subNode){
+					if(subNode !== undefined){
+						ret.push(subNode);
+					}
+				});
+			});
+			return ret._stash(this);	// dojo.NodeList
+		},
+
+		filter: function(/*String|Function*/ filter){
+			// summary:
+			//		"masks" the built-in javascript filter() method (supported
+			//		in Dojo via `dojo.filter`) to support passing a simple
+			//		string filter in addition to supporting filtering function
+			//		objects.
+			// filter:
+			//		If a string, a CSS rule like ".thinger" or "div > span".
+			// example:
+			//		"regular" JS filter syntax as exposed in dojo.filter:
+			//		|	dojo.query("*").filter(function(item){
+			//		|		// highlight every paragraph
+			//		|		return (item.nodeName == "p");
+			//		|	}).style("backgroundColor", "yellow");
+			// example:
+			//		the same filtering using a CSS selector
+			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
+
+			var a = arguments, items = this, start = 0;
+			if(typeof filter == "string"){ // inline'd type check
+				items = query._filterResult(this, a[0]);
+				if(a.length == 1){
+					// if we only got a string query, pass back the filtered results
+					return items._stash(this); // dojo.NodeList
+				}
+				// if we got a callback, run it over the filtered items
+				start = 1;
+			}
+			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo.NodeList
+		},
+
+		/*
+		// FIXME: should this be "copyTo" and include parenting info?
+		clone: function(){
+			// summary:
+			//		creates node clones of each element of this list
+			//		and returns a new list containing the clones
+		},
+		*/
+
+		addContent: function(/*String||DomNode||Object||dojo.NodeList*/ content, /*String||Integer?*/ position){
+			// summary:
+			//		add a node, NodeList or some HTML as a string to every item in the
+			//		list.  Returns the original list.
+			// description:
+			//		a copy of the HTML content is added to each item in the
+			//		list, with an optional position argument. If no position
+			//		argument is provided, the content is appended to the end of
+			//		each item.
+			// content:
+			//		DOM node, HTML in string format, a NodeList or an Object. If a DOM node or
+			//		NodeList, the content will be cloned if the current NodeList has more than one
+			//		element. Only the DOM nodes are cloned, no event handlers. If it is an Object,
+			//		it should be an object with at "template" String property that has the HTML string
+			//		to insert. If dojo.string has already been dojo.required, then dojo.string.substitute
+			//		will be used on the "template" to generate the final HTML string. Other allowed
+			//		properties on the object are: "parse" if the HTML
+			//		string should be parsed for widgets (dojo.require("dojo.parser") to get that
+			//		option to work), and "templateFunc" if a template function besides dojo.string.substitute
+			//		should be used to transform the "template".
+			// position:
+			//		can be one of:
+			//		|	"last"||"end" (default)
+			//		|	"first||"start"
+			//		|	"before"
+			//		|	"after"
+			//		|	"replace" (replaces nodes in this NodeList with new content)
+			//		|	"only" (removes other children of the nodes so new content is the only child)
+			//		or an offset in the childNodes property
+			// example:
+			//		appends content to the end if the position is omitted
+			//	|	dojo.query("h3 > p").addContent("hey there!");
+			// example:
+			//		add something to the front of each element that has a
+			//		"thinger" property:
+			//	|	dojo.query("[thinger]").addContent("...", "first");
+			// example:
+			//		adds a header before each element of the list
+			//	|	dojo.query(".note").addContent("<h4>NOTE:</h4>", "before");
+			// example:
+			//		add a clone of a DOM node to the end of every element in
+			//		the list, removing it from its existing parent.
+			//	|	dojo.query(".note").addContent(dojo.byId("foo"));
+			// example:
+			//		Append nodes from a templatized string.
+			//		dojo.require("dojo.string");
+			//		dojo.query(".note").addContent({
+			//			template: '<b>${id}: </b><span>${name}</span>',
+			//			id: "user332",
+			//			name: "Mr. Anderson"
+			//		});
+			// example:
+			//		Append nodes from a templatized string that also has widgets parsed.
+			//		dojo.require("dojo.string");
+			//		dojo.require("dojo.parser");
+			//		var notes = dojo.query(".note").addContent({
+			//			template: '<button dojoType="dijit.form.Button">${text}</button>',
+			//			parse: true,
+			//			text: "Send"
+			//		});
+			content = this._normalize(content, this[0]);
+			for(var i = 0, node; (node = this[i]); i++){
+				this._place(content, node, position, i > 0);
+			}
+			return this; //dojo.NodeList
+		}
+	});
+
+	/*===== return dojo.NodeList; =====*/
+	return NodeList;
+});
diff --git a/js/dojo-1.7.2/dojo/NodeList-fx.js b/js/dojo-1.7.2/dojo/NodeList-fx.js
new file mode 100644
index 0000000..2d62e11
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/NodeList-fx.js
@@ -0,0 +1,223 @@
+//>>built
+define("dojo/NodeList-fx", ["dojo/_base/NodeList", "./_base/lang", "./_base/connect", "./_base/fx", "./fx"], 
+  function(NodeList, lang, connectLib, baseFx, coreFx) {
+	// module:
+	//		dojo/NodeList-fx
+	// summary:
+	//		TODOC
+
+/*=====
+dojo["NodeList-fx"] = {
+	// summary: Adds dojo.fx animation support to dojo.query() by extending the NodeList class
+	//		with additional FX functions.  NodeList is the array-like object used to hold query results.
+};
+
+// doc alias helpers:
+NodeList = dojo.NodeList;
+=====*/
+
+lang.extend(NodeList, {
+	_anim: function(obj, method, args){
+		args = args||{};
+		var a = coreFx.combine(
+			this.map(function(item){
+				var tmpArgs = { node: item };
+				lang.mixin(tmpArgs, args);
+				return obj[method](tmpArgs);
+			})
+		);
+		return args.auto ? a.play() && this : a; // dojo.Animation|dojo.NodeList
+	},
+
+	wipeIn: function(args){
+		// summary:
+		//		wipe in all elements of this NodeList via `dojo.fx.wipeIn`
+		//
+		// args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
+		// example:
+		//		Fade in all tables with class "blah":
+		//		|	dojo.query("table.blah").wipeIn().play();
+		//
+		// example:
+		//		Utilizing `auto` to get the NodeList back:
+		//		|	dojo.query(".titles").wipeIn({ auto:true }).onclick(someFunction);
+		//
+		return this._anim(coreFx, "wipeIn", args); // dojo.Animation|dojo.NodeList
+	},
+
+	wipeOut: function(args){
+		// summary:
+		//		wipe out all elements of this NodeList via `dojo.fx.wipeOut`
+		//
+		// args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
+		// example:
+		//		Wipe out all tables with class "blah":
+		//		|	dojo.query("table.blah").wipeOut().play();
+		return this._anim(coreFx, "wipeOut", args); // dojo.Animation|dojo.NodeList
+	},
+
+	slideTo: function(args){
+		// summary:
+		//		slide all elements of the node list to the specified place via `dojo.fx.slideTo`
+		//
+		// args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
+		// example:
+		//		|	Move all tables with class "blah" to 300/300:
+		//		|	dojo.query("table.blah").slideTo({
+		//		|		left: 40,
+		//		|		top: 50
+		//		|	}).play();
+		return this._anim(coreFx, "slideTo", args); // dojo.Animation|dojo.NodeList
+	},
+
+
+	fadeIn: function(args){
+		// summary:
+		//		fade in all elements of this NodeList via `dojo.fadeIn`
+		//
+		// args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
+		// example:
+		//		Fade in all tables with class "blah":
+		//		|	dojo.query("table.blah").fadeIn().play();
+		return this._anim(baseFx, "fadeIn", args); // dojo.Animation|dojo.NodeList
+	},
+
+	fadeOut: function(args){
+		// summary:
+		//		fade out all elements of this NodeList via `dojo.fadeOut`
+		//
+		// args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
+		// example:
+		//		Fade out all elements with class "zork":
+		//		|	dojo.query(".zork").fadeOut().play();
+		// example:
+		//		Fade them on a delay and do something at the end:
+		//		|	var fo = dojo.query(".zork").fadeOut();
+		//		|	dojo.connect(fo, "onEnd", function(){ /*...*/ });
+		//		|	fo.play();
+		// example:
+		//		Using `auto`:
+		//		|	dojo.query("li").fadeOut({ auto:true }).filter(filterFn).forEach(doit);
+		//
+		return this._anim(baseFx, "fadeOut", args); // dojo.Animation|dojo.NodeList
+	},
+
+	animateProperty: function(args){
+		// summary:
+		//		Animate all elements of this NodeList across the properties specified.
+		//		syntax identical to `dojo.animateProperty`
+		//
+		// args: Object?
+		//		Additional dojo.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo.Animation|dojo.NodeList
+		//		A special args member `auto` can be passed to automatically play the animation.
+		//		If args.auto is present, the original dojo.NodeList will be returned for further
+		//		chaining. Otherwise the dojo.Animation instance is returned and must be .play()'ed
+		//
+		// example:
+		//	|	dojo.query(".zork").animateProperty({
+		//	|		duration: 500,
+		//	|		properties: {
+		//	|			color:		{ start: "black", end: "white" },
+		//	|			left:		{ end: 300 }
+		//	|		}
+		//	|	}).play();
+		//
+		//	example:
+		//	|	dojo.query(".grue").animateProperty({
+		//	|		auto:true,
+		//	|		properties: {
+		//	|			height:240
+		//	|		}
+		//	|	}).onclick(handler);
+		return this._anim(baseFx, "animateProperty", args); // dojo.Animation|dojo.NodeList
+	},
+
+	anim: function( /*Object*/			properties,
+					/*Integer?*/		duration,
+					/*Function?*/		easing,
+					/*Function?*/		onEnd,
+					/*Integer?*/		delay){
+		// summary:
+		//		Animate one or more CSS properties for all nodes in this list.
+		//		The returned animation object will already be playing when it
+		//		is returned. See the docs for `dojo.anim` for full details.
+		// properties: Object
+		//		the properties to animate. does NOT support the `auto` parameter like other
+		//		NodeList-fx methods.
+		// duration: Integer?
+		//		Optional. The time to run the animations for
+		// easing: Function?
+		//		Optional. The easing function to use.
+		// onEnd: Function?
+		//		A function to be called when the animation ends
+		// delay:
+		//		how long to delay playing the returned animation
+		// example:
+		//		Another way to fade out:
+		//	|	dojo.query(".thinger").anim({ opacity: 0 });
+		// example:
+		//		animate all elements with the "thigner" class to a width of 500
+		//		pixels over half a second
+		//	|	dojo.query(".thinger").anim({ width: 500 }, 700);
+		var canim = coreFx.combine(
+			this.map(function(item){
+				return baseFx.animateProperty({
+					node: item,
+					properties: properties,
+					duration: duration||350,
+					easing: easing
+				});
+			})
+		);
+		if(onEnd){
+			connectLib.connect(canim, "onEnd", onEnd);
+		}
+		return canim.play(delay||0); // dojo.Animation
+	}
+});
+
+return NodeList;
+});
diff --git a/js/dojo-1.7.2/dojo/NodeList-html.js b/js/dojo-1.7.2/dojo/NodeList-html.js
new file mode 100644
index 0000000..1e53f60
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/NodeList-html.js
@@ -0,0 +1,56 @@
+//>>built
+define("dojo/NodeList-html", ["./query", "./_base/lang", "./html"], function(query, lang, html) {
+	// module:
+	//		dojo/NodeList-html
+	// summary:
+	//		TODOC
+
+var NodeList = query.NodeList;
+
+/*=====
+dojo["NodeList-html"] = {
+	// summary: Adds a chainable html method to dojo.query() / Nodelist instances for setting/replacing node content
+};
+
+// doc helper aliases:
+NodeList = dojo.NodeList;
+=====*/
+
+lang.extend(NodeList, {
+	html: function(/* String|DomNode|NodeList? */ content, /* Object? */params){
+		//	summary:
+		//		see `dojo.html.set()`. Set the content of all elements of this NodeList
+		//
+		//	content:
+		//		An html string, node or enumerable list of nodes for insertion into the dom
+		//
+		//	params:
+		//		Optional flags/properties to configure the content-setting. See dojo.html._ContentSetter
+		//
+		//	description:
+		//		Based around `dojo.html.set()`, set the content of the Elements in a
+		//		NodeList to the given content (string/node/nodelist), with optional arguments
+		//		to further tune the set content behavior.
+		//
+		//	example:
+		//	| dojo.query(".thingList").html("<li dojoType='dojo.dnd.Moveable'>1</li><li dojoType='dojo.dnd.Moveable'>2</li><li dojoType='dojo.dnd.Moveable'>3</li>",
+		//	| {
+		//	| 	parseContent: true,
+		//	| 	onBegin: function(){
+		//	| 		this.content = this.content.replace(/([0-9])/g, this.id + ": $1");
+		//	| 		this.inherited("onBegin", arguments);
+		//	| 	}
+		//	| }).removeClass("notdone").addClass("done");
+
+		var dhs = new html._ContentSetter(params || {});
+		this.forEach(function(elm){
+			dhs.node = elm;
+			dhs.set(content);
+			dhs.tearDown();
+		});
+		return this; // dojo.NodeList
+	}
+});
+
+return NodeList;
+});
diff --git a/js/dojo-1.7.2/dojo/NodeList-manipulate.js b/js/dojo-1.7.2/dojo/NodeList-manipulate.js
new file mode 100644
index 0000000..c5ea878
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/NodeList-manipulate.js
@@ -0,0 +1,731 @@
+//>>built
+define("dojo/NodeList-manipulate", ["./query", "./_base/lang", "./_base/array", "./dom-construct", "./NodeList-dom"], function(dquery, lang, array, construct) {
+	// module:
+	//		dojo/NodeList-manipulate
+	// summary:
+	//		TODOC
+
+var NodeList = dquery.NodeList;
+
+/*=====
+dojo["NodeList-manipulate"] = {
+	// summary: Adds a chainable methods to dojo.query() / Nodelist instances for manipulating HTML
+	// and DOM nodes and their properties.
+};
+
+// doc alias helpers:
+NodeList = dojo.NodeList;
+=====*/
+
+//TODO: add a way to parse for widgets in the injected markup?
+
+	function getText(/*DOMNode*/node){
+		// summary:
+		// 		recursion method for text() to use. Gets text value for a node.
+		// description:
+		// 		Juse uses nodedValue so things like <br/> tags do not end up in
+		// 		the text as any sort of line return.
+		var text = "", ch = node.childNodes;
+		for(var i = 0, n; n = ch[i]; i++){
+			//Skip comments.
+			if(n.nodeType != 8){
+				if(n.nodeType == 1){
+					text += getText(n);
+				}else{
+					text += n.nodeValue;
+				}
+			}
+		}
+		return text;
+	}
+
+	function getWrapInsertion(/*DOMNode*/node){
+		// summary:
+		// 		finds the innermost element to use for wrap insertion.
+
+		//Make it easy, assume single nesting, no siblings.
+		while(node.childNodes[0] && node.childNodes[0].nodeType == 1){
+			node = node.childNodes[0];
+		}
+		return node; //DOMNode
+	}
+
+	function makeWrapNode(/*DOMNode||String*/html, /*DOMNode*/refNode){
+		// summary:
+		// 		convert HTML into nodes if it is not already a node.
+		if(typeof html == "string"){
+			html = construct.toDom(html, (refNode && refNode.ownerDocument));
+			if(html.nodeType == 11){
+				//DocumentFragment cannot handle cloneNode, so choose first child.
+				html = html.childNodes[0];
+			}
+		}else if(html.nodeType == 1 && html.parentNode){
+			//This element is already in the DOM clone it, but not its children.
+			html = html.cloneNode(false);
+		}
+		return html; /*DOMNode*/
+	}
+
+	lang.extend(NodeList, {
+		_placeMultiple: function(/*String||Node||NodeList*/query, /*String*/position){
+			// summary:
+			// 		private method for inserting queried nodes into all nodes in this NodeList
+			// 		at different positions. Differs from NodeList.place because it will clone
+			// 		the nodes in this NodeList if the query matches more than one element.
+			var nl2 = typeof query == "string" || query.nodeType ? dquery(query) : query;
+			var toAdd = [];
+			for(var i = 0; i < nl2.length; i++){
+				//Go backwards in DOM to make dom insertions easier via insertBefore
+				var refNode = nl2[i];
+				var length = this.length;
+				for(var j = length - 1, item; item = this[j]; j--){
+					if(i > 0){
+						//Need to clone the item. This also means
+						//it needs to be added to the current NodeList
+						//so it can also be the target of other chaining operations.
+						item = this._cloneNode(item);
+						toAdd.unshift(item);
+					}
+					if(j == length - 1){
+						construct.place(item, refNode, position);
+					}else{
+						refNode.parentNode.insertBefore(item, refNode);
+					}
+					refNode = item;
+				}
+			}
+
+			if(toAdd.length){
+				//Add the toAdd items to the current NodeList. Build up list of args
+				//to pass to splice.
+				toAdd.unshift(0);
+				toAdd.unshift(this.length - 1);
+				Array.prototype.splice.apply(this, toAdd);
+			}
+
+			return this; //dojo.NodeList
+		},
+
+		innerHTML: function(/*String?||DOMNode?|NodeList?*/value){
+			// summary:
+			// 		allows setting the innerHTML of each node in the NodeList,
+			// 		if there is a value passed in, otherwise, reads the innerHTML value of the first node.
+			// description:
+			// 		This method is simpler than the dojo.NodeList.html() method provided by
+			// 		`dojo.NodeList-html`. This method just does proper innerHTML insertion of HTML fragments,
+			// 		and it allows for the innerHTML to be read for the first node in the node list.
+			// 		Since dojo.NodeList-html already took the "html" name, this method is called
+			// 		"innerHTML". However, if dojo.NodeList-html has not been loaded yet, this
+			// 		module will define an "html" method that can be used instead. Be careful if you
+			// 		are working in an environment where it is possible that dojo.NodeList-html could
+			// 		have been loaded, since its definition of "html" will take precedence.
+			// 		The nodes represented by the value argument will be cloned if more than one
+			// 		node is in this NodeList. The nodes in this NodeList are returned in the "set"
+			// 		usage of this method, not the HTML that was inserted.
+			//	returns:
+			//		if no value is passed, the result is String, the innerHTML of the first node.
+			//		If a value is passed, the return is this dojo.NodeList
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo"></div>
+			//	|	<div id="bar"></div>
+			//		This code inserts <p>Hello World</p> into both divs:
+			//	|	dojo.query("div").innerHTML("<p>Hello World</p>");
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo"><p>Hello Mars</p></div>
+			//	|	<div id="bar"><p>Hello World</p></div>
+			//		This code returns "<p>Hello Mars</p>":
+			//	|	var message = dojo.query("div").innerHTML();
+			if(arguments.length){
+				return this.addContent(value, "only"); //dojo.NodeList
+			}else{
+				return this[0].innerHTML; //String
+			}
+		},
+
+		/*=====
+		html: function(value){
+			// summary:
+			//		see the information for "innerHTML". "html" is an alias for "innerHTML", but is
+			// 		only defined if dojo.NodeList-html has not been loaded.
+			// description:
+			// 		An alias for the "innerHTML" method, but only defined if there is not an existing
+			// 		"html" method on dojo.NodeList. Be careful if you are working in an environment
+			// 		where it is possible that dojo.NodeList-html could have been loaded, since its
+			// 		definition of "html" will take precedence. If you are not sure if dojo.NodeList-html
+			// 		could be loaded, use the "innerHTML" method.
+			//	value: String?||DOMNode?||NodeList?
+			//		optional. The HTML fragment to use as innerHTML. If value is not passed, then the innerHTML
+			// 		of the first element in this NodeList is returned.
+			//	returns:
+			//		if no value is passed, the result is String, the innerHTML of the first node.
+			//		If a value is passed, the return is this dojo.NodeList
+			return; // dojo.NodeList
+			return; // String
+		},
+		=====*/
+
+		text: function(/*String*/value){
+			// summary:
+			// 		allows setting the text value of each node in the NodeList,
+			// 		if there is a value passed in, otherwise, returns the text value for all the
+			// 		nodes in the NodeList in one string.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo"></div>
+			//	|	<div id="bar"></div>
+			//		This code inserts "Hello World" into both divs:
+			//	|	dojo.query("div").text("Hello World");
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo"><p>Hello Mars <span>today</span></p></div>
+			//	|	<div id="bar"><p>Hello World</p></div>
+			//		This code returns "Hello Mars today":
+			//	|	var message = dojo.query("div").text();
+			//	returns:
+			//		if no value is passed, the result is String, the text value of the first node.
+			//		If a value is passed, the return is this dojo.NodeList
+			if(arguments.length){
+				for(var i = 0, node; node = this[i]; i++){
+					if(node.nodeType == 1){
+						construct.empty(node);
+						node.appendChild(node.ownerDocument.createTextNode(value));
+					}
+				}
+				return this; //dojo.NodeList
+			}else{
+				var result = "";
+				for(i = 0; node = this[i]; i++){
+					result += getText(node);
+				}
+				return result; //String
+			}
+		},
+
+		val: function(/*String||Array*/value){
+			// summary:
+			// 		If a value is passed, allows seting the value property of form elements in this
+			// 		NodeList, or properly selecting/checking the right value for radio/checkbox/select
+			// 		elements. If no value is passed, the value of the first node in this NodeList
+			// 		is returned.
+			//	returns:
+			//		if no value is passed, the result is String or an Array, for the value of the
+			//		first node.
+			//		If a value is passed, the return is this dojo.NodeList
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<input type="text" value="foo">
+			//	|	<select multiple>
+			//	|		<option value="red" selected>Red</option>
+			//	|		<option value="blue">Blue</option>
+			//	|		<option value="yellow" selected>Yellow</option>
+			//	|	</select>
+			//		This code gets and sets the values for the form fields above:
+			//	|	dojo.query('[type="text"]').val(); //gets value foo
+			//	|	dojo.query('[type="text"]').val("bar"); //sets the input's value to "bar"
+			// 	|	dojo.query("select").val() //gets array value ["red", "yellow"]
+			// 	|	dojo.query("select").val(["blue", "yellow"]) //Sets the blue and yellow options to selected.
+
+			//Special work for input elements.
+			if(arguments.length){
+				var isArray = lang.isArray(value);
+				for(var index = 0, node; node = this[index]; index++){
+					var name = node.nodeName.toUpperCase();
+					var type = node.type;
+					var newValue = isArray ? value[index] : value;
+
+					if(name == "SELECT"){
+						var opts = node.options;
+						for(var i = 0; i < opts.length; i++){
+							var opt = opts[i];
+							if(node.multiple){
+								opt.selected = (array.indexOf(value, opt.value) != -1);
+							}else{
+								opt.selected = (opt.value == newValue);
+							}
+						}
+					}else if(type == "checkbox" || type == "radio"){
+						node.checked = (node.value == newValue);
+					}else{
+						node.value = newValue;
+					}
+				}
+				return this; //dojo.NodeList
+			}else{
+				//node already declared above.
+				node = this[0];
+				if(!node || node.nodeType != 1){
+					return undefined;
+				}
+				value = node.value || "";
+				if(node.nodeName.toUpperCase() == "SELECT" && node.multiple){
+					//A multivalued selectbox. Do the pain.
+					value = [];
+					//opts declared above in if block.
+					opts = node.options;
+					//i declared above in if block;
+					for(i = 0; i < opts.length; i++){
+						//opt declared above in if block
+						opt = opts[i];
+						if(opt.selected){
+							value.push(opt.value);
+						}
+					}
+					if(!value.length){
+						value = null;
+					}
+				}
+				return value; //String||Array
+			}
+		},
+
+		append: function(/*String||DOMNode||NodeList*/content){
+			// summary:
+			// 		appends the content to every node in the NodeList.
+			// description:
+			// 		The content will be cloned if the length of NodeList
+			// 		is greater than 1. Only the DOM nodes are cloned, not
+			// 		any attached event handlers.
+			// returns:
+			//		dojo.NodeList, the nodes currently in this NodeList will be returned,
+			//		not the appended content.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo"><p>Hello Mars</p></div>
+			//	|	<div id="bar"><p>Hello World</p></div>
+			//		Running this code:
+			//	|	dojo.query("div").append("<span>append</span>");
+			//		Results in this DOM structure:
+			//	|	<div id="foo"><p>Hello Mars</p><span>append</span></div>
+			//	|	<div id="bar"><p>Hello World</p><span>append</span></div>
+			return this.addContent(content, "last"); //dojo.NodeList
+		},
+
+		appendTo: function(/*String*/query){
+			// summary:
+			// 		appends nodes in this NodeList to the nodes matched by
+			// 		the query passed to appendTo.
+			// description:
+			// 		The nodes in this NodeList will be cloned if the query
+			// 		matches more than one element. Only the DOM nodes are cloned, not
+			// 		any attached event handlers.
+			// returns:
+			//		dojo.NodeList, the nodes currently in this NodeList will be returned,
+			//		not the matched nodes from the query.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<span>append</span>
+			//	|	<p>Hello Mars</p>
+			//	|	<p>Hello World</p>
+			//		Running this code:
+			//	|	dojo.query("span").appendTo("p");
+			//		Results in this DOM structure:
+			//	|	<p>Hello Mars<span>append</span></p>
+			//	|	<p>Hello World<span>append</span></p>
+			return this._placeMultiple(query, "last"); //dojo.NodeList
+		},
+
+		prepend: function(/*String||DOMNode||NodeList*/content){
+			// summary:
+			// 		prepends the content to every node in the NodeList.
+			// description:
+			// 		The content will be cloned if the length of NodeList
+			// 		is greater than 1. Only the DOM nodes are cloned, not
+			// 		any attached event handlers.
+			// returns:
+			//		dojo.NodeList, the nodes currently in this NodeList will be returned,
+			//		not the appended content.
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo"><p>Hello Mars</p></div>
+			//	|	<div id="bar"><p>Hello World</p></div>
+			//		Running this code:
+			//	|	dojo.query("div").prepend("<span>prepend</span>");
+			//		Results in this DOM structure:
+			//	|	<div id="foo"><span>prepend</span><p>Hello Mars</p></div>
+			//	|	<div id="bar"><span>prepend</span><p>Hello World</p></div>
+			return this.addContent(content, "first"); //dojo.NodeList
+		},
+
+		prependTo: function(/*String*/query){
+			// summary:
+			// 		prepends nodes in this NodeList to the nodes matched by
+			// 		the query passed to prependTo.
+			// description:
+			// 		The nodes in this NodeList will be cloned if the query
+			// 		matches more than one element. Only the DOM nodes are cloned, not
+			// 		any attached event handlers.
+			// returns:
+			//		dojo.NodeList, the nodes currently in this NodeList will be returned,
+			//		not the matched nodes from the query.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<span>prepend</span>
+			//	|	<p>Hello Mars</p>
+			//	|	<p>Hello World</p>
+			//		Running this code:
+			//	|	dojo.query("span").prependTo("p");
+			//		Results in this DOM structure:
+			//	|	<p><span>prepend</span>Hello Mars</p>
+			//	|	<p><span>prepend</span>Hello World</p>
+			return this._placeMultiple(query, "first"); //dojo.NodeList
+		},
+
+		after: function(/*String||Element||NodeList*/content){
+			// summary:
+			// 		Places the content after every node in the NodeList.
+			// description:
+			// 		The content will be cloned if the length of NodeList
+			// 		is greater than 1. Only the DOM nodes are cloned, not
+			// 		any attached event handlers.
+			// returns:
+			//		dojo.NodeList, the nodes currently in this NodeList will be returned,
+			//		not the appended content.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo"><p>Hello Mars</p></div>
+			//	|	<div id="bar"><p>Hello World</p></div>
+			//		Running this code:
+			//	|	dojo.query("div").after("<span>after</span>");
+			//		Results in this DOM structure:
+			//	|	<div id="foo"><p>Hello Mars</p></div><span>after</span>
+			//	|	<div id="bar"><p>Hello World</p></div><span>after</span>
+			return this.addContent(content, "after"); //dojo.NodeList
+		},
+
+		insertAfter: function(/*String*/query){
+			// summary:
+			// 		The nodes in this NodeList will be placed after the nodes
+			// 		matched by the query passed to insertAfter.
+			// description:
+			// 		The nodes in this NodeList will be cloned if the query
+			// 		matches more than one element. Only the DOM nodes are cloned, not
+			// 		any attached event handlers.
+			// returns:
+			//		dojo.NodeList, the nodes currently in this NodeList will be returned,
+			//		not the matched nodes from the query.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<span>after</span>
+			//	|	<p>Hello Mars</p>
+			//	|	<p>Hello World</p>
+			//		Running this code:
+			//	|	dojo.query("span").insertAfter("p");
+			//		Results in this DOM structure:
+			//	|	<p>Hello Mars</p><span>after</span>
+			//	|	<p>Hello World</p><span>after</span>
+			return this._placeMultiple(query, "after"); //dojo.NodeList
+		},
+
+		before: function(/*String||DOMNode||NodeList*/content){
+			// summary:
+			// 		Places the content before every node in the NodeList.
+			// description:
+			// 		The content will be cloned if the length of NodeList
+			// 		is greater than 1. Only the DOM nodes are cloned, not
+			// 		any attached event handlers.
+			// returns:
+			//		dojo.NodeList, the nodes currently in this NodeList will be returned,
+			//		not the appended content.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo"><p>Hello Mars</p></div>
+			//	|	<div id="bar"><p>Hello World</p></div>
+			//		Running this code:
+			//	|	dojo.query("div").before("<span>before</span>");
+			//		Results in this DOM structure:
+			//	|	<span>before</span><div id="foo"><p>Hello Mars</p></div>
+			//	|	<span>before</span><div id="bar"><p>Hello World</p></div>
+			return this.addContent(content, "before"); //dojo.NodeList
+		},
+
+		insertBefore: function(/*String*/query){
+			// summary:
+			// 		The nodes in this NodeList will be placed after the nodes
+			// 		matched by the query passed to insertAfter.
+			// description:
+			// 		The nodes in this NodeList will be cloned if the query
+			// 		matches more than one element. Only the DOM nodes are cloned, not
+			// 		any attached event handlers.
+			// returns:
+			//		dojo.NodeList, the nodes currently in this NodeList will be returned,
+			//		not the matched nodes from the query.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<span>before</span>
+			//	|	<p>Hello Mars</p>
+			//	|	<p>Hello World</p>
+			//		Running this code:
+			//	|	dojo.query("span").insertBefore("p");
+			//		Results in this DOM structure:
+			//	|	<span>before</span><p>Hello Mars</p>
+			//	|	<span>before</span><p>Hello World</p>
+			return this._placeMultiple(query, "before"); //dojo.NodeList
+		},
+
+		/*=====
+		remove: function(simpleFilter){
+			//	summary:
+			//		alias for dojo.NodeList's orphan method. Removes elements
+			// 		in this list that match the simple filter from their parents
+			// 		and returns them as a new NodeList.
+			//	simpleFilter: String
+			//		single-expression CSS rule. For example, ".thinger" or
+			//		"#someId[attrName='value']" but not "div > span". In short,
+			//		anything which does not invoke a descent to evaluate but
+			//		can instead be used to test a single node is acceptable.
+			//	returns:
+			//		dojo.NodeList
+			return; // dojo.NodeList
+		},
+		=====*/
+		remove: NodeList.prototype.orphan,
+
+		wrap: function(/*String||DOMNode*/html){
+			// summary:
+			// 		Wrap each node in the NodeList with html passed to wrap.
+			// description:
+			// 		html will be cloned if the NodeList has more than one
+			// 		element. Only DOM nodes are cloned, not any attached
+			// 		event handlers.
+			// returns:
+			//		dojo.NodeList, the nodes in the current NodeList will be returned,
+			//		not the nodes from html argument.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<b>one</b>
+			//	|	<b>two</b>
+			//		Running this code:
+			//	|	dojo.query("b").wrap("<div><span></span></div>");
+			//		Results in this DOM structure:
+			//	|	<div><span><b>one</b></span></div>
+			//	|	<div><span><b>two</b></span></div>
+			if(this[0]){
+				html = makeWrapNode(html, this[0]);
+
+				//Now cycle through the elements and do the insertion.
+				for(var i = 0, node; node = this[i]; i++){
+					//Always clone because if html is used to hold one of
+					//the "this" nodes, then on the clone of html it will contain
+					//that "this" node, and that would be bad.
+					var clone = this._cloneNode(html);
+					if(node.parentNode){
+						node.parentNode.replaceChild(clone, node);
+					}
+					//Find deepest element and insert old node in it.
+					var insertion = getWrapInsertion(clone);
+					insertion.appendChild(node);
+				}
+			}
+			return this; //dojo.NodeList
+		},
+
+		wrapAll: function(/*String||DOMNode*/html){
+			// summary:
+			// 		Insert html where the first node in this NodeList lives, then place all
+			// 		nodes in this NodeList as the child of the html.
+			// returns:
+			//		dojo.NodeList, the nodes in the current NodeList will be returned,
+			//		not the nodes from html argument.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div class="container">
+			// 	|		<div class="red">Red One</div>
+			// 	|		<div class="blue">Blue One</div>
+			// 	|		<div class="red">Red Two</div>
+			// 	|		<div class="blue">Blue Two</div>
+			//	|	</div>
+			//		Running this code:
+			//	|	dojo.query(".red").wrapAll('<div class="allRed"></div>');
+			//		Results in this DOM structure:
+			//	|	<div class="container">
+			// 	|		<div class="allRed">
+			// 	|			<div class="red">Red One</div>
+			// 	|			<div class="red">Red Two</div>
+			// 	|		</div>
+			// 	|		<div class="blue">Blue One</div>
+			// 	|		<div class="blue">Blue Two</div>
+			//	|	</div>
+			if(this[0]){
+				html = makeWrapNode(html, this[0]);
+
+				//Place the wrap HTML in place of the first node.
+				this[0].parentNode.replaceChild(html, this[0]);
+
+				//Now cycle through the elements and move them inside
+				//the wrap.
+				var insertion = getWrapInsertion(html);
+				for(var i = 0, node; node = this[i]; i++){
+					insertion.appendChild(node);
+				}
+			}
+			return this; //dojo.NodeList
+		},
+
+		wrapInner: function(/*String||DOMNode*/html){
+			// summary:
+			// 		For each node in the NodeList, wrap all its children with the passed in html.
+			// description:
+			// 		html will be cloned if the NodeList has more than one
+			// 		element. Only DOM nodes are cloned, not any attached
+			// 		event handlers.
+			// returns:
+			//		dojo.NodeList, the nodes in the current NodeList will be returned,
+			//		not the nodes from html argument.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div class="container">
+			// 	|		<div class="red">Red One</div>
+			// 	|		<div class="blue">Blue One</div>
+			// 	|		<div class="red">Red Two</div>
+			// 	|		<div class="blue">Blue Two</div>
+			//	|	</div>
+			//		Running this code:
+			//	|	dojo.query(".red").wrapInner('<span class="special"></span>');
+			//		Results in this DOM structure:
+			//	|	<div class="container">
+			// 	|		<div class="red"><span class="special">Red One</span></div>
+			// 	|		<div class="blue">Blue One</div>
+			// 	|		<div class="red"><span class="special">Red Two</span></div>
+			// 	|		<div class="blue">Blue Two</div>
+			//	|	</div>
+			if(this[0]){
+				html = makeWrapNode(html, this[0]);
+				for(var i = 0; i < this.length; i++){
+					//Always clone because if html is used to hold one of
+					//the "this" nodes, then on the clone of html it will contain
+					//that "this" node, and that would be bad.
+					var clone = this._cloneNode(html);
+
+					//Need to convert the childNodes to an array since wrapAll modifies the
+					//DOM and can change the live childNodes NodeList.
+					this._wrap(lang._toArray(this[i].childNodes), null, this._NodeListCtor).wrapAll(clone);
+				}
+			}
+			return this; //dojo.NodeList
+		},
+
+		replaceWith: function(/*String||DOMNode||NodeList*/content){
+			// summary:
+			// 		Replaces each node in ths NodeList with the content passed to replaceWith.
+			// description:
+			// 		The content will be cloned if the length of NodeList
+			// 		is greater than 1. Only the DOM nodes are cloned, not
+			// 		any attached event handlers.
+			// returns:
+			//		The nodes currently in this NodeList will be returned, not the replacing content.
+			//		Note that the returned nodes have been removed from the DOM.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div class="container">
+			// 	|		<div class="red">Red One</div>
+			// 	|		<div class="blue">Blue One</div>
+			// 	|		<div class="red">Red Two</div>
+			// 	|		<div class="blue">Blue Two</div>
+			//	|	</div>
+			//		Running this code:
+			//	|	dojo.query(".red").replaceWith('<div class="green">Green</div>');
+			//		Results in this DOM structure:
+			//	|	<div class="container">
+			// 	|		<div class="green">Green</div>
+			// 	|		<div class="blue">Blue One</div>
+			// 	|		<div class="green">Green</div>
+			// 	|		<div class="blue">Blue Two</div>
+			//	|	</div>
+			content = this._normalize(content, this[0]);
+			for(var i = 0, node; node = this[i]; i++){
+				this._place(content, node, "before", i > 0);
+				node.parentNode.removeChild(node);
+			}
+			return this; //dojo.NodeList
+		},
+
+		replaceAll: function(/*String*/query){
+			// summary:
+			// 		replaces nodes matched by the query passed to replaceAll with the nodes
+			// 		in this NodeList.
+			// description:
+			// 		The nodes in this NodeList will be cloned if the query
+			// 		matches more than one element. Only the DOM nodes are cloned, not
+			// 		any attached event handlers.
+			// returns:
+			//		The nodes currently in this NodeList will be returned, not the matched nodes
+			//		from the query. The nodes currently in this NodeLIst could have
+			//		been cloned, so the returned NodeList will include the cloned nodes.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div class="container">
+			// 	|		<div class="spacer">___</div>
+			// 	|		<div class="red">Red One</div>
+			// 	|		<div class="spacer">___</div>
+			// 	|		<div class="blue">Blue One</div>
+			// 	|		<div class="spacer">___</div>
+			// 	|		<div class="red">Red Two</div>
+			// 	|		<div class="spacer">___</div>
+			// 	|		<div class="blue">Blue Two</div>
+			//	|	</div>
+			//		Running this code:
+			//	|	dojo.query(".red").replaceAll(".blue");
+			//		Results in this DOM structure:
+			//	|	<div class="container">
+			// 	|		<div class="spacer">___</div>
+			// 	|		<div class="spacer">___</div>
+			// 	|		<div class="red">Red One</div>
+			// 	|		<div class="red">Red Two</div>
+			// 	|		<div class="spacer">___</div>
+			// 	|		<div class="spacer">___</div>
+			// 	|		<div class="red">Red One</div>
+			// 	|		<div class="red">Red Two</div>
+			//	|	</div>
+			var nl = dquery(query);
+			var content = this._normalize(this, this[0]);
+			for(var i = 0, node; node = nl[i]; i++){
+				this._place(content, node, "before", i > 0);
+				node.parentNode.removeChild(node);
+			}
+			return this; //dojo.NodeList
+		},
+
+		clone: function(){
+			// summary:
+			// 		Clones all the nodes in this NodeList and returns them as a new NodeList.
+			// description:
+			// 		Only the DOM nodes are cloned, not any attached event handlers.
+			// returns:
+			//		dojo.NodeList, a cloned set of the original nodes.
+			//	example:
+			//		assume a DOM created by this markup:
+			//	|	<div class="container">
+			// 	|		<div class="red">Red One</div>
+			// 	|		<div class="blue">Blue One</div>
+			// 	|		<div class="red">Red Two</div>
+			// 	|		<div class="blue">Blue Two</div>
+			//	|	</div>
+			//		Running this code:
+			//	|	dojo.query(".red").clone().appendTo(".container");
+			//		Results in this DOM structure:
+			//	|	<div class="container">
+			// 	|		<div class="red">Red One</div>
+			// 	|		<div class="blue">Blue One</div>
+			// 	|		<div class="red">Red Two</div>
+			// 	|		<div class="blue">Blue Two</div>
+			// 	|		<div class="red">Red One</div>
+			// 	|		<div class="red">Red Two</div>
+			//	|	</div>
+
+			//TODO: need option to clone events?
+			var ary = [];
+			for(var i = 0; i < this.length; i++){
+				ary.push(this._cloneNode(this[i]));
+			}
+			return this._wrap(ary, this, this._NodeListCtor); //dojo.NodeList
+		}
+	});
+
+	//set up html method if one does not exist
+	if(!NodeList.prototype.html){
+		NodeList.prototype.html = NodeList.prototype.innerHTML;
+	}
+
+return NodeList;
+});
diff --git a/js/dojo-1.7.2/dojo/NodeList-traverse.js b/js/dojo-1.7.2/dojo/NodeList-traverse.js
new file mode 100644
index 0000000..12967ae
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/NodeList-traverse.js
@@ -0,0 +1,509 @@
+//>>built
+define("dojo/NodeList-traverse", ["./query", "./_base/lang", "./_base/array"], function(dquery, lang, array) {
+	// module:
+	//		dojo/NodeList-traverse
+	// summary:
+	//		TODOC
+
+var NodeList = dquery.NodeList;
+
+/*=====
+dojo["NodeList-traverse"] = {
+	// summary: Adds a chainable methods to dojo.query() / Nodelist instances for traversing the DOM
+};
+
+// doc alias helpers:
+NodeList = dojo.NodeList;
+=====*/
+
+lang.extend(NodeList, {
+	_buildArrayFromCallback: function(/*Function*/callback){
+		// summary:
+		// 		builds a new array of possibly differing size based on the input list.
+		// 		Since the returned array is likely of different size than the input array,
+		// 		the array's map function cannot be used.
+		var ary = [];
+		for(var i = 0; i < this.length; i++){
+			var items = callback.call(this[i], this[i], ary);
+			if(items){
+				ary = ary.concat(items);
+			}
+		}
+		return ary;	//Array
+	},
+
+	_getUniqueAsNodeList: function(/*Array*/ nodes){
+		// summary:
+		// 		given a list of nodes, make sure only unique
+		// 		elements are returned as our NodeList object.
+		// 		Does not call _stash().
+		var ary = [];
+		//Using for loop for better speed.
+		for(var i = 0, node; node = nodes[i]; i++){
+			//Should be a faster way to do this. dojo.query has a private
+			//_zip function that may be inspirational, but there are pathways
+			//in query that force nozip?
+			if(node.nodeType == 1 && array.indexOf(ary, node) == -1){
+				ary.push(node);
+			}
+		}
+		return this._wrap(ary, null, this._NodeListCtor);	 //dojo.NodeList
+	},
+
+	_getUniqueNodeListWithParent: function(/*Array*/ nodes, /*String*/ query){
+		// summary:
+		// 		gets unique element nodes, filters them further
+		// 		with an optional query and then calls _stash to track parent NodeList.
+		var ary = this._getUniqueAsNodeList(nodes);
+		ary = (query ? dquery._filterResult(ary, query) : ary);
+		return ary._stash(this);  //dojo.NodeList
+	},
+
+	_getRelatedUniqueNodes: function(/*String?*/ query, /*Function*/ callback){
+		// summary:
+		// 		cycles over all the nodes and calls a callback
+		// 		to collect nodes for a possible inclusion in a result.
+		// 		The callback will get two args: callback(node, ary),
+		// 		where ary is the array being used to collect the nodes.
+		return this._getUniqueNodeListWithParent(this._buildArrayFromCallback(callback), query);  //dojo.NodeList
+	},
+
+	children: function(/*String?*/ query){
+		// summary:
+		// 		Returns all immediate child elements for nodes in this dojo.NodeList.
+		// 		Optionally takes a query to filter the child elements.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		// query:
+		//		a CSS selector.
+		// returns:
+		//		dojo.NodeList, all immediate child elements for the nodes in this dojo.NodeList.
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red">Red One</div>
+		// 	|		Some Text
+		// 	|		<div class="blue">Blue One</div>
+		// 	|		<div class="red">Red Two</div>
+		// 	|		<div class="blue">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".container").children();
+		//		returns the four divs that are children of the container div.
+		//		Running this code:
+		//	|	dojo.query(".container").children(".red");
+		//		returns the two divs that have the class "red".
+		return this._getRelatedUniqueNodes(query, function(node, ary){
+			return lang._toArray(node.childNodes);
+		}); //dojo.NodeList
+	},
+
+	closest: function(/*String*/ query, /*String|DOMNode?*/ root){
+		// summary:
+		// 		Returns closest parent that matches query, including current node in this
+		// 		dojo.NodeList if it matches the query.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		// query:
+		//		a CSS selector.
+		// root:
+		//		If specified, query is relative to "root" rather than document body.
+		// returns:
+		//		dojo.NodeList, the closest parent that matches the query, including the current
+		//		node in this dojo.NodeList if it matches the query.
+		// example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		//	|		<div class="red">Red One</div>
+		//	|		Some Text
+		//	|		<div class="blue">Blue One</div>
+		//	|		<div class="red">Red Two</div>
+		//	|		<div class="blue">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".red").closest(".container");
+		//		returns the div with class "container".
+		return this._getRelatedUniqueNodes(null, function(node, ary){
+			do{
+				if(dquery._filterResult([node], query, root).length){
+					return node;
+				}
+			}while(node != root && (node = node.parentNode) && node.nodeType == 1);
+			return null; //To make rhino strict checking happy.
+		}); //dojo.NodeList
+	},
+
+	parent: function(/*String?*/ query){
+		// summary:
+		// 		Returns immediate parent elements for nodes in this dojo.NodeList.
+		// 		Optionally takes a query to filter the parent elements.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		//	query:
+		//		a CSS selector.
+		// returns:
+		//		dojo.NodeList, immediate parent elements for nodes in this dojo.NodeList.
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red">Red One</div>
+		// 	|		<div class="blue first"><span class="text">Blue One</span></div>
+		// 	|		<div class="red">Red Two</div>
+		// 	|		<div class="blue"><span class="text">Blue Two</span></div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".text").parent();
+		//		returns the two divs with class "blue".
+		//		Running this code:
+		//	|	dojo.query(".text").parent(".first");
+		//		returns the one div with class "blue" and "first".
+		return this._getRelatedUniqueNodes(query, function(node, ary){
+			return node.parentNode;
+		}); //dojo.NodeList
+	},
+
+	parents: function(/*String?*/ query){
+		// summary:
+		// 		Returns all parent elements for nodes in this dojo.NodeList.
+		// 		Optionally takes a query to filter the child elements.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		//	query:
+		//		a CSS selector.
+		// returns:
+		//		dojo.NodeList, all parent elements for nodes in this dojo.NodeList.
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red">Red One</div>
+		// 	|		<div class="blue first"><span class="text">Blue One</span></div>
+		// 	|		<div class="red">Red Two</div>
+		// 	|		<div class="blue"><span class="text">Blue Two</span></div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".text").parents();
+		//		returns the two divs with class "blue", the div with class "container",
+		// 	|	the body element and the html element.
+		//		Running this code:
+		//	|	dojo.query(".text").parents(".container");
+		//		returns the one div with class "container".
+		return this._getRelatedUniqueNodes(query, function(node, ary){
+			var pary = [];
+			while(node.parentNode){
+				node = node.parentNode;
+				pary.push(node);
+			}
+			return pary;
+		}); //dojo.NodeList
+	},
+
+	siblings: function(/*String?*/ query){
+		// summary:
+		// 		Returns all sibling elements for nodes in this dojo.NodeList.
+		// 		Optionally takes a query to filter the sibling elements.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		//	query:
+		//		a CSS selector.
+		// returns:
+		//		dojo.NodeList, all sibling elements for nodes in this dojo.NodeList.
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red">Red One</div>
+		// 	|		Some Text
+		// 	|		<div class="blue first">Blue One</div>
+		// 	|		<div class="red">Red Two</div>
+		// 	|		<div class="blue">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".first").siblings();
+		//		returns the two divs with class "red" and the other div
+		// 	|	with class "blue" that does not have "first".
+		//		Running this code:
+		//	|	dojo.query(".first").siblings(".red");
+		//		returns the two div with class "red".
+		return this._getRelatedUniqueNodes(query, function(node, ary){
+			var pary = [];
+			var nodes = (node.parentNode && node.parentNode.childNodes);
+			for(var i = 0; i < nodes.length; i++){
+				if(nodes[i] != node){
+					pary.push(nodes[i]);
+				}
+			}
+			return pary;
+		}); //dojo.NodeList
+	},
+
+	next: function(/*String?*/ query){
+		// summary:
+		// 		Returns the next element for nodes in this dojo.NodeList.
+		// 		Optionally takes a query to filter the next elements.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		//	query:
+		//		a CSS selector.
+		// returns:
+		//		dojo.NodeList, the next element for nodes in this dojo.NodeList.
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red">Red One</div>
+		// 	|		Some Text
+		// 	|		<div class="blue first">Blue One</div>
+		// 	|		<div class="red">Red Two</div>
+		// 	|		<div class="blue last">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".first").next();
+		//		returns the div with class "red" and has innerHTML of "Red Two".
+		//		Running this code:
+		//	|	dojo.query(".last").next(".red");
+		//		does not return any elements.
+		return this._getRelatedUniqueNodes(query, function(node, ary){
+			var next = node.nextSibling;
+			while(next && next.nodeType != 1){
+				next = next.nextSibling;
+			}
+			return next;
+		}); //dojo.NodeList
+	},
+
+	nextAll: function(/*String?*/ query){
+		// summary:
+		// 		Returns all sibling elements that come after the nodes in this dojo.NodeList.
+		// 		Optionally takes a query to filter the sibling elements.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		//	query:
+		//		a CSS selector.
+		// returns:
+		//		dojo.NodeList, all sibling elements that come after the nodes in this dojo.NodeList.
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red">Red One</div>
+		// 	|		Some Text
+		// 	|		<div class="blue first">Blue One</div>
+		// 	|		<div class="red next">Red Two</div>
+		// 	|		<div class="blue next">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".first").nextAll();
+		//		returns the two divs with class of "next".
+		//		Running this code:
+		//	|	dojo.query(".first").nextAll(".red");
+		//		returns the one div with class "red" and innerHTML "Red Two".
+		return this._getRelatedUniqueNodes(query, function(node, ary){
+			var pary = [];
+			var next = node;
+			while((next = next.nextSibling)){
+				if(next.nodeType == 1){
+					pary.push(next);
+				}
+			}
+			return pary;
+		}); //dojo.NodeList
+	},
+
+	prev: function(/*String?*/ query){
+		// summary:
+		// 		Returns the previous element for nodes in this dojo.NodeList.
+		// 		Optionally takes a query to filter the previous elements.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		//	query:
+		//		a CSS selector.
+		// returns:
+		//		dojo.NodeList, the previous element for nodes in this dojo.NodeList.
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red">Red One</div>
+		// 	|		Some Text
+		// 	|		<div class="blue first">Blue One</div>
+		// 	|		<div class="red">Red Two</div>
+		// 	|		<div class="blue">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".first").prev();
+		//		returns the div with class "red" and has innerHTML of "Red One".
+		//		Running this code:
+		//	|	dojo.query(".first").prev(".blue");
+		//		does not return any elements.
+		return this._getRelatedUniqueNodes(query, function(node, ary){
+			var prev = node.previousSibling;
+			while(prev && prev.nodeType != 1){
+				prev = prev.previousSibling;
+			}
+			return prev;
+		}); //dojo.NodeList
+	},
+
+	prevAll: function(/*String?*/ query){
+		// summary:
+		// 		Returns all sibling elements that come before the nodes in this dojo.NodeList.
+		// 		Optionally takes a query to filter the sibling elements.
+		// description:
+		// 		The returned nodes will be in reverse DOM order -- the first node in the list will
+		// 		be the node closest to the original node/NodeList.
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		//	query:
+		//		a CSS selector.
+		// returns:
+		//		dojo.NodeList, all sibling elements that come before the nodes in this dojo.NodeList.
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red prev">Red One</div>
+		// 	|		Some Text
+		// 	|		<div class="blue prev">Blue One</div>
+		// 	|		<div class="red second">Red Two</div>
+		// 	|		<div class="blue">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".second").prevAll();
+		//		returns the two divs with class of "prev".
+		//		Running this code:
+		//	|	dojo.query(".first").prevAll(".red");
+		//		returns the one div with class "red prev" and innerHTML "Red One".
+		return this._getRelatedUniqueNodes(query, function(node, ary){
+			var pary = [];
+			var prev = node;
+			while((prev = prev.previousSibling)){
+				if(prev.nodeType == 1){
+					pary.push(prev);
+				}
+			}
+			return pary;
+		}); //dojo.NodeList
+	},
+
+	andSelf: function(){
+		// summary:
+		// 		Adds the nodes from the previous dojo.NodeList to the current dojo.NodeList.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		// returns:
+		//		dojo.NodeList
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red prev">Red One</div>
+		// 	|		Some Text
+		// 	|		<div class="blue prev">Blue One</div>
+		// 	|		<div class="red second">Red Two</div>
+		// 	|		<div class="blue">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".second").prevAll().andSelf();
+		//		returns the two divs with class of "prev", as well as the div with class "second".
+		return this.concat(this._parent);	//dojo.NodeList
+	},
+
+	//Alternate methods for the :first/:last/:even/:odd pseudos.
+	first: function(){
+		// summary:
+		// 		Returns the first node in this dojo.NodeList as a dojo.NodeList.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		// returns:
+		//		dojo.NodeList, with the first node in this dojo.NodeList
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red">Red One</div>
+		// 	|		<div class="blue first">Blue One</div>
+		// 	|		<div class="red">Red Two</div>
+		// 	|		<div class="blue last">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".blue").first();
+		//		returns the div with class "blue" and "first".
+		return this._wrap(((this[0] && [this[0]]) || []), this); //dojo.NodeList
+	},
+
+	last: function(){
+		// summary:
+		// 		Returns the last node in this dojo.NodeList as a dojo.NodeList.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		// returns:
+		//		dojo.NodeList, with the last node in this dojo.NodeList
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="red">Red One</div>
+		// 	|		<div class="blue first">Blue One</div>
+		// 	|		<div class="red">Red Two</div>
+		// 	|		<div class="blue last">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".blue").last();
+		//		returns the last div with class "blue",
+		return this._wrap((this.length ? [this[this.length - 1]] : []), this); //dojo.NodeList
+	},
+
+	even: function(){
+		// summary:
+		// 		Returns the even nodes in this dojo.NodeList as a dojo.NodeList.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		// returns:
+		//		dojo.NodeList, with the even nodes in this dojo.NodeList
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="interior red">Red One</div>
+		// 	|		<div class="interior blue">Blue One</div>
+		// 	|		<div class="interior red">Red Two</div>
+		// 	|		<div class="interior blue">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".interior").even();
+		//		returns the two divs with class "blue"
+		return this.filter(function(item, i){
+			return i % 2 != 0;
+		}); //dojo.NodeList
+	},
+
+	odd: function(){
+		// summary:
+		// 		Returns the odd nodes in this dojo.NodeList as a dojo.NodeList.
+		// description:
+		// 		.end() can be used on the returned dojo.NodeList to get back to the
+		// 		original dojo.NodeList.
+		// returns:
+		//		dojo.NodeList, with the odd nodes in this dojo.NodeList
+		//	example:
+		//		assume a DOM created by this markup:
+		//	|	<div class="container">
+		// 	|		<div class="interior red">Red One</div>
+		// 	|		<div class="interior blue">Blue One</div>
+		// 	|		<div class="interior red">Red Two</div>
+		// 	|		<div class="interior blue">Blue Two</div>
+		//	|	</div>
+		//		Running this code:
+		//	|	dojo.query(".interior").odd();
+		//		returns the two divs with class "red"
+		return this.filter(function(item, i){
+			return i % 2 == 0;
+		}); //dojo.NodeList
+	}
+});
+
+return NodeList;
+});
diff --git a/js/dojo-1.7.2/dojo/OpenAjax.js b/js/dojo-1.7.2/dojo/OpenAjax.js
new file mode 100644
index 0000000..0733641
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/OpenAjax.js
@@ -0,0 +1,194 @@
+/*******************************************************************************
+ * OpenAjax.js
+ *
+ * Reference implementation of the OpenAjax Hub, as specified by OpenAjax Alliance.
+ * Specification is under development at:
+ *
+ *   http://www.openajax.org/member/wiki/OpenAjax_Hub_Specification
+ *
+ * Copyright 2006-2007 OpenAjax Alliance
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0 . Unless
+ * required by applicable law or agreed to in writing, software distributed
+ * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ ******************************************************************************/
+
+// prevent re-definition of the OpenAjax object
+if(!window["OpenAjax"]){
+	OpenAjax = new function(){
+		// summary: the OpenAjax hub
+		// description: see http://www.openajax.org/member/wiki/OpenAjax_Hub_Specification
+
+		var t = true;
+		var f = false;
+		var g = window;
+		var libs;
+		var ooh = "org.openajax.hub.";
+
+		var h = {};
+		this.hub = h;
+		h.implementer = "http://openajax.org";
+		h.implVersion = "0.6";
+		h.specVersion = "0.6";
+		h.implExtraData = {};
+		var libs = {};
+		h.libraries = libs;
+
+		h.registerLibrary = function(prefix, nsURL, version, extra){
+			libs[prefix] = {
+				prefix: prefix,
+				namespaceURI: nsURL,
+				version: version,
+				extraData: extra
+			};
+			this.publish(ooh+"registerLibrary", libs[prefix]);
+		};
+		h.unregisterLibrary = function(prefix){
+			this.publish(ooh+"unregisterLibrary", libs[prefix]);
+			delete libs[prefix];
+		};
+
+		h._subscriptions = { c:{}, s:[] };
+		h._cleanup = [];
+		h._subIndex = 0;
+		h._pubDepth = 0;
+
+		h.subscribe = function(name, callback, scope, subscriberData, filter){
+			if(!scope){
+				scope = window;
+			}
+			var handle = name + "." + this._subIndex;
+			var sub = { scope: scope, cb: callback, fcb: filter, data: subscriberData, sid: this._subIndex++, hdl: handle };
+			var path = name.split(".");
+	 		this._subscribe(this._subscriptions, path, 0, sub);
+			return handle;
+		};
+
+		h.publish = function(name, message){
+			var path = name.split(".");
+			this._pubDepth++;
+			this._publish(this._subscriptions, path, 0, name, message);
+			this._pubDepth--;
+			if((this._cleanup.length > 0) && (this._pubDepth == 0)){
+				for(var i = 0; i < this._cleanup.length; i++){
+					this.unsubscribe(this._cleanup[i].hdl);
+				}
+				delete(this._cleanup);
+				this._cleanup = [];
+			}
+		};
+
+		h.unsubscribe = function(sub){
+			var path = sub.split(".");
+			var sid = path.pop();
+			this._unsubscribe(this._subscriptions, path, 0, sid);
+		};
+		
+		h._subscribe = function(tree, path, index, sub){
+			var token = path[index];
+			if(index == path.length){
+				tree.s.push(sub);
+			}else{
+				if(typeof tree.c == "undefined"){
+					tree.c = {};
+				}
+				if(typeof tree.c[token] == "undefined"){
+					tree.c[token] = { c: {}, s: [] };
+					this._subscribe(tree.c[token], path, index + 1, sub);
+				}else{
+					this._subscribe(tree.c[token], path, index + 1, sub);
+				}
+			}
+		};
+
+		h._publish = function(tree, path, index, name, msg){
+			if(typeof tree != "undefined"){
+				var node;
+				if(index == path.length){
+					node = tree;
+				}else{
+					this._publish(tree.c[path[index]], path, index + 1, name, msg);
+					this._publish(tree.c["*"], path, index + 1, name, msg);
+					node = tree.c["**"];
+				}
+				if(typeof node != "undefined"){
+					var callbacks = node.s;
+					var max = callbacks.length;
+					for(var i = 0; i < max; i++){
+						if(callbacks[i].cb){
+							var sc = callbacks[i].scope;
+							var cb = callbacks[i].cb;
+							var fcb = callbacks[i].fcb;
+							var d = callbacks[i].data;
+							if(typeof cb == "string"){
+								// get a function object
+								cb = sc[cb];
+							}
+							if(typeof fcb == "string"){
+								// get a function object
+								fcb = sc[fcb];
+							}
+							if((!fcb) ||
+								(fcb.call(sc, name, msg, d))){
+								cb.call(sc, name, msg, d);
+							}
+						}
+					}
+				}
+			}
+		};
+			
+		h._unsubscribe = function(tree, path, index, sid){
+			if(typeof tree != "undefined"){
+				if(index < path.length){
+					var childNode = tree.c[path[index]];
+					this._unsubscribe(childNode, path, index + 1, sid);
+					if(childNode.s.length == 0){
+						for(var x in childNode.c)
+							return;
+						delete tree.c[path[index]];
+					}
+					return;
+				}
+				else{
+					var callbacks = tree.s;
+					var max = callbacks.length;
+					for(var i = 0; i < max; i++)
+						if(sid == callbacks[i].sid){
+							if(this._pubDepth > 0){
+								callbacks[i].cb = null;
+								this._cleanup.push(callbacks[i]);
+							}
+							else
+								callbacks.splice(i, 1);
+							return;
+						}
+				}
+			}
+		};
+		// The following function is provided for automatic testing purposes.
+		// It is not expected to be deployed in run-time OpenAjax Hub implementations.
+		h.reinit = function()
+		{
+			for (var lib in OpenAjax.hub.libraries) {
+				delete OpenAjax.hub.libraries[lib];
+			}
+			OpenAjax.hub.registerLibrary("OpenAjax", "http://openajax.org/hub", "0.6", {});
+
+			delete OpenAjax._subscriptions;
+			OpenAjax._subscriptions = {c:{},s:[]};
+			delete OpenAjax._cleanup;
+			OpenAjax._cleanup = [];
+			OpenAjax._subIndex = 0;
+			OpenAjax._pubDepth = 0;
+		}
+	};
+	// Register the OpenAjax Hub itself as a library.
+	OpenAjax.hub.registerLibrary("OpenAjax", "http://openajax.org/hub", "0.6", {});
+
+}
diff --git a/js/dojo-1.7.2/dojo/Stateful.js b/js/dojo-1.7.2/dojo/Stateful.js
new file mode 100644
index 0000000..f527a1b
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/Stateful.js
@@ -0,0 +1,140 @@
+//>>built
+define("dojo/Stateful", ["./_base/kernel", "./_base/declare", "./_base/lang", "./_base/array"], function(dojo, declare, lang, array) {
+	// module:
+	//		dojo/Stateful
+	// summary:
+	//		TODOC
+
+return dojo.declare("dojo.Stateful", null, {
+	// summary:
+	//		Base class for objects that provide named properties with optional getter/setter
+	//		control and the ability to watch for property changes
+	// example:
+	//	|	var obj = new dojo.Stateful();
+	//	|	obj.watch("foo", function(){
+	//	|		console.log("foo changed to " + this.get("foo"));
+	//	|	});
+	//	|	obj.set("foo","bar");
+	postscript: function(mixin){
+		if(mixin){
+			lang.mixin(this, mixin);
+		}
+	},
+
+	get: function(/*String*/name){
+		// summary:
+		//		Get a property on a Stateful instance.
+		//	name:
+		//		The property to get.
+		//	returns:
+		//		The property value on this Stateful instance.
+		// description:
+		//		Get a named property on a Stateful object. The property may
+		//		potentially be retrieved via a getter method in subclasses. In the base class
+		// 		this just retrieves the object's property.
+		// 		For example:
+		//	|	stateful = new dojo.Stateful({foo: 3});
+		//	|	stateful.get("foo") // returns 3
+		//	|	stateful.foo // returns 3
+
+		return this[name]; //Any
+	},
+	set: function(/*String*/name, /*Object*/value){
+		// summary:
+		//		Set a property on a Stateful instance
+		//	name:
+		//		The property to set.
+		//	value:
+		//		The value to set in the property.
+		//	returns:
+		//		The function returns this dojo.Stateful instance.
+		// description:
+		//		Sets named properties on a stateful object and notifies any watchers of
+		// 		the property. A programmatic setter may be defined in subclasses.
+		// 		For example:
+		//	|	stateful = new dojo.Stateful();
+		//	|	stateful.watch(function(name, oldValue, value){
+		//	|		// this will be called on the set below
+		//	|	}
+		//	|	stateful.set(foo, 5);
+		//
+		//	set() may also be called with a hash of name/value pairs, ex:
+		//	|	myObj.set({
+		//	|		foo: "Howdy",
+		//	|		bar: 3
+		//	|	})
+		//	This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
+		if(typeof name === "object"){
+			for(var x in name){
+				this.set(x, name[x]);
+			}
+			return this;
+		}
+		var oldValue = this[name];
+		this[name] = value;
+		if(this._watchCallbacks){
+			this._watchCallbacks(name, oldValue, value);
+		}
+		return this; //dojo.Stateful
+	},
+	watch: function(/*String?*/name, /*Function*/callback){
+		// summary:
+		//		Watches a property for changes
+		//	name:
+		//		Indicates the property to watch. This is optional (the callback may be the
+		// 		only parameter), and if omitted, all the properties will be watched
+		// returns:
+		//		An object handle for the watch. The unwatch method of this object
+		// 		can be used to discontinue watching this property:
+		//		|	var watchHandle = obj.watch("foo", callback);
+		//		|	watchHandle.unwatch(); // callback won't be called now
+		//	callback:
+		//		The function to execute when the property changes. This will be called after
+		//		the property has been changed. The callback will be called with the |this|
+		//		set to the instance, the first argument as the name of the property, the
+		// 		second argument as the old value and the third argument as the new value.
+
+		var callbacks = this._watchCallbacks;
+		if(!callbacks){
+			var self = this;
+			callbacks = this._watchCallbacks = function(name, oldValue, value, ignoreCatchall){
+				var notify = function(propertyCallbacks){
+					if(propertyCallbacks){
+                        propertyCallbacks = propertyCallbacks.slice();
+						for(var i = 0, l = propertyCallbacks.length; i < l; i++){
+							try{
+								propertyCallbacks[i].call(self, name, oldValue, value);
+							}catch(e){
+								console.error(e);
+							}
+						}
+					}
+				};
+				notify(callbacks['_' + name]);
+				if(!ignoreCatchall){
+					notify(callbacks["*"]); // the catch-all
+				}
+			}; // we use a function instead of an object so it will be ignored by JSON conversion
+		}
+		if(!callback && typeof name === "function"){
+			callback = name;
+			name = "*";
+		}else{
+			// prepend with dash to prevent name conflicts with function (like "name" property)
+			name = '_' + name;
+		}
+		var propertyCallbacks = callbacks[name];
+		if(typeof propertyCallbacks !== "object"){
+			propertyCallbacks = callbacks[name] = [];
+		}
+		propertyCallbacks.push(callback);
+		return {
+			unwatch: function(){
+				propertyCallbacks.splice(array.indexOf(propertyCallbacks, callback), 1);
+			}
+		}; //Object
+	}
+
+});
+
+});
diff --git a/js/dojo-1.7.2/dojo/_base/Color.js b/js/dojo-1.7.2/dojo/_base/Color.js
new file mode 100644
index 0000000..c124c89
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/Color.js
@@ -0,0 +1,221 @@
+//>>built
+define("dojo/_base/Color", ["./kernel", "./lang", "./array", "./config"], function(dojo, lang, ArrayUtil, config){
+
+	var Color = dojo.Color = function(/*Array|String|Object*/ color){
+		// summary:
+		//		Takes a named string, hex string, array of rgb or rgba values,
+		//		an object with r, g, b, and a properties, or another `dojo.Color` object
+		//		and creates a new Color instance to work from.
+		//
+		// example:
+		//		Work with a Color instance:
+		//	 | var c = new dojo.Color();
+		//	 | c.setColor([0,0,0]); // black
+		//	 | var hex = c.toHex(); // #000000
+		//
+		// example:
+		//		Work with a node's color:
+		//	 | var color = dojo.style("someNode", "backgroundColor");
+		//	 | var n = new dojo.Color(color);
+		//	 | // adjust the color some
+		//	 | n.r *= .5;
+		//	 | console.log(n.toString()); // rgb(128, 255, 255);
+		if(color){ this.setColor(color); }
+	};
+
+	/*=====
+	lang.mixin(dojo.Color,{
+		named:{
+			// summary: Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values.
+		}
+	});
+	=====*/
+
+	// FIXME:
+	// there's got to be a more space-efficient way to encode or discover
+	// these!! Use hex?
+	Color.named = {
+		"black":  [0,0,0],
+		"silver": [192,192,192],
+		"gray":	  [128,128,128],
+		"white":  [255,255,255],
+		"maroon": [128,0,0],
+		"red":	  [255,0,0],
+		"purple": [128,0,128],
+		"fuchsia":[255,0,255],
+		"green":  [0,128,0],
+		"lime":	  [0,255,0],
+		"olive":  [128,128,0],
+		"yellow": [255,255,0],
+		"navy":	  [0,0,128],
+		"blue":	  [0,0,255],
+		"teal":	  [0,128,128],
+		"aqua":	  [0,255,255],
+		"transparent": config.transparentColor || [0,0,0,0]
+	};
+
+	lang.extend(Color, {
+		r: 255, g: 255, b: 255, a: 1,
+		_set: function(r, g, b, a){
+			var t = this; t.r = r; t.g = g; t.b = b; t.a = a;
+		},
+		setColor: function(/*Array|String|Object*/ color){
+			// summary:
+			//		Takes a named string, hex string, array of rgb or rgba values,
+			//		an object with r, g, b, and a properties, or another `dojo.Color` object
+			//		and sets this color instance to that value.
+			//
+			// example:
+			//	|	var c = new dojo.Color(); // no color
+			//	|	c.setColor("#ededed"); // greyish
+			if(lang.isString(color)){
+				Color.fromString(color, this);
+			}else if(lang.isArray(color)){
+				Color.fromArray(color, this);
+			}else{
+				this._set(color.r, color.g, color.b, color.a);
+				if(!(color instanceof Color)){ this.sanitize(); }
+			}
+			return this;	// dojo.Color
+		},
+		sanitize: function(){
+			// summary:
+			//		Ensures the object has correct attributes
+			// description:
+			//		the default implementation does nothing, include dojo.colors to
+			//		augment it with real checks
+			return this;	// dojo.Color
+		},
+		toRgb: function(){
+			// summary:
+			//		Returns 3 component array of rgb values
+			// example:
+			//	|	var c = new dojo.Color("#000000");
+			//	|	console.log(c.toRgb()); // [0,0,0]
+			var t = this;
+			return [t.r, t.g, t.b]; // Array
+		},
+		toRgba: function(){
+			// summary:
+			//		Returns a 4 component array of rgba values from the color
+			//		represented by this object.
+			var t = this;
+			return [t.r, t.g, t.b, t.a];	// Array
+		},
+		toHex: function(){
+			// summary:
+			//		Returns a CSS color string in hexadecimal representation
+			// example:
+			//	|	console.log(new dojo.Color([0,0,0]).toHex()); // #000000
+			var arr = ArrayUtil.map(["r", "g", "b"], function(x){
+				var s = this[x].toString(16);
+				return s.length < 2 ? "0" + s : s;
+			}, this);
+			return "#" + arr.join("");	// String
+		},
+		toCss: function(/*Boolean?*/ includeAlpha){
+			// summary:
+			//		Returns a css color string in rgb(a) representation
+			// example:
+			//	|	var c = new dojo.Color("#FFF").toCss();
+			//	|	console.log(c); // rgb('255','255','255')
+			var t = this, rgb = t.r + ", " + t.g + ", " + t.b;
+			return (includeAlpha ? "rgba(" + rgb + ", " + t.a : "rgb(" + rgb) + ")";	// String
+		},
+		toString: function(){
+			// summary:
+			//		Returns a visual representation of the color
+			return this.toCss(true); // String
+		}
+	});
+
+	Color.blendColors = dojo.blendColors = function(
+		/*dojo.Color*/ start,
+		/*dojo.Color*/ end,
+		/*Number*/ weight,
+		/*dojo.Color?*/ obj
+	){
+		// summary:
+		//		Blend colors end and start with weight from 0 to 1, 0.5 being a 50/50 blend,
+		//		can reuse a previously allocated dojo.Color object for the result
+		var t = obj || new Color();
+		ArrayUtil.forEach(["r", "g", "b", "a"], function(x){
+			t[x] = start[x] + (end[x] - start[x]) * weight;
+			if(x != "a"){ t[x] = Math.round(t[x]); }
+		});
+		return t.sanitize();	// dojo.Color
+	};
+
+	Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){
+		// summary:
+		//		Returns a `dojo.Color` instance from a string of the form
+		//		"rgb(...)" or "rgba(...)". Optionally accepts a `dojo.Color`
+		//		object to update with the parsed value and return instead of
+		//		creating a new object.
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);
+		return m && Color.fromArray(m[1].split(/\s*,\s*/), obj);	// dojo.Color
+	};
+
+	Color.fromHex = dojo.colorFromHex = function(/*String*/ color, /*dojo.Color?*/ obj){
+		// summary:
+		//		Converts a hex string with a '#' prefix to a color object.
+		//		Supports 12-bit #rgb shorthand. Optionally accepts a
+		//		`dojo.Color` object to update with the parsed value.
+		//
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		//
+		// example:
+		//	 | var thing = dojo.colorFromHex("#ededed"); // grey, longhand
+		//
+		// example:
+		//	| var thing = dojo.colorFromHex("#000"); // black, shorthand
+		var t = obj || new Color(),
+			bits = (color.length == 4) ? 4 : 8,
+			mask = (1 << bits) - 1;
+		color = Number("0x" + color.substr(1));
+		if(isNaN(color)){
+			return null; // dojo.Color
+		}
+		ArrayUtil.forEach(["b", "g", "r"], function(x){
+			var c = color & mask;
+			color >>= bits;
+			t[x] = bits == 4 ? 17 * c : c;
+		});
+		t.a = 1;
+		return t;	// dojo.Color
+	};
+
+	Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*dojo.Color?*/ obj){
+		// summary:
+		//		Builds a `dojo.Color` from a 3 or 4 element array, mapping each
+		//		element in sequence to the rgb(a) values of the color.
+		// example:
+		//		| var myColor = dojo.colorFromArray([237,237,237,0.5]); // grey, 50% alpha
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		var t = obj || new Color();
+		t._set(Number(a[0]), Number(a[1]), Number(a[2]), Number(a[3]));
+		if(isNaN(t.a)){ t.a = 1; }
+		return t.sanitize();	// dojo.Color
+	};
+
+	Color.fromString = dojo.colorFromString = function(/*String*/ str, /*dojo.Color?*/ obj){
+		// summary:
+		//		Parses `str` for a color value. Accepts hex, rgb, and rgba
+		//		style color values.
+		// description:
+		//		Acceptable input values for str may include arrays of any form
+		//		accepted by dojo.colorFromArray, hex strings such as "#aaaaaa", or
+		//		rgb or rgba strings such as "rgb(133, 200, 16)" or "rgba(10, 10,
+		//		10, 50)"
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		var a = Color.named[str];
+		return a && Color.fromArray(a, obj) || Color.fromRgb(str, obj) || Color.fromHex(str, obj);	// dojo.Color
+	};
+
+	return Color;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/Deferred.js b/js/dojo-1.7.2/dojo/_base/Deferred.js
new file mode 100644
index 0000000..b098809
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/Deferred.js
@@ -0,0 +1,367 @@
+//>>built
+define("dojo/_base/Deferred", ["./kernel", "./lang"], function(dojo, lang){
+	// module:
+	//		dojo/_base/Deferred
+	// summary:
+	//		This module defines dojo.Deferred.
+
+	var mutator = function(){};
+	var freeze = Object.freeze || function(){};
+	// A deferred provides an API for creating and resolving a promise.
+	dojo.Deferred = function(/*Function?*/ canceller){
+		// summary:
+		//		Deferreds provide a generic means for encapsulating an asynchronous
+		//		operation and notifying users of the completion and result of the operation.
+		// description:
+		//		The dojo.Deferred API is based on the concept of promises that provide a
+		//		generic interface into the eventual completion of an asynchronous action.
+		//		The motivation for promises fundamentally is about creating a
+		//		separation of concerns that allows one to achieve the same type of
+		//		call patterns and logical data flow in asynchronous code as can be
+		//		achieved in synchronous code. Promises allows one
+		//		to be able to call a function purely with arguments needed for
+		//		execution, without conflating the call with concerns of whether it is
+		//		sync or async. One shouldn't need to alter a call's arguments if the
+		//		implementation switches from sync to async (or vice versa). By having
+		//		async functions return promises, the concerns of making the call are
+		//		separated from the concerns of asynchronous interaction (which are
+		//		handled by the promise).
+		//
+		//		The dojo.Deferred is a type of promise that provides methods for fulfilling the
+		//		promise with a successful result or an error. The most important method for
+		//		working with Dojo's promises is the then() method, which follows the
+		//		CommonJS proposed promise API. An example of using a Dojo promise:
+		//
+		//		|	var resultingPromise = someAsyncOperation.then(function(result){
+		//		|		... handle result ...
+		//		|	},
+		//		|	function(error){
+		//		|		... handle error ...
+		//		|	});
+		//
+		//		The .then() call returns a new promise that represents the result of the
+		//		execution of the callback. The callbacks will never affect the original promises value.
+		//
+		//		The dojo.Deferred instances also provide the following functions for backwards compatibility:
+		//
+		//			* addCallback(handler)
+		//			* addErrback(handler)
+		//			* callback(result)
+		//			* errback(result)
+		//
+		//		Callbacks are allowed to return promises themselves, so
+		//		you can build complicated sequences of events with ease.
+		//
+		//		The creator of the Deferred may specify a canceller.  The canceller
+		//		is a function that will be called if Deferred.cancel is called
+		//		before the Deferred fires. You can use this to implement clean
+		//		aborting of an XMLHttpRequest, etc. Note that cancel will fire the
+		//		deferred with a CancelledError (unless your canceller returns
+		//		another kind of error), so the errbacks should be prepared to
+		//		handle that error for cancellable Deferreds.
+		// example:
+		//	|	var deferred = new dojo.Deferred();
+		//	|	setTimeout(function(){ deferred.callback({success: true}); }, 1000);
+		//	|	return deferred;
+		// example:
+		//		Deferred objects are often used when making code asynchronous. It
+		//		may be easiest to write functions in a synchronous manner and then
+		//		split code using a deferred to trigger a response to a long-lived
+		//		operation. For example, instead of register a callback function to
+		//		denote when a rendering operation completes, the function can
+		//		simply return a deferred:
+		//
+		//		|	// callback style:
+		//		|	function renderLotsOfData(data, callback){
+		//		|		var success = false
+		//		|		try{
+		//		|			for(var x in data){
+		//		|				renderDataitem(data[x]);
+		//		|			}
+		//		|			success = true;
+		//		|		}catch(e){ }
+		//		|		if(callback){
+		//		|			callback(success);
+		//		|		}
+		//		|	}
+		//
+		//		|	// using callback style
+		//		|	renderLotsOfData(someDataObj, function(success){
+		//		|		// handles success or failure
+		//		|		if(!success){
+		//		|			promptUserToRecover();
+		//		|		}
+		//		|	});
+		//		|	// NOTE: no way to add another callback here!!
+		// example:
+		//		Using a Deferred doesn't simplify the sending code any, but it
+		//		provides a standard interface for callers and senders alike,
+		//		providing both with a simple way to service multiple callbacks for
+		//		an operation and freeing both sides from worrying about details
+		//		such as "did this get called already?". With Deferreds, new
+		//		callbacks can be added at any time.
+		//
+		//		|	// Deferred style:
+		//		|	function renderLotsOfData(data){
+		//		|		var d = new dojo.Deferred();
+		//		|		try{
+		//		|			for(var x in data){
+		//		|				renderDataitem(data[x]);
+		//		|			}
+		//		|			d.callback(true);
+		//		|		}catch(e){
+		//		|			d.errback(new Error("rendering failed"));
+		//		|		}
+		//		|		return d;
+		//		|	}
+		//
+		//		|	// using Deferred style
+		//		|	renderLotsOfData(someDataObj).then(null, function(){
+		//		|		promptUserToRecover();
+		//		|	});
+		//		|	// NOTE: addErrback and addCallback both return the Deferred
+		//		|	// again, so we could chain adding callbacks or save the
+		//		|	// deferred for later should we need to be notified again.
+		// example:
+		//		In this example, renderLotsOfData is synchronous and so both
+		//		versions are pretty artificial. Putting the data display on a
+		//		timeout helps show why Deferreds rock:
+		//
+		//		|	// Deferred style and async func
+		//		|	function renderLotsOfData(data){
+		//		|		var d = new dojo.Deferred();
+		//		|		setTimeout(function(){
+		//		|			try{
+		//		|				for(var x in data){
+		//		|					renderDataitem(data[x]);
+		//		|				}
+		//		|				d.callback(true);
+		//		|			}catch(e){
+		//		|				d.errback(new Error("rendering failed"));
+		//		|			}
+		//		|		}, 100);
+		//		|		return d;
+		//		|	}
+		//
+		//		|	// using Deferred style
+		//		|	renderLotsOfData(someDataObj).then(null, function(){
+		//		|		promptUserToRecover();
+		//		|	});
+		//
+		//		Note that the caller doesn't have to change his code at all to
+		//		handle the asynchronous case.
+
+		var result, finished, isError, head, nextListener;
+		var promise = (this.promise = {});
+
+		function complete(value){
+			if(finished){
+				throw new Error("This deferred has already been resolved");
+			}
+			result = value;
+			finished = true;
+			notify();
+		}
+		function notify(){
+			var mutated;
+			while(!mutated && nextListener){
+				var listener = nextListener;
+				nextListener = nextListener.next;
+				if((mutated = (listener.progress == mutator))){ // assignment and check
+					finished = false;
+				}
+				var func = (isError ? listener.error : listener.resolved);
+				if(func){
+					try{
+						var newResult = func(result);
+						if (newResult && typeof newResult.then === "function"){
+							newResult.then(lang.hitch(listener.deferred, "resolve"), lang.hitch(listener.deferred, "reject"), lang.hitch(listener.deferred, "progress"));
+							continue;
+						}
+						var unchanged = mutated && newResult === undefined;
+						if(mutated && !unchanged){
+							isError = newResult instanceof Error;
+						}
+						listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult);
+					}catch(e){
+						listener.deferred.reject(e);
+					}
+				}else{
+					if(isError){
+						listener.deferred.reject(result);
+					}else{
+						listener.deferred.resolve(result);
+					}
+				}
+			}
+		}
+		// calling resolve will resolve the promise
+		this.resolve = this.callback = function(value){
+			// summary:
+			//		Fulfills the Deferred instance successfully with the provide value
+			this.fired = 0;
+			this.results = [value, null];
+			complete(value);
+		};
+
+
+		// calling error will indicate that the promise failed
+		this.reject = this.errback = function(error){
+			// summary:
+			//		Fulfills the Deferred instance as an error with the provided error
+			isError = true;
+			this.fired = 1;
+			complete(error);
+			this.results = [null, error];
+			if(!error || error.log !== false){
+				(dojo.config.deferredOnError || function(x){ console.error(x); })(error);
+			}
+		};
+		// call progress to provide updates on the progress on the completion of the promise
+		this.progress = function(update){
+			// summary:
+			//		Send progress events to all listeners
+			var listener = nextListener;
+			while(listener){
+				var progress = listener.progress;
+				progress && progress(update);
+				listener = listener.next;
+			}
+		};
+		this.addCallbacks = function(callback, errback){
+			// summary:
+			//		Adds callback and error callback for this deferred instance.
+			// callback: Function?
+			// 		The callback attached to this deferred object.
+			// errback: Function?
+			// 		The error callback attached to this deferred object.
+			// returns:
+			// 		Returns this deferred object.
+			this.then(callback, errback, mutator);
+			return this;	// dojo.Deferred
+		};
+		// provide the implementation of the promise
+		promise.then = this.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){
+			// summary:
+			//		Adds a fulfilledHandler, errorHandler, and progressHandler to be called for
+			//		completion of a promise. The fulfilledHandler is called when the promise
+			//		is fulfilled. The errorHandler is called when a promise fails. The
+			//		progressHandler is called for progress events. All arguments are optional
+			//		and non-function values are ignored. The progressHandler is not only an
+			//		optional argument, but progress events are purely optional. Promise
+			//		providers are not required to ever create progress events.
+			//
+			//		This function will return a new promise that is fulfilled when the given
+			//		fulfilledHandler or errorHandler callback is finished. This allows promise
+			//		operations to be chained together. The value returned from the callback
+			//		handler is the fulfillment value for the returned promise. If the callback
+			//		throws an error, the returned promise will be moved to failed state.
+			//
+			// returns: 
+			//		Returns a new promise that represents the result of the
+			//		execution of the callback. The callbacks will never affect the original promises value.
+			// example:
+			//		An example of using a CommonJS compliant promise:
+			//		|	asyncComputeTheAnswerToEverything().
+			//		|		then(addTwo).
+			//		|		then(printResult, onError);
+			//		|	>44
+			//
+			var returnDeferred = progressCallback == mutator ? this : new dojo.Deferred(promise.cancel);
+			var listener = {
+				resolved: resolvedCallback,
+				error: errorCallback,
+				progress: progressCallback,
+				deferred: returnDeferred
+			};
+			if(nextListener){
+				head = head.next = listener;
+			}
+			else{
+				nextListener = head = listener;
+			}
+			if(finished){
+				notify();
+			}
+			return returnDeferred.promise; // Promise
+		};
+		var deferred = this;
+		promise.cancel = this.cancel = function (){
+			// summary:
+			//		Cancels the asynchronous operation
+			if(!finished){
+				var error = canceller && canceller(deferred);
+				if(!finished){
+					if (!(error instanceof Error)){
+						error = new Error(error);
+					}
+					error.log = false;
+					deferred.reject(error);
+				}
+			}
+		};
+		freeze(promise);
+	};
+	lang.extend(dojo.Deferred, {
+		addCallback: function (/*Function*/ callback){
+			// summary:
+			// 		Adds successful callback for this deferred instance.
+			// returns:
+			// 		Returns this deferred object.
+			return this.addCallbacks(lang.hitch.apply(dojo, arguments));	// dojo.Deferred
+		},
+
+		addErrback: function (/*Function*/ errback){
+			// summary:
+			// 		Adds error callback for this deferred instance.
+			// returns:
+			// 		Returns this deferred object.
+			return this.addCallbacks(null, lang.hitch.apply(dojo, arguments));	// dojo.Deferred
+		},
+
+		addBoth: function (/*Function*/ callback){
+			// summary:
+			// 		Add handler as both successful callback and error callback for this deferred instance.
+			// returns:
+			// 		Returns this deferred object.
+			var enclosed = lang.hitch.apply(dojo, arguments);
+			return this.addCallbacks(enclosed, enclosed);	// dojo.Deferred
+		},
+		fired: -1
+	});
+
+	dojo.Deferred.when = dojo.when = function(promiseOrValue, /*Function?*/ callback, /*Function?*/ errback, /*Function?*/ progressHandler){
+		// summary:
+		//		This provides normalization between normal synchronous values and
+		//		asynchronous promises, so you can interact with them in a common way
+		// returns:
+		// 		Returns a new promise that represents the result of the execution of callback 
+		// 		when parameter "promiseOrValue" is promise.
+		// 		Returns the execution result of callback when parameter "promiseOrValue" is value.
+		// example:
+		//		|	function printFirstAndLast(items){
+		//		|		dojo.when(findFirst(items), console.log);
+		//		|		dojo.when(findLast(items), console.log);
+		//		|	}
+		//		|	function findFirst(items){
+		//		|		return dojo.when(items, function(items){
+		//		|			return items[0];
+		//		|		});
+		//		|	}
+		//		|	function findLast(items){
+		//		|		return dojo.when(items, function(items){
+		//		|			return items[items.length - 1];
+		//		|		});
+		//		|	}
+		//		And now all three of his functions can be used sync or async.
+		//		|	printFirstAndLast([1,2,3,4]) will work just as well as
+		//		|	printFirstAndLast(dojo.xhrGet(...));
+
+		if(promiseOrValue && typeof promiseOrValue.then === "function"){
+			return promiseOrValue.then(callback, errback, progressHandler);
+		}
+		return callback ? callback(promiseOrValue) : promiseOrValue;	// Promise
+	};
+
+	return dojo.Deferred;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/NodeList.js b/js/dojo-1.7.2/dojo/_base/NodeList.js
new file mode 100644
index 0000000..9fa9b2e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/NodeList.js
@@ -0,0 +1,101 @@
+//>>built
+define("dojo/_base/NodeList", ["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){
+  //  module:
+  //    dojo/_base/NodeList
+  //  summary:
+  //    This module defines dojo.NodeList.
+ 
+var NodeList = query.NodeList;
+
+	/*=====
+	dojo.extend(dojo.NodeList, {
+		connect: function(methodName, objOrFunc, funcName){
+			// summary:
+			//		attach event handlers to every item of the NodeList. Uses dojo.connect()
+			//		so event properties are normalized
+			// methodName: String
+			//		the name of the method to attach to. For DOM events, this should be
+			//		the lower-case name of the event
+			// objOrFunc: Object|Function|String
+			//		if 2 arguments are passed (methodName, objOrFunc), objOrFunc should
+			//		reference a function or be the name of the function in the global
+			//		namespace to attach. If 3 arguments are provided
+			//		(methodName, objOrFunc, funcName), objOrFunc must be the scope to
+			//		locate the bound function in
+			// funcName: String?
+			//		optional. A string naming the function in objOrFunc to bind to the
+			//		event. May also be a function reference.
+			// example:
+			//		add an onclick handler to every button on the page
+			//		|	dojo.query("div:nth-child(odd)").connect("onclick", function(e){
+			//		|		console.log("clicked!");
+			//		|	});
+			// example:
+			//		attach foo.bar() to every odd div's onmouseover
+			//		|	dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
+		},
+		coords: function(){
+			// summary:
+			//		Deprecated: Use position() for border-box x/y/w/h
+			//		or marginBox() for margin-box w/h/l/t.
+			//		Returns the box objects of all elements in a node list as
+			//		an Array (*not* a NodeList). Acts like `dojo.coords`, though assumes
+			//		the node passed is each node in this list.
+
+			return dojo.map(this, dojo.coords); // Array
+		}
+	 });
+
+	 var NodeList = dojo.NodeList;
+	=====*/
+	var nlp = NodeList.prototype;
+
+	// don't bind early to dojo.connect since we no longer explicitly depend on it
+	nlp.connect = NodeList._adaptAsForEach(function(){
+		return dojo.connect.apply(this, arguments);
+	});
+	nlp.coords = NodeList._adaptAsMap(dojo.coords);
+
+	NodeList.events = [
+		// summary:
+		//		list of all DOM events used in NodeList
+		"blur", "focus", "change", "click", "error", "keydown", "keypress",
+		"keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove",
+		"mouseout", "mouseover", "mouseup", "submit"
+	];
+
+	// FIXME: pseudo-doc the above automatically generated on-event functions
+
+	// syntactic sugar for DOM events
+	array.forEach(NodeList.events, function(evt){
+			var _oe = "on" + evt;
+			nlp[_oe] = function(a, b){
+				return this.connect(_oe, a, b);
+			};
+				// FIXME: should these events trigger publishes?
+				/*
+				return (a ? this.connect(_oe, a, b) :
+							this.forEach(function(n){
+								// FIXME:
+								//		listeners get buried by
+								//		addEventListener and can't be dug back
+								//		out to be triggered externally.
+								// see:
+								//		http://developer.mozilla.org/en/docs/DOM:element
+
+								console.log(n, evt, _oe);
+
+								// FIXME: need synthetic event support!
+								var _e = { target: n, faux: true, type: evt };
+								// dojo._event_listener._synthesizeEvent({}, { target: n, faux: true, type: evt });
+								try{ n[evt](_e); }catch(e){ console.log(e); }
+								try{ n[_oe](_e); }catch(e){ console.log(e); }
+							})
+				);
+				*/
+		}
+	);
+
+	dojo.NodeList = NodeList;
+	return dojo.NodeList;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/array.js b/js/dojo-1.7.2/dojo/_base/array.js
new file mode 100644
index 0000000..c3139d0
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/array.js
@@ -0,0 +1,344 @@
+//>>built
+define("dojo/_base/array", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
+	// module:
+	//		dojo/_base/array
+	// summary:
+	//		This module defines the Javascript v1.6 array extensions.
+
+	/*=====
+	dojo.indexOf = function(arr, value, fromIndex, findLast){
+		// summary:
+		//		locates the first index of the provided value in the
+		//		passed array. If the value is not found, -1 is returned.
+		// description:
+		//		This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when
+		//		run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
+		//		1.6's indexOf skips the holes in the sparse array.
+		//		For details on this method, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+		// arr: Array
+		// value: Object
+		// fromIndex: Integer?
+		// findLast: Boolean?
+		// returns: Number
+	};
+	dojo.lastIndexOf = function(arr, value, fromIndex){
+		// summary:
+		//		locates the last index of the provided value in the passed
+		//		array. If the value is not found, -1 is returned.
+		// description:
+		//		This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when
+		//		run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
+		//		1.6's lastIndexOf skips the holes in the sparse array.
+		//		For details on this method, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf
+		//	arr: Array,
+		//	value: Object,
+		//	fromIndex: Integer?
+		//	returns: Number
+	};
+	dojo.forEach = function(arr, callback, thisObject){
+		//	summary:
+		//		for every item in arr, callback is invoked. Return values are ignored.
+		//		If you want to break out of the loop, consider using dojo.every() or dojo.some().
+		//		forEach does not allow breaking out of the loop over the items in arr.
+		//	arr:
+		//		the array to iterate over. If a string, operates on individual characters.
+		//	callback:
+		//		a function is invoked with three arguments: item, index, and array
+		//	thisObject:
+		//		may be used to scope the call to callback
+		//	description:
+		//		This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach
+		//	example:
+		//	| // log out all members of the array:
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		function(item){
+		//	|			console.log(item);
+		//	|		}
+		//	| );
+		//	example:
+		//	| // log out the members and their indexes
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		function(item, idx, arr){
+		//	|			console.log(item, "at index:", idx);
+		//	|		}
+		//	| );
+		//	example:
+		//	| // use a scoped object member as the callback
+		//	|
+		//	| var obj = {
+		//	|		prefix: "logged via obj.callback:",
+		//	|		callback: function(item){
+		//	|			console.log(this.prefix, item);
+		//	|		}
+		//	| };
+		//	|
+		//	| // specifying the scope function executes the callback in that scope
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		obj.callback,
+		//	|		obj
+		//	| );
+		//	|
+		//	| // alternately, we can accomplish the same thing with dojo.hitch()
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		dojo.hitch(obj, "callback")
+		//	| );
+		//	arr: Array|String
+		//	callback: Function|String
+		//	thisObject: Object?
+	};
+	dojo.every = function(arr, callback, thisObject){
+		// summary:
+		//		Determines whether or not every item in arr satisfies the
+		//		condition implemented by callback.
+		// arr: Array|String
+		//		the array to iterate on. If a string, operates on individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments: item, index,
+		//		and array and returns true if the condition is met.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Boolean
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
+		// example:
+		//	| // returns false
+		//	| dojo.every([1, 2, 3, 4], function(item){ return item>1; });
+		// example:
+		//	| // returns true
+		//	| dojo.every([1, 2, 3, 4], function(item){ return item>0; });
+	};
+	dojo.some = function(arr, callback, thisObject){
+		// summary:
+		//		Determines whether or not any item in arr satisfies the
+		//		condition implemented by callback.
+		// arr: Array|String
+		//		the array to iterate over. If a string, operates on individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments: item, index,
+		//		and array and returns true if the condition is met.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Boolean
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
+		// example:
+		//	| // is true
+		//	| dojo.some([1, 2, 3, 4], function(item){ return item>1; });
+		// example:
+		//	| // is false
+		//	| dojo.some([1, 2, 3, 4], function(item){ return item<1; });
+	};
+	dojo.map = function(arr, callback, thisObject){
+		// summary:
+		//		applies callback to each element of arr and returns
+		//		an Array with the results
+		// arr: Array|String
+		//		the array to iterate on. If a string, operates on
+		//		individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments, (item, index,
+		//		array),	 and returns a value
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Array
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+		// example:
+		//	| // returns [2, 3, 4, 5]
+		//	| dojo.map([1, 2, 3, 4], function(item){ return item+1 });
+	};
+	dojo.filter = function(arr, callback, thisObject){
+		// summary:
+		//		Returns a new Array with those items from arr that match the
+		//		condition implemented by callback.
+		// arr: Array
+		//		the array to iterate over.
+		// callback: Function|String
+		//		a function that is invoked with three arguments (item,
+		//		index, array). The return of this function is expected to
+		//		be a boolean which determines whether the passed-in item
+		//		will be included in the returned array.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Array
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+		// example:
+		//	| // returns [2, 3, 4]
+		//	| dojo.filter([1, 2, 3, 4], function(item){ return item>1; });
+	};
+	=====*/
+
+	// our old simple function builder stuff
+	var cache = {}, u, array; // the export object
+
+	function clearCache(){
+		cache = {};
+	}
+
+	function buildFn(fn){
+		return cache[fn] = new Function("item", "index", "array", fn); // Function
+	}
+	// magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+
+	// every & some
+
+	function everyOrSome(some){
+		var every = !some;
+		return function(a, fn, o){
+			var i = 0, l = a && a.length || 0, result;
+			if(l && typeof a == "string") a = a.split("");
+			if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+			if(o){
+				for(; i < l; ++i){
+					result = !fn.call(o, a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}else{
+				for(; i < l; ++i){
+					result = !fn(a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}
+			return every; // Boolean
+		}
+	}
+	// var every = everyOrSome(false), some = everyOrSome(true);
+
+	// indexOf, lastIndexOf
+
+	function index(up){
+		var delta = 1, lOver = 0, uOver = 0;
+		if(!up){
+			delta = lOver = uOver = -1;
+		}
+		return function(a, x, from, last){
+			if(last && delta > 0){
+				// TODO: why do we use a non-standard signature? why do we need "last"?
+				return array.lastIndexOf(a, x, from);
+			}
+			var l = a && a.length || 0, end = up ? l + uOver : lOver, i;
+			if(from === u){
+				i = up ? lOver : l + uOver;
+			}else{
+				if(from < 0){
+					i = l + from;
+					if(i < 0){
+						i = lOver;
+					}
+				}else{
+					i = from >= l ? l + uOver : from;
+				}
+			}
+			if(l && typeof a == "string") a = a.split("");
+			for(; i != end; i += delta){
+				if(a[i] == x){
+					return i; // Number
+				}
+			}
+			return -1; // Number
+		}
+	}
+	// var indexOf = index(true), lastIndexOf = index(false);
+
+	function forEach(a, fn, o){
+		var i = 0, l = a && a.length || 0;
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				fn.call(o, a[i], i, a);
+			}
+		}else{
+			for(; i < l; ++i){
+				fn(a[i], i, a);
+			}
+		}
+	}
+
+	function map(a, fn, o, Ctr){
+		// TODO: why do we have a non-standard signature here? do we need "Ctr"?
+		var i = 0, l = a && a.length || 0, out = new (Ctr || Array)(l);
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				out[i] = fn.call(o, a[i], i, a);
+			}
+		}else{
+			for(; i < l; ++i){
+				out[i] = fn(a[i], i, a);
+			}
+		}
+		return out; // Array
+	}
+
+	function filter(a, fn, o){
+		// TODO: do we need "Ctr" here like in map()?
+		var i = 0, l = a && a.length || 0, out = [], value;
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				value = a[i];
+				if(fn.call(o, value, i, a)){
+					out.push(value);
+				}
+			}
+		}else{
+			for(; i < l; ++i){
+				value = a[i];
+				if(fn(value, i, a)){
+					out.push(value);
+				}
+			}
+		}
+		return out; // Array
+	}
+
+	array = {
+		every:       everyOrSome(false),
+		some:        everyOrSome(true),
+		indexOf:     index(true),
+		lastIndexOf: index(false),
+		forEach:     forEach,
+		map:         map,
+		filter:      filter,
+		clearCache:  clearCache
+	};
+
+	1 && lang.mixin(dojo, array);
+
+	/*===== return dojo.array; =====*/
+	return array;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/browser.js b/js/dojo-1.7.2/dojo/_base/browser.js
new file mode 100644
index 0000000..c930ca7
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/browser.js
@@ -0,0 +1,22 @@
+//>>built
+if(require.has){
+	require.has.add("config-selectorEngine", "acme");
+}
+define("dojo/_base/browser", [
+	"../ready",
+	"./kernel",
+	"./connect", // until we decide if connect is going back into non-browser environments
+	"./unload",
+	"./window",
+	"./event",
+	"./html",
+	"./NodeList",
+	"../query",
+	"./xhr",
+	"./fx"], function(dojo) {
+	// module:
+	//		dojo/_base/browser
+	// summary:
+	//		This module causes the browser-only base modules to be loaded.
+	return dojo;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/config.js b/js/dojo-1.7.2/dojo/_base/config.js
new file mode 100644
index 0000000..dfafdaf
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/config.js
@@ -0,0 +1,175 @@
+//>>built
+define("dojo/_base/config", ["../has", "require"], function(has, require){
+	// module:
+	//		dojo/_base/config
+	// summary:
+	//		This module defines the user configuration during bootstrap.
+	// description:
+	//		By defining user configuration as a module value, an entire configuration can be specified in a build,
+    //		thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
+    //		Also, when multiple instances of dojo exist in a single application, each will necessarily be located
+	//		at an unique absolute module identifier as given by the package configuration. Implementing configuration
+	//		as a module allows for specifying unique, per-instance configurations.
+	// example:
+	//		Create a second instance of dojo with a different, instance-uniqe configuration (assume the loader and
+	//		dojo.js are already loaded).
+	//		|	// specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
+	//		|	require({
+	//		|		packages:[{
+	//		|			name:"myDojo",
+	//		|			location:".", //assume baseUrl points to dojo.js
+	//		|	    }]
+	//		|	});
+	//		|
+	//		|	// specify a configuration for the myDojo instance
+	//		|	define("myDojo/config", {
+	//		|		// normal configuration variables go here, e.g.,
+	//		|		locale:"fr-ca"
+	//		|	});
+	//		|
+	//		|	// load and use the new instance of dojo
+	//		|	require(["myDojo"], function(dojo) {
+	//		|		// dojo is the new instance of dojo
+	//		|		// use as required
+	//		|	});
+
+	var result = {};
+	if(1){
+		// must be the dojo loader; take a shallow copy of require.rawConfig
+		var src = require.rawConfig, p;
+		for(p in src){
+			result[p] = src[p];
+		}
+	}else{
+		var adviseHas = function(featureSet, prefix, booting){
+			for(p in featureSet){
+				p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
+			}
+		};
+		result = 1 ?
+			// must be a built version of the dojo loader; all config stuffed in require.rawConfig
+			require.rawConfig :
+			// a foreign loader
+			this.dojoConfig || this.djConfig || {};
+		adviseHas(result, "config", 1);
+		adviseHas(result.has, "", 1);
+	}
+	return result;
+
+/*=====
+// note:
+//		'dojoConfig' does not exist under 'dojo.*' so that it can be set before the
+//		'dojo' variable exists.
+// note:
+//		Setting any of these variables *after* the library has loaded does
+//		nothing at all.
+
+// FIXME: can we document these on dojo.config object and explain they must be set via djConfig/dojoConfig global prior to loading dojo.js
+
+dojoConfig = {
+	// summary:
+	//		Application code can set the global 'dojoConfig' prior to loading
+	//		the library to control certain global settings for how dojo works.
+	//
+	// isDebug: Boolean
+	//		Defaults to `false`. If set to `true`, ensures that Dojo provides
+	//		extended debugging feedback via Firebug. If Firebug is not available
+	//		on your platform, setting `isDebug` to `true` will force Dojo to
+	//		pull in (and display) the version of Firebug Lite which is
+	//		integrated into the Dojo distribution, thereby always providing a
+	//		debugging/logging console when `isDebug` is enabled. Note that
+	//		Firebug's `console.*` methods are ALWAYS defined by Dojo. If
+	//		`isDebug` is false and you are on a platform without Firebug, these
+	//		methods will be defined as no-ops.
+	isDebug: false,
+	// locale: String
+	//		The locale to assume for loading localized resources in this page,
+	//		specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
+	//		Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
+	//		See the documentation for `dojo.i18n` and `dojo.requireLocalization`
+	//		for details on loading localized resources. If no locale is specified,
+	//		Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
+	//		or `navigator.language` properties.
+	locale: undefined,
+	// extraLocale: Array
+	//		No default value. Specifies additional locales whose
+	//		resources should also be loaded alongside the default locale when
+	//		calls to `dojo.requireLocalization()` are processed.
+	extraLocale: undefined,
+	// baseUrl: String
+	//		The directory in which `dojo.js` is located. Under normal
+	//		conditions, Dojo auto-detects the correct location from which it
+	//		was loaded. You may need to manually configure `baseUrl` in cases
+	//		where you have renamed `dojo.js` or in which `<base>` tags confuse
+	//		some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
+	//		either the value of `djConfig.baseUrl` if one is provided or the
+	//		auto-detected root if not. Other modules are located relative to
+	//		this path. The path should end in a slash.
+	baseUrl: undefined,
+	// modulePaths: Object
+	//		A map of module names to paths relative to `dojo.baseUrl`. The
+	//		key/value pairs correspond directly to the arguments which
+	//		`dojo.registerModulePath` accepts. Specifiying
+	//		`djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
+	//		of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
+	//		modules may be configured via `djConfig.modulePaths`.
+	modulePaths: {},
+	// afterOnLoad: Boolean
+	//		Indicates Dojo was added to the page after the page load. In this case
+	//		Dojo will not wait for the page DOMContentLoad/load events and fire
+	//		its dojo.addOnLoad callbacks after making sure all outstanding
+	//		dojo.required modules have loaded. Only works with a built dojo.js,
+	//		it does not work the dojo.js directly from source control.
+	afterOnLoad: false,
+	// addOnLoad: Function or Array
+	//		Adds a callback via dojo.addOnLoad. Useful when Dojo is added after
+	//		the page loads and djConfig.afterOnLoad is true. Supports the same
+	//		arguments as dojo.addOnLoad. When using a function reference, use
+	//		`djConfig.addOnLoad = function(){};`. For object with function name use
+	//		`djConfig.addOnLoad = [myObject, "functionName"];` and for object with
+	//		function reference use
+	//		`djConfig.addOnLoad = [myObject, function(){}];`
+	addOnLoad: null,
+	// require: Array
+	//		An array of module names to be loaded immediately after dojo.js has been included
+	//		in a page.
+	require: [],
+	// defaultDuration: Array
+	//		Default duration, in milliseconds, for wipe and fade animations within dijits.
+	//		Assigned to dijit.defaultDuration.
+	defaultDuration: 200,
+	// dojoBlankHtmlUrl: String
+	//		Used by some modules to configure an empty iframe. Used by dojo.io.iframe and
+	//		dojo.back, and dijit popup support in IE where an iframe is needed to make sure native
+	//		controls do not bleed through the popups. Normally this configuration variable
+	//		does not need to be set, except when using cross-domain/CDN Dojo builds.
+	//		Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
+	//		to the path on your domain your copy of blank.html.
+	dojoBlankHtmlUrl: undefined,
+	//	ioPublish: Boolean?
+	//		Set this to true to enable publishing of topics for the different phases of
+	//		IO operations. Publishing is done via dojo.publish. See dojo.__IoPublish for a list
+	//		of topics that are published.
+	ioPublish: false,
+	//	useCustomLogger: Anything?
+	//		If set to a value that evaluates to true such as a string or array and
+	//		isDebug is true and Firebug is not available or running, then it bypasses
+	//		the creation of Firebug Lite allowing you to define your own console object.
+	useCustomLogger: undefined,
+	// transparentColor: Array
+	//		Array containing the r, g, b components used as transparent color in dojo.Color;
+	//		if undefined, [255,255,255] (white) will be used.
+	transparentColor: undefined,
+	// skipIeDomLoaded: Boolean
+	//		For IE only, skip the DOMContentLoaded hack used. Sometimes it can cause an Operation
+	//		Aborted error if the rest of the page triggers script defers before the DOM is ready.
+	//		If this is config value is set to true, then dojo.addOnLoad callbacks will not be
+	//		triggered until the page load event, which is after images and iframes load. If you
+	//		want to trigger the callbacks sooner, you can put a script block in the bottom of
+	//		your HTML that calls dojo._loadInit();. If you are using multiversion support, change
+	//		"dojo." to the appropriate scope name for dojo.
+	skipIeDomLoaded: false
+}
+=====*/
+});
+
diff --git a/js/dojo-1.7.2/dojo/_base/configFirefoxExtension.js b/js/dojo-1.7.2/dojo/_base/configFirefoxExtension.js
new file mode 100644
index 0000000..ce30c91
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/configFirefoxExtension.js
@@ -0,0 +1,334 @@
+// TODO: this file needs to be converted to the v1.7 loader
+
+// a host environment specifically built for Mozilla extensions, but derived
+// from the browser host environment
+if(typeof window != 'undefined'){
+	dojo.isBrowser = true;
+	dojo._name = "browser";
+
+
+	// FIXME: PORTME
+	//	http://developer.mozilla.org/en/mozIJSSubScriptLoader
+
+
+	// attempt to figure out the path to dojo if it isn't set in the config
+	(function(){
+		// this is a scope protection closure. We set browser versions and grab
+		// the URL we were loaded from here.
+
+		// FIXME: need to probably use a different reference to "document" to get the hosting XUL environment
+
+		dojo.baseUrl = dojo.config.baseUrl;
+
+		// fill in the rendering support information in dojo.render.*
+		var n = navigator;
+		var dua = n.userAgent;
+		var dav = n.appVersion;
+		var tv = parseFloat(dav);
+
+		dojo.isMozilla = dojo.isMoz = tv;
+		if(dojo.isMoz){
+			dojo.isFF = parseFloat(dua.split("Firefox/")[1]) || undefined;
+		}
+
+		// FIXME
+		dojo.isQuirks = document.compatMode == "BackCompat";
+
+		// FIXME
+		// TODO: is the HTML LANG attribute relevant?
+		dojo.locale = dojo.config.locale || n.language.toLowerCase();
+
+		dojo._xhrObj = function(){
+			return new XMLHttpRequest();
+		};
+
+		// monkey-patch _loadUri to handle file://, chrome://, and resource:// url's
+		var oldLoadUri = dojo._loadUri;
+		dojo._loadUri = function(uri, cb){
+			var handleLocal = ["file:", "chrome:", "resource:"].some(function(prefix){
+				return String(uri).indexOf(prefix) == 0;
+			});
+			if(handleLocal){
+				// see:
+				//		http://developer.mozilla.org/en/mozIJSSubScriptLoader
+				var l = Components.classes["@mozilla.org/moz/jssubscript-loader;1"]
+					.getService(Components.interfaces.mozIJSSubScriptLoader);
+				var value = l.loadSubScript(uri, dojo.global);
+				if(cb){ cb(value); }
+				return true;
+			}else{
+				// otherwise, call the pre-existing version
+				return oldLoadUri.apply(dojo, arguments);
+			}
+		};
+
+		// FIXME: PORTME
+		dojo._isDocumentOk = function(http){
+			var stat = http.status || 0;
+			return (stat >= 200 && stat < 300) || 	// Boolean
+				stat == 304 || 						// allow any 2XX response code
+				stat == 1223 || 						// get it out of the cache
+				(!stat && (location.protocol == "file:" || location.protocol == "chrome:") );
+		};
+
+		// FIXME: PORTME
+		// var owloc = window.location+"";
+		// var base = document.getElementsByTagName("base");
+		// var hasBase = (base && base.length > 0);
+		var hasBase = false;
+
+		dojo._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){
+			// summary: Read the contents of the specified uri and return those contents.
+			// uri:
+			//		A relative or absolute uri. If absolute, it still must be in
+			//		the same "domain" as we are.
+			// fail_ok:
+			//		Default false. If fail_ok and loading fails, return null
+			//		instead of throwing.
+			// returns: The response text. null is returned when there is a
+			//		failure and failure is okay (an exception otherwise)
+
+			// alert("_getText: " + uri);
+
+			// NOTE: must be declared before scope switches ie. this._xhrObj()
+			var http = dojo._xhrObj();
+
+			if(!hasBase && dojo._Url){
+				uri = (new dojo._Url(uri)).toString();
+			}
+			if(dojo.config.cacheBust){
+				//Make sure we have a string before string methods are used on uri
+				uri += "";
+				uri += (uri.indexOf("?") == -1 ? "?" : "&") + String(dojo.config.cacheBust).replace(/\W+/g, "");
+			}
+			var handleLocal = ["file:", "chrome:", "resource:"].some(function(prefix){
+				return String(uri).indexOf(prefix) == 0;
+			});
+			if(handleLocal){
+				// see:
+				//		http://forums.mozillazine.org/viewtopic.php?p=921150#921150
+				var ioService = Components.classes["@mozilla.org/network/io-service;1"]
+					.getService(Components.interfaces.nsIIOService);
+				var scriptableStream = Components
+					.classes["@mozilla.org/scriptableinputstream;1"]
+					.getService(Components.interfaces.nsIScriptableInputStream);
+
+				var channel = ioService.newChannel(uri, null, null);
+				var input = channel.open();
+				scriptableStream.init(input);
+				var str = scriptableStream.read(input.available());
+				scriptableStream.close();
+				input.close();
+				return str;
+			}else{
+				http.open('GET', uri, false);
+				try{
+					http.send(null);
+					// alert(http);
+					if(!dojo._isDocumentOk(http)){
+						var err = Error("Unable to load " + uri + " status:" + http.status);
+						err.status = http.status;
+						err.responseText = http.responseText;
+						throw err;
+					}
+				}catch(e){
+					if(fail_ok){
+						return null;
+					} // null
+					// rethrow the exception
+					throw e;
+				}
+				return http.responseText; // String
+			}
+		};
+
+		dojo._windowUnloaders = [];
+
+		// FIXME: PORTME
+		dojo.windowUnloaded = function(){
+			// summary:
+			//		signal fired by impending window destruction. You may use
+			//		dojo.addOnWIndowUnload() or dojo.connect() to this method to perform
+			//		page/application cleanup methods. See dojo.addOnWindowUnload for more info.
+			var mll = dojo._windowUnloaders;
+			while(mll.length){
+				(mll.pop())();
+			}
+		};
+
+		// FIXME: PORTME
+		dojo.addOnWindowUnload = function(/*Object?*/obj, /*String|Function?*/functionName){
+			// summary:
+			//		registers a function to be triggered when window.onunload fires.
+			//		Be careful trying to modify the DOM or access JavaScript properties
+			//		during this phase of page unloading: they may not always be available.
+			//		Consider dojo.addOnUnload() if you need to modify the DOM or do heavy
+			//		JavaScript work.
+			// example:
+			//	|	dojo.addOnWindowUnload(functionPointer)
+			//	|	dojo.addOnWindowUnload(object, "functionName")
+			//	|	dojo.addOnWindowUnload(object, function(){ /* ... */});
+
+			dojo._onto(dojo._windowUnloaders, obj, functionName);
+		};
+
+		// XUL specific APIs
+		var contexts = [];
+		var current = null;
+		dojo._defaultContext = [ window, document ];
+
+		dojo.pushContext = function(/*Object|String?*/g, /*MDocumentElement?*/d){
+			//	summary:
+			//		causes subsequent calls to Dojo methods to assume the
+			//		passed object and, optionally, document as the default
+			//		scopes to use. A 2-element array of the previous global and
+			//		document are returned.
+			//	description:
+			//		dojo.pushContext treats contexts as a stack. The
+			//		auto-detected contexts which are initially provided using
+			//		dojo.setContext() require authors to keep state in order to
+			//		"return" to a previous context, whereas the
+			//		dojo.pushContext and dojo.popContext methods provide a more
+			//		natural way to augment blocks of code to ensure that they
+			//		execute in a different window or frame without issue. If
+			//		called without any arguments, the default context (the
+			//		context when Dojo is first loaded) is instead pushed into
+			//		the stack. If only a single string is passed, a node in the
+			//		intitial context's document is looked up and its
+			//		contextWindow and contextDocument properties are used as
+			//		the context to push. This means that iframes can be given
+			//		an ID and code can be executed in the scope of the iframe's
+			//		document in subsequent calls easily.
+			//	g:
+			//		The global context. If a string, the id of the frame to
+			//		search for a context and document.
+			//	d:
+			//		The document element to execute subsequent code with.
+			var old = [dojo.global, dojo.doc];
+			contexts.push(old);
+			var n;
+			if(!g && !d){
+				n = dojo._defaultContext;
+			}else{
+				n = [ g, d ];
+				if(!d && dojo.isString(g)){
+					var t = document.getElementById(g);
+					if(t.contentDocument){
+						n = [t.contentWindow, t.contentDocument];
+					}
+				}
+			}
+			current = n;
+			dojo.setContext.apply(dojo, n);
+			return old; // Array
+		};
+
+		dojo.popContext = function(){
+			//	summary:
+			//		If the context stack contains elements, ensure that
+			//		subsequent code executes in the *previous* context to the
+			//		current context. The current context set ([global,
+			//		document]) is returned.
+			var oc = current;
+			if(!contexts.length){
+				return oc;
+			}
+			dojo.setContext.apply(dojo, contexts.pop());
+			return oc;
+		};
+
+		// FIXME:
+		//		don't really like the current arguments and order to
+		//		_inContext, so don't make it public until it's right!
+		dojo._inContext = function(g, d, f){
+			var a = dojo._toArray(arguments);
+			f = a.pop();
+			if(a.length == 1){
+				d = null;
+			}
+			dojo.pushContext(g, d);
+			var r = f();
+			dojo.popContext();
+			return r;
+		};
+
+	})();
+
+	dojo._initFired = false;
+	//	BEGIN DOMContentLoaded, from Dean Edwards (http://dean.edwards.name/weblog/2006/06/again/)
+	dojo._loadInit = function(e){
+		dojo._initFired = true;
+		// allow multiple calls, only first one will take effect
+		// A bug in khtml calls events callbacks for document for event which isnt supported
+		// for example a created contextmenu event calls DOMContentLoaded, workaround
+		var type = (e && e.type) ? e.type.toLowerCase() : "load";
+		if(arguments.callee.initialized || (type != "domcontentloaded" && type != "load")){ return; }
+		arguments.callee.initialized = true;
+		if(dojo._inFlightCount == 0){
+			dojo._modulesLoaded();
+		}
+	};
+
+	/*
+	(function(){
+		var _w = window;
+		var _handleNodeEvent = function(evtName, fp){
+			// summary:
+			//		non-destructively adds the specified function to the node's
+			//		evtName handler.
+			// evtName: should be in the form "onclick" for "onclick" handlers.
+			// Make sure you pass in the "on" part.
+			var oldHandler = _w[evtName] || function(){};
+			_w[evtName] = function(){
+				fp.apply(_w, arguments);
+				oldHandler.apply(_w, arguments);
+			};
+		};
+		// FIXME: PORT
+		// FIXME: dojo.unloaded requires dojo scope, so using anon function wrapper.
+		_handleNodeEvent("onbeforeunload", function() { dojo.unloaded(); });
+		_handleNodeEvent("onunload", function() { dojo.windowUnloaded(); });
+	})();
+	*/
+
+
+	//	FIXME: PORTME
+	// 		this event fires a lot, namely for all plugin XUL overlays and for
+	// 		all iframes (in addition to window navigations). We only want
+	// 		Dojo's to fire once..but we might care if pages navigate. We'll
+	// 		probably need an extension-specific API
+	if(!dojo.config.afterOnLoad){
+		window.addEventListener("DOMContentLoaded", function(e){
+			dojo._loadInit(e);
+			// console.log("DOM content loaded", e);
+		}, false);
+	}
+
+} //if (typeof window != 'undefined')
+
+//Register any module paths set up in djConfig. Need to do this
+//in the hostenvs since hostenv_browser can read djConfig from a
+//script tag's attribute.
+(function(){
+	var mp = dojo.config["modulePaths"];
+	if(mp){
+		for(var param in mp){
+			dojo.registerModulePath(param, mp[param]);
+		}
+	}
+})();
+
+//Load debug code if necessary.
+if(dojo.config.isDebug){
+	// logging stub for extension logging
+	console.log = function(m){
+		var s = Components.classes["@mozilla.org/consoleservice;1"].getService(
+			Components.interfaces.nsIConsoleService
+			);
+		s.logStringMessage(m);
+	};
+	console.debug = function(){
+		console.log(dojo._toArray(arguments).join(" "));
+	};
+	// FIXME: what about the rest of the console.* methods? And is there any way to reach into firebug and log into it directly?
+}
diff --git a/js/dojo-1.7.2/dojo/_base/configNode.js b/js/dojo-1.7.2/dojo/_base/configNode.js
new file mode 100644
index 0000000..7cd6f14
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/configNode.js
@@ -0,0 +1,87 @@
+exports.config = function(config){
+	//	summary:
+	//		This module provides bootstrap configuration for running dojo in node.js
+
+	// any command line arguments with the load flag are pushed into deps
+	for(var deps = [], args = [], i = 0; i < process.argv.length; i++){
+		var arg = (process.argv[i] + "").split("=");
+		if(arg[0] == "load"){
+			deps.push(arg[1]);
+		}else{
+			args.push(arg);
+		}
+	}
+
+	var fs = require("fs");
+
+	// make sure global require exists
+	//if (typeof global.require=="undefined") {
+	//	global.require= {};
+	//}
+
+	// reset the has cache with node-appropriate values;
+	var hasCache = {
+		"host-node":1,
+		"host-browser":0,
+		"dom":0,
+		"dojo-has-api":1,
+		"dojo-xhr-factory":0,
+		"dojo-inject-api":1,
+		"dojo-timeout-api":0,
+		"dojo-trace-api":1,
+		"dojo-dom-ready-api":0,
+		"dojo-publish-privates":1,
+		"dojo-sniff":0,
+		"dojo-loader":1,
+		"dojo-test-xd":0,
+		"dojo-test-sniff":0
+	};
+	for(var p in hasCache){
+		config.hasCache[p] = hasCache[p];
+	}
+
+	var vm = require('vm');
+
+
+	// reset some configuration switches with node-appropriate values
+	var nodeConfig = {
+		baseUrl: __dirname.match(/(.+)[\/\\]_base$/)[1],
+		commandLineArgs:args,
+		deps:deps,
+		timeout:0,
+
+		// TODO: really get the locale
+		locale:"en-us",
+
+		loaderPatch: {
+			log:function(item){
+				// define debug for console messages during dev instead of console.log
+				// (node's heavy async makes console.log confusing sometimes)
+				var util = require("util");
+				util.debug(util.inspect(item));
+			},
+
+			eval: function(__text, __urlHint){
+				return vm.runInThisContext(__text, __urlHint);
+			},
+
+			injectUrl: function(url, callback){
+				try{
+					vm.runInThisContext(fs.readFileSync(url, "utf8"), url);
+					callback();
+				}catch(e){
+					this.log("failed to load resource (" + url + ")");
+					this.log(e);
+				}
+			},
+
+			getText: function(url, sync, onLoad){
+				// TODO: implement async and http/https handling
+				onLoad(fs.readFileSync(url, "utf8"));
+			}
+		}
+	};
+	for(p in nodeConfig){
+		config[p] = nodeConfig[p];
+	}
+};
diff --git a/js/dojo-1.7.2/dojo/_base/configRhino.js b/js/dojo-1.7.2/dojo/_base/configRhino.js
new file mode 100644
index 0000000..ec64759
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/configRhino.js
@@ -0,0 +1,121 @@
+function rhinoDojoConfig(config, baseUrl, rhinoArgs){
+	//	summary:
+	//		This module provides bootstrap configuration for running dojo in rhino.
+
+	// TODO: v1.6 tries to set dojo.doc and dojo.body in rhino; why?
+
+	// get a minimal console up
+	var log = function(hint, args){
+		print((hint ? hint + ":" : "") + args[0]);
+		for(var i = 1; i < args.length; i++){
+			print(", " + args[i]);
+		}
+	};
+	// intentionally define console in the global namespace
+	console= {
+		log: function(){ log(0, arguments); },
+		error: function(){ log("ERROR", arguments); },
+		warn: function(){ log("WARN", arguments); }
+	};
+
+	// any command line arguments with the load flag are pushed into deps
+	for(var deps = [], i = 0; i < rhinoArgs.length; i++){
+		var arg = (rhinoArgs[i] + "").split("=");
+		if(arg[0] == "load"){
+			deps.push(arg[1]);
+		}
+	}
+
+	// provides timed callbacks using Java threads
+	if(typeof setTimeout == "undefined" || typeof clearTimeout == "undefined"){
+		var timeouts = [];
+		clearTimeout = function(idx){
+			if(!timeouts[idx]){ return; }
+			timeouts[idx].stop();
+		};
+
+		setTimeout = function(func, delay){
+			var def = {
+				sleepTime:delay,
+				hasSlept:false,
+
+				run:function(){
+					if(!this.hasSlept){
+						this.hasSlept = true;
+						java.lang.Thread.currentThread().sleep(this.sleepTime);
+					}
+					try{
+						func();
+					}catch(e){
+						console.debug("Error running setTimeout thread:" + e);
+					}
+				}
+			};
+
+			var runnable = new java.lang.Runnable(def);
+			var thread = new java.lang.Thread(runnable);
+			thread.start();
+			return timeouts.push(thread) - 1;
+		};
+	}
+
+	var isLocal = function(url){
+		return (new java.io.File(url)).exists();
+	};
+
+	// reset the has cache with node-appropriate values;
+	var hasCache = {
+		"host-rhino":1,
+		"host-browser":0,
+		"dom":0,
+		"dojo-has-api":1,
+		"dojo-xhr-factory":0,
+		"dojo-inject-api":1,
+		"dojo-timeout-api":0,
+		"dojo-trace-api":1,
+		"dojo-loader-catches":1,
+		"dojo-dom-ready-api":0,
+		"dojo-publish-privates":1,
+		"dojo-sniff":0,
+		"dojo-loader":1,
+		"dojo-test-xd":0,
+		"dojo-test-sniff":0
+	};
+	for(var p in hasCache){
+		config.hasCache[p] = hasCache[p];
+	}
+
+	// reset some configuration switches with rhino-appropriate values
+	var rhinoConfig = {
+		baseUrl:baseUrl,
+		commandLineArgs:rhinoArgs,
+		deps:deps,
+		timeout:0,
+		locale:String(java.util.Locale.getDefault().toString().replace('_', '-').toLowerCase()),
+
+		loaderPatch:{
+			injectUrl: function(url, callback){
+				try{
+					if(isLocal(url)){
+						load(url);
+					}else{
+						require.eval(readUrl(url, "UTF-8"));
+					}
+					callback();
+				}catch(e){
+					console.log("failed to load resource (" + url + ")");
+					console.log(e);
+				}
+			},
+
+			getText: function(url, sync, onLoad){
+				// TODO: test https://bugzilla.mozilla.org/show_bug.cgi?id=471005; see v1.6 hostenv_rhino
+				// note: async mode not supported in rhino
+				onLoad(isLocal(url) ? readFile(url, "UTF-8") : readUrl(url, "UTF-8"));
+			}
+		}
+	};
+	for(p in rhinoConfig){
+		config[p] = rhinoConfig[p];
+	}
+}
diff --git a/js/dojo-1.7.2/dojo/_base/configSpidermonkey.js b/js/dojo-1.7.2/dojo/_base/configSpidermonkey.js
new file mode 100644
index 0000000..0da0d71
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/configSpidermonkey.js
@@ -0,0 +1,84 @@
+// TODO: this file needs to be converted to the v1.7 loader
+
+
+/*
+ * SpiderMonkey host environment
+ */
+
+if(dojo.config["baseUrl"]){
+	dojo.baseUrl = dojo.config["baseUrl"];
+}else{
+	dojo.baseUrl = "./";
+}
+
+dojo._name = 'spidermonkey';
+
+/*=====
+dojo.isSpidermonkey = {
+	// summary: Detect spidermonkey
+};
+=====*/
+
+dojo.isSpidermonkey = true;
+dojo.exit = function(exitcode){
+	quit(exitcode);
+};
+
+if(typeof print == "function"){
+	console.debug = print;
+}
+
+if(typeof line2pc == 'undefined'){
+	throw new Error("attempt to use SpiderMonkey host environment when no 'line2pc' global");
+}
+
+dojo._spidermonkeyCurrentFile = function(depth){
+	//
+	//	This is a hack that determines the current script file by parsing a
+	//	generated stack trace (relying on the non-standard "stack" member variable
+	//	of the SpiderMonkey Error object).
+	//
+	//	If param depth is passed in, it'll return the script file which is that far down
+	//	the stack, but that does require that you know how deep your stack is when you are
+	//	calling.
+	//
+	var s = '';
+	try{
+		throw Error("whatever");
+	}catch(e){
+		s = e.stack;
+	}
+	// lines are like: bu_getCurrentScriptURI_spidermonkey("ScriptLoader.js")@burst/Runtime.js:101
+	var matches = s.match(/[^@]*\.js/gi);
+	if(!matches){
+		throw Error("could not parse stack string: '" + s + "'");
+	}
+	var fname = (typeof depth != 'undefined' && depth) ? matches[depth + 1] : matches[matches.length - 1];
+	if(!fname){
+		throw Error("could not find file name in stack string '" + s + "'");
+	}
+	//print("SpiderMonkeyRuntime got fname '" + fname + "' from stack string '" + s + "'");
+	return fname;
+};
+
+// print(dojo._spidermonkeyCurrentFile(0));
+
+dojo._loadUri = function(uri){
+	// spidermonkey load() evaluates the contents into the global scope (which
+	// is what we want).
+	// TODO: sigh, load() does not return a useful value.
+	// Perhaps it is returning the value of the last thing evaluated?
+	// var ok =
+	load(uri);
+	// console.log("spidermonkey load(", uri, ") returned ", ok);
+	return 1;
+};
+
+//Register any module paths set up in djConfig. Need to do this
+//in the hostenvs since hostenv_browser can read djConfig from a
+//script tag's attribute.
+if(dojo.config["modulePaths"]){
+	for(var param in dojo.config["modulePaths"]){
+		dojo.registerModulePath(param, dojo.config["modulePaths"][param]);
+	}
+}
diff --git a/js/dojo-1.7.2/dojo/_base/connect.js b/js/dojo-1.7.2/dojo/_base/connect.js
new file mode 100644
index 0000000..2d9514d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/connect.js
@@ -0,0 +1,401 @@
+//>>built
+define("dojo/_base/connect", ["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(kernel, on, hub, aspect, eventModule, mouse, has, lang){
+//  module:
+//    dojo/_base/connect
+//  summary:
+//    This module defines the dojo.connect API.
+//		This modules also provides keyboard event handling helpers.
+//		This module exports an extension event for emulating Firefox's keypress handling.
+//		However, this extension event exists primarily for backwards compatibility and
+//		is not recommended. WebKit and IE uses an alternate keypress handling (only
+//		firing for printable characters, to distinguish from keydown events), and most
+//		consider the WebKit/IE behavior more desirable.
+has.add("events-keypress-typed", function(){ // keypresses should only occur a printable character is hit
+	var testKeyEvent = {charCode: 0};
+	try{
+		testKeyEvent = document.createEvent("KeyboardEvent");
+		(testKeyEvent.initKeyboardEvent || testKeyEvent.initKeyEvent).call(testKeyEvent, "keypress", true, true, null, false, false, false, false, 9, 3);
+	}catch(e){}
+	return testKeyEvent.charCode == 0 && !has("opera");
+});
+
+function connect_(obj, event, context, method, dontFix){
+	method = lang.hitch(context, method);
+	if(!obj || !(obj.addEventListener || obj.attachEvent)){
+		// it is a not a DOM node and we are using the dojo.connect style of treating a
+		// method like an event, must go right to aspect
+		return aspect.after(obj || kernel.global, event, method, true);
+	}
+	if(typeof event == "string" && event.substring(0, 2) == "on"){
+		event = event.substring(2);
+	}
+	if(!obj){
+		obj = kernel.global;
+	}
+	if(!dontFix){
+		switch(event){
+			// dojo.connect has special handling for these event types
+			case "keypress":
+				event = keypress;
+				break;
+			case "mouseenter":
+				event = mouse.enter;
+				break;
+			case "mouseleave":
+				event = mouse.leave;
+				break;
+		}
+	}
+	return on(obj, event, method, dontFix);
+}
+
+var _punctMap = {
+	106:42,
+	111:47,
+	186:59,
+	187:43,
+	188:44,
+	189:45,
+	190:46,
+	191:47,
+	192:96,
+	219:91,
+	220:92,
+	221:93,
+	222:39,
+	229:113
+};
+var evtCopyKey = has("mac") ? "metaKey" : "ctrlKey";
+
+
+var _synthesizeEvent = function(evt, props){
+	var faux = lang.mixin({}, evt, props);
+	setKeyChar(faux);
+	// FIXME: would prefer to use lang.hitch: lang.hitch(evt, evt.preventDefault);
+	// but it throws an error when preventDefault is invoked on Safari
+	// does Event.preventDefault not support "apply" on Safari?
+	faux.preventDefault = function(){ evt.preventDefault(); };
+	faux.stopPropagation = function(){ evt.stopPropagation(); };
+	return faux;
+};
+function setKeyChar(evt){
+	evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
+	evt.charOrCode = evt.keyChar || evt.keyCode;
+}
+var keypress;
+if(has("events-keypress-typed")){
+	// this emulates Firefox's keypress behavior where every keydown can correspond to a keypress
+	var _trySetKeyCode = function(e, code){
+		try{
+			// squelch errors when keyCode is read-only
+			// (e.g. if keyCode is ctrl or shift)
+			return (e.keyCode = code);
+		}catch(e){
+			return 0;
+		}
+	};
+	keypress = function(object, listener){
+		var keydownSignal = on(object, "keydown", function(evt){
+			// munge key/charCode
+			var k=evt.keyCode;
+			// These are Windows Virtual Key Codes
+			// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
+			var unprintable = (k!=13 || (has("ie") >= 9 && !has("quirks"))) && k!=32 && (k!=27||!has("ie")) && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229;
+			// synthesize keypress for most unprintables and CTRL-keys
+			if(unprintable||evt.ctrlKey){
+				var c = unprintable ? 0 : k;
+				if(evt.ctrlKey){
+					if(k==3 || k==13){
+						return listener.call(evt.currentTarget, evt); // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
+					}else if(c>95 && c<106){
+						c -= 48; // map CTRL-[numpad 0-9] to ASCII
+					}else if((!evt.shiftKey)&&(c>=65&&c<=90)){
+						c += 32; // map CTRL-[A-Z] to lowercase
+					}else{
+						c = _punctMap[c] || c; // map other problematic CTRL combinations to ASCII
+					}
+				}
+				// simulate a keypress event
+				var faux = _synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
+				listener.call(evt.currentTarget, faux);
+				if(has("ie")){
+					_trySetKeyCode(evt, faux.keyCode);
+				}
+			}
+		});
+		var keypressSignal = on(object, "keypress", function(evt){
+			var c = evt.charCode;
+			c = c>=32 ? c : 0;
+			evt = _synthesizeEvent(evt, {charCode: c, faux: true});
+			return listener.call(this, evt);
+		});
+		return {
+			remove: function(){
+				keydownSignal.remove();
+				keypressSignal.remove();
+			}
+		};
+	};
+}else{
+	if(has("opera")){
+		keypress = function(object, listener){
+			return on(object, "keypress", function(evt){
+				var c = evt.which;
+				if(c==3){
+					c=99; // Mozilla maps CTRL-BREAK to CTRL-c
+				}
+				// can't trap some keys at all, like INSERT and DELETE
+				// there is no differentiating info between DELETE and ".", or INSERT and "-"
+				c = c<32 && !evt.shiftKey ? 0 : c;
+				if(evt.ctrlKey && !evt.shiftKey && c>=65 && c<=90){
+					// lowercase CTRL-[A-Z] keys
+					c += 32;
+				}
+				return listener.call(this, _synthesizeEvent(evt, { charCode: c }));
+			});
+		};
+	}else{
+		keypress = function(object, listener){
+			return on(object, "keypress", function(evt){
+				setKeyChar(evt);
+				return listener.call(this, evt);
+			});
+		};
+	}
+}
+
+var connect = {
+	_keypress:keypress,
+
+	connect:function(obj, event, context, method, dontFix){
+		// normalize arguments
+		var a=arguments, args=[], i=0;
+		// if a[0] is a String, obj was omitted
+		args.push(typeof a[0] == "string" ? null : a[i++], a[i++]);
+		// if the arg-after-next is a String or Function, context was NOT omitted
+		var a1 = a[i+1];
+		args.push(typeof a1 == "string" || typeof a1 == "function" ? a[i++] : null, a[i++]);
+		// absorb any additional arguments
+		for(var l=a.length; i<l; i++){	args.push(a[i]); }
+		return connect_.apply(this, args);
+	},
+
+	disconnect:function(handle){
+		if(handle){
+			handle.remove();
+		}
+	},
+
+	subscribe:function(topic, context, method){
+		return hub.subscribe(topic, lang.hitch(context, method));
+	},
+
+	publish:function(topic, args){
+		return hub.publish.apply(hub, [topic].concat(args));
+	},
+
+	connectPublisher:function(topic, obj, event){
+		var pf = function(){ connect.publish(topic, arguments); };
+		return event ? connect.connect(obj, event, pf) : connect.connect(obj, pf); //Handle
+	},
+
+	isCopyKey: function(e){
+		return e[evtCopyKey];	// Boolean
+	}
+};
+connect.unsubscribe = connect.disconnect;
+
+1 && lang.mixin(kernel, connect);
+return connect;
+
+/*=====
+dojo.connect = function(obj, event, context, method, dontFix){
+	// summary:
+	//		`dojo.connect` is the core event handling and delegation method in
+	//		Dojo. It allows one function to "listen in" on the execution of
+	//		any other, triggering the second whenever the first is called. Many
+	//		listeners may be attached to a function, and source functions may
+	//		be either regular function calls or DOM events.
+	//
+	// description:
+	//		Connects listeners to actions, so that after event fires, a
+	//		listener is called with the same arguments passed to the original
+	//		function.
+	//
+	//		Since `dojo.connect` allows the source of events to be either a
+	//		"regular" JavaScript function or a DOM event, it provides a uniform
+	//		interface for listening to all the types of events that an
+	//		application is likely to deal with though a single, unified
+	//		interface. DOM programmers may want to think of it as
+	//		"addEventListener for everything and anything".
+	//
+	//		When setting up a connection, the `event` parameter must be a
+	//		string that is the name of the method/event to be listened for. If
+	//		`obj` is null, `kernel.global` is assumed, meaning that connections
+	//		to global methods are supported but also that you may inadvertently
+	//		connect to a global by passing an incorrect object name or invalid
+	//		reference.
+	//
+	//		`dojo.connect` generally is forgiving. If you pass the name of a
+	//		function or method that does not yet exist on `obj`, connect will
+	//		not fail, but will instead set up a stub method. Similarly, null
+	//		arguments may simply be omitted such that fewer than 4 arguments
+	//		may be required to set up a connection See the examples for details.
+	//
+	//		The return value is a handle that is needed to
+	//		remove this connection with `dojo.disconnect`.
+	//
+	// obj: Object|null:
+	//		The source object for the event function.
+	//		Defaults to `kernel.global` if null.
+	//		If obj is a DOM node, the connection is delegated
+	//		to the DOM event manager (unless dontFix is true).
+	//
+	// event: String:
+	//		String name of the event function in obj.
+	//		I.e. identifies a property `obj[event]`.
+	//
+	// context: Object|null
+	//		The object that method will receive as "this".
+	//
+	//		If context is null and method is a function, then method
+	//		inherits the context of event.
+	//
+	//		If method is a string then context must be the source
+	//		object object for method (context[method]). If context is null,
+	//		kernel.global is used.
+	//
+	// method: String|Function:
+	//		A function reference, or name of a function in context.
+	//		The function identified by method fires after event does.
+	//		method receives the same arguments as the event.
+	//		See context argument comments for information on method's scope.
+	//
+	// dontFix: Boolean?
+	//		If obj is a DOM node, set dontFix to true to prevent delegation
+	//		of this connection to the DOM event manager.
+	//
+	// example:
+	//		When obj.onchange(), do ui.update():
+	//	|	dojo.connect(obj, "onchange", ui, "update");
+	//	|	dojo.connect(obj, "onchange", ui, ui.update); // same
+	//
+	// example:
+	//		Using return value for disconnect:
+	//	|	var link = dojo.connect(obj, "onchange", ui, "update");
+	//	|	...
+	//	|	dojo.disconnect(link);
+	//
+	// example:
+	//		When onglobalevent executes, watcher.handler is invoked:
+	//	|	dojo.connect(null, "onglobalevent", watcher, "handler");
+	//
+	// example:
+	//		When ob.onCustomEvent executes, customEventHandler is invoked:
+	//	|	dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
+	//	|	dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
+	//
+	// example:
+	//		When ob.onCustomEvent executes, customEventHandler is invoked
+	//		with the same scope (this):
+	//	|	dojo.connect(ob, "onCustomEvent", null, customEventHandler);
+	//	|	dojo.connect(ob, "onCustomEvent", customEventHandler); // same
+	//
+	// example:
+	//		When globalEvent executes, globalHandler is invoked
+	//		with the same scope (this):
+	//	|	dojo.connect(null, "globalEvent", null, globalHandler);
+	//	|	dojo.connect("globalEvent", globalHandler); // same
+}
+=====*/
+
+/*=====
+dojo.disconnect = function(handle){
+	// summary:
+	//		Remove a link created by dojo.connect.
+	// description:
+	//		Removes the connection between event and the method referenced by handle.
+	// handle: Handle:
+	//		the return value of the dojo.connect call that created the connection.
+}
+=====*/
+
+/*=====
+dojo.subscribe = function(topic, context, method){
+	//	summary:
+	//		Attach a listener to a named topic. The listener function is invoked whenever the
+	//		named topic is published (see: dojo.publish).
+	//		Returns a handle which is needed to unsubscribe this listener.
+	//	topic: String:
+	//		The topic to which to subscribe.
+	//	context: Object|null:
+	//		Scope in which method will be invoked, or null for default scope.
+	//	method: String|Function:
+	//		The name of a function in context, or a function reference. This is the function that
+	//		is invoked when topic is published.
+	//	example:
+	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); });
+	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
+}
+=====*/
+
+/*=====
+dojo.unsubscribe = function(handle){
+	//	summary:
+	//		Remove a topic listener.
+	//	handle: Handle
+	//		The handle returned from a call to subscribe.
+	//	example:
+	//	|	var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+	//	|	...
+	//	|	dojo.unsubscribe(alerter);
+}
+=====*/
+
+/*=====
+dojo.publish = function(topic, args){
+	//	summary:
+	//		Invoke all listener method subscribed to topic.
+	//	topic: String:
+	//		The name of the topic to publish.
+	//	args: Array?
+	//		An array of arguments. The arguments will be applied
+	//		to each topic subscriber (as first class parameters, via apply).
+	//	example:
+	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
+}
+=====*/
+
+/*=====
+dojo.connectPublisher = function(topic, obj, event){
+	//	summary:
+	//		Ensure that every time obj.event() is called, a message is published
+	//		on the topic. Returns a handle which can be passed to
+	//		dojo.disconnect() to disable subsequent automatic publication on
+	//		the topic.
+	//	topic: String:
+	//		The name of the topic to publish.
+	//	obj: Object|null:
+	//		The source object for the event function. Defaults to kernel.global
+	//		if null.
+	//	event: String:
+	//		The name of the event function in obj.
+	//		I.e. identifies a property obj[event].
+	//	example:
+	//	|	dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
+}
+=====*/
+
+/*=====
+dojo.isCopyKey = function(e){
+	// summary:
+	//		Checks an event for the copy key (meta on Mac, and ctrl anywhere else)
+	// e: Event
+	//		Event object to examine
+}
+=====*/
+
+});
+
+
diff --git a/js/dojo-1.7.2/dojo/_base/declare.js b/js/dojo-1.7.2/dojo/_base/declare.js
new file mode 100644
index 0000000..65b37a2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/declare.js
@@ -0,0 +1,1051 @@
+//>>built
+define("dojo/_base/declare", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
+	// module:
+	//		dojo/_base/declare
+	// summary:
+	//		This module defines dojo.declare.
+
+	var mix = lang.mixin, op = Object.prototype, opts = op.toString,
+		xtor = new Function, counter = 0, cname = "constructor";
+
+	function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); }
+
+	// C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/)
+	function c3mro(bases, className){
+		var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1,
+			l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs;
+
+		// build a list of bases naming them if needed
+		for(; i < l; ++i){
+			base = bases[i];
+			if(!base){
+				err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className);
+			}else if(opts.call(base) != "[object Function]"){
+				err("mixin #" + i + " is not a callable constructor.", className);
+			}
+			lin = base._meta ? base._meta.bases : [base];
+			top = 0;
+			// add bases to the name map
+			for(j = lin.length - 1; j >= 0; --j){
+				proto = lin[j].prototype;
+				if(!proto.hasOwnProperty("declaredClass")){
+					proto.declaredClass = "uniqName_" + (counter++);
+				}
+				name = proto.declaredClass;
+				if(!nameMap.hasOwnProperty(name)){
+					nameMap[name] = {count: 0, refs: [], cls: lin[j]};
+					++clsCount;
+				}
+				rec = nameMap[name];
+				if(top && top !== rec){
+					rec.refs.push(top);
+					++top.count;
+				}
+				top = rec;
+			}
+			++top.count;
+			roots[0].refs.push(top);
+		}
+
+		// remove classes without external references recursively
+		while(roots.length){
+			top = roots.pop();
+			result.push(top.cls);
+			--clsCount;
+			// optimization: follow a single-linked chain
+			while(refs = top.refs, refs.length == 1){
+				top = refs[0];
+				if(!top || --top.count){
+					// branch or end of chain => do not end to roots
+					top = 0;
+					break;
+				}
+				result.push(top.cls);
+				--clsCount;
+			}
+			if(top){
+				// branch
+				for(i = 0, l = refs.length; i < l; ++i){
+					top = refs[i];
+					if(!--top.count){
+						roots.push(top);
+					}
+				}
+			}
+		}
+		if(clsCount){
+			err("can't build consistent linearization", className);
+		}
+
+		// calculate the superclass offset
+		base = bases[0];
+		result[0] = base ?
+			base._meta && base === result[result.length - base._meta.bases.length] ?
+				base._meta.bases.length : 1 : 0;
+
+		return result;
+	}
+
+	function inherited(args, a, f){
+		var name, chains, bases, caller, meta, base, proto, opf, pos,
+			cache = this._inherited = this._inherited || {};
+
+		// crack arguments
+		if(typeof args == "string"){
+			name = args;
+			args = a;
+			a = f;
+		}
+		f = 0;
+
+		caller = args.callee;
+		name = name || caller.nom;
+		if(!name){
+			err("can't deduce a name to call inherited()", this.declaredClass);
+		}
+
+		meta = this.constructor._meta;
+		bases = meta.bases;
+
+		pos = cache.p;
+		if(name != cname){
+			// method
+			if(cache.c !== caller){
+				// cache bust
+				pos = 0;
+				base = bases[0];
+				meta = base._meta;
+				if(meta.hidden[name] !== caller){
+					// error detection
+					chains = meta.chains;
+					if(chains && typeof chains[name] == "string"){
+						err("calling chained method with inherited: " + name, this.declaredClass);
+					}
+					// find caller
+					do{
+						meta = base._meta;
+						proto = base.prototype;
+						if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){
+							break;
+						}
+					}while(base = bases[++pos]); // intentional assignment
+					pos = base ? pos : -1;
+				}
+			}
+			// find next
+			base = bases[++pos];
+			if(base){
+				proto = base.prototype;
+				if(base._meta && proto.hasOwnProperty(name)){
+					f = proto[name];
+				}else{
+					opf = op[name];
+					do{
+						proto = base.prototype;
+						f = proto[name];
+						if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){
+							break;
+						}
+					}while(base = bases[++pos]); // intentional assignment
+				}
+			}
+			f = base && f || op[name];
+		}else{
+			// constructor
+			if(cache.c !== caller){
+				// cache bust
+				pos = 0;
+				meta = bases[0]._meta;
+				if(meta && meta.ctor !== caller){
+					// error detection
+					chains = meta.chains;
+					if(!chains || chains.constructor !== "manual"){
+						err("calling chained constructor with inherited", this.declaredClass);
+					}
+					// find caller
+					while(base = bases[++pos]){ // intentional assignment
+						meta = base._meta;
+						if(meta && meta.ctor === caller){
+							break;
+						}
+					}
+					pos = base ? pos : -1;
+				}
+			}
+			// find next
+			while(base = bases[++pos]){	// intentional assignment
+				meta = base._meta;
+				f = meta ? meta.ctor : base;
+				if(f){
+					break;
+				}
+			}
+			f = base && f;
+		}
+
+		// cache the found super method
+		cache.c = f;
+		cache.p = pos;
+
+		// now we have the result
+		if(f){
+			return a === true ? f : f.apply(this, a || args);
+		}
+		// intentionally no return if a super method was not found
+	}
+
+	function getInherited(name, args){
+		if(typeof name == "string"){
+			return this.__inherited(name, args, true);
+		}
+		return this.__inherited(name, true);
+	}
+
+	function inherited__debug(args, a1, a2){
+		var f = this.getInherited(args, a1);
+		if(f){ return f.apply(this, a2 || a1 || args); }
+		// intentionally no return if a super method was not found
+	}
+
+	var inheritedImpl = dojo.config.isDebug ? inherited__debug : inherited;
+
+	// emulation of "instanceof"
+	function isInstanceOf(cls){
+		var bases = this.constructor._meta.bases;
+		for(var i = 0, l = bases.length; i < l; ++i){
+			if(bases[i] === cls){
+				return true;
+			}
+		}
+		return this instanceof cls;
+	}
+
+	function mixOwn(target, source){
+		// add props adding metadata for incoming functions skipping a constructor
+		for(var name in source){
+			if(name != cname && source.hasOwnProperty(name)){
+				target[name] = source[name];
+			}
+		}
+		if(has("bug-for-in-skips-shadowed")){
+			for(var extraNames= lang._extraNames, i= extraNames.length; i;){
+				name = extraNames[--i];
+				if(name != cname && source.hasOwnProperty(name)){
+					  target[name] = source[name];
+				}
+			}
+		}
+	}
+
+	// implementation of safe mixin function
+	function safeMixin(target, source){
+		var name, t;
+		// add props adding metadata for incoming functions skipping a constructor
+		for(name in source){
+			t = source[name];
+			if((t !== op[name] || !(name in op)) && name != cname){
+				if(opts.call(t) == "[object Function]"){
+					// non-trivial function method => attach its name
+					t.nom = name;
+				}
+				target[name] = t;
+			}
+		}
+		if(has("bug-for-in-skips-shadowed")){
+			for(var extraNames= lang._extraNames, i= extraNames.length; i;){
+				name = extraNames[--i];
+				t = source[name];
+				if((t !== op[name] || !(name in op)) && name != cname){
+					if(opts.call(t) == "[object Function]"){
+						// non-trivial function method => attach its name
+						  t.nom = name;
+					}
+					target[name] = t;
+				}
+			}
+		}
+		return target;
+	}
+
+	function extend(source){
+		declare.safeMixin(this.prototype, source);
+		return this;
+	}
+
+	// chained constructor compatible with the legacy dojo.declare()
+	function chainedConstructor(bases, ctorSpecial){
+		return function(){
+			var a = arguments, args = a, a0 = a[0], f, i, m,
+				l = bases.length, preArgs;
+
+			if(!(this instanceof a.callee)){
+				// not called via new, so force it
+				return applyNew(a);
+			}
+
+			//this._inherited = {};
+			// perform the shaman's rituals of the original dojo.declare()
+			// 1) call two types of the preamble
+			if(ctorSpecial && (a0 && a0.preamble || this.preamble)){
+				// full blown ritual
+				preArgs = new Array(bases.length);
+				// prepare parameters
+				preArgs[0] = a;
+				for(i = 0;;){
+					// process the preamble of the 1st argument
+					a0 = a[0];
+					if(a0){
+						f = a0.preamble;
+						if(f){
+							a = f.apply(this, a) || a;
+						}
+					}
+					// process the preamble of this class
+					f = bases[i].prototype;
+					f = f.hasOwnProperty("preamble") && f.preamble;
+					if(f){
+						a = f.apply(this, a) || a;
+					}
+					// one peculiarity of the preamble:
+					// it is called if it is not needed,
+					// e.g., there is no constructor to call
+					// let's watch for the last constructor
+					// (see ticket #9795)
+					if(++i == l){
+						break;
+					}
+					preArgs[i] = a;
+				}
+			}
+			// 2) call all non-trivial constructors using prepared arguments
+			for(i = l - 1; i >= 0; --i){
+				f = bases[i];
+				m = f._meta;
+				f = m ? m.ctor : f;
+				if(f){
+					f.apply(this, preArgs ? preArgs[i] : a);
+				}
+			}
+			// 3) continue the original ritual: call the postscript
+			f = this.postscript;
+			if(f){
+				f.apply(this, args);
+			}
+		};
+	}
+
+
+	// chained constructor compatible with the legacy dojo.declare()
+	function singleConstructor(ctor, ctorSpecial){
+		return function(){
+			var a = arguments, t = a, a0 = a[0], f;
+
+			if(!(this instanceof a.callee)){
+				// not called via new, so force it
+				return applyNew(a);
+			}
+
+			//this._inherited = {};
+			// perform the shaman's rituals of the original dojo.declare()
+			// 1) call two types of the preamble
+			if(ctorSpecial){
+				// full blown ritual
+				if(a0){
+					// process the preamble of the 1st argument
+					f = a0.preamble;
+					if(f){
+						t = f.apply(this, t) || t;
+					}
+				}
+				f = this.preamble;
+				if(f){
+					// process the preamble of this class
+					f.apply(this, t);
+					// one peculiarity of the preamble:
+					// it is called even if it is not needed,
+					// e.g., there is no constructor to call
+					// let's watch for the last constructor
+					// (see ticket #9795)
+				}
+			}
+			// 2) call a constructor
+			if(ctor){
+				ctor.apply(this, a);
+			}
+			// 3) continue the original ritual: call the postscript
+			f = this.postscript;
+			if(f){
+				f.apply(this, a);
+			}
+		};
+	}
+
+	// plain vanilla constructor (can use inherited() to call its base constructor)
+	function simpleConstructor(bases){
+		return function(){
+			var a = arguments, i = 0, f, m;
+
+			if(!(this instanceof a.callee)){
+				// not called via new, so force it
+				return applyNew(a);
+			}
+
+			//this._inherited = {};
+			// perform the shaman's rituals of the original dojo.declare()
+			// 1) do not call the preamble
+			// 2) call the top constructor (it can use this.inherited())
+			for(; f = bases[i]; ++i){ // intentional assignment
+				m = f._meta;
+				f = m ? m.ctor : f;
+				if(f){
+					f.apply(this, a);
+					break;
+				}
+			}
+			// 3) call the postscript
+			f = this.postscript;
+			if(f){
+				f.apply(this, a);
+			}
+		};
+	}
+
+	function chain(name, bases, reversed){
+		return function(){
+			var b, m, f, i = 0, step = 1;
+			if(reversed){
+				i = bases.length - 1;
+				step = -1;
+			}
+			for(; b = bases[i]; i += step){ // intentional assignment
+				m = b._meta;
+				f = (m ? m.hidden : b.prototype)[name];
+				if(f){
+					f.apply(this, arguments);
+				}
+			}
+		};
+	}
+
+	// forceNew(ctor)
+	// return a new object that inherits from ctor.prototype but
+	// without actually running ctor on the object.
+	function forceNew(ctor){
+		// create object with correct prototype using a do-nothing
+		// constructor
+		xtor.prototype = ctor.prototype;
+		var t = new xtor;
+		xtor.prototype = null;	// clean up
+		return t;
+	}
+
+	// applyNew(args)
+	// just like 'new ctor()' except that the constructor and its arguments come
+	// from args, which must be an array or an arguments object
+	function applyNew(args){
+		// create an object with ctor's prototype but without
+		// calling ctor on it.
+		var ctor = args.callee, t = forceNew(ctor);
+		// execute the real constructor on the new object
+		ctor.apply(t, args);
+		return t;
+	}
+
+	function declare(className, superclass, props){
+		// crack parameters
+		if(typeof className != "string"){
+			props = superclass;
+			superclass = className;
+			className = "";
+		}
+		props = props || {};
+
+		var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass;
+
+		// build a prototype
+		if(opts.call(superclass) == "[object Array]"){
+			// C3 MRO
+			bases = c3mro(superclass, className);
+			t = bases[0];
+			mixins = bases.length - t;
+			superclass = bases[mixins];
+		}else{
+			bases = [0];
+			if(superclass){
+				if(opts.call(superclass) == "[object Function]"){
+					t = superclass._meta;
+					bases = bases.concat(t ? t.bases : superclass);
+				}else{
+					err("base class is not a callable constructor.", className);
+				}
+			}else if(superclass !== null){
+				err("unknown base class. Did you use dojo.require to pull it in?", className);
+			}
+		}
+		if(superclass){
+			for(i = mixins - 1;; --i){
+				proto = forceNew(superclass);
+				if(!i){
+					// stop if nothing to add (the last base)
+					break;
+				}
+				// mix in properties
+				t = bases[i];
+				(t._meta ? mixOwn : mix)(proto, t.prototype);
+				// chain in new constructor
+				ctor = new Function;
+				ctor.superclass = superclass;
+				ctor.prototype = proto;
+				superclass = proto.constructor = ctor;
+			}
+		}else{
+			proto = {};
+		}
+		// add all properties
+		declare.safeMixin(proto, props);
+		// add constructor
+		t = props.constructor;
+		if(t !== op.constructor){
+			t.nom = cname;
+			proto.constructor = t;
+		}
+
+		// collect chains and flags
+		for(i = mixins - 1; i; --i){ // intentional assignment
+			t = bases[i]._meta;
+			if(t && t.chains){
+				chains = mix(chains || {}, t.chains);
+			}
+		}
+		if(proto["-chains-"]){
+			chains = mix(chains || {}, proto["-chains-"]);
+		}
+
+		// build ctor
+		t = !chains || !chains.hasOwnProperty(cname);
+		bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) :
+			(bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t));
+
+		// add meta information to the constructor
+		ctor._meta  = {bases: bases, hidden: props, chains: chains,
+			parents: parents, ctor: props.constructor};
+		ctor.superclass = superclass && superclass.prototype;
+		ctor.extend = extend;
+		ctor.prototype = proto;
+		proto.constructor = ctor;
+
+		// add "standard" methods to the prototype
+		proto.getInherited = getInherited;
+		proto.isInstanceOf = isInstanceOf;
+		proto.inherited    = inheritedImpl;
+		proto.__inherited  = inherited;
+
+		// add name if specified
+		if(className){
+			proto.declaredClass = className;
+			lang.setObject(className, ctor);
+		}
+
+		// build chains and add them to the prototype
+		if(chains){
+			for(name in chains){
+				if(proto[name] && typeof chains[name] == "string" && name != cname){
+					t = proto[name] = chain(name, bases, chains[name] === "after");
+					t.nom = name;
+				}
+			}
+		}
+		// chained methods do not return values
+		// no need to chain "invisible" functions
+
+		return ctor;	// Function
+	}
+
+	/*=====
+	dojo.declare = function(className, superclass, props){
+		//	summary:
+		//		Create a feature-rich constructor from compact notation.
+		//	className: String?:
+		//		The optional name of the constructor (loosely, a "class")
+		//		stored in the "declaredClass" property in the created prototype.
+		//		It will be used as a global name for a created constructor.
+		//	superclass: Function|Function[]:
+		//		May be null, a Function, or an Array of Functions. This argument
+		//		specifies a list of bases (the left-most one is the most deepest
+		//		base).
+		//	props: Object:
+		//		An object whose properties are copied to the created prototype.
+		//		Add an instance-initialization function by making it a property
+		//		named "constructor".
+		//	returns:
+		//		New constructor function.
+		//	description:
+		//		Create a constructor using a compact notation for inheritance and
+		//		prototype extension.
+		//
+		//		Mixin ancestors provide a type of multiple inheritance.
+		//		Prototypes of mixin ancestors are copied to the new class:
+		//		changes to mixin prototypes will not affect classes to which
+		//		they have been mixed in.
+		//
+		//		Ancestors can be compound classes created by this version of
+		//		dojo.declare. In complex cases all base classes are going to be
+		//		linearized according to C3 MRO algorithm
+		//		(see http://www.python.org/download/releases/2.3/mro/ for more
+		//		details).
+		//
+		//		"className" is cached in "declaredClass" property of the new class,
+		//		if it was supplied. The immediate super class will be cached in
+		//		"superclass" property of the new class.
+		//
+		//		Methods in "props" will be copied and modified: "nom" property
+		//		(the declared name of the method) will be added to all copied
+		//		functions to help identify them for the internal machinery. Be
+		//		very careful, while reusing methods: if you use the same
+		//		function under different names, it can produce errors in some
+		//		cases.
+		//
+		//		It is possible to use constructors created "manually" (without
+		//		dojo.declare) as bases. They will be called as usual during the
+		//		creation of an instance, their methods will be chained, and even
+		//		called by "this.inherited()".
+		//
+		//		Special property "-chains-" governs how to chain methods. It is
+		//		a dictionary, which uses method names as keys, and hint strings
+		//		as values. If a hint string is "after", this method will be
+		//		called after methods of its base classes. If a hint string is
+		//		"before", this method will be called before methods of its base
+		//		classes.
+		//
+		//		If "constructor" is not mentioned in "-chains-" property, it will
+		//		be chained using the legacy mode: using "after" chaining,
+		//		calling preamble() method before each constructor, if available,
+		//		and calling postscript() after all constructors were executed.
+		//		If the hint is "after", it is chained as a regular method, but
+		//		postscript() will be called after the chain of constructors.
+		//		"constructor" cannot be chained "before", but it allows
+		//		a special hint string: "manual", which means that constructors
+		//		are not going to be chained in any way, and programmer will call
+		//		them manually using this.inherited(). In the latter case
+		//		postscript() will be called after the construction.
+		//
+		//		All chaining hints are "inherited" from base classes and
+		//		potentially can be overridden. Be very careful when overriding
+		//		hints! Make sure that all chained methods can work in a proposed
+		//		manner of chaining.
+		//
+		//		Once a method was chained, it is impossible to unchain it. The
+		//		only exception is "constructor". You don't need to define a
+		//		method in order to supply a chaining hint.
+		//
+		//		If a method is chained, it cannot use this.inherited() because
+		//		all other methods in the hierarchy will be called automatically.
+		//
+		//		Usually constructors and initializers of any kind are chained
+		//		using "after" and destructors of any kind are chained as
+		//		"before". Note that chaining assumes that chained methods do not
+		//		return any value: any returned value will be discarded.
+		//
+		//	example:
+		//	|	dojo.declare("my.classes.bar", my.classes.foo, {
+		//	|		// properties to be added to the class prototype
+		//	|		someValue: 2,
+		//	|		// initialization function
+		//	|		constructor: function(){
+		//	|			this.myComplicatedObject = new ReallyComplicatedObject();
+		//	|		},
+		//	|		// other functions
+		//	|		someMethod: function(){
+		//	|			doStuff();
+		//	|		}
+		//	|	});
+		//
+		//	example:
+		//	|	var MyBase = dojo.declare(null, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var MyClass1 = dojo.declare(MyBase, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var MyClass2 = dojo.declare(MyBase, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var MyDiamond = dojo.declare([MyClass1, MyClass2], {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//
+		//	example:
+		//	|	var F = function(){ console.log("raw constructor"); };
+		//	|	F.prototype.method = function(){
+		//	|		console.log("raw method");
+		//	|	};
+		//	|	var A = dojo.declare(F, {
+		//	|		constructor: function(){
+		//	|			console.log("A.constructor");
+		//	|		},
+		//	|		method: function(){
+		//	|			console.log("before calling F.method...");
+		//	|			this.inherited(arguments);
+		//	|			console.log("...back in A");
+		//	|		}
+		//	|	});
+		//	|	new A().method();
+		//	|	// will print:
+		//	|	// raw constructor
+		//	|	// A.constructor
+		//	|	// before calling F.method...
+		//	|	// raw method
+		//	|	// ...back in A
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		"-chains-": {
+		//	|			destroy: "before"
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		constructor: function(){
+		//	|			console.log("B.constructor");
+		//	|		},
+		//	|		destroy: function(){
+		//	|			console.log("B.destroy");
+		//	|		}
+		//	|	});
+		//	|	var C = dojo.declare(B, {
+		//	|		constructor: function(){
+		//	|			console.log("C.constructor");
+		//	|		},
+		//	|		destroy: function(){
+		//	|			console.log("C.destroy");
+		//	|		}
+		//	|	});
+		//	|	new C().destroy();
+		//	|	// prints:
+		//	|	// B.constructor
+		//	|	// C.constructor
+		//	|	// C.destroy
+		//	|	// B.destroy
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		"-chains-": {
+		//	|			constructor: "manual"
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		constructor: function(){
+		//	|			// ...
+		//	|			// call the base constructor with new parameters
+		//	|			this.inherited(arguments, [1, 2, 3]);
+		//	|			// ...
+		//	|		}
+		//	|	});
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		"-chains-": {
+		//	|			m1: "before"
+		//	|		},
+		//	|		m1: function(){
+		//	|			console.log("A.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			console.log("A.m2");
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		"-chains-": {
+		//	|			m2: "after"
+		//	|		},
+		//	|		m1: function(){
+		//	|			console.log("B.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			console.log("B.m2");
+		//	|		}
+		//	|	});
+		//	|	var x = new B();
+		//	|	x.m1();
+		//	|	// prints:
+		//	|	// B.m1
+		//	|	// A.m1
+		//	|	x.m2();
+		//	|	// prints:
+		//	|	// A.m2
+		//	|	// B.m2
+		return new Function(); // Function
+	};
+	=====*/
+
+	/*=====
+	dojo.safeMixin = function(target, source){
+		//	summary:
+		//		Mix in properties skipping a constructor and decorating functions
+		//		like it is done by dojo.declare.
+		//	target: Object
+		//		Target object to accept new properties.
+		//	source: Object
+		//		Source object for new properties.
+		//	description:
+		//		This function is used to mix in properties like lang.mixin does,
+		//		but it skips a constructor property and decorates functions like
+		//		dojo.declare does.
+		//
+		//		It is meant to be used with classes and objects produced with
+		//		dojo.declare. Functions mixed in with dojo.safeMixin can use
+		//		this.inherited() like normal methods.
+		//
+		//		This function is used to implement extend() method of a constructor
+		//		produced with dojo.declare().
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		m1: function(){
+		//	|			console.log("A.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			console.log("A.m2");
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		m1: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("B.m1");
+		//	|		}
+		//	|	});
+		//	|	B.extend({
+		//	|		m2: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("B.m2");
+		//	|		}
+		//	|	});
+		//	|	var x = new B();
+		//	|	dojo.safeMixin(x, {
+		//	|		m1: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("X.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("X.m2");
+		//	|		}
+		//	|	});
+		//	|	x.m2();
+		//	|	// prints:
+		//	|	// A.m1
+		//	|	// B.m1
+		//	|	// X.m1
+	};
+	=====*/
+
+	/*=====
+	Object.inherited = function(name, args, newArgs){
+		//	summary:
+		//		Calls a super method.
+		//	name: String?
+		//		The optional method name. Should be the same as the caller's
+		//		name. Usually "name" is specified in complex dynamic cases, when
+		//		the calling method was dynamically added, undecorated by
+		//		dojo.declare, and it cannot be determined.
+		//	args: Arguments
+		//		The caller supply this argument, which should be the original
+		//		"arguments".
+		//	newArgs: Object?
+		//		If "true", the found function will be returned without
+		//		executing it.
+		//		If Array, it will be used to call a super method. Otherwise
+		//		"args" will be used.
+		//	returns:
+		//		Whatever is returned by a super method, or a super method itself,
+		//		if "true" was specified as newArgs.
+		//	description:
+		//		This method is used inside method of classes produced with
+		//		dojo.declare to call a super method (next in the chain). It is
+		//		used for manually controlled chaining. Consider using the regular
+		//		chaining, because it is faster. Use "this.inherited()" only in
+		//		complex cases.
+		//
+		//		This method cannot me called from automatically chained
+		//		constructors including the case of a special (legacy)
+		//		constructor chaining. It cannot be called from chained methods.
+		//
+		//		If "this.inherited()" cannot find the next-in-chain method, it
+		//		does nothing and returns "undefined". The last method in chain
+		//		can be a default method implemented in Object, which will be
+		//		called last.
+		//
+		//		If "name" is specified, it is assumed that the method that
+		//		received "args" is the parent method for this call. It is looked
+		//		up in the chain list and if it is found the next-in-chain method
+		//		is called. If it is not found, the first-in-chain method is
+		//		called.
+		//
+		//		If "name" is not specified, it will be derived from the calling
+		//		method (using a methoid property "nom").
+		//
+		//	example:
+		//	|	var B = dojo.declare(A, {
+		//	|		method1: function(a, b, c){
+		//	|			this.inherited(arguments);
+		//	|		},
+		//	|		method2: function(a, b){
+		//	|			return this.inherited(arguments, [a + b]);
+		//	|		}
+		//	|	});
+		//	|	// next method is not in the chain list because it is added
+		//	|	// manually after the class was created.
+		//	|	B.prototype.method3 = function(){
+		//	|		console.log("This is a dynamically-added method.");
+		//	|		this.inherited("method3", arguments);
+		//	|	};
+		//	example:
+		//	|	var B = dojo.declare(A, {
+		//	|		method: function(a, b){
+		//	|			var super = this.inherited(arguments, true);
+		//	|			// ...
+		//	|			if(!super){
+		//	|				console.log("there is no super method");
+		//	|				return 0;
+		//	|			}
+		//	|			return super.apply(this, arguments);
+		//	|		}
+		//	|	});
+		return	{};	// Object
+	}
+	=====*/
+
+	/*=====
+	Object.getInherited = function(name, args){
+		//	summary:
+		//		Returns a super method.
+		//	name: String?
+		//		The optional method name. Should be the same as the caller's
+		//		name. Usually "name" is specified in complex dynamic cases, when
+		//		the calling method was dynamically added, undecorated by
+		//		dojo.declare, and it cannot be determined.
+		//	args: Arguments
+		//		The caller supply this argument, which should be the original
+		//		"arguments".
+		//	returns:
+		//		Returns a super method (Function) or "undefined".
+		//	description:
+		//		This method is a convenience method for "this.inherited()".
+		//		It uses the same algorithm but instead of executing a super
+		//		method, it returns it, or "undefined" if not found.
+		//
+		//	example:
+		//	|	var B = dojo.declare(A, {
+		//	|		method: function(a, b){
+		//	|			var super = this.getInherited(arguments);
+		//	|			// ...
+		//	|			if(!super){
+		//	|				console.log("there is no super method");
+		//	|				return 0;
+		//	|			}
+		//	|			return super.apply(this, arguments);
+		//	|		}
+		//	|	});
+		return	{};	// Object
+	}
+	=====*/
+
+	/*=====
+	Object.isInstanceOf = function(cls){
+		//	summary:
+		//		Checks the inheritance chain to see if it is inherited from this
+		//		class.
+		//	cls: Function
+		//		Class constructor.
+		//	returns:
+		//		"true", if this object is inherited from this class, "false"
+		//		otherwise.
+		//	description:
+		//		This method is used with instances of classes produced with
+		//		dojo.declare to determine of they support a certain interface or
+		//		not. It models "instanceof" operator.
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var B = dojo.declare(null, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var C = dojo.declare([A, B], {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var D = dojo.declare(A, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|
+		//	|	var a = new A(), b = new B(), c = new C(), d = new D();
+		//	|
+		//	|	console.log(a.isInstanceOf(A)); // true
+		//	|	console.log(b.isInstanceOf(A)); // false
+		//	|	console.log(c.isInstanceOf(A)); // true
+		//	|	console.log(d.isInstanceOf(A)); // true
+		//	|
+		//	|	console.log(a.isInstanceOf(B)); // false
+		//	|	console.log(b.isInstanceOf(B)); // true
+		//	|	console.log(c.isInstanceOf(B)); // true
+		//	|	console.log(d.isInstanceOf(B)); // false
+		//	|
+		//	|	console.log(a.isInstanceOf(C)); // false
+		//	|	console.log(b.isInstanceOf(C)); // false
+		//	|	console.log(c.isInstanceOf(C)); // true
+		//	|	console.log(d.isInstanceOf(C)); // false
+		//	|
+		//	|	console.log(a.isInstanceOf(D)); // false
+		//	|	console.log(b.isInstanceOf(D)); // false
+		//	|	console.log(c.isInstanceOf(D)); // false
+		//	|	console.log(d.isInstanceOf(D)); // true
+		return	{};	// Object
+	}
+	=====*/
+
+	/*=====
+	Object.extend = function(source){
+		//	summary:
+		//		Adds all properties and methods of source to constructor's
+		//		prototype, making them available to all instances created with
+		//		constructor. This method is specific to constructors created with
+		//		dojo.declare.
+		//	source: Object
+		//		Source object which properties are going to be copied to the
+		//		constructor's prototype.
+		//	description:
+		//		Adds source properties to the constructor's prototype. It can
+		//		override existing properties.
+		//
+		//		This method is similar to dojo.extend function, but it is specific
+		//		to constructors produced by dojo.declare. It is implemented
+		//		using dojo.safeMixin, and it skips a constructor property,
+		//		and properly decorates copied functions.
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		m1: function(){},
+		//	|		s1: "Popokatepetl"
+		//	|	});
+		//	|	A.extend({
+		//	|		m1: function(){},
+		//	|		m2: function(){},
+		//	|		f1: true,
+		//	|		d1: 42
+		//	|	});
+	};
+	=====*/
+
+	dojo.safeMixin = declare.safeMixin = safeMixin;
+	dojo.declare = declare;
+
+	return declare;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/event.js b/js/dojo-1.7.2/dojo/_base/event.js
new file mode 100644
index 0000000..9ffd8fb
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/event.js
@@ -0,0 +1,52 @@
+//>>built
+define("dojo/_base/event", ["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){
+  //  module:
+  //    dojo/_base/event
+  //  summary:
+  //    This module defines dojo DOM event API.
+	if(on._fixEvent){
+		var fixEvent = on._fixEvent;
+		on._fixEvent = function(evt, se){
+			// add some additional normalization for back-compat, this isn't in on.js because it is somewhat more expensive
+			evt = fixEvent(evt, se);
+			if(evt){
+				dom.normalizeEvent(evt);
+			}
+			return evt;
+		};		
+	}
+	dojo.fixEvent = function(/*Event*/ evt, /*DOMNode*/ sender){
+		// summary:
+		//		normalizes properties on the event object including event
+		//		bubbling methods, keystroke normalization, and x/y positions
+		// evt: Event
+		//		native event object
+		// sender: DOMNode
+		//		node to treat as "currentTarget"
+		if(on._fixEvent){
+			return on._fixEvent(evt, sender);
+		}
+		return evt;	// Event
+	};
+	
+	dojo.stopEvent = function(/*Event*/ evt){
+		// summary:
+		//		prevents propagation and clobbers the default action of the
+		//		passed event
+		// evt: Event
+		//		The event object. If omitted, window.event is used on IE.
+		if(has("dom-addeventlistener") || (evt && evt.preventDefault)){
+			evt.preventDefault();
+			evt.stopPropagation();
+		}else{
+			evt = evt || window.event;
+			evt.cancelBubble = true;
+			on._preventDefault.call(evt);
+		}
+	};
+
+	return {
+		fix: dojo.fixEvent,
+		stop: dojo.stopEvent
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/_base/fx.js b/js/dojo-1.7.2/dojo/_base/fx.js
new file mode 100644
index 0000000..61b1798
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/fx.js
@@ -0,0 +1,667 @@
+//>>built
+define("dojo/_base/fx", ["./kernel", "./lang", "../Evented", "./Color", "./connect", "./sniff", "../dom", "../dom-style"], function(dojo, lang, Evented, Color, connect, has, dom, style){
+	// module:
+	//		dojo/_base/fx
+	// summary:
+	//		This module defines the base dojo.fx implementation.
+	// notes:
+	//		Animation loosely package based on Dan Pupius' work, contributed under CLA; see
+	//		http://pupius.co.uk/js/Toolkit.Drawing.js
+
+	var _mixin = lang.mixin;
+
+	dojo._Line = function(/*int*/ start, /*int*/ end){
+		//	summary:
+		//		dojo._Line is the object used to generate values from a start value
+		//		to an end value
+		//	start: int
+		//		Beginning value for range
+		//	end: int
+		//		Ending value for range
+		this.start = start;
+		this.end = end;
+	};
+
+	dojo._Line.prototype.getValue = function(/*float*/ n){
+		//	summary: Returns the point on the line
+		//	n: a floating point number greater than 0 and less than 1
+		return ((this.end - this.start) * n) + this.start; // Decimal
+	};
+
+	dojo.Animation = function(args){
+		//	summary:
+		//		A generic animation class that fires callbacks into its handlers
+		//		object at various states.
+		//	description:
+		//		A generic animation class that fires callbacks into its handlers
+		//		object at various states. Nearly all dojo animation functions
+		//		return an instance of this method, usually without calling the
+		//		.play() method beforehand. Therefore, you will likely need to
+		//		call .play() on instances of `dojo.Animation` when one is
+		//		returned.
+		// args: Object
+		//		The 'magic argument', mixing all the properties into this
+		//		animation instance.
+
+		_mixin(this, args);
+		if(lang.isArray(this.curve)){
+			this.curve = new dojo._Line(this.curve[0], this.curve[1]);
+		}
+
+	};
+	dojo.Animation.prototype = new Evented();
+	// Alias to drop come 2.0:
+	dojo._Animation = dojo.Animation;
+
+	lang.extend(dojo.Animation, {
+		// duration: Integer
+		//		The time in milliseonds the animation will take to run
+		duration: 350,
+
+	/*=====
+		// curve: dojo._Line|Array
+		//		A two element array of start and end values, or a `dojo._Line` instance to be
+		//		used in the Animation.
+		curve: null,
+
+		// easing: Function?
+		//		A Function to adjust the acceleration (or deceleration) of the progress
+		//		across a dojo._Line
+		easing: null,
+	=====*/
+
+		// repeat: Integer?
+		//		The number of times to loop the animation
+		repeat: 0,
+
+		// rate: Integer?
+		//		the time in milliseconds to wait before advancing to next frame
+		//		(used as a fps timer: 1000/rate = fps)
+		rate: 20 /* 50 fps */,
+
+	/*=====
+		// delay: Integer?
+		//		The time in milliseconds to wait before starting animation after it
+		//		has been .play()'ed
+		delay: null,
+
+		// beforeBegin: Event?
+		//		Synthetic event fired before a dojo.Animation begins playing (synchronous)
+		beforeBegin: null,
+
+		// onBegin: Event?
+		//		Synthetic event fired as a dojo.Animation begins playing (useful?)
+		onBegin: null,
+
+		// onAnimate: Event?
+		//		Synthetic event fired at each interval of a `dojo.Animation`
+		onAnimate: null,
+
+		// onEnd: Event?
+		//		Synthetic event fired after the final frame of a `dojo.Animation`
+		onEnd: null,
+
+		// onPlay: Event?
+		//		Synthetic event fired any time a `dojo.Animation` is play()'ed
+		onPlay: null,
+
+		// onPause: Event?
+		//		Synthetic event fired when a `dojo.Animation` is paused
+		onPause: null,
+
+		// onStop: Event
+		//		Synthetic event fires when a `dojo.Animation` is stopped
+		onStop: null,
+
+	=====*/
+
+		_percent: 0,
+		_startRepeatCount: 0,
+
+		_getStep: function(){
+			var _p = this._percent,
+				_e = this.easing
+			;
+			return _e ? _e(_p) : _p;
+		},
+		_fire: function(/*Event*/ evt, /*Array?*/ args){
+			//	summary:
+			//		Convenience function.  Fire event "evt" and pass it the
+			//		arguments specified in "args".
+			//	description:
+			//		Convenience function.  Fire event "evt" and pass it the
+			//		arguments specified in "args".
+			//		Fires the callback in the scope of the `dojo.Animation`
+			//		instance.
+			//	evt:
+			//		The event to fire.
+			//	args:
+			//		The arguments to pass to the event.
+			var a = args||[];
+			if(this[evt]){
+				if(dojo.config.debugAtAllCosts){
+					this[evt].apply(this, a);
+				}else{
+					try{
+						this[evt].apply(this, a);
+					}catch(e){
+						// squelch and log because we shouldn't allow exceptions in
+						// synthetic event handlers to cause the internal timer to run
+						// amuck, potentially pegging the CPU. I'm not a fan of this
+						// squelch, but hopefully logging will make it clear what's
+						// going on
+						console.error("exception in animation handler for:", evt);
+						console.error(e);
+					}
+				}
+			}
+			return this; // dojo.Animation
+		},
+
+		play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
+			// summary:
+			//		Start the animation.
+			// delay:
+			//		How many milliseconds to delay before starting.
+			// gotoStart:
+			//		If true, starts the animation from the beginning; otherwise,
+			//		starts it from its current position.
+			// returns: dojo.Animation
+			//		The instance to allow chaining.
+
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			if(gotoStart){
+				_t._stopTimer();
+				_t._active = _t._paused = false;
+				_t._percent = 0;
+			}else if(_t._active && !_t._paused){
+				return _t;
+			}
+
+			_t._fire("beforeBegin", [_t.node]);
+
+			var de = delay || _t.delay,
+				_p = lang.hitch(_t, "_play", gotoStart);
+
+			if(de > 0){
+				_t._delayTimer = setTimeout(_p, de);
+				return _t;
+			}
+			_p();
+			return _t;	// dojo.Animation
+		},
+
+		_play: function(gotoStart){
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			_t._startTime = new Date().valueOf();
+			if(_t._paused){
+				_t._startTime -= _t.duration * _t._percent;
+			}
+
+			_t._active = true;
+			_t._paused = false;
+			var value = _t.curve.getValue(_t._getStep());
+			if(!_t._percent){
+				if(!_t._startRepeatCount){
+					_t._startRepeatCount = _t.repeat;
+				}
+				_t._fire("onBegin", [value]);
+			}
+
+			_t._fire("onPlay", [value]);
+
+			_t._cycle();
+			return _t; // dojo.Animation
+		},
+
+		pause: function(){
+			// summary: Pauses a running animation.
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			_t._stopTimer();
+			if(!_t._active){ return _t; /*dojo.Animation*/ }
+			_t._paused = true;
+			_t._fire("onPause", [_t.curve.getValue(_t._getStep())]);
+			return _t; // dojo.Animation
+		},
+
+		gotoPercent: function(/*Decimal*/ percent, /*Boolean?*/ andPlay){
+			//	summary:
+			//		Sets the progress of the animation.
+			//	percent:
+			//		A percentage in decimal notation (between and including 0.0 and 1.0).
+			//	andPlay:
+			//		If true, play the animation after setting the progress.
+			var _t = this;
+			_t._stopTimer();
+			_t._active = _t._paused = true;
+			_t._percent = percent;
+			if(andPlay){ _t.play(); }
+			return _t; // dojo.Animation
+		},
+
+		stop: function(/*boolean?*/ gotoEnd){
+			// summary: Stops a running animation.
+			// gotoEnd: If true, the animation will end.
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			if(!_t._timer){ return _t; /* dojo.Animation */ }
+			_t._stopTimer();
+			if(gotoEnd){
+				_t._percent = 1;
+			}
+			_t._fire("onStop", [_t.curve.getValue(_t._getStep())]);
+			_t._active = _t._paused = false;
+			return _t; // dojo.Animation
+		},
+
+		status: function(){
+			// summary:
+			//		Returns a string token representation of the status of
+			//		the animation, one of: "paused", "playing", "stopped"
+			if(this._active){
+				return this._paused ? "paused" : "playing"; // String
+			}
+			return "stopped"; // String
+		},
+
+		_cycle: function(){
+			var _t = this;
+			if(_t._active){
+				var curr = new Date().valueOf();
+				var step = (curr - _t._startTime) / (_t.duration);
+
+				if(step >= 1){
+					step = 1;
+				}
+				_t._percent = step;
+
+				// Perform easing
+				if(_t.easing){
+					step = _t.easing(step);
+				}
+
+				_t._fire("onAnimate", [_t.curve.getValue(step)]);
+
+				if(_t._percent < 1){
+					_t._startTimer();
+				}else{
+					_t._active = false;
+
+					if(_t.repeat > 0){
+						_t.repeat--;
+						_t.play(null, true);
+					}else if(_t.repeat == -1){
+						_t.play(null, true);
+					}else{
+						if(_t._startRepeatCount){
+							_t.repeat = _t._startRepeatCount;
+							_t._startRepeatCount = 0;
+						}
+					}
+					_t._percent = 0;
+					_t._fire("onEnd", [_t.node]);
+					!_t.repeat && _t._stopTimer();
+				}
+			}
+			return _t; // dojo.Animation
+		},
+
+		_clearTimer: function(){
+			// summary: Clear the play delay timer
+			clearTimeout(this._delayTimer);
+			delete this._delayTimer;
+		}
+
+	});
+
+	// the local timer, stubbed into all Animation instances
+	var ctr = 0,
+		timer = null,
+		runner = {
+			run: function(){}
+		};
+
+	lang.extend(dojo.Animation, {
+
+		_startTimer: function(){
+			if(!this._timer){
+				this._timer = connect.connect(runner, "run", this, "_cycle");
+				ctr++;
+			}
+			if(!timer){
+				timer = setInterval(lang.hitch(runner, "run"), this.rate);
+			}
+		},
+
+		_stopTimer: function(){
+			if(this._timer){
+				connect.disconnect(this._timer);
+				this._timer = null;
+				ctr--;
+			}
+			if(ctr <= 0){
+				clearInterval(timer);
+				timer = null;
+				ctr = 0;
+			}
+		}
+
+	});
+
+	var _makeFadeable =
+				has("ie") ? function(node){
+			// only set the zoom if the "tickle" value would be the same as the
+			// default
+			var ns = node.style;
+			// don't set the width to auto if it didn't already cascade that way.
+			// We don't want to f anyones designs
+			if(!ns.width.length && style.get(node, "width") == "auto"){
+				ns.width = "auto";
+			}
+		} :
+				function(){};
+
+	dojo._fade = function(/*Object*/ args){
+		//	summary:
+		//		Returns an animation that will fade the node defined by
+		//		args.node from the start to end values passed (args.start
+		//		args.end) (end is mandatory, start is optional)
+
+		args.node = dom.byId(args.node);
+		var fArgs = _mixin({ properties: {} }, args),
+			props = (fArgs.properties.opacity = {});
+
+		props.start = !("start" in fArgs) ?
+			function(){
+				return +style.get(fArgs.node, "opacity")||0;
+			} : fArgs.start;
+		props.end = fArgs.end;
+
+		var anim = dojo.animateProperty(fArgs);
+		connect.connect(anim, "beforeBegin", lang.partial(_makeFadeable, fArgs.node));
+
+		return anim; // dojo.Animation
+	};
+
+	/*=====
+	dojo.__FadeArgs = function(node, duration, easing){
+		//	node: DOMNode|String
+		//		The node referenced in the animation
+		//	duration: Integer?
+		//		Duration of the animation in milliseconds.
+		//	easing: Function?
+		//		An easing function.
+		this.node = node;
+		this.duration = duration;
+		this.easing = easing;
+	}
+	=====*/
+
+	dojo.fadeIn = function(/*dojo.__FadeArgs*/ args){
+		// summary:
+		//		Returns an animation that will fade node defined in 'args' from
+		//		its current opacity to fully opaque.
+		return dojo._fade(_mixin({ end: 1 }, args)); // dojo.Animation
+	};
+
+	dojo.fadeOut = function(/*dojo.__FadeArgs*/ args){
+		// summary:
+		//		Returns an animation that will fade node defined in 'args'
+		//		from its current opacity to fully transparent.
+		return dojo._fade(_mixin({ end: 0 }, args)); // dojo.Animation
+	};
+
+	dojo._defaultEasing = function(/*Decimal?*/ n){
+		// summary: The default easing function for dojo.Animation(s)
+		return 0.5 + ((Math.sin((n + 1.5) * Math.PI)) / 2);	// Decimal
+	};
+
+	var PropLine = function(properties){
+		// PropLine is an internal class which is used to model the values of
+		// an a group of CSS properties across an animation lifecycle. In
+		// particular, the "getValue" function handles getting interpolated
+		// values between start and end for a particular CSS value.
+		this._properties = properties;
+		for(var p in properties){
+			var prop = properties[p];
+			if(prop.start instanceof Color){
+				// create a reusable temp color object to keep intermediate results
+				prop.tempColor = new Color();
+			}
+		}
+	};
+
+	PropLine.prototype.getValue = function(r){
+		var ret = {};
+		for(var p in this._properties){
+			var prop = this._properties[p],
+				start = prop.start;
+			if(start instanceof Color){
+				ret[p] = Color.blendColors(start, prop.end, r, prop.tempColor).toCss();
+			}else if(!lang.isArray(start)){
+				ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units || "px" : 0);
+			}
+		}
+		return ret;
+	};
+
+	/*=====
+	dojo.declare("dojo.__AnimArgs", [dojo.__FadeArgs], {
+		// Properties: Object?
+		//	A hash map of style properties to Objects describing the transition,
+		//	such as the properties of dojo._Line with an additional 'units' property
+		properties: {}
+
+		//TODOC: add event callbacks
+	});
+	=====*/
+
+	dojo.animateProperty = function(/*dojo.__AnimArgs*/ args){
+		// summary:
+		//		Returns an animation that will transition the properties of
+		//		node defined in `args` depending how they are defined in
+		//		`args.properties`
+		//
+		// description:
+		//		`dojo.animateProperty` is the foundation of most `dojo.fx`
+		//		animations. It takes an object of "properties" corresponding to
+		//		style properties, and animates them in parallel over a set
+		//		duration.
+		//
+		// example:
+		//		A simple animation that changes the width of the specified node.
+		//	|	dojo.animateProperty({
+		//	|		node: "nodeId",
+		//	|		properties: { width: 400 },
+		//	|	}).play();
+		//		Dojo figures out the start value for the width and converts the
+		//		integer specified for the width to the more expressive but
+		//		verbose form `{ width: { end: '400', units: 'px' } }` which you
+		//		can also specify directly. Defaults to 'px' if ommitted.
+		//
+		// example:
+		//		Animate width, height, and padding over 2 seconds... the
+		//		pedantic way:
+		//	|	dojo.animateProperty({ node: node, duration:2000,
+		//	|		properties: {
+		//	|			width: { start: '200', end: '400', units:"px" },
+		//	|			height: { start:'200', end: '400', units:"px" },
+		//	|			paddingTop: { start:'5', end:'50', units:"px" }
+		//	|		}
+		//	|	}).play();
+		//		Note 'paddingTop' is used over 'padding-top'. Multi-name CSS properties
+		//		are written using "mixed case", as the hyphen is illegal as an object key.
+		//
+		// example:
+		//		Plug in a different easing function and register a callback for
+		//		when the animation ends. Easing functions accept values between
+		//		zero and one and return a value on that basis. In this case, an
+		//		exponential-in curve.
+		//	|	dojo.animateProperty({
+		//	|		node: "nodeId",
+		//	|		// dojo figures out the start value
+		//	|		properties: { width: { end: 400 } },
+		//	|		easing: function(n){
+		//	|			return (n==0) ? 0 : Math.pow(2, 10 * (n - 1));
+		//	|		},
+		//	|		onEnd: function(node){
+		//	|			// called when the animation finishes. The animation
+		//	|			// target is passed to this function
+		//	|		}
+		//	|	}).play(500); // delay playing half a second
+		//
+		// example:
+		//		Like all `dojo.Animation`s, animateProperty returns a handle to the
+		//		Animation instance, which fires the events common to Dojo FX. Use `dojo.connect`
+		//		to access these events outside of the Animation definiton:
+		//	|	var anim = dojo.animateProperty({
+		//	|		node:"someId",
+		//	|		properties:{
+		//	|			width:400, height:500
+		//	|		}
+		//	|	});
+		//	|	dojo.connect(anim,"onEnd", function(){
+		//	|		console.log("animation ended");
+		//	|	});
+		//	|	// play the animation now:
+		//	|	anim.play();
+		//
+		// example:
+		//		Each property can be a function whose return value is substituted along.
+		//		Additionally, each measurement (eg: start, end) can be a function. The node
+		//		reference is passed direcly to callbacks.
+		//	|	dojo.animateProperty({
+		//	|		node:"mine",
+		//	|		properties:{
+		//	|			height:function(node){
+		//	|				// shrink this node by 50%
+		//	|				return dojo.position(node).h / 2
+		//	|			},
+		//	|			width:{
+		//	|				start:function(node){ return 100; },
+		//	|				end:function(node){ return 200; }
+		//	|			}
+		//	|		}
+		//	|	}).play();
+		//
+
+		var n = args.node = dom.byId(args.node);
+		if(!args.easing){ args.easing = dojo._defaultEasing; }
+
+		var anim = new dojo.Animation(args);
+		connect.connect(anim, "beforeBegin", anim, function(){
+			var pm = {};
+			for(var p in this.properties){
+				// Make shallow copy of properties into pm because we overwrite
+				// some values below. In particular if start/end are functions
+				// we don't want to overwrite them or the functions won't be
+				// called if the animation is reused.
+				if(p == "width" || p == "height"){
+					this.node.display = "block";
+				}
+				var prop = this.properties[p];
+				if(lang.isFunction(prop)){
+					prop = prop(n);
+				}
+				prop = pm[p] = _mixin({}, (lang.isObject(prop) ? prop: { end: prop }));
+
+				if(lang.isFunction(prop.start)){
+					prop.start = prop.start(n);
+				}
+				if(lang.isFunction(prop.end)){
+					prop.end = prop.end(n);
+				}
+				var isColor = (p.toLowerCase().indexOf("color") >= 0);
+				function getStyle(node, p){
+					// dojo.style(node, "height") can return "auto" or "" on IE; this is more reliable:
+					var v = { height: node.offsetHeight, width: node.offsetWidth }[p];
+					if(v !== undefined){ return v; }
+					v = style.get(node, p);
+					return (p == "opacity") ? +v : (isColor ? v : parseFloat(v));
+				}
+				if(!("end" in prop)){
+					prop.end = getStyle(n, p);
+				}else if(!("start" in prop)){
+					prop.start = getStyle(n, p);
+				}
+
+				if(isColor){
+					prop.start = new Color(prop.start);
+					prop.end = new Color(prop.end);
+				}else{
+					prop.start = (p == "opacity") ? +prop.start : parseFloat(prop.start);
+				}
+			}
+			this.curve = new PropLine(pm);
+		});
+		connect.connect(anim, "onAnimate", lang.hitch(style, "set", anim.node));
+		return anim; // dojo.Animation
+	};
+
+	dojo.anim = function(	/*DOMNode|String*/	node,
+							/*Object*/			properties,
+							/*Integer?*/		duration,
+							/*Function?*/		easing,
+							/*Function?*/		onEnd,
+							/*Integer?*/		delay){
+		//	summary:
+		//		A simpler interface to `dojo.animateProperty()`, also returns
+		//		an instance of `dojo.Animation` but begins the animation
+		//		immediately, unlike nearly every other Dojo animation API.
+		//	description:
+		//		`dojo.anim` is a simpler (but somewhat less powerful) version
+		//		of `dojo.animateProperty`.  It uses defaults for many basic properties
+		//		and allows for positional parameters to be used in place of the
+		//		packed "property bag" which is used for other Dojo animation
+		//		methods.
+		//
+		//		The `dojo.Animation` object returned from `dojo.anim` will be
+		//		already playing when it is returned from this function, so
+		//		calling play() on it again is (usually) a no-op.
+		//	node:
+		//		a DOM node or the id of a node to animate CSS properties on
+		//	duration:
+		//		The number of milliseconds over which the animation
+		//		should run. Defaults to the global animation default duration
+		//		(350ms).
+		//	easing:
+		//		An easing function over which to calculate acceleration
+		//		and deceleration of the animation through its duration.
+		//		A default easing algorithm is provided, but you may
+		//		plug in any you wish. A large selection of easing algorithms
+		//		are available in `dojo.fx.easing`.
+		//	onEnd:
+		//		A function to be called when the animation finishes
+		//		running.
+		//	delay:
+		//		The number of milliseconds to delay beginning the
+		//		animation by. The default is 0.
+		//	example:
+		//		Fade out a node
+		//	|	dojo.anim("id", { opacity: 0 });
+		//	example:
+		//		Fade out a node over a full second
+		//	|	dojo.anim("id", { opacity: 0 }, 1000);
+		return dojo.animateProperty({ // dojo.Animation
+			node: node,
+			duration: duration || dojo.Animation.prototype.duration,
+			properties: properties,
+			easing: easing,
+			onEnd: onEnd
+		}).play(delay || 0);
+	};
+
+	return {
+		_Line: dojo._Line,
+		Animation: dojo.Animation,
+		_fade: dojo._fade,
+		fadeIn: dojo.fadeIn,
+		fadeOut: dojo.fadeOut,
+		_defaultEasing: dojo._defaultEasing,
+		animateProperty: dojo.animateProperty,
+		anim: dojo.anim
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/_base/html.js b/js/dojo-1.7.2/dojo/_base/html.js
new file mode 100644
index 0000000..240be89
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/html.js
@@ -0,0 +1,390 @@
+//>>built
+define("dojo/_base/html", ["./kernel", "../dom", "../dom-style", "../dom-attr", "../dom-prop", "../dom-class", "../dom-construct", "../dom-geometry"], function(dojo, dom, style, attr, prop, cls, ctr, geom){
+	// module:
+	//		dojo/dom
+	// summary:
+	//		This module is a stub for the core dojo DOM API.
+
+	// mix-in dom
+	dojo.byId = dom.byId;
+	dojo.isDescendant = dom.isDescendant;
+	dojo.setSelectable = dom.setSelectable;
+
+	// mix-in dom-attr
+	dojo.getAttr = attr.get;
+	dojo.setAttr = attr.set;
+	dojo.hasAttr = attr.has;
+	dojo.removeAttr = attr.remove;
+	dojo.getNodeProp = attr.getNodeProp;
+
+	dojo.attr = function(node, name, value){
+		// summary:
+		//		Gets or sets an attribute on an HTML element.
+		// description:
+		//		Handles normalized getting and setting of attributes on DOM
+		//		Nodes. If 2 arguments are passed, and a the second argument is a
+		//		string, acts as a getter.
+		//
+		//		If a third argument is passed, or if the second argument is a
+		//		map of attributes, acts as a setter.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to get or set the attribute on
+		// name: String|Object
+		//		the name of the attribute to get or set.
+		// value: String?
+		//		The value to set for the attribute
+		// returns:
+		//		when used as a getter, the value of the requested attribute
+		//		or null if that attribute does not have a specified or
+		//		default value;
+		//
+		//		when used as a setter, the DOM node
+		//
+		// example:
+		//	|	// get the current value of the "foo" attribute on a node
+		//	|	dojo.attr(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.attr("nodeId", "foo");
+		//
+		// example:
+		//	|	// use attr() to set the tab index
+		//	|	dojo.attr("nodeId", "tabIndex", 3);
+		//	|
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.attr("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.attr("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.attr("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.style("someNode", obj);
+
+		if(arguments.length == 2){
+			return attr[typeof name == "string" ? "get" : "set"](node, name);
+		}
+		return attr.set(node, name, value);
+	};
+
+	// mix-in dom-class
+	dojo.hasClass = cls.contains;
+	dojo.addClass = cls.add;
+	dojo.removeClass = cls.remove;
+	dojo.toggleClass = cls.toggle;
+	dojo.replaceClass = cls.replace;
+
+	// mix-in dom-construct
+	dojo._toDom = dojo.toDom = ctr.toDom;
+	dojo.place = ctr.place;
+	dojo.create = ctr.create;
+	dojo.empty = function(node){ ctr.empty(node); };
+	dojo._destroyElement = dojo.destroy = function(node){ ctr.destroy(node); };
+
+	// mix-in dom-geometry
+	dojo._getPadExtents = dojo.getPadExtents = geom.getPadExtents;
+	dojo._getBorderExtents = dojo.getBorderExtents = geom.getBorderExtents;
+	dojo._getPadBorderExtents = dojo.getPadBorderExtents = geom.getPadBorderExtents;
+	dojo._getMarginExtents = dojo.getMarginExtents = geom.getMarginExtents;
+	dojo._getMarginSize = dojo.getMarginSize = geom.getMarginSize;
+	dojo._getMarginBox = dojo.getMarginBox = geom.getMarginBox;
+	dojo.setMarginBox = geom.setMarginBox;
+	dojo._getContentBox = dojo.getContentBox = geom.getContentBox;
+	dojo.setContentSize = geom.setContentSize;
+	dojo._isBodyLtr = dojo.isBodyLtr = geom.isBodyLtr;
+	dojo._docScroll = dojo.docScroll = geom.docScroll;
+	dojo._getIeDocumentElementOffset = dojo.getIeDocumentElementOffset = geom.getIeDocumentElementOffset;
+	dojo._fixIeBiDiScrollLeft = dojo.fixIeBiDiScrollLeft = geom.fixIeBiDiScrollLeft;
+	dojo.position = geom.position;
+
+	dojo.marginBox = function marginBox(/*DomNode|String*/node, /*Object?*/box){
+		// summary:
+		//		Getter/setter for the margin-box of node.
+		// description:
+		//		Getter/setter for the margin-box of node.
+		//		Returns an object in the expected format of box (regardless
+		//		if box is passed). The object might look like:
+		//			`{ l: 50, t: 200, w: 300: h: 150 }`
+		//		for a node offset from its parent 50px to the left, 200px from
+		//		the top with a margin width of 300px and a margin-height of
+		//		150px.
+		// node:
+		//		id or reference to DOM Node to get/set box for
+		// box:
+		//		If passed, denotes that dojo.marginBox() should
+		//		update/set the margin box for node. Box is an object in the
+		//		above format. All properties are optional if passed.
+		// example:
+		//		Retrieve the margin box of a passed node
+		//	|	var box = dojo.marginBox("someNodeId");
+		//	|	console.dir(box);
+		//
+		// example:
+		//		Set a node's margin box to the size of another node
+		//	|	var box = dojo.marginBox("someNodeId");
+		//	|	dojo.marginBox("someOtherNode", box);
+		return box ? geom.setMarginBox(node, box) : geom.getMarginBox(node); // Object
+	};
+
+	dojo.contentBox = function contentBox(/*DomNode|String*/node, /*Object?*/box){
+		// summary:
+		//		Getter/setter for the content-box of node.
+		// description:
+		//		Returns an object in the expected format of box (regardless if box is passed).
+		//		The object might look like:
+		//			`{ l: 50, t: 200, w: 300: h: 150 }`
+		//		for a node offset from its parent 50px to the left, 200px from
+		//		the top with a content width of 300px and a content-height of
+		//		150px. Note that the content box may have a much larger border
+		//		or margin box, depending on the box model currently in use and
+		//		CSS values set/inherited for node.
+		//		While the getter will return top and left values, the
+		//		setter only accepts setting the width and height.
+		// node:
+		//		id or reference to DOM Node to get/set box for
+		// box:
+		//		If passed, denotes that dojo.contentBox() should
+		//		update/set the content box for node. Box is an object in the
+		//		above format, but only w (width) and h (height) are supported.
+		//		All properties are optional if passed.
+		return box ? geom.setContentSize(node, box) : geom.getContentBox(node); // Object
+	};
+
+	dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){
+		// summary:
+		//		Deprecated: Use position() for border-box x/y/w/h
+		//		or marginBox() for margin-box w/h/l/t.
+		//		Returns an object representing a node's size and position.
+		//
+		// description:
+		//		Returns an object that measures margin-box (w)idth/(h)eight
+		//		and absolute position x/y of the border-box. Also returned
+		//		is computed (l)eft and (t)op values in pixels from the
+		//		node's offsetParent as returned from marginBox().
+		//		Return value will be in the form:
+		//|			{ l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 }
+		//		Does not act as a setter. If includeScroll is passed, the x and
+		//		y params are affected as one would expect in dojo.position().
+		dojo.deprecated("dojo.coords()", "Use dojo.position() or dojo.marginBox().");
+		node = dom.byId(node);
+		var s = style.getComputedStyle(node), mb = geom.getMarginBox(node, s);
+		var abs = geom.position(node, includeScroll);
+		mb.x = abs.x;
+		mb.y = abs.y;
+		return mb;	// Object
+	};
+
+	// mix-in dom-prop
+	dojo.getProp = prop.get;
+	dojo.setProp = prop.set;
+
+	dojo.prop = function(/*DomNode|String*/node, /*String|Object*/name, /*String?*/value){
+		// summary:
+		//		Gets or sets a property on an HTML element.
+		// description:
+		//		Handles normalized getting and setting of properties on DOM
+		//		Nodes. If 2 arguments are passed, and a the second argument is a
+		//		string, acts as a getter.
+		//
+		//		If a third argument is passed, or if the second argument is a
+		//		map of attributes, acts as a setter.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node:
+		//		id or reference to the element to get or set the property on
+		// name:
+		//		the name of the property to get or set.
+		// value:
+		//		The value to set for the property
+		// returns:
+		//		when used as a getter, the value of the requested property
+		//		or null if that attribute does not have a specified or
+		//		default value;
+		//
+		//		when used as a setter, the DOM node
+		//
+		// example:
+		//	|	// get the current value of the "foo" property on a node
+		//	|	dojo.prop(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.prop("nodeId", "foo");
+		//
+		// example:
+		//	|	// use prop() to set the tab index
+		//	|	dojo.prop("nodeId", "tabIndex", 3);
+		//	|
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.prop("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.prop("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.prop("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.style("someNode", obj);
+
+		if(arguments.length == 2){
+			return prop[typeof name == "string" ? "get" : "set"](node, name);
+		}
+		// setter
+		return prop.set(node, name, value);
+	};
+
+	// mix-in dom-style
+	dojo.getStyle = style.get;
+	dojo.setStyle = style.set;
+	dojo.getComputedStyle = style.getComputedStyle;
+	dojo.__toPixelValue = dojo.toPixelValue = style.toPixelValue;
+
+	dojo.style = function(node, name, value){
+		// summary:
+		//		Accesses styles on a node. If 2 arguments are
+		//		passed, acts as a getter. If 3 arguments are passed, acts
+		//		as a setter.
+		// description:
+		//		Getting the style value uses the computed style for the node, so the value
+		//		will be a calculated value, not just the immediate node.style value.
+		//		Also when getting values, use specific style names,
+		//		like "borderBottomWidth" instead of "border" since compound values like
+		//		"border" are not necessarily reflected as expected.
+		//		If you want to get node dimensions, use `dojo.marginBox()`,
+		//		`dojo.contentBox()` or `dojo.position()`.
+		// node: DOMNode|String
+		//		id or reference to node to get/set style for
+		// name: String?|Object?
+		//		the style property to set in DOM-accessor format
+		//		("borderWidth", not "border-width") or an object with key/value
+		//		pairs suitable for setting each property.
+		// value: String?
+		//		If passed, sets value on the node for style, handling
+		//		cross-browser concerns.  When setting a pixel value,
+		//		be sure to include "px" in the value. For instance, top: "200px".
+		//		Otherwise, in some cases, some browsers will not apply the style.
+		// returns:
+		//		when used as a getter, return the computed style of the node if passing in an ID or node,
+		//		or return the normalized, computed value for the property when passing in a node and a style property
+		// example:
+		//		Passing only an ID or node returns the computed style object of
+		//		the node:
+		//	|	dojo.style("thinger");
+		// example:
+		//		Passing a node and a style property returns the current
+		//		normalized, computed value for that property:
+		//	|	dojo.style("thinger", "opacity"); // 1 by default
+		//
+		// example:
+		//		Passing a node, a style property, and a value changes the
+		//		current display of the node and returns the new computed value
+		//	|	dojo.style("thinger", "opacity", 0.5); // == 0.5
+		//
+		// example:
+		//		Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
+		//	|	dojo.style("thinger", {
+		//	|		"opacity": 0.5,
+		//	|		"border": "3px solid black",
+		//	|		"height": "300px"
+		//	|	});
+		//
+		// example:
+		//		When the CSS style property is hyphenated, the JavaScript property is camelCased.
+		//		font-size becomes fontSize, and so on.
+		//	|	dojo.style("thinger",{
+		//	|		fontSize:"14pt",
+		//	|		letterSpacing:"1.2em"
+		//	|	});
+		//
+		// example:
+		//		dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
+		//		dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()`
+		//	|	dojo.query(".someClassName").style("visibility","hidden");
+		//	|	// or
+		//	|	dojo.query("#baz > div").style({
+		//	|		opacity:0.75,
+		//	|		fontSize:"13pt"
+		//	|	});
+
+		switch(arguments.length){
+			case 1:
+				return style.get(node);
+			case 2:
+				return style[typeof name == "string" ? "get" : "set"](node, name);
+		}
+		// setter
+		return style.set(node, name, value);
+	};
+
+	return dojo;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/json.js b/js/dojo-1.7.2/dojo/_base/json.js
new file mode 100644
index 0000000..56b8d78
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/json.js
@@ -0,0 +1,86 @@
+//>>built
+define("dojo/_base/json", ["./kernel", "../json"], function(dojo, json){
+  // module:
+  //    dojo/_base/json
+  // summary:
+  //    This module defines the dojo JSON API.
+
+dojo.fromJson = function(/*String*/ js){
+	// summary:
+	//		Parses a JavaScript expression and returns a JavaScript value.
+	// description:
+	//		Throws for invalid JavaScript expressions. It does not use a strict JSON parser. It
+	//		always delegates to eval(). The content passed to this method must therefore come
+	//		from a trusted source.
+	//		It is recommend that you use dojo/json's parse function for an
+	//		implementation uses the (faster) native JSON parse when available.
+	// js:
+	//		a string literal of a JavaScript expression, for instance:
+	//			`'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
+
+	return eval("(" + js + ")"); // Object
+};
+
+/*=====
+dojo._escapeString = function(){
+	// summary:
+	//		Adds escape sequences for non-visual characters, double quote and
+	//		backslash and surrounds with double quotes to form a valid string
+	//		literal.
+};
+=====*/
+dojo._escapeString = json.stringify; // just delegate to json.stringify
+
+dojo.toJsonIndentStr = "\t";
+dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint){
+	// summary:
+	//		Returns a [JSON](http://json.org) serialization of an object.
+	// description:
+	//		Returns a [JSON](http://json.org) serialization of an object.
+	//		Note that this doesn't check for infinite recursion, so don't do that!
+	//		It is recommend that you use dojo/json's stringify function for an lighter
+	//		and faster implementation that matches the native JSON API and uses the
+	//		native JSON serializer when available.
+	// it:
+	//		an object to be serialized. Objects may define their own
+	//		serialization via a special "__json__" or "json" function
+	//		property. If a specialized serializer has been defined, it will
+	//		be used as a fallback.
+	//		Note that in 1.6, toJson would serialize undefined, but this no longer supported
+	//		since it is not supported by native JSON serializer.
+	// prettyPrint:
+	//		if true, we indent objects and arrays to make the output prettier.
+	//		The variable `dojo.toJsonIndentStr` is used as the indent string --
+	//		to use something other than the default (tab), change that variable
+	//		before calling dojo.toJson().
+	//		Note that if native JSON support is available, it will be used for serialization,
+	//		and native implementations vary on the exact spacing used in pretty printing.
+	// returns:
+	// 		A JSON string serialization of the passed-in object.
+	// example:
+	//		simple serialization of a trivial object
+	//		|	var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true });
+	//		|	doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
+	// example:
+	//		a custom serializer for an objects of a particular class:
+	//		|	dojo.declare("Furby", null, {
+	//		|		furbies: "are strange",
+	//		|		furbyCount: 10,
+	//		|		__json__: function(){
+	//		|		},
+	//		|	});
+
+	// use dojo/json
+	return json.stringify(it, function(key, value){
+		if(value){
+			var tf = value.__json__||value.json;
+			if(typeof tf == "function"){
+				return tf.call(value);
+			}
+		}
+		return value;
+	}, prettyPrint && dojo.toJsonIndentStr);	// String
+};
+
+return dojo;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/kernel.js b/js/dojo-1.7.2/dojo/_base/kernel.js
new file mode 100644
index 0000000..2e1ae77
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/kernel.js
@@ -0,0 +1,303 @@
+//>>built
+define("dojo/_base/kernel", ["../has", "./config", "require", "module"], function(has, config, require, module){
+	// module:
+	//		dojo/_base/kernel
+	// summary:
+	//		This module is the foundational module of the dojo boot sequence; it defines the dojo object.
+	var
+		// loop variables for this module
+		i, p,
+
+		// create dojo, dijit, and dojox
+		// FIXME: in 2.0 remove dijit, dojox being created by dojo
+		dijit = {},
+		dojox = {},
+		dojo = {
+			// notice dojo takes ownership of the value of the config module
+			config:config,
+			global:this,
+			dijit:dijit,
+			dojox:dojox
+		};
+
+
+	// Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide
+	// a _scopeName property for the dojo, dijit, and dojox root object so those packages can create
+	// unique names in the global space.
+	//
+	// Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox,
+	// where global when in fact they are either global under different names or not global at all. In v1.6-, the
+	// config variable "scopeMap" was used to map names as used within a module to global names. This has been
+	// subsumed by the dojo packageMap configuration variable which relocates packages to different names. See
+	// http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details.
+	//
+	// The following computations contort the packageMap for this dojo instance into a scopeMap.
+	var scopeMap =
+			// a map from a name used in a legacy module to the (global variable name, object addressed by that name)
+			// always map dojo, dijit, and dojox
+			{
+				dojo:["dojo", dojo],
+				dijit:["dijit", dijit],
+				dojox:["dojox", dojox]
+			},
+
+		packageMap =
+			// the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config
+			(require.packs && require.packs[module.id.match(/[^\/]+/)[0]].packageMap) || {},
+
+		item;
+
+	// process all mapped top-level names for this instance of dojo
+	for(p in packageMap){
+		if(scopeMap[p]){
+			// mapped dojo, dijit, or dojox
+			scopeMap[p][0] = packageMap[p];
+		}else{
+			// some other top-level name
+			scopeMap[p] = [packageMap[p], {}];
+		}
+	}
+
+	// publish those names to _scopeName and, optionally, the global namespace
+	for(p in scopeMap){
+		item = scopeMap[p];
+		item[1]._scopeName = item[0];
+		if(!config.noGlobals){
+			this[item[0]] = item[1];
+		}
+	}
+	dojo.scopeMap = scopeMap;
+
+	// FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated
+	dojo.baseUrl = dojo.config.baseUrl = require.baseUrl;
+	dojo.isAsync = !1 || require.async;
+	dojo.locale = config.locale;
+
+	/*=====
+		dojo.version = function(){
+			// summary:
+			//		Version number of the Dojo Toolkit
+			// major: Integer
+			//		Major version. If total version is "1.2.0beta1", will be 1
+			// minor: Integer
+			//		Minor version. If total version is "1.2.0beta1", will be 2
+			// patch: Integer
+			//		Patch version. If total version is "1.2.0beta1", will be 0
+			// flag: String
+			//		Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
+			// revision: Number
+			//		The SVN rev from which dojo was pulled
+			this.major = 0;
+			this.minor = 0;
+			this.patch = 0;
+			this.flag = "";
+			this.revision = 0;
+		}
+	=====*/
+	var rev = "$Rev: 27913 $".match(/\d+/);
+	dojo.version = {
+		major: 1, minor: 7, patch: 2, flag: "",
+		revision: rev ? +rev[0] : NaN,
+		toString: function(){
+			var v = dojo.version;
+			return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")";	// String
+		}
+	};
+
+
+	// If 1 is truthy, then as a dojo module is defined it should push it's definitions
+	// into the dojo object, and conversely. In 2.0, it will likely be unusual to augment another object
+	// as a result of defining a module. This has feature gives a way to force 2.0 behavior as the code
+	// is migrated. Absent specific advice otherwise, set extend-dojo to truthy.
+	true || has.add("extend-dojo", 1);
+
+
+	dojo.eval = function(scriptText){
+		//	summary:
+		//		A legacy method created for use exclusively by internal Dojo methods. Do not use this method
+		//		directly unless you understand its possibly-different implications on the platforms your are targeting.
+		//	description:
+		//		Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers
+		//		that support indirect eval.
+		//
+		//		As usual, IE does not. On IE, the only way to implement global eval is to
+		//		use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval.
+		//		This implementation uses the technique of executing eval in the scope of a function that is a single scope
+		//		frame below the global scope; thereby coming close to the global scope. Note carefully that
+		//
+		//		dojo.eval("var pi = 3.14;");
+		//
+		//		will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want
+		//		to define a global variable using dojo.eval, write something like
+		//
+		//		dojo.eval("window.pi = 3.14;")
+		//	scriptText:
+		//		The text to evaluation.
+		//	returns:
+		//		The result of the evaluation. Often `undefined`
+	};
+
+	(Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
+
+
+	if(0){
+		dojo.exit = function(exitcode){
+			quit(exitcode);
+		};
+	} else{
+		dojo.exit = function(){
+		};
+	}
+
+	true || has.add("dojo-guarantee-console",
+		// ensure that console.log, console.warn, etc. are defined
+		1
+	);
+	if(1){
+		typeof console != "undefined" || (console = {});
+		//	Be careful to leave 'log' always at the end
+		var cn = [
+			"assert", "count", "debug", "dir", "dirxml", "error", "group",
+			"groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
+			"trace", "warn", "log"
+		];
+		var tn;
+		i = 0;
+		while((tn = cn[i++])){
+			if(!console[tn]){
+				(function(){
+					var tcn = tn + "";
+					console[tcn] = ('log' in console) ? function(){
+						var a = Array.apply({}, arguments);
+						a.unshift(tcn + ":");
+						console["log"](a.join(" "));
+					} : function(){};
+					console[tcn]._fake = true;
+				})();
+			}
+		}
+	}
+
+	has.add("dojo-debug-messages",
+		// include dojo.deprecated/dojo.experimental implementations
+		!!config.isDebug
+	);
+	if(has("dojo-debug-messages")){
+		dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
+			//	summary:
+			//		Log a debug message to indicate that a behavior has been
+			//		deprecated.
+			//	behaviour: String
+			//		The API or behavior being deprecated. Usually in the form
+			//		of "myApp.someFunction()".
+			//	extra: String?
+			//		Text to append to the message. Often provides advice on a
+			//		new function or facility to achieve the same goal during
+			//		the deprecation period.
+			//	removal: String?
+			//		Text to indicate when in the future the behavior will be
+			//		removed. Usually a version number.
+			//	example:
+			//	| dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");
+
+			var message = "DEPRECATED: " + behaviour;
+			if(extra){ message += " " + extra; }
+			if(removal){ message += " -- will be removed in version: " + removal; }
+			console.warn(message);
+		};
+
+		dojo.experimental = function(/* String */ moduleName, /* String? */ extra){
+			//	summary: Marks code as experimental.
+			//	description:
+			//		This can be used to mark a function, file, or module as
+			//		experimental.	 Experimental code is not ready to be used, and the
+			//		APIs are subject to change without notice.	Experimental code may be
+			//		completed deleted without going through the normal deprecation
+			//		process.
+			//	moduleName: String
+			//		The name of a module, or the name of a module file or a specific
+			//		function
+			//	extra: String?
+			//		some additional message for the user
+			//	example:
+			//	| dojo.experimental("dojo.data.Result");
+			//	example:
+			//	| dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");
+
+			var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice.";
+			if(extra){ message += " " + extra; }
+			console.warn(message);
+		};
+	}else{
+		dojo.deprecated = dojo.experimental =  function(){};
+	}
+
+	true || has.add("dojo-modulePaths",
+		// consume dojo.modulePaths processing
+		1
+	);
+	if(1){
+		// notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run;
+		// this is the v1.6- behavior.
+		if(config.modulePaths){
+			dojo.deprecated("dojo.modulePaths", "use paths configuration");
+			var paths = {};
+			for(p in config.modulePaths){
+				paths[p.replace(/\./g, "/")] = config.modulePaths[p];
+			}
+			require({paths:paths});
+		}
+	}
+
+	true || has.add("dojo-moduleUrl",
+		// include dojo.moduleUrl
+		1
+	);
+	if(1){
+		dojo.moduleUrl = function(/*String*/module, /*String?*/url){
+			//	summary:
+			//		Returns a URL relative to a module.
+			//	example:
+			//	|	var pngPath = dojo.moduleUrl("acme","images/small.png");
+			//	|	console.dir(pngPath); // list the object properties
+			//	|	// create an image and set it's source to pngPath's value:
+			//	|	var img = document.createElement("img");
+			//	|	img.src = pngPath;
+			//	|	// add our image to the document
+			//	|	dojo.body().appendChild(img);
+			//	example:
+			//		you may de-reference as far as you like down the package
+			//		hierarchy.  This is sometimes handy to avoid lenghty relative
+			//		urls or for building portable sub-packages. In this example,
+			//		the `acme.widget` and `acme.util` directories may be located
+			//		under different roots (see `dojo.registerModulePath`) but the
+			//		the modules which reference them can be unaware of their
+			//		relative locations on the filesystem:
+			//	|	// somewhere in a configuration block
+			//	|	dojo.registerModulePath("acme.widget", "../../acme/widget");
+			//	|	dojo.registerModulePath("acme.util", "../../util");
+			//	|
+			//	|	// ...
+			//	|
+			//	|	// code in a module using acme resources
+			//	|	var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
+			//	|	var dataPath = dojo.moduleUrl("acme.util","resources/data.json");
+
+			dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0");
+
+			// require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then
+			// remove the suffix from the result. This way clients can request a url w/out a filetype. This should be
+			// rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0).
+			// Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config.
+			var result = null;
+			if(module){
+				result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/");
+			}
+			return result;
+		};
+	}
+
+	dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling
+
+	return dojo;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/lang.js b/js/dojo-1.7.2/dojo/_base/lang.js
new file mode 100644
index 0000000..1c9c6c0
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/lang.js
@@ -0,0 +1,708 @@
+//>>built
+define("dojo/_base/lang", ["./kernel", "../has", "./sniff"], function(dojo, has){
+	//	module:
+	//		dojo/_base/lang
+	//	summary:
+	//		This module defines Javascript language extensions.
+
+	has.add("bug-for-in-skips-shadowed", function(){
+		// if true, the for-in interator skips object properties that exist in Object's prototype (IE 6 - ?)
+		for(var i in {toString: 1}){
+			return 0;
+		}
+		return 1;
+	});
+
+	var _extraNames =
+			has("bug-for-in-skips-shadowed") ?
+				"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split(".") : [],
+
+		_extraLen = _extraNames.length,
+
+		_mixin = function(dest, source, copyFunc){
+			var name, s, i, empty = {};
+			for(name in source){
+				// the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source"
+				// inherited from Object.prototype.	 For example, if dest has a custom toString() method,
+				// don't overwrite it with the toString() method that source inherited from Object.prototype
+				s = source[name];
+				if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
+					dest[name] = copyFunc ? copyFunc(s) : s;
+				}
+			}
+
+			if(has("bug-for-in-skips-shadowed")){
+				if(source){
+					for(i = 0; i < _extraLen; ++i){
+						name = _extraNames[i];
+						s = source[name];
+						if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
+							dest[name] = copyFunc ? copyFunc(s) : s;
+						}
+					}
+				}
+			}
+
+			return dest; // Object
+		},
+
+		mixin = function(dest, sources){
+			if(!dest){ dest = {}; }
+			for(var i = 1, l = arguments.length; i < l; i++){
+				lang._mixin(dest, arguments[i]);
+			}
+			return dest; // Object
+		},
+
+		getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){
+			var p, i = 0, dojoGlobal = dojo.global;
+			if(!context){
+				if(!parts.length){
+					return dojoGlobal;
+				}else{
+					p = parts[i++];
+					try{
+						context = dojo.scopeMap[p] && dojo.scopeMap[p][1];
+					}catch(e){}
+					context = context || (p in dojoGlobal ? dojoGlobal[p] : (create ? dojoGlobal[p] = {} : undefined));
+				}
+			}
+			while(context && (p = parts[i++])){
+				context = (p in context ? context[p] : (create ? context[p] = {} : undefined));
+			}
+			return context; // mixed
+		},
+
+		setObject = function(name, value, context){
+			var parts = name.split("."), p = parts.pop(), obj = getProp(parts, true, context);
+			return obj && p ? (obj[p] = value) : undefined; // Object
+		},
+
+		getObject = function(name, create, context){
+			return getProp(name.split("."), create, context); // Object
+		},
+
+		exists = function(name, obj){
+			return lang.getObject(name, false, obj) !== undefined; // Boolean
+		},
+
+		opts = Object.prototype.toString,
+
+		// Crockford (ish) functions
+
+		isString = function(it){
+			return (typeof it == "string" || it instanceof String); // Boolean
+		},
+
+		isArray = function(it){
+			return it && (it instanceof Array || typeof it == "array"); // Boolean
+		},
+
+		isFunction = function(it){
+			return opts.call(it) === "[object Function]";
+		},
+
+		isObject = function(it){
+			return it !== undefined &&
+				(it === null || typeof it == "object" || lang.isArray(it) || lang.isFunction(it)); // Boolean
+		},
+
+		isArrayLike = function(it){
+			return it && it !== undefined && // Boolean
+				// keep out built-in constructors (Number, String, ...) which have length
+				// properties
+				!lang.isString(it) && !lang.isFunction(it) &&
+				!(it.tagName && it.tagName.toLowerCase() == 'form') &&
+				(lang.isArray(it) || isFinite(it.length));
+		},
+
+		isAlien = function(it){
+			return it && !lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
+		},
+
+		extend = function(constructor, props){
+			for(var i=1, l=arguments.length; i<l; i++){
+				lang._mixin(constructor.prototype, arguments[i]);
+			}
+			return constructor; // Object
+		},
+
+		_hitchArgs = function(scope, method){
+			var pre = _toArray(arguments, 2);
+			var named = lang.isString(method);
+			return function(){
+				// arrayify arguments
+				var args = _toArray(arguments);
+				// locate our method
+				var f = named ? (scope||dojo.global)[method] : method;
+				// invoke with collected args
+				return f && f.apply(scope || this, pre.concat(args)); // mixed
+			}; // Function
+		},
+
+		hitch = function(scope, method){
+			if(arguments.length > 2){
+				return lang._hitchArgs.apply(dojo, arguments); // Function
+			}
+			if(!method){
+				method = scope;
+				scope = null;
+			}
+			if(lang.isString(method)){
+				scope = scope || dojo.global;
+				if(!scope[method]){ throw(['dojo.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
+				return function(){ return scope[method].apply(scope, arguments || []); }; // Function
+			}
+			return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
+		},
+
+		delegate = (function(){
+			// boodman/crockford delegation w/ cornford optimization
+			function TMP(){}
+			return function(obj, props){
+				TMP.prototype = obj;
+				var tmp = new TMP();
+				TMP.prototype = null;
+				if(props){
+					lang._mixin(tmp, props);
+				}
+				return tmp; // Object
+			};
+		})(),
+
+		efficient = function(obj, offset, startWith){
+			return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
+		},
+
+		_toArray =
+			has("ie") ?
+				(function(){
+					function slow(obj, offset, startWith){
+						var arr = startWith||[];
+						for(var x = offset || 0; x < obj.length; x++){
+							arr.push(obj[x]);
+						}
+						return arr;
+					}
+					return function(obj){
+						return ((obj.item) ? slow : efficient).apply(this, arguments);
+					};
+				})() : efficient,
+
+		partial = function(/*Function|String*/method /*, ...*/){
+			var arr = [ null ];
+			return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function
+		},
+
+		clone = function(/*anything*/ src){
+			if(!src || typeof src != "object" || lang.isFunction(src)){
+				// null, undefined, any non-object, or function
+				return src;	// anything
+			}
+			if(src.nodeType && "cloneNode" in src){
+				// DOM Node
+				return src.cloneNode(true); // Node
+			}
+			if(src instanceof Date){
+				// Date
+				return new Date(src.getTime());	// Date
+			}
+			if(src instanceof RegExp){
+				// RegExp
+				return new RegExp(src);   // RegExp
+			}
+			var r, i, l;
+			if(lang.isArray(src)){
+				// array
+				r = [];
+				for(i = 0, l = src.length; i < l; ++i){
+					if(i in src){
+						r.push(clone(src[i]));
+					}
+				}
+	// we don't clone functions for performance reasons
+	//		}else if(d.isFunction(src)){
+	//			// function
+	//			r = function(){ return src.apply(this, arguments); };
+			}else{
+				// generic objects
+				r = src.constructor ? new src.constructor() : {};
+			}
+			return lang._mixin(r, src, clone);
+		},
+
+
+		trim = String.prototype.trim ?
+			function(str){ return str.trim(); } :
+			function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); },
+
+
+		_pattern = /\{([^\}]+)\}/g,
+
+		replace = function(tmpl, map, pattern){
+			return tmpl.replace(pattern || _pattern, lang.isFunction(map) ?
+				map : function(_, k){ return getObject(k, false, map); });
+		},
+
+		lang = {
+			_extraNames:_extraNames,
+			_mixin:_mixin,
+			mixin:mixin,
+			setObject:setObject,
+			getObject:getObject,
+			exists:exists,
+			isString:isString,
+			isArray:isArray,
+			isFunction:isFunction,
+			isObject:isObject,
+			isArrayLike:isArrayLike,
+			isAlien:isAlien,
+			extend:extend,
+			_hitchArgs:_hitchArgs,
+			hitch:hitch,
+			delegate:delegate,
+			_toArray:_toArray,
+			partial:partial,
+			clone:clone,
+			trim:trim,
+			replace:replace
+		};
+
+	1 && mixin(dojo, lang);
+	return lang;
+
+	/*=====
+	dojo._extraNames
+	// summary:
+	//		Array of strings. Lists property names that must be explicitly processed during for-in interation
+	//		in environments that have has("bug-for-in-skips-shadowed") true.
+	=====*/
+
+	/*=====
+	dojo._mixin = function(dest, source, copyFunc){
+		//	summary:
+		//		Copies/adds all properties of source to dest; returns dest.
+		//	dest: Object:
+		//		The object to which to copy/add all properties contained in source.
+		//	source: Object:
+		//		The object from which to draw all properties to copy into dest.
+		//	copyFunc: Function?:
+		//		The process used to copy/add a property in source; defaults to the Javascript assignment operator.
+		//	returns:
+		//		dest, as modified
+		//	description:
+		//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
+		//		found in Object.prototype, are copied/added to dest. Copying/adding each particular property is
+		//		delegated to copyFunc (if any); copyFunc defaults to the Javascript assignment operator if not provided.
+		//		Notice that by default, _mixin executes a so-called "shallow copy" and aggregate types are copied/added by reference.
+	}
+	=====*/
+
+	/*=====
+	dojo.mixin = function(dest, sources){
+	//	summary:
+	//		Copies/adds all properties of one or more sources to dest; returns dest.
+	//	dest: Object
+	//		The object to which to copy/add all properties contained in source. If dest is falsy, then
+	//		a new object is manufactured before copying/adding properties begins.
+	//	sources: Object...
+	//		One of more objects from which to draw all properties to copy into dest. sources are processed
+	//		left-to-right and if more than one of these objects contain the same property name, the right-most
+	//		value "wins".
+	//	returns: Object
+	//		dest, as modified
+	//	description:
+	//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
+	//		found in Object.prototype, are copied/added from sources to dest. sources are processed left to right.
+	//		The Javascript assignment operator is used to copy/add each property; therefore, by default, mixin
+	//		executes a so-called "shallow copy" and aggregate types are copied/added by reference.
+	//	example:
+	//		make a shallow copy of an object
+	//	| var copy = lang.mixin({}, source);
+	//	example:
+	//		many class constructors often take an object which specifies
+	//		values to be configured on the object. In this case, it is
+	//		often simplest to call `lang.mixin` on the `this` object:
+	//	| dojo.declare("acme.Base", null, {
+	//	|		constructor: function(properties){
+	//	|			// property configuration:
+	//	|			lang.mixin(this, properties);
+	//	|
+	//	|			console.log(this.quip);
+	//	|			//	...
+	//	|		},
+	//	|		quip: "I wasn't born yesterday, you know - I've seen movies.",
+	//	|		// ...
+	//	| });
+	//	|
+	//	| // create an instance of the class and configure it
+	//	| var b = new acme.Base({quip: "That's what it does!" });
+	//	example:
+	//		copy in properties from multiple objects
+	//	| var flattened = lang.mixin(
+	//	|		{
+	//	|			name: "Frylock",
+	//	|			braces: true
+	//	|		},
+	//	|		{
+	//	|			name: "Carl Brutanananadilewski"
+	//	|		}
+	//	| );
+	//	|
+	//	| // will print "Carl Brutanananadilewski"
+	//	| console.log(flattened.name);
+	//	| // will print "true"
+	//	| console.log(flattened.braces);
+	}
+	=====*/
+
+	/*=====
+	dojo.setObject = function(name, value, context){
+	// summary:
+	//		Set a property from a dot-separated string, such as "A.B.C"
+	//	description:
+	//		Useful for longer api chains where you have to test each object in
+	//		the chain, or when you have an object reference in string format.
+	//		Objects are created as needed along `path`. Returns the passed
+	//		value if setting is successful or `undefined` if not.
+	//	name: String
+	//		Path to a property, in the form "A.B.C".
+	//	value: anything
+	//		value or object to place at location given by name
+	//	context: Object?
+	//		Optional. Object to use as root of path. Defaults to
+	//		`dojo.global`.
+	//	example:
+	//		set the value of `foo.bar.baz`, regardless of whether
+	//		intermediate objects already exist:
+	//	| lang.setObject("foo.bar.baz", value);
+	//	example:
+	//		without `lang.setObject`, we often see code like this:
+	//	| // ensure that intermediate objects are available
+	//	| if(!obj["parent"]){ obj.parent = {}; }
+	//	| if(!obj.parent["child"]){ obj.parent.child = {}; }
+	//	| // now we can safely set the property
+	//	| obj.parent.child.prop = "some value";
+	//		whereas with `lang.setObject`, we can shorten that to:
+	//	| lang.setObject("parent.child.prop", "some value", obj);
+	}
+	=====*/
+
+	/*=====
+	dojo.getObject = function(name, create, context){
+	// summary:
+	//		Get a property from a dot-separated string, such as "A.B.C"
+	//	description:
+	//		Useful for longer api chains where you have to test each object in
+	//		the chain, or when you have an object reference in string format.
+	//	name: String
+	//		Path to an property, in the form "A.B.C".
+	//	create: Boolean?
+	//		Optional. Defaults to `false`. If `true`, Objects will be
+	//		created at any point along the 'path' that is undefined.
+	//	context: Object?
+	//		Optional. Object to use as root of path. Defaults to
+	//		'dojo.global'. Null may be passed.
+	}
+	=====*/
+
+	/*=====
+	dojo.exists = function(name, obj){
+	//	summary:
+	//		determine if an object supports a given method
+	//	description:
+	//		useful for longer api chains where you have to test each object in
+	//		the chain. Useful for object and method detection.
+	//	name: String
+	//		Path to an object, in the form "A.B.C".
+	//	obj: Object?
+	//		Object to use as root of path. Defaults to
+	//		'dojo.global'. Null may be passed.
+	//	example:
+	//	| // define an object
+	//	| var foo = {
+	//	|		bar: { }
+	//	| };
+	//	|
+	//	| // search the global scope
+	//	| lang.exists("foo.bar"); // true
+	//	| lang.exists("foo.bar.baz"); // false
+	//	|
+	//	| // search from a particular scope
+	//	| lang.exists("bar", foo); // true
+	//	| lang.exists("bar.baz", foo); // false
+	}
+	=====*/
+
+	/*=====
+	dojo.isString = function(it){
+	//	summary:
+	//		Return true if it is a String
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.isArray = function(it){
+	//	summary:
+	//		Return true if it is an Array.
+	//		Does not work on Arrays created in other windows.
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.isFunction = function(it){
+	// summary:
+	//		Return true if it is a Function
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.isObject = function(it){
+	// summary:
+	//		Returns true if it is a JavaScript object (or an Array, a Function
+	//		or null)
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.isArrayLike = function(it){
+	//	summary:
+	//		similar to dojo.isArray() but more permissive
+	//	it: anything
+	//		Item to test.
+	//	returns:
+	//		If it walks like a duck and quacks like a duck, return `true`
+	//	description:
+	//		Doesn't strongly test for "arrayness".  Instead, settles for "isn't
+	//		a string or number and has a length property". Arguments objects
+	//		and DOM collections will return true when passed to
+	//		dojo.isArrayLike(), but will return false when passed to
+	//		dojo.isArray().
+	}
+	=====*/
+
+	/*=====
+	dojo.isAlien = function(it){
+	// summary:
+	//		Returns true if it is a built-in function or some other kind of
+	//		oddball that *should* report as a function but doesn't
+	}
+	=====*/
+
+	/*=====
+	dojo.extend = function(constructor, props){
+	// summary:
+	//		Adds all properties and methods of props to constructor's
+	//		prototype, making them available to all instances created with
+	//		constructor.
+	//	constructor: Object
+	//		Target constructor to extend.
+	//	props: Object...
+	//		One or more objects to mix into constructor.prototype
+	}
+	=====*/
+
+	/*=====
+	dojo.hitch = function(scope, method){
+	//	summary:
+	//		Returns a function that will only ever execute in the a given scope.
+	//		This allows for easy use of object member functions
+	//		in callbacks and other places in which the "this" keyword may
+	//		otherwise not reference the expected scope.
+	//		Any number of default positional arguments may be passed as parameters
+	//		beyond "method".
+	//		Each of these values will be used to "placehold" (similar to curry)
+	//		for the hitched function.
+	//	scope: Object
+	//		The scope to use when method executes. If method is a string,
+	//		scope is also the object containing method.
+	//	method: Function|String...
+	//		A function to be hitched to scope, or the name of the method in
+	//		scope to be hitched.
+	//	example:
+	//	|	dojo.hitch(foo, "bar")();
+	//		runs foo.bar() in the scope of foo
+	//	example:
+	//	|	dojo.hitch(foo, myFunction);
+	//		returns a function that runs myFunction in the scope of foo
+	//	example:
+	//		Expansion on the default positional arguments passed along from
+	//		hitch. Passed args are mixed first, additional args after.
+	//	|	var foo = { bar: function(a, b, c){ console.log(a, b, c); } };
+	//	|	var fn = dojo.hitch(foo, "bar", 1, 2);
+	//	|	fn(3); // logs "1, 2, 3"
+	//	example:
+	//	|	var foo = { bar: 2 };
+	//	|	dojo.hitch(foo, function(){ this.bar = 10; })();
+	//		execute an anonymous function in scope of foo
+	}
+	=====*/
+
+	/*=====
+	dojo.delegate = function(obj, props){
+		//	summary:
+		//		Returns a new object which "looks" to obj for properties which it
+		//		does not have a value for. Optionally takes a bag of properties to
+		//		seed the returned object with initially.
+		//	description:
+		//		This is a small implementaton of the Boodman/Crockford delegation
+		//		pattern in JavaScript. An intermediate object constructor mediates
+		//		the prototype chain for the returned object, using it to delegate
+		//		down to obj for property lookup when object-local lookup fails.
+		//		This can be thought of similarly to ES4's "wrap", save that it does
+		//		not act on types but rather on pure objects.
+		//	obj: Object
+		//		The object to delegate to for properties not found directly on the
+		//		return object or in props.
+		//	props: Object...
+		//		an object containing properties to assign to the returned object
+		//	returns:
+		//		an Object of anonymous type
+		//	example:
+		//	|	var foo = { bar: "baz" };
+		//	|	var thinger = dojo.delegate(foo, { thud: "xyzzy"});
+		//	|	thinger.bar == "baz"; // delegated to foo
+		//	|	foo.thud == undefined; // by definition
+		//	|	thinger.thud == "xyzzy"; // mixed in from props
+		//	|	foo.bar = "thonk";
+		//	|	thinger.bar == "thonk"; // still delegated to foo's bar
+	}
+	=====*/
+
+	/*=====
+	dojo.partial = function(method){
+	//	summary:
+	//		similar to hitch() except that the scope object is left to be
+	//		whatever the execution context eventually becomes.
+	//	method: Function|String
+	//	description:
+	//		Calling dojo.partial is the functional equivalent of calling:
+	//		|	dojo.hitch(null, funcName, ...);
+	}
+	=====*/
+
+	/*=====
+	dojo.trim = function(str){
+		//	summary:
+		//		Trims whitespace from both sides of the string
+		//	str: String
+		//		String to be trimmed
+		//	returns: String
+		//		Returns the trimmed string
+		//	description:
+		//		This version of trim() was selected for inclusion into the base due
+		//		to its compact size and relatively good performance
+		//		(see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript)
+		//		Uses String.prototype.trim instead, if available.
+		//		The fastest but longest version of this function is located at
+		//		dojo.string.trim()
+	}
+	=====*/
+
+	/*=====
+	dojo.clone = function(src){
+	// summary:
+	//		Clones objects (including DOM nodes) and all children.
+	//		Warning: do not clone cyclic structures.
+	//	src:
+	//		The object to clone
+	}
+	=====*/
+
+	/*=====
+	dojo._toArray = function(obj, offset, startWith){
+		//	summary:
+		//		Converts an array-like object (i.e. arguments, DOMCollection) to an
+		//		array. Returns a new Array with the elements of obj.
+		//	obj: Object
+		//		the object to "arrayify". We expect the object to have, at a
+		//		minimum, a length property which corresponds to integer-indexed
+		//		properties.
+		//	offset: Number?
+		//		the location in obj to start iterating from. Defaults to 0.
+		//		Optional.
+		//	startWith: Array?
+		//		An array to pack with the properties of obj. If provided,
+		//		properties in obj are appended at the end of startWith and
+		//		startWith is the returned array.
+	}
+	=====*/
+
+	/*=====
+	dojo.replace = function(tmpl, map, pattern){
+		//	summary:
+		//		Performs parameterized substitutions on a string. Throws an
+		//		exception if any parameter is unmatched.
+		//	tmpl: String
+		//		String to be used as a template.
+		//	map: Object|Function
+		//		If an object, it is used as a dictionary to look up substitutions.
+		//		If a function, it is called for every substitution with following
+		//		parameters: a whole match, a name, an offset, and the whole template
+		//		string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace
+		//		for more details).
+		//	pattern: RegEx?
+		//		Optional regular expression objects that overrides the default pattern.
+		//		Must be global and match one item. The default is: /\{([^\}]+)\}/g,
+		//		which matches patterns like that: "{xxx}", where "xxx" is any sequence
+		//		of characters, which doesn't include "}".
+		//	returns: String
+		//		Returns the substituted string.
+		//	example:
+		//	|	// uses a dictionary for substitutions:
+		//	|	dojo.replace("Hello, {name.first} {name.last} AKA {nick}!",
+		//	|		{
+		//	|			nick: "Bob",
+		//	|			name: {
+		//	|				first:	"Robert",
+		//	|				middle: "X",
+		//	|				last:		"Cringely"
+		//	|			}
+		//	|		});
+		//	|	// returns: Hello, Robert Cringely AKA Bob!
+		//	example:
+		//	|	// uses an array for substitutions:
+		//	|	dojo.replace("Hello, {0} {2}!",
+		//	|		["Robert", "X", "Cringely"]);
+		//	|	// returns: Hello, Robert Cringely!
+		//	example:
+		//	|	// uses a function for substitutions:
+		//	|	function sum(a){
+		//	|		var t = 0;
+		//	|		dojo.forEach(a, function(x){ t += x; });
+		//	|		return t;
+		//	|	}
+		//	|	dojo.replace(
+		//	|		"{count} payments averaging {avg} USD per payment.",
+		//	|		dojo.hitch(
+		//	|			{ payments: [11, 16, 12] },
+		//	|			function(_, key){
+		//	|				switch(key){
+		//	|					case "count": return this.payments.length;
+		//	|					case "min":		return Math.min.apply(Math, this.payments);
+		//	|					case "max":		return Math.max.apply(Math, this.payments);
+		//	|					case "sum":		return sum(this.payments);
+		//	|					case "avg":		return sum(this.payments) / this.payments.length;
+		//	|				}
+		//	|			}
+		//	|		)
+		//	|	);
+		//	|	// prints: 3 payments averaging 13 USD per payment.
+		//	example:
+		//	|	// uses an alternative PHP-like pattern for substitutions:
+		//	|	dojo.replace("Hello, ${0} ${2}!",
+		//	|		["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
+		//	|	// returns: Hello, Robert Cringely!
+		return "";	// String
+	}
+	=====*/
+});
+
diff --git a/js/dojo-1.7.2/dojo/_base/loader.js b/js/dojo-1.7.2/dojo/_base/loader.js
new file mode 100644
index 0000000..5271bb9
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/loader.js
@@ -0,0 +1,672 @@
+//>>built
+define("dojo/_base/loader", ["./kernel", "../has", "require", "module", "./json", "./lang", "./array"], function(dojo, has, require, thisModule, json, lang, array) {
+	// module:
+	//		dojo/_base/lader
+	// summary:
+	//		This module defines the v1.x synchronous loader API.
+
+	// signal the loader in sync mode...
+	//>>pure-amd
+
+	if (!1){
+		console.error("cannot load the Dojo v1.x loader with a foreign loader");
+		return 0;
+	}
+
+	var makeErrorToken = function(id){
+			return {src:thisModule.id, id:id};
+		},
+
+		slashName = function(name){
+			return name.replace(/\./g, "/");
+		},
+
+		buildDetectRe = /\/\/>>built/,
+
+		dojoRequireCallbacks = [],
+		dojoRequireModuleStack = [],
+
+		dojoRequirePlugin = function(mid, require, loaded){
+			dojoRequireCallbacks.push(loaded);
+			array.forEach(mid.split(","), function(mid){
+				var module = getModule(mid, require.module);
+				dojoRequireModuleStack.push(module);
+				injectModule(module);
+			});
+			checkDojoRequirePlugin();
+		},
+
+		touched,
+
+		traverse = function(m){
+			if(touched[m.mid] || /loadInit\!/.test(m.mid)){
+				// loadInit plugin modules are dependencies of modules in dojoRequireModuleStack...
+				// which would cause a circular dependency chain that would never be resolved if checked here
+				// notice all dependencies of any particular loadInit plugin module will already
+				// be checked since those are pushed into dojoRequireModuleStack explicitly by the
+				// plugin...so if a particular loadInitPlugin module's dependencies are not really
+				// on board, that *will* be detected elsewhere in the traversal.
+				return true;
+			}
+		    touched[m.mid] = 1;
+			if(m.injected!==arrived && !m.executed){
+				return false;
+			}
+			for(var deps = m.deps || [], i= 0; i<deps.length; i++){
+				if(!traverse(deps[i])){
+					return false;
+				}
+			}
+			return true;
+		},
+
+		checkDojoRequirePlugin = function(){
+			touched = {};
+			dojoRequireModuleStack = array.filter(dojoRequireModuleStack, function(module){
+				return !traverse(module);
+			});
+			if(!dojoRequireModuleStack.length){
+				loaderVars.holdIdle();
+				var oldCallbacks = dojoRequireCallbacks;
+				dojoRequireCallbacks = [];
+				array.forEach(oldCallbacks, function(cb){cb(1);});
+				loaderVars.releaseIdle();
+			}
+		},
+
+		dojoLoadInitPlugin = function(mid, require, loaded){
+			// mid names a module that defines a "dojo load init" bundle, an object with two properties:
+			//
+			//   * names: a vector of module ids that give top-level names to define in the lexical scope of def
+			//   * def: a function that contains some some legacy loader API applications
+			//
+			// The point of def is to possibly cause some modules to be loaded (but not executed) by dojo/require! where the module
+			// ids are possibly-determined at runtime. For example, here is dojox.gfx from v1.6 expressed as an AMD module using the dojo/loadInit
+			// and dojo/require plugins.
+			//
+			// // dojox/gfx:
+			//
+			//   define("*loadInit_12, {
+			//     names:["dojo", "dijit", "dojox"],
+			//     def: function(){
+			//       dojo.loadInit(function(){
+			//         var gfx = lang.getObject("dojox.gfx", true);
+			//
+			//         //
+			//         // code required to set gfx properties ommitted...
+			//         //
+			//
+			//         // now use the calculations to include the runtime-dependent module
+			//         dojo.require("dojox.gfx." + gfx.renderer);
+			//       });
+			//	   }
+			//   });
+			//
+			//   define(["dojo", "dojo/loadInit!" + id].concat("dojo/require!dojox/gfx/matric,dojox/gfx/_base"), function(dojo){
+			//     // when this AMD factory function is executed, the following modules are guaranteed downloaded but not executed:
+			//     //   "dojox.gfx." + gfx.renderer
+			//     //   dojox.gfx.matrix
+			//     //   dojox.gfx._base
+			//     dojo.provide("dojo.gfx");
+			//     dojo.require("dojox.gfx.matrix");
+			//     dojo.require("dojox.gfx._base");
+			//     dojo.require("dojox.gfx." + gfx.renderer);
+			//     return lang.getObject("dojo.gfx");
+			//   });
+			//  })();
+			//
+			// The idea is to run the legacy loader API with global variables shadowed, which allows these variables to
+			// be relocated. For example, dojox and dojo could be relocated to different names by giving a packageMap and the code above will
+			// execute properly (because the plugin below resolves the load init bundle.names module with respect to the module that demanded
+			// the plugin resource).
+			//
+			// Note that the relocation is specified in the runtime configuration; relocated names need not be set at build-time.
+			//
+			// Warning: this is not the best way to express dojox.gfx as and AMD module. In fact, the module has been properly converted in
+			// v1.7. However, this technique allows the builder to convert legacy modules into AMD modules and guarantee the codepath is the
+			// same in the converted AMD module.
+			require([mid], function(bundle){
+				// notice how names is resolved with respect to the module that demanded the plugin resource
+				require(bundle.names, function(){
+					// bring the bundle names into scope
+					for(var scopeText = "", args= [], i = 0; i<arguments.length; i++){
+						scopeText+= "var " + bundle.names[i] + "= arguments[" + i + "]; ";
+						args.push(arguments[i]);
+					}
+					eval(scopeText);
+
+					var callingModule = require.module,
+						deps = [],
+						hold = {},
+						requireList = [],
+						p,
+						syncLoaderApi = {
+							provide:function(moduleName){
+								// mark modules that arrive consequent to multiple provides in this module as arrived since they can't be injected
+								moduleName = slashName(moduleName);
+								var providedModule = getModule(moduleName, callingModule);
+								if(providedModule!==callingModule){
+									setArrived(providedModule);
+								}
+							},
+							require:function(moduleName, omitModuleCheck){
+								moduleName = slashName(moduleName);
+								omitModuleCheck && (getModule(moduleName, callingModule).result = nonmodule);
+								requireList.push(moduleName);
+							},
+							requireLocalization:function(moduleName, bundleName, locale){
+								// since we're going to need dojo/i8n, add it to deps if not already there
+								deps.length || (deps = ["dojo/i18n"]);
+
+								// figure out if the bundle is xdomain; if so, add it to the depsSet
+								locale = (locale || dojo.locale).toLowerCase();
+								moduleName = slashName(moduleName) + "/nls/" + (/root/i.test(locale) ? "" : locale + "/") + slashName(bundleName);
+								if(getModule(moduleName, callingModule).isXd){
+									deps.push("dojo/i18n!" + moduleName);
+								}// else the bundle will be loaded synchronously when the module is evaluated
+							},
+							loadInit:function(f){
+								f();
+							}
+						};
+
+					// hijack the correct dojo and apply bundle.def
+					try{
+						for(p in syncLoaderApi){
+							hold[p] = dojo[p];
+							dojo[p] = syncLoaderApi[p];
+						}
+						bundle.def.apply(null, args);
+					}catch(e){
+						signal("error", [makeErrorToken("failedDojoLoadInit"), e]);
+					}finally{
+						for(p in syncLoaderApi){
+							dojo[p] = hold[p];
+						}
+					}
+
+					// requireList is the list of modules that need to be downloaded but not executed before the callingModule can be executed
+					requireList.length && deps.push("dojo/require!" + requireList.join(","));
+
+					dojoRequireCallbacks.push(loaded);
+					array.forEach(requireList, function(mid){
+						var module = getModule(mid, require.module);
+						dojoRequireModuleStack.push(module);
+						injectModule(module);
+					});
+					checkDojoRequirePlugin();
+				});
+			});
+		},
+
+		extractApplication = function(
+			text,             // the text to search
+			startSearch,      // the position in text to start looking for the closing paren
+			startApplication  // the position in text where the function application expression starts
+		){
+			// find end of the call by finding the matching end paren
+			// Warning: as usual, this will fail in the presense of unmatched right parans contained in strings, regexs, or unremoved comments
+			var parenRe = /\(|\)/g,
+				matchCount = 1,
+				match;
+			parenRe.lastIndex = startSearch;
+			while((match = parenRe.exec(text))){
+				if(match[0] == ")"){
+					matchCount -= 1;
+				}else{
+					matchCount += 1;
+				}
+				if(matchCount == 0){
+					break;
+				}
+			}
+
+			if(matchCount != 0){
+				throw "unmatched paren around character " + parenRe.lastIndex + " in: " + text;
+			}
+
+			//Put the master matching string in the results.
+			return [dojo.trim(text.substring(startApplication, parenRe.lastIndex))+";\n", parenRe.lastIndex];
+		},
+
+		// the following regex is taken from 1.6. It is a very poor technique to remove comments and
+		// will fail in some cases; for example, consider the code...
+		//
+		//    var message = "Category-1 */* Category-2";
+		//
+		// The regex that follows will see a /* comment and trash the code accordingly. In fact, there are all
+		// kinds of cases like this with strings and regexs that will cause this design to fail miserably.
+		//
+		// Alternative regex designs exist that will result in less-likely failures, but will still fail in many cases.
+		// The only solution guaranteed 100% correct is to parse the code and that seems overkill for this
+		// backcompat/unbuilt-xdomain layer. In the end, since it's been this way for a while, we won't change it.
+		// See the opening paragraphs of Chapter 7 or ECME-262 which describes the lexical abiguity further.
+		removeCommentRe = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,
+
+		syncLoaderApiRe = /(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg,
+
+		amdLoaderApiRe = /(^|\s)(require|define)\s*\(/m,
+
+		extractLegacyApiApplications = function(text, noCommentText){
+			// scan the noCommentText for any legacy loader API applications. Copy such applications into result (this is
+			// used by the builder). Move dojo.loadInit applications to loadInitApplications string. Copy all other applications
+			// to otherApplications string. If no applications were found, return 0, signalling an AMD module. Otherwise, return
+			// loadInitApplications + otherApplications. Fixup text by replacing
+			//
+			//   dojo.loadInit(// etc...
+			//
+			// with
+			//
+			//   \n 0 && dojo.loadInit(// etc...
+			//
+			// Which results in the dojo.loadInit from *not* being applied. This design goes a long way towards protecting the
+			// code from an over-agressive removeCommentRe. However...
+			//
+			// WARNING: the removeCommentRe will cause an error if a detected comment removes all or part of a legacy-loader application
+			// that is not in a comment.
+
+			var match, startSearch, startApplication, application,
+				loadInitApplications = [],
+				otherApplications = [],
+				allApplications = [];
+
+			// noCommentText may be provided by a build app with comments extracted by a better method than regex (hopefully)
+			noCommentText = noCommentText || text.replace(removeCommentRe, function(match){
+				// remove iff the detected comment has text that looks like a sync loader API application; this helps by
+				// removing as little as possible, minimizing the changes the janky regex will kill the module
+				syncLoaderApiRe.lastIndex = amdLoaderApiRe.lastIndex = 0;
+				return (syncLoaderApiRe.test(match) || amdLoaderApiRe.test(match)) ? "" : match;
+			});
+
+			// find and extract all dojo.loadInit applications
+			while((match = syncLoaderApiRe.exec(noCommentText))){
+				startSearch = syncLoaderApiRe.lastIndex;
+				startApplication = startSearch  - match[0].length;
+				application = extractApplication(noCommentText, startSearch, startApplication);
+				if(match[2]=="loadInit"){
+					loadInitApplications.push(application[0]);
+				}else{
+					otherApplications.push(application[0]);
+				}
+				syncLoaderApiRe.lastIndex = application[1];
+			}
+			allApplications = loadInitApplications.concat(otherApplications);
+			if(allApplications.length || !amdLoaderApiRe.test(noCommentText)){
+				// either there were some legacy loader API applications or there were no AMD API applications
+				return [text.replace(/(^|\s)dojo\.loadInit\s*\(/g, "\n0 && dojo.loadInit("), allApplications.join(""), allApplications];
+			}else{
+				// legacy loader API *was not* detected and AMD API *was* detected; therefore, assume it's an AMD module
+				return 0;
+			}
+		},
+
+		transformToAmd = function(module, text){
+			// This is roughly the equivalent of dojo._xdCreateResource in 1.6-; however, it expresses a v1.6- dojo
+			// module in terms of AMD define instead of creating the dojo proprietary xdomain module expression.
+			// The module could have originated from several sources:
+			//
+			//   * amd require() a module, e.g., require(["my/module"])
+			//   * amd require() a nonmodule, e.g., require(["my/resource.js"')
+			//   * amd define() deps vector (always a module)
+			//   * dojo.require() a module, e.g. dojo.require("my.module")
+			//   * dojo.require() a nonmodule, e.g., dojo.require("my.module", true)
+			//   * dojo.requireIf/requireAfterIf/platformRequire a module
+			//
+			// The module is scanned for legacy loader API applications; if none are found, then assume the module is an
+			// AMD module and return 0. Otherwise, a synthetic dojo/loadInit plugin resource is created and the module text
+			// is rewritten as an AMD module with the single dependency of this synthetic resource. When the dojo/loadInit
+			// plugin loaded the synthetic resource, it will cause all dojo.loadInit's to be executed, find all dojo.require's
+			// (either directly consequent to dojo.require or indirectly consequent to dojo.require[After]If or
+			// dojo.platformRequire, and finally cause loading of all dojo.required modules with the dojo/require plugin. Thus,
+			// when the dojo/loadInit plugin reports it has been loaded, all modules required by the given module are guaranteed
+			// loaded (but not executed). This then allows the module to execute it's code path without interupts, thereby
+			// following the synchronous code path.
+
+			var extractResult, id, names = [], namesAsStrings = [];
+			if(buildDetectRe.test(text) || !(extractResult = extractLegacyApiApplications(text))){
+				// buildDetectRe.test(text) => a built module, always AMD
+				// extractResult==0 => no sync API
+				return 0;
+			}
+
+			// manufacture a synthetic module id that can never be a real mdule id (just like require does)
+			id = module.mid + "-*loadInit";
+
+			// construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name
+			// the dojo/loadInit plugin assumes the first name in names is "dojo"
+
+			for(var p in getModule("dojo", module).result.scopeMap){
+				names.push(p);
+				namesAsStrings.push('"' + p + '"');
+			}
+
+			// rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource
+			return "// xdomain rewrite of " + module.path + "\n" +
+				"define('" + id + "',{\n" +
+				"\tnames:" + dojo.toJson(names) + ",\n" +
+				"\tdef:function(" + names.join(",") + "){" + extractResult[1] + "}" +
+				"});\n\n" +
+			    "define(" + dojo.toJson(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});";
+		},
+
+		loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd),
+
+		sync =
+			loaderVars.sync,
+
+		xd =
+			loaderVars.xd,
+
+		arrived =
+			loaderVars.arrived,
+
+		nonmodule =
+			loaderVars.nonmodule,
+
+		executing =
+			loaderVars.executing,
+
+		executed =
+			loaderVars.executed,
+
+		syncExecStack =
+			loaderVars.syncExecStack,
+
+		modules =
+			loaderVars.modules,
+
+		execQ =
+			loaderVars.execQ,
+
+		getModule =
+			loaderVars.getModule,
+
+		injectModule =
+			loaderVars.injectModule,
+
+		setArrived =
+			loaderVars.setArrived,
+
+		signal =
+			loaderVars.signal,
+
+		finishExec =
+			loaderVars.finishExec,
+
+		execModule =
+			loaderVars.execModule,
+
+		getLegacyMode =
+			loaderVars.getLegacyMode;
+
+	dojo.provide = function(mid){
+		var executingModule = syncExecStack[0],
+			module = lang.mixin(getModule(slashName(mid), require.module), {
+				executed:executing,
+				result:lang.getObject(mid, true)
+			});
+		setArrived(module);
+		if(executingModule){
+			(executingModule.provides || (executingModule.provides = [])).push(function(){
+				module.result = lang.getObject(mid);
+				delete module.provides;
+				module.executed!==executed && finishExec(module);
+			});
+		}// else dojo.provide called not consequent to loading; therefore, give up trying to publish module value to loader namespace
+		return module.result;
+	};
+
+	has.add("config-publishRequireResult", 1, 0, 0);
+
+	dojo.require = function(moduleName, omitModuleCheck) {
+		//	summary:
+		//		loads a Javascript module from the appropriate URI
+		//
+		//	moduleName: String
+		//		module name to load, using periods for separators,
+		//		 e.g. "dojo.date.locale".  Module paths are de-referenced by dojo's
+		//		internal mapping of locations to names and are disambiguated by
+		//		longest prefix. See `dojo.registerModulePath()` for details on
+		//		registering new modules.
+		//
+		//	omitModuleCheck: Boolean?
+		//		if `true`, omitModuleCheck skips the step of ensuring that the
+		//		loaded file actually defines the symbol it is referenced by.
+		//		For example if it called as `dojo.require("a.b.c")` and the
+		//		file located at `a/b/c.js` does not define an object `a.b.c`,
+		//		and exception will be throws whereas no exception is raised
+		//		when called as `dojo.require("a.b.c", true)`
+		//
+		//	description:
+		// 		Modules are loaded via dojo.require by using one of two loaders: the normal loader
+		// 		and the xdomain loader. The xdomain loader is used when dojo was built with a
+		// 		custom build that specified loader=xdomain and the module lives on a modulePath
+		// 		that is a whole URL, with protocol and a domain. The versions of Dojo that are on
+		// 		the Google and AOL CDNs use the xdomain loader.
+		//
+		// 		If the module is loaded via the xdomain loader, it is an asynchronous load, since
+		// 		the module is added via a dynamically created script tag. This
+		// 		means that dojo.require() can return before the module has loaded. However, this
+		// 		should only happen in the case where you do dojo.require calls in the top-level
+		// 		HTML page, or if you purposely avoid the loader checking for dojo.require
+		// 		dependencies in your module by using a syntax like dojo["require"] to load the module.
+		//
+		// 		Sometimes it is useful to not have the loader detect the dojo.require calls in the
+		// 		module so that you can dynamically load the modules as a result of an action on the
+		// 		page, instead of right at module load time.
+		//
+		// 		Also, for script blocks in an HTML page, the loader does not pre-process them, so
+		// 		it does not know to download the modules before the dojo.require calls occur.
+		//
+		// 		So, in those two cases, when you want on-the-fly module loading or for script blocks
+		// 		in the HTML page, special care must be taken if the dojo.required code is loaded
+		// 		asynchronously. To make sure you can execute code that depends on the dojo.required
+		// 		modules, be sure to add the code that depends on the modules in a dojo.addOnLoad()
+		// 		callback. dojo.addOnLoad waits for all outstanding modules to finish loading before
+		// 		executing.
+		//
+		// 		This type of syntax works with both xdomain and normal loaders, so it is good
+		// 		practice to always use this idiom for on-the-fly code loading and in HTML script
+		// 		blocks. If at some point you change loaders and where the code is loaded from,
+		// 		it will all still work.
+		//
+		// 		More on how dojo.require
+		//		`dojo.require("A.B")` first checks to see if symbol A.B is
+		//		defined. If it is, it is simply returned (nothing to do).
+		//
+		//		If it is not defined, it will look for `A/B.js` in the script root
+		//		directory.
+		//
+		//		`dojo.require` throws an exception if it cannot find a file
+		//		to load, or if the symbol `A.B` is not defined after loading.
+		//
+		//		It returns the object `A.B`, but note the caveats above about on-the-fly loading and
+		// 		HTML script blocks when the xdomain loader is loading a module.
+		//
+		//		`dojo.require()` does nothing about importing symbols into
+		//		the current namespace.  It is presumed that the caller will
+		//		take care of that.
+		//
+		// 	example:
+		// 		To use dojo.require in conjunction with dojo.ready:
+		//
+		//		|	dojo.require("foo");
+		//		|	dojo.require("bar");
+		//	   	|	dojo.addOnLoad(function(){
+		//	   	|		//you can now safely do something with foo and bar
+		//	   	|	});
+		//
+		//	example:
+		//		For example, to import all symbols into a local block, you might write:
+		//
+		//		|	with (dojo.require("A.B")) {
+		//		|		...
+		//		|	}
+		//
+		//		And to import just the leaf symbol to a local variable:
+		//
+		//		|	var B = dojo.require("A.B");
+		//	   	|	...
+		//
+		//	returns:
+		//		the required namespace object
+		function doRequire(mid, omitModuleCheck){
+			var module = getModule(slashName(mid), require.module);
+			if(syncExecStack.length && syncExecStack[0].finish){
+				// switched to async loading in the middle of evaluating a legacy module; stop
+				// applying dojo.require so the remaining dojo.requires are applied in order
+				syncExecStack[0].finish.push(mid);
+				return undefined;
+			}
+
+			// recall module.executed has values {0, executing, executed}; therefore, truthy indicates executing or executed
+			if(module.executed){
+				return module.result;
+			}
+			omitModuleCheck && (module.result = nonmodule);
+
+			var currentMode = getLegacyMode();
+
+			// recall, in sync mode to inject is to *eval* the module text
+			// if the module is a legacy module, this is the same as executing
+			// but if the module is an AMD module, this means defining, not executing
+			injectModule(module);
+			// the inject may have changed the mode
+			currentMode = getLegacyMode();
+
+			// in sync mode to dojo.require is to execute
+			if(module.executed!==executed && module.injected===arrived){
+				// the module was already here before injectModule was called probably finishing up a xdomain
+				// load, but maybe a module given to the loader directly rather than having the loader retrieve it
+				loaderVars.holdIdle();
+				execModule(module);
+				loaderVars.releaseIdle();
+			}
+			if(module.executed){
+				return module.result;
+			}
+
+			if(currentMode==sync){
+				// the only way to get here is in sync mode and dojo.required a module that
+				//   * was loaded async in the injectModule application a few lines up
+				//   * was an AMD module that had deps that are being loaded async and therefore couldn't execute
+				if(module.cjs){
+					// the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top
+					execQ.unshift(module);
+				}else{
+					// the module was a legacy module
+					syncExecStack.length && (syncExecStack[0].finish= [mid]);
+				}
+			}else{
+				// the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting
+				// the module value synchronously; make sure it gets executed though
+				execQ.push(module);
+			}
+			return undefined;
+		}
+
+		var result = doRequire(moduleName, omitModuleCheck);
+		if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){
+			lang.setObject(moduleName, result);
+		}
+		return result;
+	};
+
+	dojo.loadInit = function(f) {
+		f();
+	};
+
+	dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){
+		//	summary:
+		//		Maps a module name to a path
+		//	description:
+		//		An unregistered module is given the default path of ../[module],
+		//		relative to Dojo root. For example, module acme is mapped to
+		//		../acme.  If you want to use a different module name, use
+		//		dojo.registerModulePath.
+		//	example:
+		//		If your dojo.js is located at this location in the web root:
+		//	|	/myapp/js/dojo/dojo/dojo.js
+		//		and your modules are located at:
+		//	|	/myapp/js/foo/bar.js
+		//	|	/myapp/js/foo/baz.js
+		//	|	/myapp/js/foo/thud/xyzzy.js
+		//		Your application can tell Dojo to locate the "foo" namespace by calling:
+		//	|	dojo.registerModulePath("foo", "../../foo");
+		//		At which point you can then use dojo.require() to load the
+		//		modules (assuming they provide() the same things which are
+		//		required). The full code might be:
+		//	|	<script type="text/javascript"
+		//	|		src="/myapp/js/dojo/dojo/dojo.js"></script>
+		//	|	<script type="text/javascript">
+		//	|		dojo.registerModulePath("foo", "../../foo");
+		//	|		dojo.require("foo.bar");
+		//	|		dojo.require("foo.baz");
+		//	|		dojo.require("foo.thud.xyzzy");
+		//	|	</script>
+
+		var paths = {};
+		paths[moduleName.replace(/\./g, "/")] = prefix;
+		require({paths:paths});
+	};
+
+	dojo.platformRequire = function(/*Object*/modMap){
+		//	summary:
+		//		require one or more modules based on which host environment
+		//		Dojo is currently operating in
+		//	description:
+		//		This method takes a "map" of arrays which one can use to
+		//		optionally load dojo modules. The map is indexed by the
+		//		possible dojo.name_ values, with two additional values:
+		//		"default" and "common". The items in the "default" array will
+		//		be loaded if none of the other items have been choosen based on
+		//		dojo.name_, set by your host environment. The items in the
+		//		"common" array will *always* be loaded, regardless of which
+		//		list is chosen.
+		//	example:
+ 		//		|	dojo.platformRequire({
+		//		|		browser: [
+		//		|			"foo.sample", // simple module
+		//		|			"foo.test",
+		//		|			["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
+		//		|		],
+		//		|		default: [ "foo.sample._base" ],
+		//		|		common: [ "important.module.common" ]
+		//		|	});
+
+		var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []),
+			temp;
+		while(result.length){
+			if(lang.isArray(temp = result.shift())){
+				dojo.require.apply(dojo, temp);
+			}else{
+				dojo.require(temp);
+			}
+		}
+	};
+
+	dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){
+		// summary:
+		//		If the condition is true then call `dojo.require()` for the specified
+		//		resource
+		//
+		// example:
+		//	|	dojo.requireIf(dojo.isBrowser, "my.special.Module");
+
+		if(condition){
+			dojo.require(moduleName, omitModuleCheck);
+		}
+	};
+
+	dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){
+		require(["../i18n"], function(i18n){
+			i18n.getLocalization(moduleName, bundleName, locale);
+		});
+	};
+
+	return {
+		extractLegacyApiApplications:extractLegacyApiApplications,
+		require:loaderVars.dojoRequirePlugin,
+		loadInit:dojoLoadInitPlugin
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/_base/query.js b/js/dojo-1.7.2/dojo/_base/query.js
new file mode 100644
index 0000000..c0f3010
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/query.js
@@ -0,0 +1,4 @@
+//>>built
+define("dojo/_base/query", ["./kernel", "../query", "./NodeList"], function(dojo){
+	return dojo.query;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/sniff.js b/js/dojo-1.7.2/dojo/_base/sniff.js
new file mode 100644
index 0000000..5e69291
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/sniff.js
@@ -0,0 +1,188 @@
+//>>built
+define("dojo/_base/sniff", ["./kernel", "../has"], function(dojo, has){
+	// module:
+	//		dojo/sniff
+	// summary:
+	//		This module populates the dojo browser version sniffing properties.
+
+	if(!1){
+		return has;
+	}
+
+	dojo.isBrowser = true,
+	dojo._name = "browser";
+
+	var hasAdd = has.add,
+		n = navigator,
+		dua = n.userAgent,
+		dav = n.appVersion,
+		tv = parseFloat(dav),
+		isOpera,
+		isAIR,
+		isKhtml,
+		isWebKit,
+		isChrome,
+		isMac,
+		isSafari,
+		isMozilla ,
+		isMoz,
+		isIE,
+		isFF,
+		isQuirks,
+		isIos,
+		isAndroid,
+		isWii;
+
+	/*=====
+	dojo.isBrowser = {
+		//	example:
+		//	| if(dojo.isBrowser){ ... }
+	};
+
+	dojo.isFF = {
+		//	example:
+		//	| if(dojo.isFF > 1){ ... }
+	};
+
+	dojo.isIE = {
+		// example:
+		//	| if(dojo.isIE > 6){
+		//	|		// we are IE7
+		//	| }
+	};
+
+	dojo.isSafari = {
+		//	example:
+		//	| if(dojo.isSafari){ ... }
+		//	example:
+		//		Detect iPhone:
+		//	| if(dojo.isSafari && navigator.userAgent.indexOf("iPhone") != -1){
+		//	|		// we are iPhone. Note, iPod touch reports "iPod" above and fails this test.
+		//	| }
+	};
+
+	dojo.mixin(dojo, {
+		// isBrowser: Boolean
+		//		True if the client is a web-browser
+		isBrowser: true,
+		//	isFF: Number | undefined
+		//		Version as a Number if client is FireFox. undefined otherwise. Corresponds to
+		//		major detected FireFox version (1.5, 2, 3, etc.)
+		isFF: 2,
+		//	isIE: Number | undefined
+		//		Version as a Number if client is MSIE(PC). undefined otherwise. Corresponds to
+		//		major detected IE version (6, 7, 8, etc.)
+		isIE: 6,
+		//	isKhtml: Number | undefined
+		//		Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major
+		//		detected version.
+		isKhtml: 0,
+		//	isWebKit: Number | undefined
+		//		Version as a Number if client is a WebKit-derived browser (Konqueror,
+		//		Safari, Chrome, etc.). undefined otherwise.
+		isWebKit: 0,
+		//	isMozilla: Number | undefined
+		//		Version as a Number if client is a Mozilla-based browser (Firefox,
+		//		SeaMonkey). undefined otherwise. Corresponds to major detected version.
+		isMozilla: 0,
+		//	isOpera: Number | undefined
+		//		Version as a Number if client is Opera. undefined otherwise. Corresponds to
+		//		major detected version.
+		isOpera: 0,
+		//	isSafari: Number | undefined
+		//		Version as a Number if client is Safari or iPhone. undefined otherwise.
+		isSafari: 0,
+		//	isChrome: Number | undefined
+		//		Version as a Number if client is Chrome browser. undefined otherwise.
+		isChrome: 0,
+		//	isMac: Boolean
+		//		True if the client runs on Mac
+		isMac: 0,
+		// isIos: Boolean
+		//		True if client is iPhone, iPod, or iPad
+		isIos: 0,
+		// isAndroid: Number | undefined
+		//		Version as a Number if client is android browser. undefined otherwise.
+		isAndroid: 0,
+		// isWii: Boolean
+		//		True if client is Wii
+		isWii: 0
+	});
+	=====*/
+
+	// fill in the rendering support information in dojo.render.*
+	if(dua.indexOf("AdobeAIR") >= 0){ isAIR = 1; }
+	isKhtml = (dav.indexOf("Konqueror") >= 0) ? tv : 0;
+	isWebKit = parseFloat(dua.split("WebKit/")[1]) || undefined;
+	isChrome = parseFloat(dua.split("Chrome/")[1]) || undefined;
+	isMac = dav.indexOf("Macintosh") >= 0;
+	isIos = /iPhone|iPod|iPad/.test(dua);
+	isAndroid = parseFloat(dua.split("Android ")[1]) || undefined;
+	isWii = typeof opera != "undefined" && opera.wiiremote;
+
+	// safari detection derived from:
+	//		http://developer.apple.com/internet/safari/faq.html#anchor2
+	//		http://developer.apple.com/internet/safari/uamatrix.html
+	var index = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0);
+	if(index && !isChrome){
+		// try to grab the explicit Safari version first. If we don't get
+		// one, look for less than 419.3 as the indication that we're on something
+		// "Safari 2-ish".
+		isSafari = parseFloat(dav.split("Version/")[1]);
+		if(!isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){
+			isSafari = 2;
+		}
+	}
+
+	if (!has("dojo-webkit")) {
+		if(dua.indexOf("Opera") >= 0){
+			isOpera = tv;
+			// see http://dev.opera.com/articles/view/opera-ua-string-changes and http://www.useragentstring.com/pages/Opera/
+			// 9.8 has both styles; <9.8, 9.9 only old style
+			if(isOpera >= 9.8){
+				isOpera = parseFloat(dua.split("Version/")[1]) || tv;
+			}
+		}
+
+		if(dua.indexOf("Gecko") >= 0 && !isKhtml && !isWebKit){
+			isMozilla = isMoz = tv;
+		}
+		if(isMoz){
+			//We really need to get away from this. Consider a sane isGecko approach for the future.
+			isFF = parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined;
+		}
+		if(document.all && !isOpera){
+			isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
+			//In cases where the page has an HTTP header or META tag with
+			//X-UA-Compatible, then it is in emulation mode.
+			//Make sure isIE reflects the desired version.
+			//document.documentMode of 5 means quirks mode.
+			//Only switch the value if documentMode's major version
+			//is different from isIE's major version.
+			var mode = document.documentMode;
+			if(mode && mode != 5 && Math.floor(isIE) != mode){
+				isIE = mode;
+			}
+		}
+	}
+
+	isQuirks = document.compatMode == "BackCompat";
+
+	hasAdd("opera", dojo.isOpera = isOpera);
+	hasAdd("air", dojo.isAIR = isAIR);
+	hasAdd("khtml", dojo.isKhtml = isKhtml);
+	hasAdd("webkit", dojo.isWebKit = isWebKit);
+	hasAdd("chrome", dojo.isChrome = isChrome);
+	hasAdd("mac", dojo.isMac = isMac );
+	hasAdd("safari", dojo.isSafari = isSafari);
+	hasAdd("mozilla", dojo.isMozilla = dojo.isMoz = isMozilla );
+	hasAdd("ie", dojo.isIE = isIE );
+	hasAdd("ff", dojo.isFF = isFF);
+	hasAdd("quirks", dojo.isQuirks = isQuirks);
+	hasAdd("ios", dojo.isIos = isIos);
+	hasAdd("android", dojo.isAndroid = isAndroid);
+
+	dojo.locale = dojo.locale || (isIE ? n.userLanguage : n.language).toLowerCase();
+
+	return has;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/unload.js b/js/dojo-1.7.2/dojo/_base/unload.js
new file mode 100644
index 0000000..a79df1d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/unload.js
@@ -0,0 +1,82 @@
+//>>built
+define("dojo/_base/unload", ["./kernel", "./connect"], function(dojo, connect) {
+	// module:
+	//		dojo/unload
+	// summary:
+	//		This module contains the document and window unload detection API.
+
+	var win = window;
+
+	/*=====
+		dojo.windowUnloaded = function(){
+			// summary:
+			//		signal fired by impending window destruction. You may use
+			//		dojo.addOnWindowUnload() to register a listener for this
+			//		event. NOTE: if you wish to dojo.connect() to this method
+			//		to perform page/application cleanup, be aware that this
+			//		event WILL NOT fire if no handler has been registered with
+			//		dojo.addOnWindowUnload. This behavior started in Dojo 1.3.
+			//		Previous versions always triggered dojo.windowUnloaded. See
+			//		dojo.addOnWindowUnload for more info.
+		};
+	=====*/
+
+	dojo.addOnWindowUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){
+		// summary:
+		//		registers a function to be triggered when window.onunload
+		//		fires.
+		//	description:
+		//		The first time that addOnWindowUnload is called Dojo
+		//		will register a page listener to trigger your unload
+		//		handler with. Note that registering these handlers may
+		//		destory "fastback" page caching in browsers that support
+		//		it. Be careful trying to modify the DOM or access
+		//		JavaScript properties during this phase of page unloading:
+		//		they may not always be available. Consider
+		//		dojo.addOnUnload() if you need to modify the DOM or do
+		//		heavy JavaScript work since it fires at the eqivalent of
+		//		the page's "onbeforeunload" event.
+		// example:
+		//	| dojo.addOnWindowUnload(functionPointer)
+		//	| dojo.addOnWindowUnload(object, "functionName");
+		//	| dojo.addOnWindowUnload(object, function(){ /* ... */});
+
+		if (!dojo.windowUnloaded) {
+			connect.connect(win, "unload", (dojo.windowUnloaded= function(){}));
+		}
+		connect.connect(win, "unload", obj, functionName);
+	};
+
+	dojo.addOnUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){
+		// summary:
+		//		registers a function to be triggered when the page unloads.
+		//	description:
+		//		The first time that addOnUnload is called Dojo will
+		//		register a page listener to trigger your unload handler
+		//		with.
+		//
+		//		In a browser enviroment, the functions will be triggered
+		//		during the window.onbeforeunload event. Be careful of doing
+		//		too much work in an unload handler. onbeforeunload can be
+		//		triggered if a link to download a file is clicked, or if
+		//		the link is a javascript: link. In these cases, the
+		//		onbeforeunload event fires, but the document is not
+		//		actually destroyed. So be careful about doing destructive
+		//		operations in a dojo.addOnUnload callback.
+		//
+		//		Further note that calling dojo.addOnUnload will prevent
+		//		browsers from using a "fast back" cache to make page
+		//		loading via back button instantaneous.
+		// example:
+		//	| dojo.addOnUnload(functionPointer)
+		//	| dojo.addOnUnload(object, "functionName")
+		//	| dojo.addOnUnload(object, function(){ /* ... */});
+
+		connect.connect(win, "beforeunload", obj, functionName);
+	};
+
+	return {
+		addOnWindowUnload: dojo.addOnWindowUnload,
+		addOnUnload: dojo.addOnUnload
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/_base/url.js b/js/dojo-1.7.2/dojo/_base/url.js
new file mode 100644
index 0000000..c3f619d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/url.js
@@ -0,0 +1,112 @@
+//>>built
+define("dojo/_base/url", ["./kernel"], function(dojo) {
+	// module:
+	//		dojo/url
+	// summary:
+	//		This module contains dojo._Url
+
+	var
+		ore = new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$"),
+		ire = new RegExp("^((([^\\[:]+):)?([^@]+)@)?(\\[([^\\]]+)\\]|([^\\[:]*))(:([0-9]+))?$"),
+		_Url = function(){
+			var n = null,
+				_a = arguments,
+				uri = [_a[0]];
+			// resolve uri components relative to each other
+			for(var i = 1; i<_a.length; i++){
+				if(!_a[i]){ continue; }
+
+				// Safari doesn't support this.constructor so we have to be explicit
+				// FIXME: Tracked (and fixed) in Webkit bug 3537.
+				//		http://bugs.webkit.org/show_bug.cgi?id=3537
+				var relobj = new _Url(_a[i]+""),
+					uriobj = new _Url(uri[0]+"");
+
+				if(
+					relobj.path == "" &&
+					!relobj.scheme &&
+					!relobj.authority &&
+					!relobj.query
+				){
+					if(relobj.fragment != n){
+						uriobj.fragment = relobj.fragment;
+					}
+					relobj = uriobj;
+				}else if(!relobj.scheme){
+					relobj.scheme = uriobj.scheme;
+
+					if(!relobj.authority){
+						relobj.authority = uriobj.authority;
+
+						if(relobj.path.charAt(0) != "/"){
+							var path = uriobj.path.substring(0,
+								uriobj.path.lastIndexOf("/") + 1) + relobj.path;
+
+							var segs = path.split("/");
+							for(var j = 0; j < segs.length; j++){
+								if(segs[j] == "."){
+									// flatten "./" references
+									if(j == segs.length - 1){
+										segs[j] = "";
+									}else{
+										segs.splice(j, 1);
+										j--;
+									}
+								}else if(j > 0 && !(j == 1 && segs[0] == "") &&
+									segs[j] == ".." && segs[j-1] != ".."){
+									// flatten "../" references
+									if(j == (segs.length - 1)){
+										segs.splice(j, 1);
+										segs[j - 1] = "";
+									}else{
+										segs.splice(j - 1, 2);
+										j -= 2;
+									}
+								}
+							}
+							relobj.path = segs.join("/");
+						}
+					}
+				}
+
+				uri = [];
+				if(relobj.scheme){
+					uri.push(relobj.scheme, ":");
+				}
+				if(relobj.authority){
+					uri.push("//", relobj.authority);
+				}
+				uri.push(relobj.path);
+				if(relobj.query){
+					uri.push("?", relobj.query);
+				}
+				if(relobj.fragment){
+					uri.push("#", relobj.fragment);
+				}
+			}
+
+			this.uri = uri.join("");
+
+			// break the uri into its main components
+			var r = this.uri.match(ore);
+
+			this.scheme = r[2] || (r[1] ? "" : n);
+			this.authority = r[4] || (r[3] ? "" : n);
+			this.path = r[5]; // can never be undefined
+			this.query = r[7] || (r[6] ? "" : n);
+			this.fragment	 = r[9] || (r[8] ? "" : n);
+
+			if(this.authority != n){
+				// server based naming authority
+				r = this.authority.match(ire);
+
+				this.user = r[3] || n;
+				this.password = r[4] || n;
+				this.host = r[6] || r[7]; // ipv6 || ipv4
+				this.port = r[9] || n;
+			}
+		};
+	_Url.prototype.toString = function(){ return this.uri; };
+
+	return dojo._Url = _Url;
+});
diff --git a/js/dojo-1.7.2/dojo/_base/window.js b/js/dojo-1.7.2/dojo/_base/window.js
new file mode 100644
index 0000000..5582414
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/window.js
@@ -0,0 +1,127 @@
+//>>built
+define("dojo/_base/window", ["./kernel", "../has", "./sniff"], function(dojo, has){
+	// module:
+	//		dojo/window
+	// summary:
+	//		This module provides an API to save/set/restore the global/document scope.
+
+/*=====
+dojo.doc = {
+	// summary:
+	//		Alias for the current document. 'dojo.doc' can be modified
+	//		for temporary context shifting. Also see dojo.withDoc().
+	// description:
+	//		Refer to dojo.doc rather
+	//		than referring to 'window.document' to ensure your code runs
+	//		correctly in managed contexts.
+	// example:
+	//	|	n.appendChild(dojo.doc.createElement('div'));
+}
+=====*/
+dojo.doc = this["document"] || null;
+
+dojo.body = function(){
+	// summary:
+	//		Return the body element of the document
+	//		return the body object associated with dojo.doc
+	// example:
+	//	|	dojo.body().appendChild(dojo.doc.createElement('div'));
+
+	// Note: document.body is not defined for a strict xhtml document
+	// Would like to memoize this, but dojo.doc can change vi dojo.withDoc().
+	return dojo.doc.body || dojo.doc.getElementsByTagName("body")[0]; // Node
+};
+
+dojo.setContext = function(/*Object*/globalObject, /*DocumentElement*/globalDocument){
+	// summary:
+	//		changes the behavior of many core Dojo functions that deal with
+	//		namespace and DOM lookup, changing them to work in a new global
+	//		context (e.g., an iframe). The varibles dojo.global and dojo.doc
+	//		are modified as a result of calling this function and the result of
+	//		`dojo.body()` likewise differs.
+	dojo.global = ret.global = globalObject;
+	dojo.doc = ret.doc = globalDocument;
+};
+
+dojo.withGlobal = function(	/*Object*/globalObject,
+							/*Function*/callback,
+							/*Object?*/thisObject,
+							/*Array?*/cbArguments){
+	// summary:
+	//		Invoke callback with globalObject as dojo.global and
+	//		globalObject.document as dojo.doc.
+	// description:
+	//		Invoke callback with globalObject as dojo.global and
+	//		globalObject.document as dojo.doc. If provided, globalObject
+	//		will be executed in the context of object thisObject
+	//		When callback() returns or throws an error, the dojo.global
+	//		and dojo.doc will be restored to its previous state.
+
+	var oldGlob = dojo.global;
+	try{
+		dojo.global = ret.global = globalObject;
+		return dojo.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments);
+	}finally{
+		dojo.global = ret.global = oldGlob;
+	}
+};
+
+dojo.withDoc = function(	/*DocumentElement*/documentObject,
+							/*Function*/callback,
+							/*Object?*/thisObject,
+							/*Array?*/cbArguments){
+	// summary:
+	//		Invoke callback with documentObject as dojo.doc.
+	// description:
+	//		Invoke callback with documentObject as dojo.doc. If provided,
+	//		callback will be executed in the context of object thisObject
+	//		When callback() returns or throws an error, the dojo.doc will
+	//		be restored to its previous state.
+
+	var oldDoc = dojo.doc,
+		oldQ = dojo.isQuirks,
+		oldIE = dojo.isIE, isIE, mode, pwin;
+
+	try{
+		dojo.doc = ret.doc = documentObject;
+		// update dojo.isQuirks and the value of the has feature "quirks"
+		dojo.isQuirks = has.add("quirks", dojo.doc.compatMode == "BackCompat", true, true); // no need to check for QuirksMode which was Opera 7 only
+
+		if(has("ie")){
+			if((pwin = documentObject.parentWindow) && pwin.navigator){
+				// re-run IE detection logic and update dojo.isIE / has("ie")
+				// (the only time parentWindow/navigator wouldn't exist is if we were not
+				// passed an actual legitimate document object)
+				isIE = parseFloat(pwin.navigator.appVersion.split("MSIE ")[1]) || undefined;
+				mode = documentObject.documentMode;
+				if(mode && mode != 5 && Math.floor(isIE) != mode){
+					isIE = mode;
+				}
+				dojo.isIE = has.add("ie", isIE, true, true);
+			}
+		}
+
+		if(thisObject && typeof callback == "string"){
+			callback = thisObject[callback];
+		}
+
+		return callback.apply(thisObject, cbArguments || []);
+	}finally{
+		dojo.doc = ret.doc = oldDoc;
+		dojo.isQuirks = has.add("quirks", oldQ, true, true);
+		dojo.isIE = has.add("ie", oldIE, true, true);
+	}
+};
+
+var ret = {
+	global: dojo.global,
+	doc: dojo.doc,
+	body: dojo.body,
+	setContext: dojo.setContext,
+	withGlobal: dojo.withGlobal,
+	withDoc: dojo.withDoc
+};
+
+return ret;
+
+});
diff --git a/js/dojo-1.7.2/dojo/_base/xhr.js b/js/dojo-1.7.2/dojo/_base/xhr.js
new file mode 100644
index 0000000..793b916
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_base/xhr.js
@@ -0,0 +1,831 @@
+//>>built
+define("dojo/_base/xhr", [
+	"./kernel", "./sniff", "require", "../io-query", "../dom", "../dom-form", "./Deferred", "./json", "./lang", "./array", "../on"
+], function(dojo, has, require, ioq, dom, domForm, deferred, json, lang, array, on){
+	//	module:
+	//		dojo/_base.xhr
+	// summary:
+	//		This modules defines the dojo.xhr* API.
+
+	has.add("native-xhr", function() {
+		// if true, the environment has a native XHR implementation
+		return typeof XMLHttpRequest !== 'undefined';
+	});
+
+	if(1){
+		dojo._xhrObj = require.getXhr;
+	}else if (has("native-xhr")){
+		dojo._xhrObj = function(){
+			// summary:
+			//		does the work of portably generating a new XMLHTTPRequest object.
+			try{
+				return new XMLHttpRequest();
+			}catch(e){
+				throw new Error("XMLHTTP not available: "+e);
+			}
+		};
+	}else{
+		// PROGIDs are in order of decreasing likelihood; this will change in time.
+		for(var XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'], progid, i = 0; i < 3;){
+			try{
+				progid = XMLHTTP_PROGIDS[i++];
+				if (new ActiveXObject(progid)) {
+					// this progid works; therefore, use it from now on
+					break;
+				}
+			}catch(e){
+				// squelch; we're just trying to find a good ActiveX PROGID
+				// if they all fail, then progid ends up as the last attempt and that will signal the error
+				// the first time the client actually tries to exec an xhr
+			}
+		}
+		dojo._xhrObj= function() {
+			return new ActiveXObject(progid);
+		};
+	}
+
+	var cfg = dojo.config;
+
+	// mix in io-query and dom-form
+	dojo.objectToQuery = ioq.objectToQuery;
+	dojo.queryToObject = ioq.queryToObject;
+	dojo.fieldToObject = domForm.fieldToObject;
+	dojo.formToObject = domForm.toObject;
+	dojo.formToQuery = domForm.toQuery;
+	dojo.formToJson = domForm.toJson;
+
+	// need to block async callbacks from snatching this thread as the result
+	// of an async callback might call another sync XHR, this hangs khtml forever
+	// must checked by watchInFlight()
+
+	dojo._blockAsync = false;
+
+	// MOW: remove dojo._contentHandlers alias in 2.0
+	var handlers = dojo._contentHandlers = dojo.contentHandlers = {
+		// summary:
+		//		A map of availble XHR transport handle types. Name matches the
+		//		`handleAs` attribute passed to XHR calls.
+		//
+		// description:
+		//		A map of availble XHR transport handle types. Name matches the
+		//		`handleAs` attribute passed to XHR calls. Each contentHandler is
+		//		called, passing the xhr object for manipulation. The return value
+		//		from the contentHandler will be passed to the `load` or `handle`
+		//		functions defined in the original xhr call.
+		//
+		// example:
+		//		Creating a custom content-handler:
+		//	|	dojo.contentHandlers.makeCaps = function(xhr){
+		//	|		return xhr.responseText.toUpperCase();
+		//	|	}
+		//	|	// and later:
+		//	|	dojo.xhrGet({
+		//	|		url:"foo.txt",
+		//	|		handleAs:"makeCaps",
+		//	|		load: function(data){ /* data is a toUpper version of foo.txt */ }
+		//	|	});
+
+		"text": function(xhr){
+			// summary: A contentHandler which simply returns the plaintext response data
+			return xhr.responseText;
+		},
+		"json": function(xhr){
+			// summary: A contentHandler which returns a JavaScript object created from the response data
+			return json.fromJson(xhr.responseText || null);
+		},
+		"json-comment-filtered": function(xhr){
+			// summary: A contentHandler which expects comment-filtered JSON.
+			// description:
+			//		A contentHandler which expects comment-filtered JSON.
+			//		the json-comment-filtered option was implemented to prevent
+			//		"JavaScript Hijacking", but it is less secure than standard JSON. Use
+			//		standard JSON instead. JSON prefixing can be used to subvert hijacking.
+			//
+			//		Will throw a notice suggesting to use application/json mimetype, as
+			//		json-commenting can introduce security issues. To decrease the chances of hijacking,
+			//		use the standard `json` contentHandler, and prefix your "JSON" with: {}&&
+			//
+			//		use djConfig.useCommentedJson = true to turn off the notice
+			if(!dojo.config.useCommentedJson){
+				console.warn("Consider using the standard mimetype:application/json."
+					+ " json-commenting can introduce security issues. To"
+					+ " decrease the chances of hijacking, use the standard the 'json' handler and"
+					+ " prefix your json with: {}&&\n"
+					+ "Use djConfig.useCommentedJson=true to turn off this message.");
+			}
+
+			var value = xhr.responseText;
+			var cStartIdx = value.indexOf("\/*");
+			var cEndIdx = value.lastIndexOf("*\/");
+			if(cStartIdx == -1 || cEndIdx == -1){
+				throw new Error("JSON was not comment filtered");
+			}
+			return json.fromJson(value.substring(cStartIdx+2, cEndIdx));
+		},
+		"javascript": function(xhr){
+			// summary: A contentHandler which evaluates the response data, expecting it to be valid JavaScript
+
+			// FIXME: try Moz and IE specific eval variants?
+			return dojo.eval(xhr.responseText);
+		},
+		"xml": function(xhr){
+			// summary: A contentHandler returning an XML Document parsed from the response data
+			var result = xhr.responseXML;
+
+			if(has("ie")){
+				if((!result || !result.documentElement)){
+					//WARNING: this branch used by the xml handling in dojo.io.iframe,
+					//so be sure to test dojo.io.iframe if making changes below.
+					var ms = function(n){ return "MSXML" + n + ".DOMDocument"; };
+					var dp = ["Microsoft.XMLDOM", ms(6), ms(4), ms(3), ms(2)];
+					array.some(dp, function(p){
+						try{
+							var dom = new ActiveXObject(p);
+							dom.async = false;
+							dom.loadXML(xhr.responseText);
+							result = dom;
+						}catch(e){ return false; }
+						return true;
+					});
+				}
+		 }
+			return result; // DOMDocument
+		},
+		"json-comment-optional": function(xhr){
+			// summary: A contentHandler which checks the presence of comment-filtered JSON and
+			//		alternates between the `json` and `json-comment-filtered` contentHandlers.
+			if(xhr.responseText && /^[^{\[]*\/\*/.test(xhr.responseText)){
+				return handlers["json-comment-filtered"](xhr);
+			}else{
+				return handlers["json"](xhr);
+			}
+		}
+	};
+
+	/*=====
+	dojo.__IoArgs = function(){
+		//	url: String
+		//		URL to server endpoint.
+		//	content: Object?
+		//		Contains properties with string values. These
+		//		properties will be serialized as name1=value2 and
+		//		passed in the request.
+		//	timeout: Integer?
+		//		Milliseconds to wait for the response. If this time
+		//		passes, the then error callbacks are called.
+		//	form: DOMNode?
+		//		DOM node for a form. Used to extract the form values
+		//		and send to the server.
+		//	preventCache: Boolean?
+		//		Default is false. If true, then a
+		//		"dojo.preventCache" parameter is sent in the request
+		//		with a value that changes with each request
+		//		(timestamp). Useful only with GET-type requests.
+		//	handleAs: String?
+		//		Acceptable values depend on the type of IO
+		//		transport (see specific IO calls for more information).
+		//	rawBody: String?
+		//		Sets the raw body for an HTTP request. If this is used, then the content
+		//		property is ignored. This is mostly useful for HTTP methods that have
+		//		a body to their requests, like PUT or POST. This property can be used instead
+		//		of postData and putData for dojo.rawXhrPost and dojo.rawXhrPut respectively.
+		//	ioPublish: Boolean?
+		//		Set this explicitly to false to prevent publishing of topics related to
+		//		IO operations. Otherwise, if djConfig.ioPublish is set to true, topics
+		//		will be published via dojo.publish for different phases of an IO operation.
+		//		See dojo.__IoPublish for a list of topics that are published.
+		//	load: Function?
+		//		This function will be
+		//		called on a successful HTTP response code.
+		//	error: Function?
+		//		This function will
+		//		be called when the request fails due to a network or server error, the url
+		//		is invalid, etc. It will also be called if the load or handle callback throws an
+		//		exception, unless djConfig.debugAtAllCosts is true.	 This allows deployed applications
+		//		to continue to run even when a logic error happens in the callback, while making
+		//		it easier to troubleshoot while in debug mode.
+		//	handle: Function?
+		//		This function will
+		//		be called at the end of every request, whether or not an error occurs.
+		this.url = url;
+		this.content = content;
+		this.timeout = timeout;
+		this.form = form;
+		this.preventCache = preventCache;
+		this.handleAs = handleAs;
+		this.ioPublish = ioPublish;
+		this.load = function(response, ioArgs){
+			// ioArgs: dojo.__IoCallbackArgs
+			//		Provides additional information about the request.
+			// response: Object
+			//		The response in the format as defined with handleAs.
+		}
+		this.error = function(response, ioArgs){
+			// ioArgs: dojo.__IoCallbackArgs
+			//		Provides additional information about the request.
+			// response: Object
+			//		The response in the format as defined with handleAs.
+		}
+		this.handle = function(loadOrError, response, ioArgs){
+			// loadOrError: String
+			//		Provides a string that tells you whether this function
+			//		was called because of success (load) or failure (error).
+			// response: Object
+			//		The response in the format as defined with handleAs.
+			// ioArgs: dojo.__IoCallbackArgs
+			//		Provides additional information about the request.
+		}
+	}
+	=====*/
+
+	/*=====
+	dojo.__IoCallbackArgs = function(args, xhr, url, query, handleAs, id, canDelete, json){
+		//	args: Object
+		//		the original object argument to the IO call.
+		//	xhr: XMLHttpRequest
+		//		For XMLHttpRequest calls only, the
+		//		XMLHttpRequest object that was used for the
+		//		request.
+		//	url: String
+		//		The final URL used for the call. Many times it
+		//		will be different than the original args.url
+		//		value.
+		//	query: String
+		//		For non-GET requests, the
+		//		name1=value1&name2=value2 parameters sent up in
+		//		the request.
+		//	handleAs: String
+		//		The final indicator on how the response will be
+		//		handled.
+		//	id: String
+		//		For dojo.io.script calls only, the internal
+		//		script ID used for the request.
+		//	canDelete: Boolean
+		//		For dojo.io.script calls only, indicates
+		//		whether the script tag that represents the
+		//		request can be deleted after callbacks have
+		//		been called. Used internally to know when
+		//		cleanup can happen on JSONP-type requests.
+		//	json: Object
+		//		For dojo.io.script calls only: holds the JSON
+		//		response for JSONP-type requests. Used
+		//		internally to hold on to the JSON responses.
+		//		You should not need to access it directly --
+		//		the same object should be passed to the success
+		//		callbacks directly.
+		this.args = args;
+		this.xhr = xhr;
+		this.url = url;
+		this.query = query;
+		this.handleAs = handleAs;
+		this.id = id;
+		this.canDelete = canDelete;
+		this.json = json;
+	}
+	=====*/
+
+
+	/*=====
+	dojo.__IoPublish = function(){
+		//	summary:
+		//		This is a list of IO topics that can be published
+		//		if djConfig.ioPublish is set to true. IO topics can be
+		//		published for any Input/Output, network operation. So,
+		//		dojo.xhr, dojo.io.script and dojo.io.iframe can all
+		//		trigger these topics to be published.
+		//	start: String
+		//		"/dojo/io/start" is sent when there are no outstanding IO
+		//		requests, and a new IO request is started. No arguments
+		//		are passed with this topic.
+		//	send: String
+		//		"/dojo/io/send" is sent whenever a new IO request is started.
+		//		It passes the dojo.Deferred for the request with the topic.
+		//	load: String
+		//		"/dojo/io/load" is sent whenever an IO request has loaded
+		//		successfully. It passes the response and the dojo.Deferred
+		//		for the request with the topic.
+		//	error: String
+		//		"/dojo/io/error" is sent whenever an IO request has errored.
+		//		It passes the error and the dojo.Deferred
+		//		for the request with the topic.
+		//	done: String
+		//		"/dojo/io/done" is sent whenever an IO request has completed,
+		//		either by loading or by erroring. It passes the error and
+		//		the dojo.Deferred for the request with the topic.
+		//	stop: String
+		//		"/dojo/io/stop" is sent when all outstanding IO requests have
+		//		finished. No arguments are passed with this topic.
+		this.start = "/dojo/io/start";
+		this.send = "/dojo/io/send";
+		this.load = "/dojo/io/load";
+		this.error = "/dojo/io/error";
+		this.done = "/dojo/io/done";
+		this.stop = "/dojo/io/stop";
+	}
+	=====*/
+
+
+	dojo._ioSetArgs = function(/*dojo.__IoArgs*/args,
+			/*Function*/canceller,
+			/*Function*/okHandler,
+			/*Function*/errHandler){
+		//	summary:
+		//		sets up the Deferred and ioArgs property on the Deferred so it
+		//		can be used in an io call.
+		//	args:
+		//		The args object passed into the public io call. Recognized properties on
+		//		the args object are:
+		//	canceller:
+		//		The canceller function used for the Deferred object. The function
+		//		will receive one argument, the Deferred object that is related to the
+		//		canceller.
+		//	okHandler:
+		//		The first OK callback to be registered with Deferred. It has the opportunity
+		//		to transform the OK response. It will receive one argument -- the Deferred
+		//		object returned from this function.
+		//	errHandler:
+		//		The first error callback to be registered with Deferred. It has the opportunity
+		//		to do cleanup on an error. It will receive two arguments: error (the
+		//		Error object) and dfd, the Deferred object returned from this function.
+
+		var ioArgs = {args: args, url: args.url};
+
+		//Get values from form if requestd.
+		var formObject = null;
+		if(args.form){
+			var form = dom.byId(args.form);
+			//IE requires going through getAttributeNode instead of just getAttribute in some form cases,
+			//so use it for all. See #2844
+			var actnNode = form.getAttributeNode("action");
+			ioArgs.url = ioArgs.url || (actnNode ? actnNode.value : null);
+			formObject = domForm.toObject(form);
+		}
+
+		// set up the query params
+		var miArgs = [{}];
+
+		if(formObject){
+			// potentially over-ride url-provided params w/ form values
+			miArgs.push(formObject);
+		}
+		if(args.content){
+			// stuff in content over-rides what's set by form
+			miArgs.push(args.content);
+		}
+		if(args.preventCache){
+			miArgs.push({"dojo.preventCache": new Date().valueOf()});
+		}
+		ioArgs.query = ioq.objectToQuery(lang.mixin.apply(null, miArgs));
+
+		// .. and the real work of getting the deferred in order, etc.
+		ioArgs.handleAs = args.handleAs || "text";
+		var d = new deferred(canceller);
+		d.addCallbacks(okHandler, function(error){
+			return errHandler(error, d);
+		});
+
+		//Support specifying load, error and handle callback functions from the args.
+		//For those callbacks, the "this" object will be the args object.
+		//The callbacks will get the deferred result value as the
+		//first argument and the ioArgs object as the second argument.
+		var ld = args.load;
+		if(ld && lang.isFunction(ld)){
+			d.addCallback(function(value){
+				return ld.call(args, value, ioArgs);
+			});
+		}
+		var err = args.error;
+		if(err && lang.isFunction(err)){
+			d.addErrback(function(value){
+				return err.call(args, value, ioArgs);
+			});
+		}
+		var handle = args.handle;
+		if(handle && lang.isFunction(handle)){
+			d.addBoth(function(value){
+				return handle.call(args, value, ioArgs);
+			});
+		}
+
+		//Plug in topic publishing, if dojo.publish is loaded.
+		if(cfg.ioPublish && dojo.publish && ioArgs.args.ioPublish !== false){
+			d.addCallbacks(
+				function(res){
+					dojo.publish("/dojo/io/load", [d, res]);
+					return res;
+				},
+				function(res){
+					dojo.publish("/dojo/io/error", [d, res]);
+					return res;
+				}
+			);
+			d.addBoth(function(res){
+				dojo.publish("/dojo/io/done", [d, res]);
+				return res;
+			});
+		}
+
+		d.ioArgs = ioArgs;
+
+		// FIXME: need to wire up the xhr object's abort method to something
+		// analagous in the Deferred
+		return d;
+	};
+
+	var _deferredCancel = function(/*Deferred*/dfd){
+		// summary: canceller function for dojo._ioSetArgs call.
+
+		dfd.canceled = true;
+		var xhr = dfd.ioArgs.xhr;
+		var _at = typeof xhr.abort;
+		if(_at == "function" || _at == "object" || _at == "unknown"){
+			xhr.abort();
+		}
+		var err = dfd.ioArgs.error;
+		if(!err){
+			err = new Error("xhr cancelled");
+			err.dojoType="cancel";
+		}
+		return err;
+	};
+	var _deferredOk = function(/*Deferred*/dfd){
+		// summary: okHandler function for dojo._ioSetArgs call.
+
+		var ret = handlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);
+		return ret === undefined ? null : ret;
+	};
+	var _deferError = function(/*Error*/error, /*Deferred*/dfd){
+		// summary: errHandler function for dojo._ioSetArgs call.
+
+		if(!dfd.ioArgs.args.failOk){
+			console.error(error);
+		}
+		return error;
+	};
+
+	// avoid setting a timer per request. It degrades performance on IE
+	// something fierece if we don't use unified loops.
+	var _inFlightIntvl = null;
+	var _inFlight = [];
+
+
+	//Use a separate count for knowing if we are starting/stopping io calls.
+	//Cannot use _inFlight.length since it can change at a different time than
+	//when we want to do this kind of test. We only want to decrement the count
+	//after a callback/errback has finished, since the callback/errback should be
+	//considered as part of finishing a request.
+	var _pubCount = 0;
+	var _checkPubCount = function(dfd){
+		if(_pubCount <= 0){
+			_pubCount = 0;
+			if(cfg.ioPublish && dojo.publish && (!dfd || dfd && dfd.ioArgs.args.ioPublish !== false)){
+				dojo.publish("/dojo/io/stop");
+			}
+		}
+	};
+
+	var _watchInFlight = function(){
+		//summary:
+		//		internal method that checks each inflight XMLHttpRequest to see
+		//		if it has completed or if the timeout situation applies.
+
+		var now = (new Date()).getTime();
+		// make sure sync calls stay thread safe, if this callback is called
+		// during a sync call and this results in another sync call before the
+		// first sync call ends the browser hangs
+		if(!dojo._blockAsync){
+			// we need manual loop because we often modify _inFlight (and therefore 'i') while iterating
+			// note: the second clause is an assigment on purpose, lint may complain
+			for(var i = 0, tif; i < _inFlight.length && (tif = _inFlight[i]); i++){
+				var dfd = tif.dfd;
+				var func = function(){
+					if(!dfd || dfd.canceled || !tif.validCheck(dfd)){
+						_inFlight.splice(i--, 1);
+						_pubCount -= 1;
+					}else if(tif.ioCheck(dfd)){
+						_inFlight.splice(i--, 1);
+						tif.resHandle(dfd);
+						_pubCount -= 1;
+					}else if(dfd.startTime){
+						//did we timeout?
+						if(dfd.startTime + (dfd.ioArgs.args.timeout || 0) < now){
+							_inFlight.splice(i--, 1);
+							var err = new Error("timeout exceeded");
+							err.dojoType = "timeout";
+							dfd.errback(err);
+							//Cancel the request so the io module can do appropriate cleanup.
+							dfd.cancel();
+							_pubCount -= 1;
+						}
+					}
+				};
+				if(dojo.config.debugAtAllCosts){
+					func.call(this);
+				}else{
+//					try{
+						func.call(this);
+	/*				}catch(e){
+						dfd.errback(e);
+					}*/
+				}
+			}
+		}
+
+		_checkPubCount(dfd);
+
+		if(!_inFlight.length){
+			clearInterval(_inFlightIntvl);
+			_inFlightIntvl = null;
+		}
+	};
+
+	dojo._ioCancelAll = function(){
+		//summary: Cancels all pending IO requests, regardless of IO type
+		//(xhr, script, iframe).
+		try{
+			array.forEach(_inFlight, function(i){
+				try{
+					i.dfd.cancel();
+				}catch(e){/*squelch*/}
+			});
+		}catch(e){/*squelch*/}
+	};
+
+	//Automatically call cancel all io calls on unload
+	//in IE for trac issue #2357.
+	if(has("ie")){
+		on(window, "unload", dojo._ioCancelAll);
+	}
+
+	dojo._ioNotifyStart = function(/*Deferred*/dfd){
+		// summary:
+		//		If dojo.publish is available, publish topics
+		//		about the start of a request queue and/or the
+		//		the beginning of request.
+		// description:
+		//		Used by IO transports. An IO transport should
+		//		call this method before making the network connection.
+		if(cfg.ioPublish && dojo.publish && dfd.ioArgs.args.ioPublish !== false){
+			if(!_pubCount){
+				dojo.publish("/dojo/io/start");
+			}
+			_pubCount += 1;
+			dojo.publish("/dojo/io/send", [dfd]);
+		}
+	};
+
+	dojo._ioWatch = function(dfd, validCheck, ioCheck, resHandle){
+		// summary:
+		//		Watches the io request represented by dfd to see if it completes.
+		// dfd: Deferred
+		//		The Deferred object to watch.
+		// validCheck: Function
+		//		Function used to check if the IO request is still valid. Gets the dfd
+		//		object as its only argument.
+		// ioCheck: Function
+		//		Function used to check if basic IO call worked. Gets the dfd
+		//		object as its only argument.
+		// resHandle: Function
+		//		Function used to process response. Gets the dfd
+		//		object as its only argument.
+		var args = dfd.ioArgs.args;
+		if(args.timeout){
+			dfd.startTime = (new Date()).getTime();
+		}
+
+		_inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle});
+		if(!_inFlightIntvl){
+			_inFlightIntvl = setInterval(_watchInFlight, 50);
+		}
+		// handle sync requests
+		//A weakness: async calls in flight
+		//could have their handlers called as part of the
+		//_watchInFlight call, before the sync's callbacks
+		// are called.
+		if(args.sync){
+			_watchInFlight();
+		}
+	};
+
+	var _defaultContentType = "application/x-www-form-urlencoded";
+
+	var _validCheck = function(/*Deferred*/dfd){
+		return dfd.ioArgs.xhr.readyState; //boolean
+	};
+	var _ioCheck = function(/*Deferred*/dfd){
+		return 4 == dfd.ioArgs.xhr.readyState; //boolean
+	};
+	var _resHandle = function(/*Deferred*/dfd){
+		var xhr = dfd.ioArgs.xhr;
+		if(dojo._isDocumentOk(xhr)){
+			dfd.callback(dfd);
+		}else{
+			var err = new Error("Unable to load " + dfd.ioArgs.url + " status:" + xhr.status);
+			err.status = xhr.status;
+			err.responseText = xhr.responseText;
+			err.xhr = xhr;
+			dfd.errback(err);
+		}
+	};
+
+	dojo._ioAddQueryToUrl = function(/*dojo.__IoCallbackArgs*/ioArgs){
+		//summary: Adds query params discovered by the io deferred construction to the URL.
+		//Only use this for operations which are fundamentally GET-type operations.
+		if(ioArgs.query.length){
+			ioArgs.url += (ioArgs.url.indexOf("?") == -1 ? "?" : "&") + ioArgs.query;
+			ioArgs.query = null;
+		}
+	};
+
+	/*=====
+	dojo.declare("dojo.__XhrArgs", dojo.__IoArgs, {
+		constructor: function(){
+			//	summary:
+			//		In addition to the properties listed for the dojo._IoArgs type,
+			//		the following properties are allowed for dojo.xhr* methods.
+			//	handleAs: String?
+			//		Acceptable values are: text (default), json, json-comment-optional,
+			//		json-comment-filtered, javascript, xml. See `dojo.contentHandlers`
+			//	sync: Boolean?
+			//		false is default. Indicates whether the request should
+			//		be a synchronous (blocking) request.
+			//	headers: Object?
+			//		Additional HTTP headers to send in the request.
+			//	failOk: Boolean?
+			//		false is default. Indicates whether a request should be
+			//		allowed to fail (and therefore no console error message in
+			//		the event of a failure)
+			//	contentType: String|Boolean
+			//		"application/x-www-form-urlencoded" is default. Set to false to
+			//		prevent a Content-Type header from being sent, or to a string
+			//		to send a different Content-Type.
+			this.handleAs = handleAs;
+			this.sync = sync;
+			this.headers = headers;
+			this.failOk = failOk;
+		}
+	});
+	=====*/
+
+	dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){
+		//	summary:
+		//		Sends an HTTP request with the given method.
+		//	description:
+		//		Sends an HTTP request with the given method.
+		//		See also dojo.xhrGet(), xhrPost(), xhrPut() and dojo.xhrDelete() for shortcuts
+		//		for those HTTP methods. There are also methods for "raw" PUT and POST methods
+		//		via dojo.rawXhrPut() and dojo.rawXhrPost() respectively.
+		//	method:
+		//		HTTP method to be used, such as GET, POST, PUT, DELETE. Should be uppercase.
+		//	hasBody:
+		//		If the request has an HTTP body, then pass true for hasBody.
+
+		//Make the Deferred object for this xhr request.
+		var dfd = dojo._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError);
+		var ioArgs = dfd.ioArgs;
+
+		//Pass the args to _xhrObj, to allow alternate XHR calls based specific calls, like
+		//the one used for iframe proxies.
+		var xhr = ioArgs.xhr = dojo._xhrObj(ioArgs.args);
+		//If XHR factory fails, cancel the deferred.
+		if(!xhr){
+			dfd.cancel();
+			return dfd;
+		}
+
+		//Allow for specifying the HTTP body completely.
+		if("postData" in args){
+			ioArgs.query = args.postData;
+		}else if("putData" in args){
+			ioArgs.query = args.putData;
+		}else if("rawBody" in args){
+			ioArgs.query = args.rawBody;
+		}else if((arguments.length > 2 && !hasBody) || "POST|PUT".indexOf(method.toUpperCase()) == -1){
+			//Check for hasBody being passed. If no hasBody,
+			//then only append query string if not a POST or PUT request.
+			dojo._ioAddQueryToUrl(ioArgs);
+		}
+
+		// IE 6 is a steaming pile. It won't let you call apply() on the native function (xhr.open).
+		// workaround for IE6's apply() "issues"
+		xhr.open(method, ioArgs.url, args.sync !== true, args.user || undefined, args.password || undefined);
+		if(args.headers){
+			for(var hdr in args.headers){
+				if(hdr.toLowerCase() === "content-type" && !args.contentType){
+					args.contentType = args.headers[hdr];
+				}else if(args.headers[hdr]){
+					//Only add header if it has a value. This allows for instnace, skipping
+					//insertion of X-Requested-With by specifying empty value.
+					xhr.setRequestHeader(hdr, args.headers[hdr]);
+				}
+			}
+		}
+		// FIXME: is this appropriate for all content types?
+		if(args.contentType !== false){
+			xhr.setRequestHeader("Content-Type", args.contentType || _defaultContentType);
+		}
+		if(!args.headers || !("X-Requested-With" in args.headers)){
+			xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+		}
+		// FIXME: set other headers here!
+		dojo._ioNotifyStart(dfd);
+		if(dojo.config.debugAtAllCosts){
+			xhr.send(ioArgs.query);
+		}else{
+			try{
+				xhr.send(ioArgs.query);
+			}catch(e){
+				ioArgs.error = e;
+				dfd.cancel();
+			}
+		}
+		dojo._ioWatch(dfd, _validCheck, _ioCheck, _resHandle);
+		xhr = null;
+		return dfd; // dojo.Deferred
+	};
+
+	dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP GET request to the server.
+		return dojo.xhr("GET", args); // dojo.Deferred
+	};
+
+	dojo.rawXhrPost = dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP POST request to the server. In addtion to the properties
+		//		listed for the dojo.__XhrArgs type, the following property is allowed:
+		//	postData:
+		//		String. Send raw data in the body of the POST request.
+		return dojo.xhr("POST", args, true); // dojo.Deferred
+	};
+
+	dojo.rawXhrPut = dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP PUT request to the server. In addtion to the properties
+		//		listed for the dojo.__XhrArgs type, the following property is allowed:
+		//	putData:
+		//		String. Send raw data in the body of the PUT request.
+		return dojo.xhr("PUT", args, true); // dojo.Deferred
+	};
+
+	dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP DELETE request to the server.
+		return dojo.xhr("DELETE", args); //dojo.Deferred
+	};
+
+	/*
+	dojo.wrapForm = function(formNode){
+		//summary:
+		//		A replacement for FormBind, but not implemented yet.
+
+		// FIXME: need to think harder about what extensions to this we might
+		// want. What should we allow folks to do w/ this? What events to
+		// set/send?
+		throw new Error("dojo.wrapForm not yet implemented");
+	}
+	*/
+
+	dojo._isDocumentOk = function(http){
+		var stat = http.status || 0;
+		stat =
+			(stat >= 200 && stat < 300) || // allow any 2XX response code
+			stat == 304 ||                 // or, get it out of the cache
+			stat == 1223 ||                // or, Internet Explorer mangled the status code
+			!stat;                         // or, we're Titanium/browser chrome/chrome extension requesting a local file
+		return stat; // Boolean
+	};
+
+	dojo._getText = function(url){
+		var result;
+		dojo.xhrGet({url:url, sync:true, load:function(text){
+			result = text;
+		}});
+		return result;
+	};
+
+	// Add aliases for static functions to dojo.xhr since dojo.xhr is what's returned from this module
+	lang.mixin(dojo.xhr, {
+		_xhrObj: dojo._xhrObj,
+		fieldToObject: domForm.fieldToObject,
+		formToObject: domForm.toObject,
+		objectToQuery: ioq.objectToQuery,
+		formToQuery: domForm.toQuery,
+		formToJson: domForm.toJson,
+		queryToObject: ioq.queryToObject,
+		contentHandlers: handlers,
+		_ioSetArgs: dojo._ioSetArgs,
+		_ioCancelAll: dojo._ioCancelAll,
+		_ioNotifyStart: dojo._ioNotifyStart,
+		_ioWatch: dojo._ioWatch,
+		_ioAddQueryToUrl: dojo._ioAddQueryToUrl,
+		_isDocumentOk: dojo._isDocumentOk,
+		_getText: dojo._getText,
+		get: dojo.xhrGet,
+		post: dojo.xhrPost,
+		put: dojo.xhrPut,
+		del: dojo.xhrDelete	// because "delete" is a reserved word
+	});
+
+	return dojo.xhr;
+});
diff --git a/js/dojo-1.7.2/dojo/_firebug/LICENSE b/js/dojo-1.7.2/dojo/_firebug/LICENSE
new file mode 100644
index 0000000..8c777a2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_firebug/LICENSE
@@ -0,0 +1,37 @@
+License Disclaimer:
+
+All contents of this directory are Copyright (c) the Dojo Foundation, with the
+following exceptions:
+-------------------------------------------------------------------------------
+
+firebug.html, firebug.js, errIcon.png, infoIcon.png, warningIcon.png:
+	* Copyright (c) 2006-2007, Joe Hewitt, All rights reserved.
+	  Distributed under the terms of the BSD License (see below)
+
+-------------------------------------------------------------------------------
+
+Copyright (c) 2006-2007, Joe Hewitt
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+	list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+	this list of conditions and the following disclaimer in the documentation
+	and/or other materials provided with the distribution.
+  * Neither the name of the Dojo Foundation nor the names of its contributors
+	may be used to endorse or promote products derived from this software
+	without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/js/dojo-1.7.2/dojo/_firebug/errorIcon.png b/js/dojo-1.7.2/dojo/_firebug/errorIcon.png
new file mode 100644
index 0000000..2d75261
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_firebug/errorIcon.png
diff --git a/js/dojo-1.7.2/dojo/_firebug/firebug.css b/js/dojo-1.7.2/dojo/_firebug/firebug.css
new file mode 100644
index 0000000..2012e06
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_firebug/firebug.css
@@ -0,0 +1,211 @@
+.firebug {
+	margin: 0;
+	background:#fff;
+	font-family: Lucida Grande, Tahoma, sans-serif;
+	font-size: 11px;
+	overflow: hidden;
+	border: 1px solid black;
+	position: relative;
+}
+.firebug a {
+	text-decoration: none;
+}
+.firebug a:hover {
+	text-decoration: underline;
+}
+.firebug a:visited{
+	color:#0000FF;
+}
+.firebug #firebugToolbar {
+	height: 18px;
+	line-height:18px;
+	border-top: 1px solid ThreeDHighlight;
+	border-bottom: 1px solid ThreeDShadow;
+	padding: 2px 6px;
+	
+	background:#f0f0f0;
+}
+
+.firebug #firebugLog, .firebug #objectLog {
+	overflow: auto;
+	position: absolute;
+	left: 0;
+	width: 100%;
+}
+#objectLog{
+	overflow:scroll;
+	height:258px;
+}
+.firebug #firebugCommandLine {
+	position: absolute;
+	bottom: 0;
+	left: 0;
+	width: 100%;
+	height: 18px;
+	border: none;
+	border-top: 1px solid ThreeDShadow;
+}
+.firebug .logRow {
+	position: relative;
+	border-bottom: 1px solid #D7D7D7;
+	padding: 2px 4px 1px 6px;
+	background-color: #FFFFFF;
+}
+.firebug .logRow-command {
+	font-family: Monaco, monospace;
+	color: blue;
+}
+.firebug .objectBox-null {
+	padding: 0 2px;
+	border: 1px solid #666666;
+	background-color: #888888;
+	color: #FFFFFF;
+}
+.firebug .objectBox-string {
+	font-family: Monaco, monospace;
+	color: red;
+	white-space: pre;
+}
+.firebug .objectBox-number {
+	color: #000088;
+}
+.firebug .objectBox-function {
+	font-family: Monaco, monospace;
+	color: DarkGreen;
+}
+.firebug .objectBox-object {
+	color: DarkGreen;
+	font-weight: bold;
+}
+.firebug .logRow-info,
+.firebug .logRow-error,
+.firebug .logRow-warning
+ {
+	background: #00FFFF no-repeat 2px 2px;
+	padding-left: 20px;
+	padding-bottom: 3px;
+}
+.firebug .logRow-info {
+	background: #FFF url(infoIcon.png) no-repeat 2px 2px;
+	padding-left: 20px;
+	padding-bottom: 3px;
+}
+.firebug .logRow-warning {
+	
+	background: #00FFFF url(warningIcon.png) no-repeat 2px 2px;
+	padding-left: 20px;
+	padding-bottom: 3px;
+}
+.firebug .logRow-error {
+	background: LightYellow url(errorIcon.png) no-repeat 2px 2px;
+	padding-left: 20px;
+	padding-bottom: 3px;
+}
+.firebug .errorMessage {
+	vertical-align: top;
+	color: #FF0000;
+}
+.firebug .objectBox-sourceLink {
+	position: absolute;
+	right: 4px;
+	top: 2px;
+	padding-left: 8px;
+	font-family: Lucida Grande, sans-serif;
+	font-weight: bold;
+	color: #0000FF;
+}
+.firebug .logRow-group {
+	background: #EEEEEE;
+	border-bottom: none;
+}
+.firebug .logGroup {
+	background: #EEEEEE;
+}
+.firebug .logGroupBox {
+	margin-left: 24px;
+	border-top: 1px solid #D7D7D7;
+	border-left: 1px solid #D7D7D7;
+}
+.firebug .selectorTag,
+.firebug .selectorId,
+.firebug .selectorClass {
+	font-family: Monaco, monospace;
+	font-weight: normal;
+}
+.firebug .selectorTag {
+	color: #0000FF;
+}
+.firebug .selectorId {
+	color: DarkBlue;
+}
+.firebug .selectorClass {
+	color: red;
+}
+.firebug .objectBox-element {
+	font-family: Monaco, monospace;
+	color: #000088;
+}
+.firebug .nodeChildren {
+	margin-left: 16px;
+}
+.firebug .nodeTag {
+	color: blue;
+}
+.firebug .nodeValue {
+	color: #FF0000;
+	font-weight: normal;
+}
+.firebug .nodeText,
+.firebug .nodeComment {
+	margin: 0 2px;
+	vertical-align: top;
+}
+.firebug .nodeText {
+	color: #333333;
+}
+.firebug .nodeComment {
+	color: DarkGreen;
+}
+.firebug .propertyNameCell {
+	vertical-align: top;
+}
+.firebug .propertyName {
+	font-weight: bold;
+}
+
+/*   tabs   */
+#firebugToolbar ul.tabs{
+	margin:0 !important;
+	padding:0;
+}
+#firebugToolbar ul.tabs li{
+	list-style:none;
+	background:transparent url(tab_lft_norm.png) no-repeat left;
+	line-height:18px;
+	float:left;
+	margin-left:5px;
+}
+#firebugToolbar ul.tabs li.right{
+	float:right;
+	margin-right:5px;
+	margin-left:0;
+}
+#firebugToolbar ul.tabs li.gap{
+	margin-left:20px;
+}
+#firebugToolbar .tabs a{
+	text-decoration:none;
+	background:transparent url(tab_rgt_norm.png) no-repeat right;
+	line-height:18px;
+	padding:3px 9px 4px 0px;
+	margin-left:9px;
+	color:#333333;
+}
+#firebugToolbar .tabs li:hover{
+	background:transparent url(tab_lft_over.png) no-repeat left;
+}
+#firebugToolbar .tabs a:hover{
+	text-decoration:none;
+	background:transparent url(tab_rgt_over.png) no-repeat right;
+	color:#FFFFFF;
+}
diff --git a/js/dojo-1.7.2/dojo/_firebug/firebug.js b/js/dojo-1.7.2/dojo/_firebug/firebug.js
new file mode 100644
index 0000000..b6cfde2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_firebug/firebug.js
@@ -0,0 +1,1184 @@
+//>>built
+define("dojo/_firebug/firebug", ["../_base/kernel", "require", "../_base/html", "../_base/sniff", "../_base/array", "../_base/lang", "../_base/event", "../_base/unload"], function(dojo, require) {
+	// module:
+	//		dojo/_firebug/firebug
+	// summary:
+
+// FIREBUG LITE
+	// summary: Firebug Lite, the baby brother to Joe Hewitt's Firebug for Mozilla Firefox
+	// description:
+	//		Opens a console for logging, debugging, and error messages.
+	//		Contains partial functionality to Firebug. See function list below.
+	//	NOTE:
+	//			Firebug is a Firefox extension created by Joe Hewitt (see license). You do not need Dojo to run Firebug.
+	//			Firebug Lite is included in Dojo by permission from Joe Hewitt
+	//			If you are new to Firebug, or used to the Dojo 0.4 dojo.debug, you can learn Firebug
+	//				functionality by reading the function comments below or visiting http://www.getfirebug.com/docs.html
+	//	NOTE:
+	//		To test Firebug Lite in Firefox:
+	//			FF2: set "console = null" before loading dojo and set djConfig.isDebug=true
+	//			FF3: disable Firebug and set djConfig.isDebug=true
+	//
+	// example:
+	//		Supports inline objects in object inspector window (only simple trace of dom nodes, however)
+	//		|	console.log("my object", {foo:"bar"})
+	// example:
+	//		Option for console to open in popup window
+	//		|	var djConfig = {isDebug: true, popup:true };
+	// example:
+	//		Option for console height (ignored for popup)
+	//		|	var djConfig = {isDebug: true, debugHeight:100 }
+
+
+	var isNewIE = (/Trident/.test(window.navigator.userAgent));
+	if(isNewIE){
+		// Fixing IE's console
+		// IE doesn't insert space between arguments. How annoying.
+		var calls = ["log", "info", "debug", "warn", "error"];
+		for(var i=0;i<calls.length;i++){
+			var m = calls[i];
+			if(!console[m] ||console[m]._fake){
+				// IE9 doesn't have console.debug method, a fake one is added later
+				continue;
+			}
+			var n = "_"+calls[i];
+			console[n] = console[m];
+			console[m] = (function(){
+				var type = n;
+				return function(){
+					console[type](Array.prototype.join.call(arguments, " "));
+				};
+			})();
+		}
+		// clear the console on load. This is more than a convenience - too many logs crashes it.
+		// If closed it throws an error
+		try{ console.clear(); }catch(e){}
+	}
+
+	if(
+		dojo.isFF ||								// Firefox has Firebug
+		dojo.isChrome ||							// Chrome 3+ has a console
+		dojo.isSafari ||							// Safari 4 has a console
+		isNewIE ||									// Has the new IE console
+		window.firebug ||							// Testing for mozilla firebug lite
+		(typeof console != "undefined" && console.firebug) || //The firebug console
+		dojo.config.useCustomLogger ||				// Allow custom loggers
+		dojo.isAIR									// isDebug triggers AIRInsector, not Firebug
+	){
+		return;
+	}
+
+	// don't build firebug in iframes
+	try{
+		if(window != window.parent){
+			// but if we've got a parent logger, connect to it
+			if(window.parent["console"]){
+				window.console = window.parent.console;
+			}
+			return;
+		}
+	}catch(e){/*squelch*/}
+
+	// ***************************************************************************
+	// Placing these variables before the functions that use them to avoid a
+	// shrinksafe bug where variable renaming does not happen correctly otherwise.
+
+	// most of the objects in this script are run anonomously
+	var _firebugDoc = document;
+	var _firebugWin = window;
+	var __consoleAnchorId__ = 0;
+
+	var consoleFrame = null;
+	var consoleBody = null;
+	var consoleObjectInspector = null;
+	var fireBugTabs = null;
+	var commandLine = null;
+	var consoleToolbar = null;
+
+	var frameVisible = false;
+	var messageQueue = [];
+	var groupStack = [];
+	var timeMap = {};
+	var countMap = {};
+
+	var consoleDomInspector = null;
+	var _inspectionMoveConnection;
+	var _inspectionClickConnection;
+	var _inspectionEnabled = false;
+	var _inspectionTimer = null;
+	var _inspectTempNode = document.createElement("div");
+
+
+	var _inspectCurrentNode;
+	var _restoreBorderStyle;
+
+	// ***************************************************************************
+
+	window.console = {
+		_connects: [],
+		log: function(){
+			// summary:
+			//		Sends arguments to console.
+			logFormatted(arguments, "");
+		},
+
+		debug: function(){
+			// summary:
+			//		Sends arguments to console. Missing finctionality to show script line of trace.
+			logFormatted(arguments, "debug");
+		},
+
+		info: function(){
+			// summary:
+			//		Sends arguments to console, highlighted with (I) icon.
+			logFormatted(arguments, "info");
+		},
+
+		warn: function(){
+			// summary:
+			//		Sends warning arguments to console, highlighted with (!) icon and blue style.
+			logFormatted(arguments, "warning");
+		},
+
+		error: function(){
+			// summary:
+			//		Sends error arguments (object) to console, highlighted with (X) icon and yellow style
+			//			NEW: error object now displays in object inspector
+			logFormatted(arguments, "error");
+		},
+
+		assert: function(truth, message){
+			// summary:
+			//		Tests for true. Throws exception if false.
+			if(!truth){
+				var args = [];
+				for(var i = 1; i < arguments.length; ++i){
+					args.push(arguments[i]);
+				}
+
+				logFormatted(args.length ? args : ["Assertion Failure"], "error");
+				throw message ? message : "Assertion Failure";
+			}
+		},
+
+		dir: function(obj){
+			var str = printObject( obj );
+			str = str.replace(/\n/g, "<br />");
+			str = str.replace(/\t/g, "&nbsp;&nbsp;&nbsp;&nbsp;");
+			logRow([str], "dir");
+		},
+
+		dirxml: function(node){
+			// summary:
+			//
+			var html = [];
+			appendNode(node, html);
+			logRow(html, "dirxml");
+		},
+
+		group: function(){
+			// summary:
+			//		collects log messages into a group, starting with this call and ending with
+			//			groupEnd(). Missing collapse functionality
+			logRow(arguments, "group", pushGroup);
+		},
+
+		groupEnd: function(){
+			// summary:
+			//		Closes group. See above
+			logRow(arguments, "", popGroup);
+		},
+
+		time: function(name){
+			// summary:
+			//		Starts timers assigned to name given in argument. Timer stops and displays on timeEnd(title);
+			//	example:
+			//	|	console.time("load");
+			//	|	console.time("myFunction");
+			//	|	console.timeEnd("load");
+			//	|	console.timeEnd("myFunction");
+			timeMap[name] = new Date().getTime();
+		},
+
+		timeEnd: function(name){
+			// summary:
+			//		See above.
+			if(name in timeMap){
+				var delta = (new Date()).getTime() - timeMap[name];
+				logFormatted([name+ ":", delta+"ms"]);
+				delete timeMap[name];
+			}
+		},
+
+		count: function(name){
+			// summary:
+			//		Not supported
+			if(!countMap[name]) countMap[name] = 0;
+			countMap[name]++;
+			logFormatted([name+": "+countMap[name]]);
+		},
+
+		trace: function(_value){
+			var stackAmt = _value || 3;
+			var f = console.trace.caller; //function that called trace
+			console.log(">>> console.trace(stack)");
+			for(var i=0;i<stackAmt;i++){
+				var func = f.toString();
+				var args=[];
+				for (var a = 0; a < f.arguments.length; a++) {
+					args.push(f.arguments[a]);
+				}
+				if(f.arguments.length){
+					console.dir({"function":func, "arguments":args});
+				}else{
+					console.dir({"function":func});
+				}
+
+				f = f.caller;
+			}
+		},
+
+		profile: function(){
+			// summary:
+			//		Not supported
+			this.warn(["profile() not supported."]);
+		},
+
+		profileEnd: function(){ },
+
+		clear: function(){
+			// summary:
+			//		Clears message console. Do not call this directly
+			if(consoleBody){
+				while(consoleBody.childNodes.length){
+					dojo.destroy(consoleBody.firstChild);
+				}
+			}
+			dojo.forEach(this._connects,dojo.disconnect);
+		},
+
+		open: function(){
+			// summary:
+			//		Opens message console. Do not call this directly
+			toggleConsole(true);
+		},
+
+		close: function(){
+			// summary:
+			//		Closes message console. Do not call this directly
+			if(frameVisible){
+				toggleConsole();
+			}
+		},
+		_restoreBorder: function(){
+			if(_inspectCurrentNode){
+				_inspectCurrentNode.style.border = _restoreBorderStyle;
+			}
+		},
+		openDomInspector: function(){
+			_inspectionEnabled = true;
+			consoleBody.style.display = "none";
+			consoleDomInspector.style.display = "block";
+			consoleObjectInspector.style.display = "none";
+			document.body.style.cursor = "pointer";
+			_inspectionMoveConnection = dojo.connect(document, "mousemove", function(evt){
+				if(!_inspectionEnabled){ return; }
+				if(!_inspectionTimer){
+					_inspectionTimer = setTimeout(function(){ _inspectionTimer = null; }, 50);
+				}else{
+					return;
+				}
+				var node = evt.target;
+				if(node && (_inspectCurrentNode !== node)){
+					var parent = true;
+
+					console._restoreBorder();
+					var html = [];
+					appendNode(node, html);
+					consoleDomInspector.innerHTML = html.join("");
+
+					_inspectCurrentNode = node;
+					_restoreBorderStyle = _inspectCurrentNode.style.border;
+					_inspectCurrentNode.style.border = "#0000FF 1px solid";
+				}
+			});
+			setTimeout(function(){
+				_inspectionClickConnection = dojo.connect(document, "click", function(evt){
+					document.body.style.cursor = "";
+					_inspectionEnabled = !_inspectionEnabled;
+					dojo.disconnect(_inspectionClickConnection);
+					// console._restoreBorder();
+				});
+			}, 30);
+		},
+		_closeDomInspector: function(){
+			document.body.style.cursor = "";
+			dojo.disconnect(_inspectionMoveConnection);
+			dojo.disconnect(_inspectionClickConnection);
+			_inspectionEnabled = false;
+			console._restoreBorder();
+		},
+		openConsole:function(){
+			// summary:
+			//		Closes object inspector and opens message console. Do not call this directly
+			consoleBody.style.display = "block";
+			consoleDomInspector.style.display = "none";
+			consoleObjectInspector.style.display = "none";
+			console._closeDomInspector();
+		},
+		openObjectInspector:function(){
+			consoleBody.style.display = "none";
+			consoleDomInspector.style.display = "none";
+			consoleObjectInspector.style.display = "block";
+			console._closeDomInspector();
+		},
+		recss: function(){
+			// http://turtle.dojotoolkit.org/~david/recss.html
+			// this is placed in dojo since the console is most likely
+			// in another window and dojo is easilly accessible
+			var i,a,s;a=document.getElementsByTagName('link');
+			for(i=0;i<a.length;i++){
+				s=a[i];
+				if(s.rel.toLowerCase().indexOf('stylesheet')>=0&&s.href) {
+					var h=s.href.replace(/(&|%5C?)forceReload=\d+/,'');
+					s.href=h+(h.indexOf('?')>=0?'&':'?')+'forceReload='+new Date().valueOf();
+				}
+			}
+		}
+	};
+
+	// ***************************************************************************
+
+	function toggleConsole(forceOpen){
+		frameVisible = forceOpen || !frameVisible;
+		if(consoleFrame){
+			consoleFrame.style.display = frameVisible ? "block" : "none";
+		}
+	}
+
+	function focusCommandLine(){
+		toggleConsole(true);
+		if(commandLine){
+			commandLine.focus();
+		}
+	}
+
+	function openWin(x,y,w,h){
+		var win = window.open("","_firebug","status=0,menubar=0,resizable=1,top="+y+",left="+x+",width="+w+",height="+h+",scrollbars=1,addressbar=0");
+		if(!win){
+			var msg = "Firebug Lite could not open a pop-up window, most likely because of a blocker.\n" +
+				"Either enable pop-ups for this domain, or change the djConfig to popup=false.";
+			alert(msg);
+		}
+		createResizeHandler(win);
+		var newDoc=win.document;
+		//Safari needs an HTML height
+		var HTMLstring=	'<html style="height:100%;"><head><title>Firebug Lite</title></head>\n' +
+					'<body bgColor="#ccc" style="height:97%;" onresize="opener.onFirebugResize()">\n' +
+					'<div id="fb"></div>' +
+					'</body></html>';
+
+		newDoc.write(HTMLstring);
+		newDoc.close();
+		return win;
+	}
+
+	function createResizeHandler(wn){
+		// summary:
+		//		Creates handle for onresize window. Called from script in popup's body tag (so that it will work with IE).
+		//
+
+		var d = new Date();
+			d.setTime(d.getTime()+(60*24*60*60*1000)); // 60 days
+			d = d.toUTCString();
+
+			var dc = wn.document,
+				getViewport;
+
+			if (wn.innerWidth){
+				getViewport = function(){
+					return{w:wn.innerWidth, h:wn.innerHeight};
+				};
+			}else if (dc.documentElement && dc.documentElement.clientWidth){
+				getViewport = function(){
+					return{w:dc.documentElement.clientWidth, h:dc.documentElement.clientHeight};
+				};
+			}else if (dc.body){
+				getViewport = function(){
+					return{w:dc.body.clientWidth, h:dc.body.clientHeight};
+				};
+			}
+
+
+		window.onFirebugResize = function(){
+
+			//resize the height of the console log body
+			layout(getViewport().h);
+
+			clearInterval(wn._firebugWin_resize);
+			wn._firebugWin_resize = setTimeout(function(){
+				var x = wn.screenLeft,
+					y = wn.screenTop,
+					w = wn.outerWidth  || wn.document.body.offsetWidth,
+					h = wn.outerHeight || wn.document.body.offsetHeight;
+
+				document.cookie = "_firebugPosition=" + [x,y,w,h].join(",") + "; expires="+d+"; path=/";
+
+			 }, 5000); //can't capture window.onMove - long timeout gives better chance of capturing a resize, then the move
+
+		};
+	}
+
+
+	/*****************************************************************************/
+
+
+	function createFrame(){
+		if(consoleFrame){
+			return;
+		}
+		toggleConsole(true);
+		if(dojo.config.popup){
+			var containerHeight = "100%";
+			var cookieMatch = document.cookie.match(/(?:^|; )_firebugPosition=([^;]*)/);
+			var p = cookieMatch ? cookieMatch[1].split(",") : [2,2,320,480];
+
+			_firebugWin = openWin(p[0],p[1],p[2],p[3]);	// global
+			_firebugDoc = _firebugWin.document;			// global
+
+			dojo.config.debugContainerId = 'fb';
+
+			// connecting popup
+			_firebugWin.console = window.console;
+			_firebugWin.dojo = window.dojo;
+		}else{
+			_firebugDoc = document;
+			containerHeight = (dojo.config.debugHeight || 300) + "px";
+		}
+
+		var styleElement = _firebugDoc.createElement("link");
+		styleElement.href = require.toUrl("./firebug.css");
+		styleElement.rel = "stylesheet";
+		styleElement.type = "text/css";
+		var styleParent = _firebugDoc.getElementsByTagName("head");
+		if(styleParent){
+			styleParent = styleParent[0];
+		}
+		if(!styleParent){
+			styleParent = _firebugDoc.getElementsByTagName("html")[0];
+		}
+		if(dojo.isIE){
+			window.setTimeout(function(){ styleParent.appendChild(styleElement); }, 0);
+		}else{
+			styleParent.appendChild(styleElement);
+		}
+
+		if(dojo.config.debugContainerId){
+			consoleFrame = _firebugDoc.getElementById(dojo.config.debugContainerId);
+		}
+		if(!consoleFrame){
+			consoleFrame = _firebugDoc.createElement("div");
+			_firebugDoc.body.appendChild(consoleFrame);
+		}
+		consoleFrame.className += " firebug";
+		consoleFrame.style.height = containerHeight;
+		consoleFrame.style.display = (frameVisible ? "block" : "none");
+
+		var buildLink = function(label, title, method, _class){
+			return '<li class="'+_class+'"><a href="javascript:void(0);" onclick="console.'+ method +'(); return false;" title="'+title+'">'+label+'</a></li>';
+		};
+		consoleFrame.innerHTML =
+			  '<div id="firebugToolbar">'
+			+ '  <ul id="fireBugTabs" class="tabs">'
+
+			+ buildLink("Clear", "Remove All Console Logs", "clear", "")
+			+ buildLink("ReCSS", "Refresh CSS without reloading page", "recss", "")
+
+			+ buildLink("Console", "Show Console Logs", "openConsole", "gap")
+			+ buildLink("DOM", "Show DOM Inspector", "openDomInspector", "")
+			+ buildLink("Object", "Show Object Inspector", "openObjectInspector", "")
+			+ ((dojo.config.popup) ? "" : buildLink("Close", "Close the console", "close", "gap"))
+
+			+ '	</ul>'
+			+ '</div>'
+			+ '<input type="text" id="firebugCommandLine" />'
+			+ '<div id="firebugLog"></div>'
+			+ '<div id="objectLog" style="display:none;">Click on an object in the Log display</div>'
+			+ '<div id="domInspect" style="display:none;">Hover over HTML elements in the main page. Click to hold selection.</div>';
+
+
+		consoleToolbar = _firebugDoc.getElementById("firebugToolbar");
+
+		commandLine = _firebugDoc.getElementById("firebugCommandLine");
+		addEvent(commandLine, "keydown", onCommandLineKeyDown);
+
+		addEvent(_firebugDoc, dojo.isIE || dojo.isSafari ? "keydown" : "keypress", onKeyDown);
+
+		consoleBody = _firebugDoc.getElementById("firebugLog");
+		consoleObjectInspector = _firebugDoc.getElementById("objectLog");
+		consoleDomInspector = _firebugDoc.getElementById("domInspect");
+		fireBugTabs = _firebugDoc.getElementById("fireBugTabs");
+		layout();
+		flush();
+	}
+
+	dojo.addOnLoad(createFrame);
+
+	function clearFrame(){
+		_firebugDoc = null;
+
+		if(_firebugWin.console){
+			_firebugWin.console.clear();
+		}
+		_firebugWin = null;
+		consoleFrame = null;
+		consoleBody = null;
+		consoleObjectInspector = null;
+		consoleDomInspector = null;
+		commandLine = null;
+		messageQueue = [];
+		groupStack = [];
+		timeMap = {};
+	}
+
+
+	function evalCommandLine(){
+		var text = commandLine.value;
+		commandLine.value = "";
+
+		logRow([">  ", text], "command");
+
+		var value;
+		try{
+			value = eval(text);
+		}catch(e){
+			console.debug(e); // put exception on the console
+		}
+
+		console.log(value);
+	}
+
+	function layout(h){
+		var tHeight = 25; //consoleToolbar.offsetHeight; // tab style not ready on load - throws off layout
+		var height = h ?
+			h  - (tHeight + commandLine.offsetHeight +25 + (h*.01)) + "px" :
+			(consoleFrame.offsetHeight - tHeight - commandLine.offsetHeight) + "px";
+
+		consoleBody.style.top = tHeight + "px";
+		consoleBody.style.height = height;
+		consoleObjectInspector.style.height = height;
+		consoleObjectInspector.style.top = tHeight + "px";
+		consoleDomInspector.style.height = height;
+		consoleDomInspector.style.top = tHeight + "px";
+		commandLine.style.bottom = 0;
+
+		dojo.addOnWindowUnload(clearFrame);
+	}
+
+	function logRow(message, className, handler){
+		if(consoleBody){
+			writeMessage(message, className, handler);
+		}else{
+			messageQueue.push([message, className, handler]);
+		}
+	}
+
+	function flush(){
+		var queue = messageQueue;
+		messageQueue = [];
+
+		for(var i = 0; i < queue.length; ++i){
+			writeMessage(queue[i][0], queue[i][1], queue[i][2]);
+		}
+	}
+
+	function writeMessage(message, className, handler){
+		var isScrolledToBottom =
+			consoleBody.scrollTop + consoleBody.offsetHeight >= consoleBody.scrollHeight;
+
+		handler = handler||writeRow;
+
+		handler(message, className);
+
+		if(isScrolledToBottom){
+			consoleBody.scrollTop = consoleBody.scrollHeight - consoleBody.offsetHeight;
+		}
+	}
+
+	function appendRow(row){
+		var container = groupStack.length ? groupStack[groupStack.length-1] : consoleBody;
+		container.appendChild(row);
+	}
+
+	function writeRow(message, className){
+		var row = consoleBody.ownerDocument.createElement("div");
+		row.className = "logRow" + (className ? " logRow-"+className : "");
+		row.innerHTML = message.join("");
+		appendRow(row);
+	}
+
+	function pushGroup(message, className){
+		logFormatted(message, className);
+
+		//var groupRow = consoleBody.ownerDocument.createElement("div");
+		//groupRow.className = "logGroup";
+		var groupRowBox = consoleBody.ownerDocument.createElement("div");
+		groupRowBox.className = "logGroupBox";
+		//groupRow.appendChild(groupRowBox);
+		appendRow(groupRowBox);
+		groupStack.push(groupRowBox);
+	}
+
+	function popGroup(){
+		groupStack.pop();
+	}
+
+	// ***************************************************************************
+
+	function logFormatted(objects, className){
+		var html = [];
+
+		var format = objects[0];
+		var objIndex = 0;
+
+		if(typeof(format) != "string"){
+			format = "";
+			objIndex = -1;
+		}
+
+		var parts = parseFormat(format);
+
+		for(var i = 0; i < parts.length; ++i){
+			var part = parts[i];
+			if(part && typeof part == "object"){
+				part.appender(objects[++objIndex], html);
+			}else{
+				appendText(part, html);
+			}
+		}
+
+
+		var ids = [];
+		var obs = [];
+		for(i = objIndex+1; i < objects.length; ++i){
+			appendText(" ", html);
+
+			var object = objects[i];
+			if(object === undefined || object === null ){
+				appendNull(object, html);
+
+			}else if(typeof(object) == "string"){
+				appendText(object, html);
+
+			}else if(object instanceof Date){
+				appendText(object.toString(), html);
+
+			}else if(object.nodeType == 9){
+				appendText("[ XmlDoc ]", html);
+
+			}else{
+				// Create link for object inspector
+				// need to create an ID for this link, since it is currently text
+				var id = "_a" + __consoleAnchorId__++;
+				ids.push(id);
+				// need to save the object, so the arrays line up
+				obs.push(object);
+				var str = '<a id="'+id+'" href="javascript:void(0);">'+getObjectAbbr(object)+'</a>';
+
+				appendLink( str , html);
+			}
+		}
+
+		logRow(html, className);
+
+		// Now that the row is inserted in the DOM, loop through all of the links that were just created
+		for(i=0; i<ids.length; i++){
+			var btn = _firebugDoc.getElementById(ids[i]);
+			if(!btn){ continue; }
+
+			// store the object in the dom btn for reference later
+			// avoid parsing these objects unless necessary
+			btn.obj = obs[i];
+
+			_firebugWin.console._connects.push(dojo.connect(btn, "onclick", function(){
+
+				console.openObjectInspector();
+
+				try{
+					printObject(this.obj);
+				}catch(e){
+					this.obj = e;
+				}
+				consoleObjectInspector.innerHTML = "<pre>" + printObject( this.obj ) + "</pre>";
+			}));
+		}
+	}
+
+	function parseFormat(format){
+		var parts = [];
+
+		var reg = /((^%|[^\\]%)(\d+)?(\.)([a-zA-Z]))|((^%|[^\\]%)([a-zA-Z]))/;
+		var appenderMap = {s: appendText, d: appendInteger, i: appendInteger, f: appendFloat};
+
+		for(var m = reg.exec(format); m; m = reg.exec(format)){
+			var type = m[8] ? m[8] : m[5];
+			var appender = type in appenderMap ? appenderMap[type] : appendObject;
+			var precision = m[3] ? parseInt(m[3]) : (m[4] == "." ? -1 : 0);
+
+			parts.push(format.substr(0, m[0][0] == "%" ? m.index : m.index+1));
+			parts.push({appender: appender, precision: precision});
+
+			format = format.substr(m.index+m[0].length);
+		}
+
+		parts.push(format);
+
+		return parts;
+	}
+
+	function escapeHTML(value){
+		function replaceChars(ch){
+			switch(ch){
+				case "<":
+					return "&lt;";
+				case ">":
+					return "&gt;";
+				case "&":
+					return "&amp;";
+				case "'":
+					return "&#39;";
+				case '"':
+					return "&quot;";
+			}
+			return "?";
+		}
+		return String(value).replace(/[<>&"']/g, replaceChars);
+	}
+
+	function objectToString(object){
+		try{
+			return object+"";
+		}catch(e){
+			return null;
+		}
+	}
+
+	// ***************************************************************************
+	function appendLink(object, html){
+		// needed for object links - no HTML escaping
+		html.push( objectToString(object) );
+	}
+
+	function appendText(object, html){
+		html.push(escapeHTML(objectToString(object)));
+	}
+
+	function appendNull(object, html){
+		html.push('<span class="objectBox-null">', escapeHTML(objectToString(object)), '</span>');
+	}
+
+	function appendString(object, html){
+		html.push('<span class="objectBox-string">&quot;', escapeHTML(objectToString(object)),
+			'&quot;</span>');
+	}
+
+	function appendInteger(object, html){
+		html.push('<span class="objectBox-number">', escapeHTML(objectToString(object)), '</span>');
+	}
+
+	function appendFloat(object, html){
+		html.push('<span class="objectBox-number">', escapeHTML(objectToString(object)), '</span>');
+	}
+
+	function appendFunction(object, html){
+		html.push('<span class="objectBox-function">', getObjectAbbr(object), '</span>');
+	}
+
+	function appendObject(object, html){
+		try{
+			if(object === undefined){
+				appendNull("undefined", html);
+			}else if(object === null){
+				appendNull("null", html);
+			}else if(typeof object == "string"){
+				appendString(object, html);
+			}else if(typeof object == "number"){
+				appendInteger(object, html);
+			}else if(typeof object == "function"){
+				appendFunction(object, html);
+			}else if(object.nodeType == 1){
+				appendSelector(object, html);
+			}else if(typeof object == "object"){
+				appendObjectFormatted(object, html);
+			}else{
+				appendText(object, html);
+			}
+		}catch(e){
+			/* squelch */
+		}
+	}
+
+	function appendObjectFormatted(object, html){
+		var text = objectToString(object);
+		var reObject = /\[object (.*?)\]/;
+
+		var m = reObject.exec(text);
+		html.push('<span class="objectBox-object">', m ? m[1] : text, '</span>');
+	}
+
+	function appendSelector(object, html){
+		html.push('<span class="objectBox-selector">');
+
+		html.push('<span class="selectorTag">', escapeHTML(object.nodeName.toLowerCase()), '</span>');
+		if(object.id){
+			html.push('<span class="selectorId">#', escapeHTML(object.id), '</span>');
+		}
+		if(object.className){
+			html.push('<span class="selectorClass">.', escapeHTML(object.className), '</span>');
+		}
+
+		html.push('</span>');
+	}
+
+	function appendNode(node, html){
+		if(node.nodeType == 1){
+			html.push(
+				'<div class="objectBox-element">',
+					'&lt;<span class="nodeTag">', node.nodeName.toLowerCase(), '</span>');
+
+			for(var i = 0; i < node.attributes.length; ++i){
+				var attr = node.attributes[i];
+				if(!attr.specified){ continue; }
+
+				html.push('&nbsp;<span class="nodeName">', attr.nodeName.toLowerCase(),
+					'</span>=&quot;<span class="nodeValue">', escapeHTML(attr.nodeValue),
+					'</span>&quot;');
+			}
+
+			if(node.firstChild){
+				html.push('&gt;</div><div class="nodeChildren">');
+
+				for(var child = node.firstChild; child; child = child.nextSibling){
+					appendNode(child, html);
+				}
+
+				html.push('</div><div class="objectBox-element">&lt;/<span class="nodeTag">',
+					node.nodeName.toLowerCase(), '&gt;</span></div>');
+			}else{
+				html.push('/&gt;</div>');
+			}
+		}else if (node.nodeType == 3){
+			html.push('<div class="nodeText">', escapeHTML(node.nodeValue),
+				'</div>');
+		}
+	}
+
+	// ***************************************************************************
+
+	function addEvent(object, name, handler){
+		if(document.all){
+			object.attachEvent("on"+name, handler);
+		}else{
+			object.addEventListener(name, handler, false);
+		}
+	}
+
+	function removeEvent(object, name, handler){
+		if(document.all){
+			object.detachEvent("on"+name, handler);
+		}else{
+			object.removeEventListener(name, handler, false);
+		}
+	}
+
+	function cancelEvent(event){
+		if(document.all){
+			event.cancelBubble = true;
+		}else{
+			event.stopPropagation();
+		}
+	}
+
+	function onError(msg, href, lineNo){
+		var lastSlash = href.lastIndexOf("/");
+		var fileName = lastSlash == -1 ? href : href.substr(lastSlash+1);
+
+		var html = [
+			'<span class="errorMessage">', msg, '</span>',
+			'<div class="objectBox-sourceLink">', fileName, ' (line ', lineNo, ')</div>'
+		];
+
+		logRow(html, "error");
+	}
+
+
+	//After converting to div instead of iframe, now getting two keydowns right away in IE 6.
+	//Make sure there is a little bit of delay.
+	var onKeyDownTime = new Date().getTime();
+
+	function onKeyDown(event){
+		var timestamp = (new Date()).getTime();
+		if(timestamp > onKeyDownTime + 200){
+			event = dojo.fixEvent(event);
+			var keys = dojo.keys;
+			var ekc = event.keyCode;
+			onKeyDownTime = timestamp;
+			if(ekc == keys.F12){
+				toggleConsole();
+			}else if(
+				(ekc == keys.NUMPAD_ENTER || ekc == 76) &&
+				event.shiftKey &&
+				(event.metaKey || event.ctrlKey)
+			){
+				focusCommandLine();
+			}else{
+				return;
+			}
+			cancelEvent(event);
+		}
+	}
+
+	function onCommandLineKeyDown(e){
+		var dk = dojo.keys;
+		if(e.keyCode == 13 && commandLine.value){
+			addToHistory(commandLine.value);
+			evalCommandLine();
+		}else if(e.keyCode == 27){
+			commandLine.value = "";
+		}else if(e.keyCode == dk.UP_ARROW || e.charCode == dk.UP_ARROW){
+			navigateHistory("older");
+		}else if(e.keyCode == dk.DOWN_ARROW || e.charCode == dk.DOWN_ARROW){
+			navigateHistory("newer");
+		}else if(e.keyCode == dk.HOME || e.charCode == dk.HOME){
+			historyPosition = 1;
+			navigateHistory("older");
+		}else if(e.keyCode == dk.END || e.charCode == dk.END){
+			historyPosition = 999999;
+			navigateHistory("newer");
+		}
+	}
+
+	var historyPosition = -1;
+	var historyCommandLine = null;
+
+	function addToHistory(value){
+		var history = cookie("firebug_history");
+		history = (history) ? dojo.fromJson(history) : [];
+		var pos = dojo.indexOf(history, value);
+		if (pos != -1){
+			history.splice(pos, 1);
+		}
+		history.push(value);
+		cookie("firebug_history", dojo.toJson(history), 30);
+		while(history.length && !cookie("firebug_history")){
+			history.shift();
+			cookie("firebug_history", dojo.toJson(history), 30);
+		}
+		historyCommandLine = null;
+		historyPosition = -1;
+	}
+
+	function navigateHistory(direction){
+		var history = cookie("firebug_history");
+		history = (history) ? dojo.fromJson(history) : [];
+		if(!history.length){
+			return;
+		}
+
+		if(historyCommandLine === null){
+			historyCommandLine = commandLine.value;
+		}
+
+		if(historyPosition == -1){
+			historyPosition = history.length;
+		}
+
+		if(direction == "older"){
+			--historyPosition;
+			if(historyPosition < 0){
+				historyPosition = 0;
+			}
+		}else if(direction == "newer"){
+			++historyPosition;
+			if(historyPosition > history.length){
+				historyPosition = history.length;
+			}
+		}
+
+		if(historyPosition == history.length){
+			commandLine.value = historyCommandLine;
+			historyCommandLine = null;
+		}else{
+			commandLine.value = history[historyPosition];
+		}
+	}
+
+	function cookie(name, value){
+		var c = document.cookie;
+		if(arguments.length == 1){
+			var matches = c.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
+			return matches ? decodeURIComponent(matches[1]) : undefined; // String or undefined
+		}else{
+			var d = new Date();
+			d.setMonth(d.getMonth()+1);
+			document.cookie = name + "=" + encodeURIComponent(value) + ((d.toUtcString) ? "; expires=" + d.toUTCString() : "");
+		}
+	}
+
+	function isArray(it){
+		return it && it instanceof Array || typeof it == "array";
+	}
+
+	//***************************************************************************************************
+	// Print Object Helpers
+	function objectLength(o){
+		var cnt = 0;
+		for(var nm in o){
+			cnt++;
+		}
+		return cnt;
+	}
+
+	function printObject(o, i, txt, used){
+		// Recursively trace object, indenting to represent depth for display in object inspector
+		var ind = " \t";
+		txt = txt || "";
+		i = i || ind;
+		used = used || [];
+		var opnCls;
+
+		if(o && o.nodeType == 1){
+			var html = [];
+			appendNode(o, html);
+			return html.join("");
+		}
+
+		var br=",\n", cnt = 0, length = objectLength(o);
+
+		if(o instanceof Date){
+			return i + o.toString() + br;
+		}
+		looking:
+		for(var nm in o){
+			cnt++;
+			if(cnt==length){br = "\n";}
+			if(o[nm] === window || o[nm] === document){
+				// do nothing
+			}else if(o[nm] === null){
+				txt += i+nm + " : NULL" + br;
+			}else if(o[nm] && o[nm].nodeType){
+				if(o[nm].nodeType == 1){
+					//txt += i+nm + " : < "+o[nm].tagName+" id=\""+ o[nm].id+"\" />" + br;
+				}else if(o[nm].nodeType == 3){
+					txt += i+nm + " : [ TextNode "+o[nm].data + " ]" + br;
+				}
+
+			}else if(typeof o[nm] == "object" && (o[nm] instanceof String || o[nm] instanceof Number || o[nm] instanceof Boolean)){
+				txt += i+nm + " : " + o[nm] + "," + br;
+
+			}else if(o[nm] instanceof Date){
+				txt += i+nm + " : " + o[nm].toString() + br;
+
+			}else if(typeof(o[nm]) == "object" && o[nm]){
+				for(var j = 0, seen; seen = used[j]; j++){
+					if(o[nm] === seen){
+						txt += i+nm + " : RECURSION" + br;
+						continue looking;
+					}
+				}
+				used.push(o[nm]);
+
+				opnCls = (isArray(o[nm]))?["[","]"]:["{","}"];
+				txt += i+nm +" : " + opnCls[0] + "\n";//non-standard break, (no comma)
+				txt += printObject(o[nm], i+ind, "", used);
+				txt += i + opnCls[1] + br;
+
+			}else if(typeof o[nm] == "undefined"){
+				txt += i+nm + " : undefined" + br;
+			}else if(nm == "toString" && typeof o[nm] == "function"){
+				var toString = o[nm]();
+				if(typeof toString == "string" && toString.match(/function ?(.*?)\(/)){
+					toString = escapeHTML(getObjectAbbr(o[nm]));
+				}
+				txt += i+nm +" : " + toString + br;
+			}else{
+				txt += i+nm +" : "+ escapeHTML(getObjectAbbr(o[nm])) + br;
+			}
+		}
+		return txt;
+	}
+
+	function getObjectAbbr(obj){
+		// Gets an abbreviation of an object for display in log
+		// X items in object, including id
+		// X items in an array
+		// TODO: Firebug Sr. actually goes by char count
+		var isError = (obj instanceof Error);
+		if(obj.nodeType == 1){
+			return escapeHTML('< '+obj.tagName.toLowerCase()+' id=\"'+ obj.id+ '\" />');
+		}
+		if(obj.nodeType == 3){
+			return escapeHTML('[TextNode: "'+obj.nodeValue+'"]');
+		}
+		var nm = (obj && (obj.id || obj.name || obj.ObjectID || obj.widgetId));
+		if(!isError && nm){ return "{"+nm+"}";	}
+
+		var obCnt = 2;
+		var arCnt = 4;
+		var cnt = 0;
+
+		if(isError){
+			nm = "[ Error: "+(obj.message || obj.description || obj)+" ]";
+		}else if(isArray(obj)){
+			nm = "[" + obj.slice(0,arCnt).join(",");
+			if(obj.length > arCnt){
+				nm += " ... ("+obj.length+" items)";
+			}
+			nm += "]";
+		}else if(typeof obj == "function"){
+			nm = obj + "";
+			var reg = /function\s*([^\(]*)(\([^\)]*\))[^\{]*\{/;
+			var m = reg.exec(nm);
+			if(m){
+				if(!m[1]){
+					m[1] = "function";
+				}
+				nm = m[1] + m[2];
+			}else{
+				nm = "function()";
+			}
+		}else if(typeof obj != "object" || typeof obj == "string"){
+			nm = obj + "";
+		}else{
+			nm = "{";
+			for(var i in obj){
+				cnt++;
+				if(cnt > obCnt){ break; }
+				nm += i+":"+escapeHTML(obj[i])+"  ";
+			}
+			nm+="}";
+		}
+
+		return nm;
+	}
+
+	//*************************************************************************************
+
+	//window.onerror = onError;
+
+	addEvent(document, dojo.isIE || dojo.isSafari ? "keydown" : "keypress", onKeyDown);
+
+	if(	(document.documentElement.getAttribute("debug") == "true")||
+		(dojo.config.isDebug)
+	){
+		toggleConsole(true);
+	}
+
+	dojo.addOnWindowUnload(function(){
+		// Erase the globals and event handlers I created, to prevent spurious leak warnings
+		removeEvent(document, dojo.isIE || dojo.isSafari ? "keydown" : "keypress", onKeyDown);
+		window.onFirebugResize = null;
+		window.console = null;
+	});
+
+});
diff --git a/js/dojo-1.7.2/dojo/_firebug/infoIcon.png b/js/dojo-1.7.2/dojo/_firebug/infoIcon.png
new file mode 100644
index 0000000..da1e533
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_firebug/infoIcon.png
diff --git a/js/dojo-1.7.2/dojo/_firebug/tab_lft_norm.png b/js/dojo-1.7.2/dojo/_firebug/tab_lft_norm.png
new file mode 100644
index 0000000..f0479a2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_firebug/tab_lft_norm.png
diff --git a/js/dojo-1.7.2/dojo/_firebug/tab_lft_over.png b/js/dojo-1.7.2/dojo/_firebug/tab_lft_over.png
new file mode 100644
index 0000000..2f36cca
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_firebug/tab_lft_over.png
diff --git a/js/dojo-1.7.2/dojo/_firebug/tab_rgt_norm.png b/js/dojo-1.7.2/dojo/_firebug/tab_rgt_norm.png
new file mode 100644
index 0000000..464af3e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_firebug/tab_rgt_norm.png
diff --git a/js/dojo-1.7.2/dojo/_firebug/tab_rgt_over.png b/js/dojo-1.7.2/dojo/_firebug/tab_rgt_over.png
new file mode 100644
index 0000000..2bc2cd0
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_firebug/tab_rgt_over.png
diff --git a/js/dojo-1.7.2/dojo/_firebug/warningIcon.png b/js/dojo-1.7.2/dojo/_firebug/warningIcon.png
new file mode 100644
index 0000000..de51084
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/_firebug/warningIcon.png
diff --git a/js/dojo-1.7.2/dojo/aspect.js b/js/dojo-1.7.2/dojo/aspect.js
new file mode 100644
index 0000000..1962283
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/aspect.js
@@ -0,0 +1,208 @@
+//>>built
+define("dojo/aspect", [], function(){
+
+// TODOC: after/before/around return object
+// TODOC: after/before/around param types. 
+
+/*=====
+	dojo.aspect = {
+		// summary: provides aspect oriented programming functionality, allowing for
+		//		one to add before, around, or after advice on existing methods.
+		//
+		// example:
+		//	|	define(["dojo/aspect"], function(aspect){
+		//	|		var signal = aspect.after(targetObject, "methodName", function(someArgument){
+		//	|			this will be called when targetObject.methodName() is called, after the original function is called
+		//	|		});
+		//
+		// example:
+		//	The returned signal object can be used to cancel the advice.
+		//	|	signal.remove(); // this will stop the advice from being executed anymore
+		//	|	aspect.before(targetObject, "methodName", function(someArgument){
+		//	|		// this will be called when targetObject.methodName() is called, before the original function is called
+		//	|	 });
+		
+		after: function(target, methodName, advice, receiveArguments){
+			// summary: The "after" export of the aspect module is a function that can be used to attach
+			//		"after" advice to a method. This function will be executed after the original method
+			//		is executed. By default the function will be called with a single argument, the return
+			//		value of the original method, or the the return value of the last executed advice (if a previous one exists).
+			//		The fourth (optional) argument can be set to true to so the function receives the original
+			//		arguments (from when the original method was called) rather than the return value.
+			//		If there are multiple "after" advisors, they are executed in the order they were registered.
+			// target: Object
+			//		This is the target object
+			// methodName: String
+			//		This is the name of the method to attach to.
+			// advice: Function
+			//		This is function to be called after the original method
+			// receiveArguments: Boolean?
+			//		If this is set to true, the advice function receives the original arguments (from when the original mehtod
+			//		was called) rather than the return value of the original/previous method.
+			// returns:
+			//		A signal object that can be used to cancel the advice. If remove() is called on this signal object, it will
+			//		stop the advice function from being executed.
+		},
+		
+		before: function(target, methodName, advice){
+			// summary: The "before" export of the aspect module is a function that can be used to attach
+			//		"before" advice to a method. This function will be executed before the original method
+			//		is executed. This function will be called with the arguments used to call the method.
+			//		This function may optionally return an array as the new arguments to use to call
+			//		the original method (or the previous, next-to-execute before advice, if one exists).
+			//		If the before method doesn't return anything (returns undefined) the original arguments
+			//		will be preserved.
+			//		If there are multiple "before" advisors, they are executed in the reverse order they were registered.
+			//
+			// target: Object
+			//		This is the target object
+			// methodName: String
+			//		This is the name of the method to attach to.
+			// advice: Function
+			//		This is function to be called before the original method	 
+		},
+
+		around: function(target, methodName, advice){
+			// summary: The "around" export of the aspect module is a function that can be used to attach
+			//		"around" advice to a method. The advisor function is immediately executed when
+			//		the around() is called, is passed a single argument that is a function that can be
+			//		called to continue execution of the original method (or the next around advisor).
+			//		The advisor function should return a function, and this function will be called whenever
+			//		the method is called. It will be called with the arguments used to call the method.
+			//		Whatever this function returns will be returned as the result of the method call (unless after advise changes it).
+			//
+			// example:
+			//		If there are multiple "around" advisors, the most recent one is executed first,
+			//		which can then delegate to the next one and so on. For example:
+			//		|	around(obj, "foo", function(originalFoo){
+			//		|		return function(){
+			//		|			var start = new Date().getTime();
+			//		|			var results = originalFoo.apply(this, arguments); // call the original
+			//		|			var end = new Date().getTime();
+			//		|			console.log("foo execution took " + (end - start) + " ms");
+			//		|			return results;
+			//		|		};
+			//		|	});
+			//
+			// target: Object
+			//		This is the target object
+			// methodName: String
+			//		This is the name of the method to attach to.
+			// advice: Function
+			//		This is function to be called around the original method
+		}
+
+	};
+=====*/
+
+	"use strict";
+	var nextId = 0;
+	function advise(dispatcher, type, advice, receiveArguments){
+		var previous = dispatcher[type];
+		var around = type == "around";
+		var signal;
+		if(around){
+			var advised = advice(function(){
+				return previous.advice(this, arguments);
+			});
+			signal = {
+				remove: function(){
+					signal.cancelled = true;
+				},
+				advice: function(target, args){
+					return signal.cancelled ?
+						previous.advice(target, args) : // cancelled, skip to next one
+						advised.apply(target, args);	// called the advised function
+				}
+			};
+		}else{
+			// create the remove handler
+			signal = {
+				remove: function(){
+					var previous = signal.previous;
+					var next = signal.next;
+					if(!next && !previous){
+						delete dispatcher[type];
+					}else{
+						if(previous){
+							previous.next = next;
+						}else{
+							dispatcher[type] = next;
+						}
+						if(next){
+							next.previous = previous;
+						}
+					}
+				},
+				id: nextId++,
+				advice: advice,
+				receiveArguments: receiveArguments
+			};
+		}
+		if(previous && !around){
+			if(type == "after"){
+				// add the listener to the end of the list
+				var next = previous;
+				while(next){
+					previous = next;
+					next = next.next;
+				}
+				previous.next = signal;
+				signal.previous = previous;
+			}else if(type == "before"){
+				// add to beginning
+				dispatcher[type] = signal;
+				signal.next = previous;
+				previous.previous = signal;
+			}
+		}else{
+			// around or first one just replaces
+			dispatcher[type] = signal;
+		}
+		return signal;
+	}
+	function aspect(type){
+		return function(target, methodName, advice, receiveArguments){
+			var existing = target[methodName], dispatcher;
+			if(!existing || existing.target != target){
+				// no dispatcher in place
+				target[methodName] = dispatcher = function(){
+					var executionId = nextId;
+					// before advice
+					var args = arguments;
+					var before = dispatcher.before;
+					while(before){
+						args = before.advice.apply(this, args) || args;
+						before = before.next;
+					}
+					// around advice
+					if(dispatcher.around){
+						var results = dispatcher.around.advice(this, args);
+					}
+					// after advice
+					var after = dispatcher.after;
+					while(after && after.id < executionId){
+						results = after.receiveArguments ? after.advice.apply(this, args) || results :
+								after.advice.call(this, results);
+						after = after.next;
+					}
+					return results;
+				};
+				if(existing){
+					dispatcher.around = {advice: function(target, args){
+						return existing.apply(target, args);
+					}};
+				}
+				dispatcher.target = target;
+			}
+			var results = advise((dispatcher || existing), type, advice, receiveArguments);
+			advice = null;
+			return results;
+		};
+	}
+	return {
+		before: aspect("before"),
+		around: aspect("around"),
+		after: aspect("after")
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/back.js b/js/dojo-1.7.2/dojo/back.js
new file mode 100644
index 0000000..09ded6e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/back.js
@@ -0,0 +1,398 @@
+//>>built
+define("dojo/back", ["./_base/kernel", "./_base/lang", "./_base/sniff", "./dom", "./dom-construct", "./_base/window", "require"], function(dojo, lang, sniff, dom, domConstruct, baseWindow, require) {
+	// module:
+	//		dojo/back
+	// summary:
+	//		TODOC
+
+	lang.getObject("back", true, dojo);
+
+/*=====
+dojo.back = {
+	// summary: Browser history management resources
+};
+=====*/
+
+	var back = dojo.back,
+
+	// everyone deals with encoding the hash slightly differently
+
+	getHash = back.getHash = function(){
+		var h = window.location.hash;
+		if(h.charAt(0) == "#"){ h = h.substring(1); }
+		return sniff("mozilla") ? h : decodeURIComponent(h);
+	},
+
+	setHash = back.setHash = function(h){
+		if(!h){ h = ""; }
+		window.location.hash = encodeURIComponent(h);
+		historyCounter = history.length;
+	};
+
+	var initialHref = (typeof(window) !== "undefined") ? window.location.href : "";
+	var initialHash = (typeof(window) !== "undefined") ? getHash() : "";
+	var initialState = null;
+
+	var locationTimer = null;
+	var bookmarkAnchor = null;
+	var historyIframe = null;
+	var forwardStack = [];
+	var historyStack = [];
+	var moveForward = false;
+	var changingUrl = false;
+	var historyCounter;
+
+	function handleBackButton(){
+		//summary: private method. Do not call this directly.
+
+		//The "current" page is always at the top of the history stack.
+		var current = historyStack.pop();
+		if(!current){ return; }
+		var last = historyStack[historyStack.length-1];
+		if(!last && historyStack.length == 0){
+			last = initialState;
+		}
+		if(last){
+			if(last.kwArgs["back"]){
+				last.kwArgs["back"]();
+			}else if(last.kwArgs["backButton"]){
+				last.kwArgs["backButton"]();
+			}else if(last.kwArgs["handle"]){
+				last.kwArgs.handle("back");
+			}
+		}
+		forwardStack.push(current);
+	}
+
+	back.goBack = handleBackButton;
+
+	function handleForwardButton(){
+		//summary: private method. Do not call this directly.
+		var last = forwardStack.pop();
+		if(!last){ return; }
+		if(last.kwArgs["forward"]){
+			last.kwArgs.forward();
+		}else if(last.kwArgs["forwardButton"]){
+			last.kwArgs.forwardButton();
+		}else if(last.kwArgs["handle"]){
+			last.kwArgs.handle("forward");
+		}
+		historyStack.push(last);
+	}
+
+	back.goForward = handleForwardButton;
+
+	function createState(url, args, hash){
+		//summary: private method. Do not call this directly.
+		return {"url": url, "kwArgs": args, "urlHash": hash};	//Object
+	}
+
+	function getUrlQuery(url){
+		//summary: private method. Do not call this directly.
+		var segments = url.split("?");
+		if(segments.length < 2){
+			return null; //null
+		}
+		else{
+			return segments[1]; //String
+		}
+	}
+
+	function loadIframeHistory(){
+		//summary: private method. Do not call this directly.
+		var url = (dojo.config["dojoIframeHistoryUrl"] || require.toUrl("./resources/iframe_history.html")) + "?" + (new Date()).getTime();
+		moveForward = true;
+		if(historyIframe){
+			sniff("webkit") ? historyIframe.location = url : window.frames[historyIframe.name].location = url;
+		}else{
+			//console.warn("dojo.back: Not initialised. You need to call dojo.back.init() from a <script> block that lives inside the <body> tag.");
+		}
+		return url; //String
+	}
+
+	function checkLocation(){
+		if(!changingUrl){
+			var hsl = historyStack.length;
+
+			var hash = getHash();
+
+			if((hash === initialHash||window.location.href == initialHref)&&(hsl == 1)){
+				// FIXME: could this ever be a forward button?
+				// we can't clear it because we still need to check for forwards. Ugg.
+				// clearInterval(this.locationTimer);
+				handleBackButton();
+				return;
+			}
+
+			// first check to see if we could have gone forward. We always halt on
+			// a no-hash item.
+			if(forwardStack.length > 0){
+				if(forwardStack[forwardStack.length-1].urlHash === hash){
+					handleForwardButton();
+					return;
+				}
+			}
+
+			// ok, that didn't work, try someplace back in the history stack
+			if((hsl >= 2)&&(historyStack[hsl-2])){
+				if(historyStack[hsl-2].urlHash === hash){
+					handleBackButton();
+				}
+			}
+		}
+	}
+
+	back.init = function(){
+		//summary: Initializes the undo stack. This must be called from a <script>
+		//		   block that lives inside the <body> tag to prevent bugs on IE.
+		// description:
+		//		Only call this method before the page's DOM is finished loading. Otherwise
+		//		it will not work. Be careful with xdomain loading or djConfig.debugAtAllCosts scenarios,
+		//		in order for this method to work, dojo.back will need to be part of a build layer.
+
+		// prevent reinit
+		if(dom.byId("dj_history")){ return; } 
+
+		var src = dojo.config["dojoIframeHistoryUrl"] || require.toUrl("./resources/iframe_history.html");
+		if (dojo._postLoad) {
+			console.error("dojo.back.init() must be called before the DOM has loaded. "
+						+ "If using xdomain loading or djConfig.debugAtAllCosts, include dojo.back "
+						+ "in a build layer.");
+		} else {
+			document.write('<iframe style="border:0;width:1px;height:1px;position:absolute;visibility:hidden;bottom:0;right:0;" name="dj_history" id="dj_history" src="' + src + '"></iframe>');
+		}
+	};
+
+	back.setInitialState = function(/*Object*/args){
+		//summary:
+		//		Sets the state object and back callback for the very first page
+		//		that is loaded.
+		//description:
+		//		It is recommended that you call this method as part of an event
+		//		listener that is registered via dojo.addOnLoad().
+		//args: Object
+		//		See the addToHistory() function for the list of valid args properties.
+		initialState = createState(initialHref, args, initialHash);
+	};
+
+	//FIXME: Make these doc comments not be awful. At least they're not wrong.
+	//FIXME: Would like to support arbitrary back/forward jumps. Have to rework iframeLoaded among other things.
+	//FIXME: is there a slight race condition in moz using change URL with the timer check and when
+	//		 the hash gets set? I think I have seen a back/forward call in quick succession, but not consistent.
+
+
+	/*=====
+	dojo.__backArgs = function(kwArgs){
+		// back: Function?
+		//		A function to be called when this state is reached via the user
+		//		clicking the back button.
+		//	forward: Function?
+		//		Upon return to this state from the "back, forward" combination
+		//		of navigation steps, this function will be called. Somewhat
+		//		analgous to the semantic of an "onRedo" event handler.
+		//	changeUrl: Boolean?|String?
+		//		Boolean indicating whether or not to create a unique hash for
+		//		this state. If a string is passed instead, it is used as the
+		//		hash.
+	}
+	=====*/
+
+	back.addToHistory = function(/*dojo.__backArgs*/ args){
+		//	summary:
+		//		adds a state object (args) to the history list.
+		//	args: dojo.__backArgs
+		//		The state object that will be added to the history list.
+		//	description:
+		//		To support getting back button notifications, the object
+		//		argument should implement a function called either "back",
+		//		"backButton", or "handle". The string "back" will be passed as
+		//		the first and only argument to this callback.
+		//
+		//		To support getting forward button notifications, the object
+		//		argument should implement a function called either "forward",
+		//		"forwardButton", or "handle". The string "forward" will be
+		//		passed as the first and only argument to this callback.
+		//
+		//		If you want the browser location string to change, define "changeUrl" on the object. If the
+		//		value of "changeUrl" is true, then a unique number will be appended to the URL as a fragment
+		//		identifier (http://some.domain.com/path#uniquenumber). If it is any other value that does
+		//		not evaluate to false, that value will be used as the fragment identifier. For example,
+		//		if changeUrl: 'page1', then the URL will look like: http://some.domain.com/path#page1
+		//
+		//		There are problems with using dojo.back with semantically-named fragment identifiers
+		//		("hash values" on an URL). In most browsers it will be hard for dojo.back to know
+		//		distinguish a back from a forward event in those cases. For back/forward support to
+		//		work best, the fragment ID should always be a unique value (something using new Date().getTime()
+		//		for example). If you want to detect hash changes using semantic fragment IDs, then
+		//		consider using dojo.hash instead (in Dojo 1.4+).
+		//
+		//	example:
+		//		|	dojo.back.addToHistory({
+		//		|		back: function(){ console.log('back pressed'); },
+		//		|		forward: function(){ console.log('forward pressed'); },
+		//		|		changeUrl: true
+		//		|	});
+
+		//	BROWSER NOTES:
+		//	Safari 1.2:
+		//	back button "works" fine, however it's not possible to actually
+		//	DETECT that you've moved backwards by inspecting window.location.
+		//	Unless there is some other means of locating.
+		//	FIXME: perhaps we can poll on history.length?
+		//	Safari 2.0.3+ (and probably 1.3.2+):
+		//	works fine, except when changeUrl is used. When changeUrl is used,
+		//	Safari jumps all the way back to whatever page was shown before
+		//	the page that uses dojo.undo.browser support.
+		//	IE 5.5 SP2:
+		//	back button behavior is macro. It does not move back to the
+		//	previous hash value, but to the last full page load. This suggests
+		//	that the iframe is the correct way to capture the back button in
+		//	these cases.
+		//	Don't test this page using local disk for MSIE. MSIE will not create
+		//	a history list for iframe_history.html if served from a file: URL.
+		//	The XML served back from the XHR tests will also not be properly
+		//	created if served from local disk. Serve the test pages from a web
+		//	server to test in that browser.
+		//	IE 6.0:
+		//	same behavior as IE 5.5 SP2
+		//	Firefox 1.0+:
+		//	the back button will return us to the previous hash on the same
+		//	page, thereby not requiring an iframe hack, although we do then
+		//	need to run a timer to detect inter-page movement.
+
+		//If addToHistory is called, then that means we prune the
+		//forward stack -- the user went back, then wanted to
+		//start a new forward path.
+		forwardStack = [];
+
+		var hash = null;
+		var url = null;
+		if(!historyIframe){
+			if(dojo.config["useXDomain"] && !dojo.config["dojoIframeHistoryUrl"]){
+				console.warn("dojo.back: When using cross-domain Dojo builds,"
+					+ " please save iframe_history.html to your domain and set djConfig.dojoIframeHistoryUrl"
+					+ " to the path on your domain to iframe_history.html");
+			}
+			historyIframe = window.frames["dj_history"];
+		}
+		if(!bookmarkAnchor){
+			bookmarkAnchor = domConstruct.create("a", {style: {display: "none"}}, baseWindow.body());
+		}
+		if(args["changeUrl"]){
+			hash = ""+ ((args["changeUrl"]!==true) ? args["changeUrl"] : (new Date()).getTime());
+
+			//If the current hash matches the new one, just replace the history object with
+			//this new one. It doesn't make sense to track different state objects for the same
+			//logical URL. This matches the browser behavior of only putting in one history
+			//item no matter how many times you click on the same #hash link, at least in Firefox
+			//and Safari, and there is no reliable way in those browsers to know if a #hash link
+			//has been clicked on multiple times. So making this the standard behavior in all browsers
+			//so that dojo.back's behavior is the same in all browsers.
+			if(historyStack.length == 0 && initialState.urlHash == hash){
+				initialState = createState(url, args, hash);
+				return;
+			}else if(historyStack.length > 0 && historyStack[historyStack.length - 1].urlHash == hash){
+				historyStack[historyStack.length - 1] = createState(url, args, hash);
+				return;
+			}
+
+			changingUrl = true;
+			setTimeout(function() {
+					setHash(hash);
+					changingUrl = false;
+				}, 1);
+			bookmarkAnchor.href = hash;
+
+			if(sniff("ie")){
+				url = loadIframeHistory();
+
+				var oldCB = args["back"]||args["backButton"]||args["handle"];
+
+				//The function takes handleName as a parameter, in case the
+				//callback we are overriding was "handle". In that case,
+				//we will need to pass the handle name to handle.
+				var tcb = function(handleName){
+					if(getHash() != ""){
+						setTimeout(function() { setHash(hash); }, 1);
+					}
+					//Use apply to set "this" to args, and to try to avoid memory leaks.
+					oldCB.apply(this, [handleName]);
+				};
+
+				//Set interceptor function in the right place.
+				if(args["back"]){
+					args.back = tcb;
+				}else if(args["backButton"]){
+					args.backButton = tcb;
+				}else if(args["handle"]){
+					args.handle = tcb;
+				}
+
+				var oldFW = args["forward"]||args["forwardButton"]||args["handle"];
+
+				//The function takes handleName as a parameter, in case the
+				//callback we are overriding was "handle". In that case,
+				//we will need to pass the handle name to handle.
+				var tfw = function(handleName){
+					if(getHash() != ""){
+						setHash(hash);
+					}
+					if(oldFW){ // we might not actually have one
+						//Use apply to set "this" to args, and to try to avoid memory leaks.
+						oldFW.apply(this, [handleName]);
+					}
+				};
+
+				//Set interceptor function in the right place.
+				if(args["forward"]){
+					args.forward = tfw;
+				}else if(args["forwardButton"]){
+					args.forwardButton = tfw;
+				}else if(args["handle"]){
+					args.handle = tfw;
+				}
+
+			}else if(!sniff("ie")){
+				// start the timer
+				if(!locationTimer){
+					locationTimer = setInterval(checkLocation, 200);
+				}
+
+			}
+		}else{
+			url = loadIframeHistory();
+		}
+
+		historyStack.push(createState(url, args, hash));
+	};
+
+	back._iframeLoaded = function(evt, ifrLoc){
+		//summary:
+		//		private method. Do not call this directly.
+		var query = getUrlQuery(ifrLoc.href);
+		if(query == null){
+			// alert("iframeLoaded");
+			// we hit the end of the history, so we should go back
+			if(historyStack.length == 1){
+				handleBackButton();
+			}
+			return;
+		}
+		if(moveForward){
+			// we were expecting it, so it's not either a forward or backward movement
+			moveForward = false;
+			return;
+		}
+
+		//Check the back stack first, since it is more likely.
+		//Note that only one step back or forward is supported.
+		if(historyStack.length >= 2 && query == getUrlQuery(historyStack[historyStack.length-2].url)){
+			handleBackButton();
+		}else if(forwardStack.length > 0 && query == getUrlQuery(forwardStack[forwardStack.length-1].url)){
+			handleForwardButton();
+		}
+	};
+
+	return dojo.back;
+	
+});
diff --git a/js/dojo-1.7.2/dojo/behavior.js b/js/dojo-1.7.2/dojo/behavior.js
new file mode 100644
index 0000000..28b3cdf
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/behavior.js
@@ -0,0 +1,249 @@
+//>>built
+define("dojo/behavior", ["./_base/kernel", "./_base/lang", "./_base/array", "./_base/connect", "./query", "./ready"], function(dojo, lang, darray, connect, query, ready) {
+	// module:
+	//		dojo/behavior
+	// summary:
+	//		TODOC
+
+
+dojo.behavior = new function(){
+	// summary:
+	//		Utility for unobtrusive/progressive event binding, DOM traversal,
+	//		and manipulation.
+	//
+	// description:
+	//
+	//		A very simple, lightweight mechanism for applying code to
+	//		existing documents, based around `dojo.query` (CSS3 selectors) for node selection,
+	//		and a simple two-command API: `dojo.behavior.add()` and `dojo.behavior.apply()`;
+	//
+	//		Behaviors apply to a given page, and are registered following the syntax
+	//		options described by `dojo.behavior.add` to match nodes to actions, or "behaviors".
+	//
+	//		Added behaviors are applied to the current DOM when .apply() is called,
+	//		matching only new nodes found since .apply() was last called.
+	//
+	function arrIn(obj, name){
+		if(!obj[name]){ obj[name] = []; }
+		return obj[name];
+	}
+
+	var _inc = 0;
+
+	function forIn(obj, scope, func){
+		var tmpObj = {};
+		for(var x in obj){
+			if(typeof tmpObj[x] == "undefined"){
+				if(!func){
+					scope(obj[x], x);
+				}else{
+					func.call(scope, obj[x], x);
+				}
+			}
+		}
+	}
+
+	// FIXME: need a better test so we don't exclude nightly Safari's!
+	this._behaviors = {};
+	this.add = function(/* Object */behaviorObj){
+		// summary:
+		//		Add the specified behavior to the list of behaviors, ignoring existing
+		//		matches.
+		// behaviorObj: Object
+		//		The behavior object that will be added to behaviors list. The behaviors
+		//		in the list will be applied the next time apply() is called.
+		// description:
+		//		Add the specified behavior to the list of behaviors which will
+		//		be applied the next time apply() is called. Calls to add() for
+		//		an already existing behavior do not replace the previous rules,
+		//		but are instead additive. New nodes which match the rule will
+		//		have all add()-ed behaviors applied to them when matched.
+		//
+		//		The "found" method is a generalized handler that's called as soon
+		//		as the node matches the selector. Rules for values that follow also
+		//		apply to the "found" key.
+		//
+		//		The "on*" handlers are attached with `dojo.connect()`, using the
+		//		matching node
+		//
+		//		If the value corresponding to the ID key is a function and not a
+		//		list, it's treated as though it was the value of "found".
+		//
+		// 		dojo.behavior.add() can be called any number of times before
+		//		the DOM is ready. `dojo.behavior.apply()` is called automatically
+		//		by `dojo.addOnLoad`, though can be called to re-apply previously added
+		//		behaviors anytime the DOM changes.
+		//
+		//		There are a variety of formats permitted in the behaviorObject
+		//
+		// example:
+		//		Simple list of properties. "found" is special. "Found" is assumed if
+		//		no property object for a given selector, and property is a function.
+		//
+		//	|	dojo.behavior.add({
+		//	|		"#id": {
+		//	|			"found": function(element){
+		//	|				// node match found
+		//	|			},
+		//	|			"onclick": function(evt){
+		//	|				// register onclick handler for found node
+		//	|			}
+		//	|		},
+		// 	|		"#otherid": function(element){
+		//	|			// assumes "found" with this syntax
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//		 If property is a string, a dojo.publish will be issued on the channel:
+		//
+		//	|	dojo.behavior.add({
+		//	|		// dojo.publish() whenever class="noclick" found on anchors
+		//	|		"a.noclick": "/got/newAnchor",
+		//	|		"div.wrapper": {
+		//	|			"onclick": "/node/wasClicked"
+		//	|		}
+		//	|	});
+		//	|	dojo.subscribe("/got/newAnchor", function(node){
+		//	|		// handle node finding when dojo.behavior.apply() is called,
+		//	|		// provided a newly matched node is found.
+		//	|	});
+		//
+		// example:
+		//		Scoping can be accomplished by passing an object as a property to
+		//		a connection handle (on*):
+		//
+		//	|	dojo.behavior.add({
+		//	|		 	"#id": {
+		//	|				// like calling dojo.hitch(foo,"bar"). execute foo.bar() in scope of foo
+		//	|				"onmouseenter": { targetObj: foo, targetFunc: "bar" },
+		//	|				"onmouseleave": { targetObj: foo, targetFunc: "baz" }
+		//	|			}
+		//	|	});
+		//
+		// example:
+		//		Bahaviors match on CSS3 Selectors, powered by dojo.query. Example selectors:
+		//
+		//	|	dojo.behavior.add({
+		//	|		// match all direct descendants
+		//	|		"#id4 > *": function(element){
+		//	|			// ...
+		//	|		},
+		//	|
+		//	|		// match the first child node that's an element
+		//	|		"#id4 > :first-child": { ... },
+		//	|
+		//	|		// match the last child node that's an element
+		//	|		"#id4 > :last-child":  { ... },
+		//	|
+		//	|		// all elements of type tagname
+		//	|		"tagname": {
+		//	|			// ...
+		//	|		},
+		//	|
+		//	|		"tagname1 tagname2 tagname3": {
+		//	|			// ...
+		//	|		},
+		//	|
+		//	|		".classname": {
+		//	|			// ...
+		//	|		},
+		//	|
+		//	|		"tagname.classname": {
+		//	|			// ...
+		//	|		}
+		//	|	});
+		//
+
+		forIn(behaviorObj, this, function(behavior, name){
+			var tBehavior = arrIn(this._behaviors, name);
+			if(typeof tBehavior["id"] != "number"){
+				tBehavior.id = _inc++;
+			}
+			var cversion = [];
+			tBehavior.push(cversion);
+			if((lang.isString(behavior))||(lang.isFunction(behavior))){
+				behavior = { found: behavior };
+			}
+			forIn(behavior, function(rule, ruleName){
+				arrIn(cversion, ruleName).push(rule);
+			});
+		});
+	};
+
+	var _applyToNode = function(node, action, ruleSetName){
+		if(lang.isString(action)){
+			if(ruleSetName == "found"){
+				connect.publish(action, [ node ]);
+			}else{
+				connect.connect(node, ruleSetName, function(){
+					connect.publish(action, arguments);
+				});
+			}
+		}else if(lang.isFunction(action)){
+			if(ruleSetName == "found"){
+				action(node);
+			}else{
+				connect.connect(node, ruleSetName, action);
+			}
+		}
+	};
+
+	this.apply = function(){
+		// summary:
+		//		Applies all currently registered behaviors to the document.
+		//
+		// description:
+		//		Applies all currently registered behaviors to the document,
+		//		taking care to ensure that only incremental updates are made
+		//		since the last time add() or apply() were called.
+		//
+		//		If new matching nodes have been added, all rules in a behavior will be
+		//		applied to that node. For previously matched nodes, only
+		//		behaviors which have been added since the last call to apply()
+		//		will be added to the nodes.
+		//
+		//		apply() is called once automatically by `dojo.addOnLoad`, so
+		//		registering behaviors with `dojo.behavior.add` before the DOM is
+		//		ready is acceptable, provided the dojo.behavior module is ready.
+		//
+		//		Calling appy() manually after manipulating the DOM is required
+		//		to rescan the DOM and apply newly .add()ed behaviors, or to match
+		//		nodes that match existing behaviors when those nodes are added to
+		//		the DOM.
+		//
+		forIn(this._behaviors, function(tBehavior, id){
+			query(id).forEach(
+				function(elem){
+					var runFrom = 0;
+					var bid = "_dj_behavior_"+tBehavior.id;
+					if(typeof elem[bid] == "number"){
+						runFrom = elem[bid];
+						if(runFrom == (tBehavior.length)){
+							return;
+						}
+					}
+					// run through the versions, applying newer rules at each step
+
+					for(var x=runFrom, tver; tver = tBehavior[x]; x++){
+						forIn(tver, function(ruleSet, ruleSetName){
+							if(lang.isArray(ruleSet)){
+								darray.forEach(ruleSet, function(action){
+									_applyToNode(elem, action, ruleSetName);
+								});
+							}
+						});
+					}
+
+					// ensure that re-application only adds new rules to the node
+					elem[bid] = tBehavior.length;
+				}
+			);
+		});
+	};
+};
+
+ready(dojo.behavior, "apply"); // FIXME: should this use a priority? before/after parser priority?
+
+return dojo.behavior;
+});
diff --git a/js/dojo-1.7.2/dojo/cache.js b/js/dojo-1.7.2/dojo/cache.js
new file mode 100644
index 0000000..c6ff260
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cache.js
@@ -0,0 +1,10 @@
+//>>built
+define("dojo/cache", ["./_base/kernel", "./text"], function(dojo, text){
+	// module:
+	//		dojo/cache
+	// summary:
+	//		The module defines dojo.cache by loading dojo/text.
+
+	//dojo.cache is defined in dojo/text
+	return dojo.cache;
+});
diff --git a/js/dojo-1.7.2/dojo/cldr/LICENSE b/js/dojo-1.7.2/dojo/cldr/LICENSE
new file mode 100644
index 0000000..7aeb1dd
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/LICENSE
@@ -0,0 +1,29 @@
+UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
+
+Unicode Data Files include all data files under the directories http://www.unicode.org/Public/, http://www.unicode.org/reports/, 
+and http://www.unicode.org/cldr/data/ . Unicode Software includes any source code published in the Unicode Standard or under
+the directories http://www.unicode.org/Public/, http://www.unicode.org/reports/, and http://www.unicode.org/cldr/data/.
+NOTICE TO USER: Carefully read the following legal agreement. BY DOWNLOADING, INSTALLING, COPYING OR 
+OTHERWISE USING UNICODE INC.'S DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"), YOU
+UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS OF THIS
+AGREEMENT. IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+COPYRIGHT AND PERMISSION NOTICE
+Copyright © 1991-2007 Unicode, Inc. All rights reserved. Distributed under the Terms of Use in http://www.unicode.org/copyright.html.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of the Unicode data files and any associated
+documentation (the "Data Files") or Unicode software and any associated documentation (the "Software") to deal in the Data 
+Files or Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell 
+copies of the Data Files or Software, and to permit persons to whom the Data Files or Software are furnished to do so, provided
+that (a) the above copyright notice(s) and this permission notice appear with all copies of the Data Files or Software, (b) both the
+above copyright notice(s) and this permission notice appear in associated documentation, and (c) there is clear notice in each modified Data File 
+or in the Software as well as in the documentation associated with the Data File(s) or Software that the data or software has been modified.
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE 
+AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
+INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, 
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF 
+CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+Except as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other 
+dealings in these Data Files or Software without prior written authorization of the copyright holder.
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/README b/js/dojo-1.7.2/dojo/cldr/README
new file mode 100644
index 0000000..3687676
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/README
@@ -0,0 +1,18 @@
+All files within this directory were derived from the Common Locale
+Data Repository (see http://unicode.org/cldr)  The CLDR project is
+responsible for the accuracy and maintenance of this data.  A copy
+of this data is checked into the Dojo util project as a zip file.
+The XML data is transformed to the JSON-style Javascript you see
+under the nls/ directory.  These Javascript files include data
+necessary to do things like format and parse dates, numbers, and
+currencies in different locales to consider cultural differences.
+They are used by other modules in core Dojo such as dojo.date,
+dojo.number and dojo.currency.  It usually is not necessary to use
+dojo.cldr directly.
+
+An arbitrary subset of locales have been checked in to dojo/cldr
+under svn.  To support other locales, the full set may be generated
+by using xslt scripts in the util/buildscripts/cldr/ ant script.
+Hundreds of locales are supported by the CLDR project.
+
+See terms of use: http://www.unicode.org/copyright.html#Exhibit1
diff --git a/js/dojo-1.7.2/dojo/cldr/monetary.js b/js/dojo-1.7.2/dojo/cldr/monetary.js
new file mode 100644
index 0000000..a277173
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/monetary.js
@@ -0,0 +1,36 @@
+//>>built
+define("dojo/cldr/monetary", ["../main"], function(dojo) {
+	// module:
+	//		dojo/cldr/monetary
+	// summary:
+	//		TODOC
+
+dojo.getObject("cldr.monetary", true, dojo);
+
+dojo.cldr.monetary.getData = function(/*String*/code){
+// summary: A mapping of currency code to currency-specific formatting information. Returns a unique object with properties: places, round.
+// code: an [ISO 4217](http://en.wikipedia.org/wiki/ISO_4217) currency code
+
+// from http://www.unicode.org/cldr/data/common/supplemental/supplementalData.xml:supplementalData/currencyData/fractions
+
+	var placesData = {
+		ADP:0,AFN:0,ALL:0,AMD:0,BHD:3,BIF:0,BYR:0,CLF:0,CLP:0,
+		COP:0,CRC:0,DJF:0,ESP:0,GNF:0,GYD:0,HUF:0,IDR:0,IQD:0,
+		IRR:3,ISK:0,ITL:0,JOD:3,JPY:0,KMF:0,KPW:0,KRW:0,KWD:3,
+		LAK:0,LBP:0,LUF:0,LYD:3,MGA:0,MGF:0,MMK:0,MNT:0,MRO:0,
+		MUR:0,OMR:3,PKR:0,PYG:0,RSD:0,RWF:0,SLL:0,SOS:0,STD:0,
+		SYP:0,TMM:0,TND:3,TRL:0,TZS:0,UGX:0,UZS:0,VND:0,VUV:0,
+		XAF:0,XOF:0,XPF:0,YER:0,ZMK:0,ZWD:0
+	};
+
+	var roundingData = {CHF:5};
+
+	var places = placesData[code], round = roundingData[code];
+	if(typeof places == "undefined"){ places = 2; }
+	if(typeof round == "undefined"){ round = 0; }
+
+	return {places: places, round: round}; // Object
+};
+
+return dojo.cldr.monetary;
+});
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ar/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/ar/buddhist.js
new file mode 100644
index 0000000..6c567a3
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ar/buddhist.js
@@ -0,0 +1,116 @@
+//>>built
+define(
+"dojo/cldr/nls/ar/buddhist", //begin v1.x content
+{
+	"dateFormatItem-yM": "M�/y G",
+	"dateFormatItem-yQ": "yyyy Q",
+	"dayPeriods-format-wide-pm": "Ù…",
+	"eraNames": [
+		"التقويم البوذي"
+	],
+	"dateFormatItem-MMMEd": "E d MMM",
+	"dateFormatItem-MMdd": "dd�/MM",
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"ÙŠ",
+		"Ù�",
+		"Ù…",
+		"Ø£",
+		"Ùˆ",
+		"Ù†",
+		"Ù„",
+		"غ",
+		"س",
+		"Ùƒ",
+		"ب",
+		"د"
+	],
+	"dayPeriods-format-wide-am": "ص",
+	"dateFormatItem-y": "y G",
+	"timeFormat-full": "zzzz h:mm:ss a",
+	"dateFormatItem-Ed": "E، d",
+	"dateFormatItem-yMMM": "MMM y G",
+	"days-standAlone-narrow": [
+		"Ø­",
+		"Ù†",
+		"Ø«",
+		"ر",
+		"Ø®",
+		"ج",
+		"س"
+	],
+	"eraAbbr": [
+		"التقويم البوذي"
+	],
+	"dateFormatItem-yyyyMM": "MM�/y G",
+	"dateFormatItem-yyyyMMMM": "MMMM، y G",
+	"dateFormat-long": "d MMMM، y G",
+	"timeFormat-medium": "h:mm:ss a",
+	"dateFormatItem-Hm": "HH:mm",
+	"dateFormat-medium": "dd�/MM�/y G",
+	"dateFormatItem-yMd": "d/�M/�y G",
+	"dateFormatItem-yMMMM": "MMMM y G",
+	"dateFormatItem-ms": "mm:ss",
+	"quarters-standAlone-narrow": [
+		"Ù¡",
+		"Ù¢",
+		"Ù£",
+		"Ù¤"
+	],
+	"dateFormatItem-MMMMEd": "E d MMMM",
+	"dateFormatItem-MMMd": "d MMM",
+	"timeFormat-long": "z h:mm:ss a",
+	"timeFormat-short": "h:mm a",
+	"dateFormatItem-MMMMd": "d MMMM",
+	"days-format-abbr": [
+		"أحد",
+		"إثنين",
+		"ثلاثاء",
+		"أربعاء",
+		"خميس",
+		"جمعة",
+		"سبت"
+	],
+	"dateFormatItem-M": "L",
+	"dateFormatItem-yMMMd": "d MMMM y G",
+	"dateFormat-short": "d�/M�/y G",
+	"dateFormatItem-yMMMEd": "EEE، d MMMM y G",
+	"dateFormat-full": "EEEE، d MMMM، y G",
+	"dateFormatItem-Md": "d/�M",
+	"dateFormatItem-yMEd": "EEE، d/�M/�y G",
+	"months-format-wide": [
+		"يناير",
+		"�براير",
+		"مارس",
+		"أبريل",
+		"مايو",
+		"يونيو",
+		"يوليو",
+		"أغسطس",
+		"سبتمبر",
+		"أكتوبر",
+		"نو�مبر",
+		"ديسمبر"
+	],
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"الربع الأول",
+		"الربع الثاني",
+		"الربع الثالث",
+		"الربع الرابع"
+	],
+	"eraNarrow": [
+		"التقويم البوذي"
+	],
+	"days-format-wide": [
+		"الأحد",
+		"الإثنين",
+		"الثلاثاء",
+		"الأربعاء",
+		"الخميس",
+		"الجمعة",
+		"السبت"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ar/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/ar/currency.js
new file mode 100644
index 0000000..9fd389c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ar/currency.js
@@ -0,0 +1,17 @@
+//>>built
+define(
+"dojo/cldr/nls/ar/currency", //begin v1.x content
+{
+	"HKD_displayName": "دولار هونج كونج",
+	"CHF_displayName": "�رنك سويسري",
+	"CAD_displayName": "دولار كندي",
+	"CNY_displayName": "يوان صيني",
+	"AUD_displayName": "دولار أسترالي",
+	"JPY_displayName": "ين ياباني",
+	"USD_displayName": "دولار أمريكي",
+	"CNY_symbol": "ي.ص",
+	"GBP_displayName": "جنيه إسترليني",
+	"EUR_displayName": "يورو"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ar/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/ar/gregorian.js
new file mode 100644
index 0000000..dd40078
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ar/gregorian.js
@@ -0,0 +1,241 @@
+//>>built
+define(
+"dojo/cldr/nls/ar/gregorian", //begin v1.x content
+{
+	"dateFormatItem-yM": "M�/yyyy",
+	"field-dayperiod": "ص/م",
+	"dateFormatItem-yQ": "yyyy Q",
+	"dayPeriods-format-wide-pm": "Ù…",
+	"field-minute": "الدقائق",
+	"eraNames": [
+		"قبل الميلاد",
+		"ميلادي"
+	],
+	"dateFormatItem-MMMEd": "E d MMM",
+	"field-day-relative+-1": "أمس",
+	"field-weekday": "اليوم",
+	"dateFormatItem-yQQQ": "y QQQ",
+	"dateFormatItem-MMdd": "dd�/MM",
+	"days-standAlone-wide": [
+		"الأحد",
+		"الإثنين",
+		"الثلاثاء",
+		"الأربعاء",
+		"الخميس",
+		"الجمعة",
+		"السبت"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"ÙŠ",
+		"Ù�",
+		"Ù…",
+		"Ø£",
+		"Ùˆ",
+		"Ù†",
+		"Ù„",
+		"غ",
+		"س",
+		"Ùƒ",
+		"ب",
+		"د"
+	],
+	"field-era": "العصر",
+	"field-hour": "الساعات",
+	"dayPeriods-format-wide-am": "ص",
+	"quarters-standAlone-abbr": [
+		"الربع الأول",
+		"الربع الثاني",
+		"الربع الثالث",
+		"الربع الرابع"
+	],
+	"dateFormatItem-y": "y",
+	"timeFormat-full": "zzzz h:mm:ss a",
+	"months-standAlone-abbr": [
+		"يناير",
+		"�براير",
+		"مارس",
+		"أبريل",
+		"مايو",
+		"يونيو",
+		"يوليو",
+		"أغسطس",
+		"سبتمبر",
+		"أكتوبر",
+		"نو�مبر",
+		"ديسمبر"
+	],
+	"dateFormatItem-Ed": "E، d",
+	"dateFormatItem-yMMM": "MMM y",
+	"field-day-relative+0": "اليوم",
+	"field-day-relative+1": "غدًا",
+	"days-standAlone-narrow": [
+		"Ø­",
+		"Ù†",
+		"Ø«",
+		"ر",
+		"Ø®",
+		"ج",
+		"س"
+	],
+	"eraAbbr": [
+		"Ù‚.Ù…",
+		"Ù…"
+	],
+	"field-day-relative+2": "بعد الغد",
+	"dateFormatItem-yyyyMM": "MM�/yyyy",
+	"dateFormatItem-yyyyMMMM": "MMMM، y",
+	"dateFormat-long": "d MMMM، y",
+	"timeFormat-medium": "h:mm:ss a",
+	"field-zone": "التوقيت",
+	"dateFormatItem-Hm": "HH:mm",
+	"dateFormat-medium": "dd�/MM�/yyyy",
+	"quarters-standAlone-wide": [
+		"الربع الأول",
+		"الربع الثاني",
+		"الربع الثالث",
+		"الربع الرابع"
+	],
+	"dateFormatItem-yMMMM": "MMMM y",
+	"dateFormatItem-ms": "mm:ss",
+	"field-year": "السنة",
+	"quarters-standAlone-narrow": [
+		"Ù¡",
+		"Ù¢",
+		"Ù£",
+		"Ù¤"
+	],
+	"field-week": "الأسبوع",
+	"months-standAlone-wide": [
+		"يناير",
+		"�براير",
+		"مارس",
+		"أبريل",
+		"مايو",
+		"يونيو",
+		"يوليو",
+		"أغسطس",
+		"سبتمبر",
+		"أكتوبر",
+		"نو�مبر",
+		"ديسمبر"
+	],
+	"dateFormatItem-MMMMEd": "E d MMMM",
+	"dateFormatItem-MMMd": "d MMM",
+	"quarters-format-narrow": [
+		"Ù¡",
+		"Ù¢",
+		"Ù£",
+		"Ù¤"
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-long": "z h:mm:ss a",
+	"months-format-abbr": [
+		"يناير",
+		"�براير",
+		"مارس",
+		"أبريل",
+		"مايو",
+		"يونيو",
+		"يوليو",
+		"أغسطس",
+		"سبتمبر",
+		"أكتوبر",
+		"نو�مبر",
+		"ديسمبر"
+	],
+	"timeFormat-short": "h:mm a",
+	"field-month": "الشهر",
+	"dateFormatItem-MMMMd": "d MMMM",
+	"quarters-format-abbr": [
+		"الربع الأول",
+		"الربع الثاني",
+		"الربع الثالث",
+		"الربع الرابع"
+	],
+	"days-format-abbr": [
+		"أحد",
+		"إثنين",
+		"ثلاثاء",
+		"أربعاء",
+		"خميس",
+		"جمعة",
+		"سبت"
+	],
+	"dateFormatItem-M": "L",
+	"days-format-narrow": [
+		"Ø­",
+		"Ù†",
+		"Ø«",
+		"ر",
+		"Ø®",
+		"ج",
+		"س"
+	],
+	"field-second": "الثواني",
+	"field-day": "يوم",
+	"months-format-narrow": [
+		"ÙŠ",
+		"Ù�",
+		"Ù…",
+		"Ø£",
+		"Ùˆ",
+		"Ù†",
+		"Ù„",
+		"غ",
+		"س",
+		"Ùƒ",
+		"ب",
+		"د"
+	],
+	"days-standAlone-abbr": [
+		"أحد",
+		"إثنين",
+		"ثلاثاء",
+		"أربعاء",
+		"خميس",
+		"جمعة",
+		"سبت"
+	],
+	"dateFormat-short": "d�/M�/yyyy",
+	"dateFormatItem-yMMMEd": "EEE، d MMMM y",
+	"dateFormat-full": "EEEE، d MMMM، y",
+	"dateFormatItem-Md": "d/�M",
+	"dateFormatItem-yMEd": "EEE، d/�M/�yyyy",
+	"months-format-wide": [
+		"يناير",
+		"�براير",
+		"مارس",
+		"أبريل",
+		"مايو",
+		"يونيو",
+		"يوليو",
+		"أغسطس",
+		"سبتمبر",
+		"أكتوبر",
+		"نو�مبر",
+		"ديسمبر"
+	],
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"الربع الأول",
+		"الربع الثاني",
+		"الربع الثالث",
+		"الربع الرابع"
+	],
+	"days-format-wide": [
+		"الأحد",
+		"الإثنين",
+		"الثلاثاء",
+		"الأربعاء",
+		"الخميس",
+		"الجمعة",
+		"السبت"
+	],
+	"eraNarrow": [
+		"Ù‚.Ù…",
+		"Ù…"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ar/hebrew.js b/js/dojo-1.7.2/dojo/cldr/nls/ar/hebrew.js
new file mode 100644
index 0000000..8c162c6
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ar/hebrew.js
@@ -0,0 +1,125 @@
+//>>built
+define(
+"dojo/cldr/nls/ar/hebrew", //begin v1.x content
+{
+	"dateFormat-medium": "dd/MM/yyyy",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"dateFormatItem-yMEd": "EEE، d/M/yyyy",
+	"timeFormat-full": "zzzz h:mm:ss a",
+	"dateFormatItem-Md": "d/M",
+	"months-standAlone-wide": [
+		"تشري",
+		"مرحشوان",
+		"كيسلو",
+		"طي�ت",
+		"شباط",
+		"آذار الأول",
+		"آذار",
+		"نيسان",
+		"أيار",
+		"سي�ان",
+		"تموز",
+		"آب",
+		"أيلول"
+	],
+	"months-format-wide-leap": "آذار الثاني",
+	"days-standAlone-narrow": [
+		"Ø­",
+		"Ù†",
+		"Ø«",
+		"ر",
+		"Ø®",
+		"ج",
+		"س"
+	],
+	"dayPeriods-format-wide-pm": "Ù…",
+	"months-standAlone-abbr": [
+		"تشري",
+		"مرحشوان",
+		"كيسلو",
+		"طي�ت",
+		"شباط",
+		"آذار الأول",
+		"آذار",
+		"نيسان",
+		"أيار",
+		"سي�ان",
+		"تموز",
+		"آب",
+		"أيلول"
+	],
+	"dayPeriods-format-wide-am": "ص",
+	"quarters-standAlone-narrow": [
+		"Ù¡",
+		"Ù¢",
+		"Ù£",
+		"Ù¤"
+	],
+	"timeFormat-medium": "h:mm:ss a",
+	"dateFormat-long": "d MMMM، y",
+	"dateFormat-short": "d/M/yyyy",
+	"dateFormatItem-yMMMEd": "EEE، d MMMM y",
+	"months-format-wide": [
+		"تشري",
+		"مرحشوان",
+		"كيسلو",
+		"طي�ت",
+		"شباط",
+		"آذار الأول",
+		"آذار",
+		"نيسان",
+		"أيار",
+		"سي�ان",
+		"تموز",
+		"آب",
+		"أيلول"
+	],
+	"dateFormatItem-yM": "M/yyyy",
+	"timeFormat-short": "h:mm a",
+	"months-format-abbr": [
+		"تشري",
+		"مرحشوان",
+		"كيسلو",
+		"طي�ت",
+		"شباط",
+		"آذار الأول",
+		"آذار",
+		"نيسان",
+		"أيار",
+		"سي�ان",
+		"تموز",
+		"آب",
+		"أيلول"
+	],
+	"timeFormat-long": "z h:mm:ss a",
+	"days-format-wide": [
+		"الأحد",
+		"الإثنين",
+		"الثلاثاء",
+		"الأربعاء",
+		"الخميس",
+		"الجمعة",
+		"السبت"
+	],
+	"dateFormatItem-yQ": "yyyy Q",
+	"dateFormatItem-yMMM": "MMM y",
+	"quarters-format-wide": [
+		"الربع الأول",
+		"الربع الثاني",
+		"الربع الثالث",
+		"الربع الرابع"
+	],
+	"dateFormat-full": "EEEE، d MMMM، y",
+	"dateFormatItem-MMMd": "d MMM",
+	"days-format-abbr": [
+		"أحد",
+		"إثنين",
+		"ثلاثاء",
+		"أربعاء",
+		"خميس",
+		"جمعة",
+		"سبت"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ar/islamic.js b/js/dojo-1.7.2/dojo/cldr/nls/ar/islamic.js
new file mode 100644
index 0000000..371cd12
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ar/islamic.js
@@ -0,0 +1,157 @@
+//>>built
+define(
+"dojo/cldr/nls/ar/islamic", //begin v1.x content
+{
+	"dateFormat-medium": "dd/MM/yyyy",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"dateFormatItem-yMEd": "EEE، d/M/yyyy",
+	"eraNarrow": [
+		"هـ"
+	],
+	"months-format-narrow": [
+		"Ù…",
+		"ص",
+		"ر",
+		"ر",
+		"ج",
+		"ج",
+		"ر",
+		"Ø´",
+		"ر",
+		"Ø´",
+		"Ø°",
+		"Ø°"
+	],
+	"timeFormat-full": "zzzz h:mm:ss a",
+	"dateFormatItem-Md": "d/M",
+	"months-standAlone-narrow": [
+		"Ù…",
+		"ص",
+		"ر",
+		"ر",
+		"ج",
+		"ج",
+		"ر",
+		"Ø´",
+		"ر",
+		"Ø´",
+		"Ø°",
+		"Ø°"
+	],
+	"months-standAlone-wide": [
+		"محرم",
+		"ص�ر",
+		"ربيع الأول",
+		"ربيع الآخر",
+		"جمادى الأولى",
+		"جمادى الآخرة",
+		"رجب",
+		"شعبان",
+		"رمضان",
+		"شوال",
+		"ذو القعدة",
+		"ذو الحجة"
+	],
+	"eraNames": [
+		"هـ"
+	],
+	"days-standAlone-narrow": [
+		"Ø­",
+		"Ù†",
+		"Ø«",
+		"ر",
+		"Ø®",
+		"ج",
+		"س"
+	],
+	"dayPeriods-format-wide-pm": "Ù…",
+	"months-standAlone-abbr": [
+		"محرم",
+		"ص�ر",
+		"ربيع الأول",
+		"ربيع الآخر",
+		"جمادى الأولى",
+		"جمادى الآخرة",
+		"رجب",
+		"شعبان",
+		"رمضان",
+		"شوال",
+		"ذو القعدة",
+		"ذو الحجة"
+	],
+	"dayPeriods-format-wide-am": "ص",
+	"quarters-standAlone-narrow": [
+		"Ù¡",
+		"Ù¢",
+		"Ù£",
+		"Ù¤"
+	],
+	"timeFormat-medium": "h:mm:ss a",
+	"dateFormat-long": "d MMMM، y",
+	"dateFormat-short": "d/M/yyyy",
+	"dateFormatItem-yMMMEd": "EEE، d MMMM y",
+	"months-format-wide": [
+		"محرم",
+		"ص�ر",
+		"ربيع الأول",
+		"ربيع الآخر",
+		"جمادى الأولى",
+		"جمادى الآخرة",
+		"رجب",
+		"شعبان",
+		"رمضان",
+		"شوال",
+		"ذو القعدة",
+		"ذو الحجة"
+	],
+	"dateFormatItem-yM": "M/yyyy",
+	"timeFormat-short": "h:mm a",
+	"months-format-abbr": [
+		"محرم",
+		"ص�ر",
+		"ربيع الأول",
+		"ربيع الآخر",
+		"جمادى الأولى",
+		"جمادى الآخرة",
+		"رجب",
+		"شعبان",
+		"رمضان",
+		"شوال",
+		"ذو القعدة",
+		"ذو الحجة"
+	],
+	"eraAbbr": [
+		"هـ"
+	],
+	"timeFormat-long": "z h:mm:ss a",
+	"days-format-wide": [
+		"الأحد",
+		"الإثنين",
+		"الثلاثاء",
+		"الأربعاء",
+		"الخميس",
+		"الجمعة",
+		"السبت"
+	],
+	"dateFormatItem-yQ": "yyyy Q",
+	"dateFormatItem-yMMM": "MMM y",
+	"quarters-format-wide": [
+		"الربع الأول",
+		"الربع الثاني",
+		"الربع الثالث",
+		"الربع الرابع"
+	],
+	"dateFormat-full": "EEEE، d MMMM، y",
+	"dateFormatItem-MMMd": "d MMM",
+	"days-format-abbr": [
+		"أحد",
+		"إثنين",
+		"ثلاثاء",
+		"أربعاء",
+		"خميس",
+		"جمعة",
+		"سبت"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ar/number.js b/js/dojo-1.7.2/dojo/cldr/nls/ar/number.js
new file mode 100644
index 0000000..5ea7ed4
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ar/number.js
@@ -0,0 +1,19 @@
+//>>built
+define(
+"dojo/cldr/nls/ar/number", //begin v1.x content
+{
+	"group": "Ù¬",
+	"percentSign": "Ùª",
+	"exponential": "اس",
+	"list": "Ø›",
+	"infinity": "∞",
+	"minusSign": "-",
+	"decimal": "Ù«",
+	"nan": "ليس رقم",
+	"perMille": "؉",
+	"decimalFormat": "#,##0.###;#,##0.###-",
+	"currencyFormat": "¤ #,##0.00;¤ #,##0.00-",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/buddhist.js
new file mode 100644
index 0000000..5ff2f1b
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/buddhist.js
@@ -0,0 +1,268 @@
+//>>built
+define("dojo/cldr/nls/buddhist", { root:
+
+//begin v1.x content
+{
+	"months-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"quarters-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4"
+	],
+	"dateFormatItem-yQQQ": "y QQQ",
+	"dateFormatItem-yMEd": "EEE, y-M-d",
+	"dateFormatItem-MMMEd": "E MMM d",
+	"eraNarrow": [
+		"BE"
+	],
+	"dateTimeFormats-appendItem-Day-Of-Week": "{0} {1}",
+	"dateFormat-long": "MMMM d, y G",
+	"months-format-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateTimeFormat-medium": "{1} {0}",
+	"dateFormatItem-EEEd": "d EEE",
+	"dayPeriods-format-wide-pm": "PM",
+	"dateFormat-full": "EEEE, MMMM d, y G",
+	"dateFormatItem-Md": "M-d",
+	"dayPeriods-format-abbr-am": "AM",
+	"dateTimeFormats-appendItem-Second": "{0} ({2}: {1})",
+	"dateFormatItem-yM": "y-M",
+	"months-standAlone-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"dateFormatItem-yMMM": "y MMM",
+	"dateFormatItem-yQ": "y Q",
+	"dateTimeFormats-appendItem-Era": "{0} {1}",
+	"months-format-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"dateTimeFormats-appendItem-Week": "{0} ({2}: {1})",
+	"dateFormatItem-H": "HH",
+	"months-standAlone-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"quarters-format-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"quarters-standAlone-wide": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"eraAbbr": [
+		"BE"
+	],
+	"days-standAlone-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"quarters-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4"
+	],
+	"dateFormatItem-h": "h a",
+	"dateTimeFormat-long": "{1} {0}",
+	"dayPeriods-format-narrow-am": "AM",
+	"dateFormatItem-MMMd": "MMM d",
+	"dateFormatItem-MEd": "E, M-d",
+	"dateTimeFormat-full": "{1} {0}",
+	"days-format-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"dateTimeFormats-appendItem-Day": "{0} ({2}: {1})",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateFormatItem-hm": "h:mm a",
+	"dateTimeFormats-appendItem-Year": "{0} {1}",
+	"dateTimeFormats-appendItem-Hour": "{0} ({2}: {1})",
+	"dayPeriods-format-abbr-pm": "PM",
+	"days-format-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"eraNames": [
+		"BE"
+	],
+	"days-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"days-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dateTimeFormats-appendItem-Quarter": "{0} ({2}: {1})",
+	"dayPeriods-format-wide-am": "AM",
+	"dateTimeFormats-appendItem-Month": "{0} ({2}: {1})",
+	"dateTimeFormats-appendItem-Minute": "{0} ({2}: {1})",
+	"dateFormat-short": "M/d/yyyy",
+	"dateFormatItem-yMMMEd": "EEE, y MMM d",
+	"dateTimeFormats-appendItem-Timezone": "{0} {1}",
+	"dateFormat-medium": "MMM d, y G",
+	"dayPeriods-format-narrow-pm": "PM",
+	"dateTimeFormat-short": "{1} {0}",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "h:mm:ss a"
+}
+//end v1.x content
+,
+	"ar": true,
+	"da": true,
+	"de": true,
+	"el": true,
+	"en": true,
+	"en-gb": true,
+	"es": true,
+	"fi": true,
+	"fr": true,
+	"hu": true,
+	"it": true,
+	"ja": true,
+	"ko": true,
+	"nb": true,
+	"nl": true,
+	"pl": true,
+	"pt": true,
+	"pt-pt": true,
+	"ro": true,
+	"ru": true,
+	"sv": true,
+	"th": true,
+	"tr": true,
+	"zh": true,
+	"zh-hant": true
+});
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ca/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/ca/currency.js
new file mode 100644
index 0000000..f343e1f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ca/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/ca/currency", //begin v1.x content
+{
+	"HKD_displayName": "dòlar de Hong Kong",
+	"CHF_displayName": "franc suís",
+	"CAD_displayName": "dòlar canadenc",
+	"CNY_displayName": "iuan renmimbi xinès",
+	"AUD_displayName": "dòlar australià",
+	"JPY_displayName": "ien japonès",
+	"USD_displayName": "dòlar dels Estats Units",
+	"GBP_displayName": "lliura esterlina britànica",
+	"EUR_displayName": "euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ca/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/ca/gregorian.js
new file mode 100644
index 0000000..b0d0e0c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ca/gregorian.js
@@ -0,0 +1,236 @@
+//>>built
+define(
+"dojo/cldr/nls/ca/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"g",
+		"f",
+		"m",
+		"a",
+		"m",
+		"j",
+		"j",
+		"a",
+		"s",
+		"o",
+		"n",
+		"d"
+	],
+	"field-weekday": "dia de la setmana",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "E d/M/yyyy",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"eraNarrow": [
+		"aC",
+		"dC"
+	],
+	"dateFormat-long": "d MMMM 'de' y",
+	"months-format-wide": [
+		"de gener",
+		"de febrer",
+		"de març",
+		"d’abril",
+		"de maig",
+		"de juny",
+		"de juliol",
+		"d’agost",
+		"de setembre",
+		"d’octubre",
+		"de novembre",
+		"de desembre"
+	],
+	"dateFormatItem-EEEd": "EEE d",
+	"dayPeriods-format-wide-pm": "p.m.",
+	"dateFormat-full": "EEEE d MMMM 'de' y",
+	"dateFormatItem-Md": "d/M",
+	"field-era": "era",
+	"dateFormatItem-yM": "M/yyyy",
+	"months-standAlone-wide": [
+		"gener",
+		"febrer",
+		"març",
+		"abril",
+		"maig",
+		"juny",
+		"juliol",
+		"agost",
+		"setembre",
+		"octubre",
+		"novembre",
+		"desembre"
+	],
+	"timeFormat-short": "H:mm",
+	"quarters-format-wide": [
+		"1r trimestre",
+		"2n trimestre",
+		"3r trimestre",
+		"4t trimestre"
+	],
+	"timeFormat-long": "H:mm:ss z",
+	"field-year": "any",
+	"dateFormatItem-yMMM": "LLL y",
+	"dateFormatItem-yQ": "Q yyyy",
+	"field-hour": "hora",
+	"months-format-abbr": [
+		"de gen.",
+		"de febr.",
+		"de març",
+		"d’abr.",
+		"de maig",
+		"de juny",
+		"de jul.",
+		"d’ag.",
+		"de set.",
+		"d’oct.",
+		"de nov.",
+		"de des."
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "H:mm:ss zzzz",
+	"field-day-relative+0": "avui",
+	"field-day-relative+1": "demà",
+	"field-day-relative+2": "demà passat",
+	"dateFormatItem-H": "H",
+	"field-day-relative+3": "d'aquí a tres dies",
+	"months-standAlone-abbr": [
+		"gen.",
+		"febr.",
+		"març",
+		"abr.",
+		"maig",
+		"juny",
+		"jul.",
+		"ag.",
+		"set.",
+		"oct.",
+		"nov.",
+		"des."
+	],
+	"quarters-format-abbr": [
+		"1T",
+		"2T",
+		"3T",
+		"4T"
+	],
+	"quarters-standAlone-wide": [
+		"1r trimestre",
+		"2n trimestre",
+		"3r trimestre",
+		"4t trimestre"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"diumenge",
+		"dilluns",
+		"dimarts",
+		"dimecres",
+		"dijous",
+		"divendres",
+		"dissabte"
+	],
+	"dateFormatItem-MMMMd": "d MMMM",
+	"timeFormat-medium": "H:mm:ss",
+	"dateFormatItem-Hm": "H:mm",
+	"quarters-standAlone-abbr": [
+		"1T",
+		"2T",
+		"3T",
+		"4T"
+	],
+	"eraAbbr": [
+		"aC",
+		"dC"
+	],
+	"field-minute": "minut",
+	"field-dayperiod": "a.m./p.m.",
+	"days-standAlone-abbr": [
+		"dg",
+		"dl",
+		"dt",
+		"dc",
+		"dj",
+		"dv",
+		"ds"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "ahir",
+	"field-day-relative+-2": "abans d'ahir",
+	"field-day-relative+-3": "fa tres dies",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-MEd": "E d/M",
+	"dateFormatItem-yMMMM": "LLLL 'del' y",
+	"field-day": "dia",
+	"days-format-wide": [
+		"diumenge",
+		"dilluns",
+		"dimarts",
+		"dimecres",
+		"dijous",
+		"divendres",
+		"dissabte"
+	],
+	"field-zone": "zona",
+	"dateFormatItem-yyyyMM": "MM/yyyy",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"g",
+		"f",
+		"m",
+		"a",
+		"m",
+		"j",
+		"j",
+		"a",
+		"s",
+		"o",
+		"n",
+		"d"
+	],
+	"dateFormatItem-hm": "h:mm a",
+	"days-format-abbr": [
+		"dg.",
+		"dl.",
+		"dt.",
+		"dc.",
+		"dj.",
+		"dv.",
+		"ds."
+	],
+	"eraNames": [
+		"aC",
+		"dC"
+	],
+	"days-format-narrow": [
+		"g",
+		"l",
+		"t",
+		"c",
+		"j",
+		"v",
+		"s"
+	],
+	"field-month": "mes",
+	"days-standAlone-narrow": [
+		"g",
+		"l",
+		"t",
+		"c",
+		"j",
+		"v",
+		"s"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "a.m.",
+	"dateFormatItem-MMMMEd": "E d MMMM",
+	"dateFormat-short": "dd/MM/yy",
+	"field-second": "segon",
+	"dateFormatItem-yMMMEd": "EEE d MMM y",
+	"field-week": "setmana",
+	"dateFormat-medium": "dd/MM/yyyy",
+	"dateFormatItem-mmss": "mm:ss",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"dateFormatItem-hms": "h:mm:ss a"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ca/number.js b/js/dojo-1.7.2/dojo/cldr/nls/ca/number.js
new file mode 100644
index 0000000..861577c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ca/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/ca/number", //begin v1.x content
+{
+	"group": ".",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/cs/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/cs/currency.js
new file mode 100644
index 0000000..ef2d26e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/cs/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/cs/currency", //begin v1.x content
+{
+	"HKD_displayName": "Dolar hongkongský",
+	"CHF_displayName": "Frank švýcarský",
+	"CAD_displayName": "Dolar kanadský",
+	"CNY_displayName": "Juan renminbi",
+	"AUD_displayName": "Dolar australský",
+	"JPY_displayName": "Jen",
+	"USD_displayName": "Dolar americký",
+	"GBP_displayName": "Libra šterlinků",
+	"EUR_displayName": "Euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/cs/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/cs/gregorian.js
new file mode 100644
index 0000000..76016e5
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/cs/gregorian.js
@@ -0,0 +1,216 @@
+//>>built
+define(
+"dojo/cldr/nls/cs/gregorian", //begin v1.x content
+{
+	"dateFormatItem-yM": "M.y",
+	"dateFormatItem-yQ": "Q yyyy",
+	"dayPeriods-format-wide-pm": "odp.",
+	"eraNames": [
+		"pÅ™.Kr.",
+		"po Kr."
+	],
+	"dateFormatItem-MMMEd": "E, d. MMM",
+	"field-day-relative+-1": "V�era",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"field-day-relative+-2": "Předev�írem",
+	"days-standAlone-wide": [
+		"neděle",
+		"pondělí",
+		"úterý",
+		"středa",
+		"�tvrtek",
+		"pátek",
+		"sobota"
+	],
+	"months-standAlone-narrow": [
+		"l",
+		"ú",
+		"b",
+		"d",
+		"k",
+		"�",
+		"�",
+		"s",
+		"z",
+		"Å™",
+		"l",
+		"p"
+	],
+	"dayPeriods-format-wide-am": "dop.",
+	"quarters-standAlone-abbr": [
+		"1. �tvrtletí",
+		"2. �tvrtletí",
+		"3. �tvrtletí",
+		"4. �tvrtletí"
+	],
+	"timeFormat-full": "H:mm:ss zzzz",
+	"dateFormatItem-yyyy": "y",
+	"months-standAlone-abbr": [
+		"1.",
+		"2.",
+		"3.",
+		"4.",
+		"5.",
+		"6.",
+		"7.",
+		"8.",
+		"9.",
+		"10.",
+		"11.",
+		"12."
+	],
+	"dateFormatItem-yMMM": "LLL y",
+	"field-day-relative+0": "Dnes",
+	"field-day-relative+1": "Zítra",
+	"days-standAlone-narrow": [
+		"N",
+		"P",
+		"Ú",
+		"S",
+		"Č",
+		"P",
+		"S"
+	],
+	"eraAbbr": [
+		"pÅ™.Kr.",
+		"po Kr."
+	],
+	"field-day-relative+2": "Pozítří",
+	"dateFormatItem-yyyyMMMM": "LLLL y",
+	"dateFormat-long": "d. MMMM y",
+	"timeFormat-medium": "H:mm:ss",
+	"dateFormatItem-EEEd": "EEE, d.",
+	"dateFormatItem-Hm": "H:mm",
+	"dateFormat-medium": "d.M.yyyy",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"dateFormatItem-yMd": "d.M.y",
+	"quarters-standAlone-wide": [
+		"1. �tvrtletí",
+		"2. �tvrtletí",
+		"3. �tvrtletí",
+		"4. �tvrtletí"
+	],
+	"months-standAlone-wide": [
+		"leden",
+		"únor",
+		"březen",
+		"duben",
+		"květen",
+		"�erven",
+		"�ervenec",
+		"srpen",
+		"září",
+		"říjen",
+		"listopad",
+		"prosinec"
+	],
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-long": "H:mm:ss z",
+	"months-format-abbr": [
+		"ledna",
+		"února",
+		"března",
+		"dubna",
+		"května",
+		"�ervna",
+		"�ervence",
+		"srpna",
+		"září",
+		"října",
+		"listopadu",
+		"prosince"
+	],
+	"timeFormat-short": "H:mm",
+	"dateFormatItem-H": "H",
+	"quarters-format-abbr": [
+		"1. �tvrtletí",
+		"2. �tvrtletí",
+		"3. �tvrtletí",
+		"4. �tvrtletí"
+	],
+	"days-format-abbr": [
+		"ne",
+		"po",
+		"út",
+		"st",
+		"�t",
+		"pá",
+		"so"
+	],
+	"days-format-narrow": [
+		"N",
+		"P",
+		"Ú",
+		"S",
+		"Č",
+		"P",
+		"S"
+	],
+	"dateFormatItem-MEd": "E, d.M",
+	"months-format-narrow": [
+		"l",
+		"ú",
+		"b",
+		"d",
+		"k",
+		"�",
+		"�",
+		"s",
+		"z",
+		"Å™",
+		"l",
+		"p"
+	],
+	"days-standAlone-abbr": [
+		"ne",
+		"po",
+		"út",
+		"st",
+		"�t",
+		"pá",
+		"so"
+	],
+	"dateFormat-short": "d.M.yy",
+	"dateFormatItem-yyyyM": "M.yyyy",
+	"dateFormatItem-yMMMEd": "EEE, d. MMM y",
+	"dateFormat-full": "EEEE, d. MMMM y",
+	"dateFormatItem-Md": "d.M",
+	"dateFormatItem-yMEd": "EEE, d.M.y",
+	"months-format-wide": [
+		"ledna",
+		"února",
+		"března",
+		"dubna",
+		"května",
+		"�ervna",
+		"�ervence",
+		"srpna",
+		"září",
+		"října",
+		"listopadu",
+		"prosince"
+	],
+	"dateFormatItem-d": "d.",
+	"quarters-format-wide": [
+		"1. �tvrtletí",
+		"2. �tvrtletí",
+		"3. �tvrtletí",
+		"4. �tvrtletí"
+	],
+	"days-format-wide": [
+		"neděle",
+		"pondělí",
+		"úterý",
+		"středa",
+		"�tvrtek",
+		"pátek",
+		"sobota"
+	],
+	"eraNarrow": [
+		"pÅ™.Kr.",
+		"po Kr."
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/cs/number.js b/js/dojo-1.7.2/dojo/cldr/nls/cs/number.js
new file mode 100644
index 0000000..222ddb1
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/cs/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/cs/number", //begin v1.x content
+{
+	"group": " ",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0 %",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/currency.js
new file mode 100644
index 0000000..fb8f36e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/currency.js
@@ -0,0 +1,49 @@
+//>>built
+define("dojo/cldr/nls/currency", { root:
+
+//begin v1.x content
+{
+	"USD_symbol": "US$",
+	"CAD_symbol": "CA$",
+	"GBP_symbol": "£",
+	"HKD_symbol": "HK$",
+	"JPY_symbol": "JPÂ¥",
+	"AUD_symbol": "AU$",
+	"CNY_symbol": "CNÂ¥",
+	"EUR_symbol": "€"
+}
+//end v1.x content
+,
+	"ar": true,
+	"ca": true,
+	"cs": true,
+	"da": true,
+	"de": true,
+	"el": true,
+	"en": true,
+	"en-au": true,
+	"en-ca": true,
+	"es": true,
+	"fi": true,
+	"fr": true,
+	"he": true,
+	"hu": true,
+	"it": true,
+	"ja": true,
+	"ko": true,
+	"nb": true,
+	"nl": true,
+	"pl": true,
+	"pt": true,
+	"ro": true,
+	"ru": true,
+	"sk": true,
+	"sl": true,
+	"sv": true,
+	"th": true,
+	"tr": true,
+	"zh": true,
+	"zh-hant": true,
+	"zh-hk": true,
+	"zh-tw": true
+});
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/da/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/da/buddhist.js
new file mode 100644
index 0000000..c4711a8
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/da/buddhist.js
@@ -0,0 +1,142 @@
+//>>built
+define(
+"dojo/cldr/nls/da/buddhist", //begin v1.x content
+{
+	"dateFormatItem-yM": "M/y G",
+	"dateFormatItem-yQ": "Q y G",
+	"dayPeriods-format-wide-pm": "e.m.",
+	"dateFormatItem-MMMEd": "E d. MMM",
+	"dateFormatItem-hms": "h.mm.ss a",
+	"dateFormatItem-yQQQ": "QQQ y G",
+	"dateFormatItem-MMdd": "dd/MM",
+	"dateFormatItem-MMM": "MMM",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dayPeriods-format-wide-am": "f.m.",
+	"dateFormatItem-y": "y G",
+	"timeFormat-full": "HH.mm.ss zzzz",
+	"dateFormatItem-yyyy": "y G",
+	"months-standAlone-abbr": [
+		"jan",
+		"feb",
+		"mar",
+		"apr",
+		"maj",
+		"jun",
+		"jul",
+		"aug",
+		"sep",
+		"okt",
+		"nov",
+		"dec"
+	],
+	"dateFormatItem-Ed": "E d.",
+	"dateFormatItem-yMMM": "MMM y G",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"O",
+		"T",
+		"F",
+		"L"
+	],
+	"dateFormatItem-yyyyMM": "MM/y G",
+	"dateFormat-long": "d. MMMM y G",
+	"timeFormat-medium": "HH.mm.ss",
+	"dateFormatItem-Hm": "HH.mm",
+	"dateFormatItem-yyMM": "MM/y G",
+	"dateFormat-medium": "d. MMM y G",
+	"dateFormatItem-Hms": "HH.mm.ss",
+	"dateFormatItem-yyMMM": "MMM y G",
+	"dateFormatItem-yMd": "d/M/y G",
+	"dateFormatItem-ms": "mm.ss",
+	"dateFormatItem-MMMMEd": "E, d. MMMM",
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-yyQ": "Q. 'kvartal' y G",
+	"timeFormat-long": "HH.mm.ss z",
+	"months-format-abbr": [
+		"jan.",
+		"feb.",
+		"mar.",
+		"apr.",
+		"maj",
+		"jun.",
+		"jul.",
+		"aug.",
+		"sep.",
+		"okt.",
+		"nov.",
+		"dec."
+	],
+	"timeFormat-short": "HH.mm",
+	"dateFormatItem-H": "HH",
+	"quarters-format-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"days-format-abbr": [
+		"søn",
+		"man",
+		"tir",
+		"ons",
+		"tor",
+		"fre",
+		"lør"
+	],
+	"dateFormatItem-M": "M",
+	"dateFormatItem-MEd": "E. d/M",
+	"dateFormatItem-hm": "h.mm a",
+	"dateFormat-short": "d/M/yyyy",
+	"dateFormatItem-yMMMEd": "EEE. d. MMM y G",
+	"dateFormat-full": "EEEE d. MMMM y G",
+	"dateFormatItem-Md": "d/M",
+	"dateFormatItem-yMEd": "EEE. d/M/y G",
+	"months-format-wide": [
+		"januar",
+		"februar",
+		"marts",
+		"april",
+		"maj",
+		"juni",
+		"juli",
+		"august",
+		"september",
+		"oktober",
+		"november",
+		"december"
+	],
+	"dateFormatItem-yyyyMMM": "MMM y G",
+	"dateFormatItem-d": "d.",
+	"quarters-format-wide": [
+		"1. kvartal",
+		"2. kvartal",
+		"3. kvartal",
+		"4. kvartal"
+	],
+	"days-format-wide": [
+		"søndag",
+		"mandag",
+		"tirsdag",
+		"onsdag",
+		"torsdag",
+		"fredag",
+		"lørdag"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/da/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/da/currency.js
new file mode 100644
index 0000000..66f8b8c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/da/currency.js
@@ -0,0 +1,17 @@
+//>>built
+define(
+"dojo/cldr/nls/da/currency", //begin v1.x content
+{
+	"HKD_displayName": "Hongkong dollar",
+	"CHF_displayName": "Schweizisk franc",
+	"CAD_displayName": "Canadisk dollar",
+	"CNY_displayName": "Kinesisk yuan renminbi",
+	"USD_symbol": "$",
+	"AUD_displayName": "Australsk dollar",
+	"JPY_displayName": "Japansk yen",
+	"USD_displayName": "Amerikansk dollar",
+	"GBP_displayName": "Britisk pund",
+	"EUR_displayName": "Euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/da/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/da/gregorian.js
new file mode 100644
index 0000000..48a0c5a
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/da/gregorian.js
@@ -0,0 +1,238 @@
+//>>built
+define(
+"dojo/cldr/nls/da/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"field-weekday": "ugedag",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "EEE. d/M/y",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"eraNarrow": [
+		"f.Kr.",
+		"e.Kr."
+	],
+	"dateFormat-long": "d. MMM y",
+	"months-format-wide": [
+		"januar",
+		"februar",
+		"marts",
+		"april",
+		"maj",
+		"juni",
+		"juli",
+		"august",
+		"september",
+		"oktober",
+		"november",
+		"december"
+	],
+	"dayPeriods-format-wide-pm": "e.m.",
+	"dateFormat-full": "EEEE 'den' d. MMMM y",
+	"dateFormatItem-Md": "d/M",
+	"field-era": "æra",
+	"dateFormatItem-yM": "M/y",
+	"months-standAlone-wide": [
+		"januar",
+		"februar",
+		"marts",
+		"april",
+		"maj",
+		"juni",
+		"juli",
+		"august",
+		"september",
+		"oktober",
+		"november",
+		"december"
+	],
+	"timeFormat-short": "HH.mm",
+	"quarters-format-wide": [
+		"1. kvartal",
+		"2. kvartal",
+		"3. kvartal",
+		"4. kvartal"
+	],
+	"timeFormat-long": "HH.mm.ss z",
+	"field-year": "Ã¥r",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "Q yyyy",
+	"field-hour": "time",
+	"dateFormatItem-MMdd": "dd/MM",
+	"months-format-abbr": [
+		"jan.",
+		"feb.",
+		"mar.",
+		"apr.",
+		"maj",
+		"jun.",
+		"jul.",
+		"aug.",
+		"sep.",
+		"okt.",
+		"nov.",
+		"dec."
+	],
+	"dateFormatItem-yyQ": "Q. 'kvartal' yy",
+	"timeFormat-full": "HH.mm.ss zzzz",
+	"field-day-relative+0": "i dag",
+	"field-day-relative+1": "i morgen",
+	"field-day-relative+2": "i overmorgen",
+	"dateFormatItem-H": "HH",
+	"field-day-relative+3": "i overovermorgen",
+	"months-standAlone-abbr": [
+		"jan",
+		"feb",
+		"mar",
+		"apr",
+		"maj",
+		"jun",
+		"jul",
+		"aug",
+		"sep",
+		"okt",
+		"nov",
+		"dec"
+	],
+	"quarters-format-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"quarters-standAlone-wide": [
+		"1. kvartal",
+		"2. kvartal",
+		"3. kvartal",
+		"4. kvartal"
+	],
+	"dateFormatItem-M": "M",
+	"days-standAlone-wide": [
+		"søndag",
+		"mandag",
+		"tirsdag",
+		"onsdag",
+		"torsdag",
+		"fredag",
+		"lørdag"
+	],
+	"dateFormatItem-yyyyMMM": "MMM y",
+	"dateFormatItem-yyMMM": "MMM yy",
+	"timeFormat-medium": "HH.mm.ss",
+	"dateFormatItem-Hm": "HH.mm",
+	"quarters-standAlone-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"eraAbbr": [
+		"f.Kr.",
+		"e.Kr."
+	],
+	"field-minute": "minut",
+	"field-dayperiod": "dagtid",
+	"days-standAlone-abbr": [
+		"søn",
+		"man",
+		"tir",
+		"ons",
+		"tor",
+		"fre",
+		"lør"
+	],
+	"dateFormatItem-d": "d.",
+	"dateFormatItem-ms": "mm.ss",
+	"field-day-relative+-1": "i går",
+	"field-day-relative+-2": "i forgårs",
+	"field-day-relative+-3": "i forforgårs",
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-MEd": "E. d/M",
+	"field-day": "dag",
+	"days-format-wide": [
+		"søndag",
+		"mandag",
+		"tirsdag",
+		"onsdag",
+		"torsdag",
+		"fredag",
+		"lørdag"
+	],
+	"field-zone": "zone",
+	"dateFormatItem-yyyyMM": "MM/yyyy",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-yyMM": "MM/yy",
+	"dateFormatItem-hm": "h.mm a",
+	"days-format-abbr": [
+		"søn",
+		"man",
+		"tir",
+		"ons",
+		"tor",
+		"fre",
+		"lør"
+	],
+	"eraNames": [
+		"f.Kr.",
+		"e.Kr."
+	],
+	"days-format-narrow": [
+		"S",
+		"M",
+		"T",
+		"O",
+		"T",
+		"F",
+		"L"
+	],
+	"field-month": "måned",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"O",
+		"T",
+		"F",
+		"L"
+	],
+	"dateFormatItem-MMM": "MMM",
+	"dayPeriods-format-wide-am": "f.m.",
+	"dateFormatItem-MMMMEd": "E, d. MMMM",
+	"dateFormat-short": "dd/MM/yy",
+	"field-second": "sekund",
+	"dateFormatItem-yMMMEd": "EEE. d. MMM y",
+	"dateFormatItem-Ed": "E d.",
+	"field-week": "uge",
+	"dateFormat-medium": "dd/MM/yyyy",
+	"dateFormatItem-Hms": "HH.mm.ss",
+	"dateFormatItem-hms": "h.mm.ss a",
+	"dateFormatItem-yyyy": "y"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/da/islamic.js b/js/dojo-1.7.2/dojo/cldr/nls/da/islamic.js
new file mode 100644
index 0000000..43e7789
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/da/islamic.js
@@ -0,0 +1,88 @@
+//>>built
+define(
+"dojo/cldr/nls/da/islamic", //begin v1.x content
+{
+	"dateFormatItem-yM": "M/y",
+	"dateFormatItem-yyyyMMMEd": "EEE. d. MMM y G",
+	"dateFormatItem-yQ": "Q yyyy",
+	"dayPeriods-format-wide-pm": "e.m.",
+	"dateFormatItem-MMMEd": "E d. MMM",
+	"dateFormatItem-hms": "h.mm.ss a",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-MMdd": "dd/MM",
+	"dateFormatItem-MMM": "MMM",
+	"dayPeriods-format-wide-am": "f.m.",
+	"timeFormat-full": "HH.mm.ss zzzz",
+	"dateFormatItem-yyyy": "y G",
+	"dateFormatItem-Ed": "E d.",
+	"dateFormatItem-yMMM": "MMM y",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"O",
+		"T",
+		"F",
+		"L"
+	],
+	"dateFormat-long": "d. MMMM y G",
+	"timeFormat-medium": "HH.mm.ss",
+	"dateFormatItem-Hm": "HH.mm",
+	"dateFormatItem-yyMM": "MM/y G",
+	"dateFormat-medium": "d. MMM y G",
+	"dateFormatItem-Hms": "HH.mm.ss",
+	"dateFormatItem-yyMMM": "MMM y G",
+	"dateFormatItem-ms": "mm.ss",
+	"dateFormatItem-MMMMEd": "E, d. MMMM",
+	"dateFormatItem-yyyyMEd": "EEE. d/M/y G",
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-yyQ": "Q. 'kvartal' y G",
+	"timeFormat-long": "HH.mm.ss z",
+	"timeFormat-short": "HH.mm",
+	"dateFormatItem-H": "HH",
+	"quarters-format-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"days-format-abbr": [
+		"søn",
+		"man",
+		"tir",
+		"ons",
+		"tor",
+		"fre",
+		"lør"
+	],
+	"dateFormatItem-M": "M",
+	"dateFormatItem-yyyyQQQ": "QQQ y G",
+	"dateFormatItem-MEd": "E. d/M",
+	"dateFormatItem-hm": "h.mm a",
+	"dateFormat-short": "d/M/y G",
+	"dateFormatItem-yyyyM": "M/y G",
+	"dateFormatItem-yMMMEd": "EEE. d. MMM y",
+	"dateFormat-full": "EEEE d. MMMM y G",
+	"dateFormatItem-Md": "d/M",
+	"dateFormatItem-yyyyQ": "Q y G",
+	"dateFormatItem-yMEd": "EEE. d/M/y",
+	"dateFormatItem-yyyyMMM": "MMM y G",
+	"dateFormatItem-d": "d.",
+	"quarters-format-wide": [
+		"1. kvartal",
+		"2. kvartal",
+		"3. kvartal",
+		"4. kvartal"
+	],
+	"days-format-wide": [
+		"søndag",
+		"mandag",
+		"tirsdag",
+		"onsdag",
+		"torsdag",
+		"fredag",
+		"lørdag"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/da/number.js b/js/dojo-1.7.2/dojo/cldr/nls/da/number.js
new file mode 100644
index 0000000..56e6a8b
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/da/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/da/number", //begin v1.x content
+{
+	"group": ".",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0 %",
+	"list": ",",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/de/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/de/buddhist.js
new file mode 100644
index 0000000..cf1f18a
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/de/buddhist.js
@@ -0,0 +1,131 @@
+//>>built
+define(
+"dojo/cldr/nls/de/buddhist", //begin v1.x content
+{
+	"dateFormatItem-yM": "M.y G",
+	"dateFormatItem-yyMMdd": "dd.MM.y G",
+	"dateFormatItem-yQ": "Q y G",
+	"dayPeriods-format-wide-pm": "nachm.",
+	"dateFormatItem-MMMEd": "E, d. MMM",
+	"dateFormatItem-yQQQ": "QQQ y G",
+	"dateFormatItem-MMdd": "dd.MM.",
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dayPeriods-format-wide-am": "vorm.",
+	"dateFormatItem-y": "y G",
+	"dateFormatItem-yyyy": "y G",
+	"months-standAlone-abbr": [
+		"Jan",
+		"Feb",
+		"Mär",
+		"Apr",
+		"Mai",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Okt",
+		"Nov",
+		"Dez"
+	],
+	"dateFormatItem-Ed": "E d.",
+	"dateFormatItem-yMMM": "MMM y G",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"D",
+		"M",
+		"D",
+		"F",
+		"S"
+	],
+	"dateFormatItem-yyyyMMMM": "MMMM y G",
+	"dateFormat-long": "d. MMMM y G",
+	"dateFormatItem-Hm": "HH:mm",
+	"dateFormatItem-MMd": "d.MM.",
+	"dateFormatItem-yyMM": "MM.y G",
+	"dateFormat-medium": "d. MMM y G",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-yyMMM": "MMM y G",
+	"dateFormatItem-yyQQQQ": "QQQQ y G",
+	"dateFormatItem-ms": "mm:ss",
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-yyQ": "Q y G",
+	"months-format-abbr": [
+		"Jan",
+		"Feb",
+		"Mär",
+		"Apr",
+		"Mai",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Okt",
+		"Nov",
+		"Dez"
+	],
+	"dateFormatItem-H": "HH 'Uhr'",
+	"days-format-abbr": [
+		"So.",
+		"Mo.",
+		"Di.",
+		"Mi.",
+		"Do.",
+		"Fr.",
+		"Sa."
+	],
+	"dateFormatItem-MMMMdd": "dd. MMMM",
+	"dateFormatItem-M": "L",
+	"dateFormatItem-MEd": "E, d.M.",
+	"dateFormat-short": "d.M.yyyy",
+	"dateFormatItem-yMMMEd": "EEE, d. MMM y G",
+	"dateFormat-full": "EEEE d. MMMM y G",
+	"dateFormatItem-Md": "d.M.",
+	"dateFormatItem-yMEd": "EEE, d.M.y G",
+	"months-format-wide": [
+		"Januar",
+		"Februar",
+		"März",
+		"April",
+		"Mai",
+		"Juni",
+		"Juli",
+		"August",
+		"September",
+		"Oktober",
+		"November",
+		"Dezember"
+	],
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"1. Quartal",
+		"2. Quartal",
+		"3. Quartal",
+		"4. Quartal"
+	],
+	"days-format-wide": [
+		"Sonntag",
+		"Montag",
+		"Dienstag",
+		"Mittwoch",
+		"Donnerstag",
+		"Freitag",
+		"Samstag"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/de/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/de/currency.js
new file mode 100644
index 0000000..a188443
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/de/currency.js
@@ -0,0 +1,18 @@
+//>>built
+define(
+"dojo/cldr/nls/de/currency", //begin v1.x content
+{
+	"HKD_displayName": "Hongkong-Dollar",
+	"CHF_displayName": "Schweizer Franken",
+	"JPY_symbol": "Â¥",
+	"CAD_displayName": "Kanadischer Dollar",
+	"CNY_displayName": "Renminbi Yuan",
+	"USD_symbol": "$",
+	"AUD_displayName": "Australischer Dollar",
+	"JPY_displayName": "Yen",
+	"USD_displayName": "US-Dollar",
+	"GBP_displayName": "Pfund Sterling",
+	"EUR_displayName": "Euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/de/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/de/gregorian.js
new file mode 100644
index 0000000..e31af15
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/de/gregorian.js
@@ -0,0 +1,238 @@
+//>>built
+define(
+"dojo/cldr/nls/de/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"field-weekday": "Wochentag",
+	"dateFormatItem-yyQQQQ": "QQQQ yy",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "EEE, d.M.y",
+	"dateFormatItem-MMMEd": "E, d. MMM",
+	"eraNarrow": [
+		"v. Chr.",
+		"n. Chr."
+	],
+	"dayPeriods-format-wide-earlyMorning": "morgens",
+	"dayPeriods-format-wide-morning": "vormittags",
+	"dateFormat-long": "d. MMMM y",
+	"months-format-wide": [
+		"Januar",
+		"Februar",
+		"März",
+		"April",
+		"Mai",
+		"Juni",
+		"Juli",
+		"August",
+		"September",
+		"Oktober",
+		"November",
+		"Dezember"
+	],
+	"dayPeriods-format-wide-evening": "abends",
+	"dayPeriods-format-wide-pm": "nachm.",
+	"dateFormat-full": "EEEE, d. MMMM y",
+	"dateFormatItem-Md": "d.M.",
+	"dateFormatItem-yyMMdd": "dd.MM.yy",
+	"dayPeriods-format-wide-noon": "Mittag",
+	"field-era": "Epoche",
+	"dateFormatItem-yM": "M.y",
+	"months-standAlone-wide": [
+		"Januar",
+		"Februar",
+		"März",
+		"April",
+		"Mai",
+		"Juni",
+		"Juli",
+		"August",
+		"September",
+		"Oktober",
+		"November",
+		"Dezember"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"1. Quartal",
+		"2. Quartal",
+		"3. Quartal",
+		"4. Quartal"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "Jahr",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "Q y",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"field-hour": "Stunde",
+	"dateFormatItem-MMdd": "dd.MM.",
+	"months-format-abbr": [
+		"Jan",
+		"Feb",
+		"Mär",
+		"Apr",
+		"Mai",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Okt",
+		"Nov",
+		"Dez"
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"field-day-relative+0": "heute",
+	"field-day-relative+1": "morgen",
+	"field-day-relative+2": "übermorgen",
+	"dateFormatItem-H": "HH 'Uhr'",
+	"field-day-relative+3": "überübermorgen",
+	"months-standAlone-abbr": [
+		"Jan",
+		"Feb",
+		"Mär",
+		"Apr",
+		"Mai",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Okt",
+		"Nov",
+		"Dez"
+	],
+	"quarters-format-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"quarters-standAlone-wide": [
+		"1. Quartal",
+		"2. Quartal",
+		"3. Quartal",
+		"4. Quartal"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"Sonntag",
+		"Montag",
+		"Dienstag",
+		"Mittwoch",
+		"Donnerstag",
+		"Freitag",
+		"Samstag"
+	],
+	"dateFormatItem-yyMMM": "MMM yy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"eraAbbr": [
+		"v. Chr.",
+		"n. Chr."
+	],
+	"field-minute": "Minute",
+	"field-dayperiod": "Tageshälfte",
+	"days-standAlone-abbr": [
+		"So.",
+		"Mo.",
+		"Di.",
+		"Mi.",
+		"Do.",
+		"Fr.",
+		"Sa."
+	],
+	"dayPeriods-format-wide-night": "nachts",
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "gestern",
+	"field-day-relative+-2": "vorgestern",
+	"field-day-relative+-3": "vorvorgestern",
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-MEd": "E, d.M.",
+	"field-day": "Tag",
+	"days-format-wide": [
+		"Sonntag",
+		"Montag",
+		"Dienstag",
+		"Mittwoch",
+		"Donnerstag",
+		"Freitag",
+		"Samstag"
+	],
+	"field-zone": "Zone",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-yyMM": "MM.yy",
+	"days-format-abbr": [
+		"So.",
+		"Mo.",
+		"Di.",
+		"Mi.",
+		"Do.",
+		"Fr.",
+		"Sa."
+	],
+	"eraNames": [
+		"v. Chr.",
+		"n. Chr."
+	],
+	"days-format-narrow": [
+		"S",
+		"M",
+		"D",
+		"M",
+		"D",
+		"F",
+		"S"
+	],
+	"field-month": "Monat",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"D",
+		"M",
+		"D",
+		"F",
+		"S"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "vorm.",
+	"dateFormatItem-MMMMdd": "dd. MMMM",
+	"dateFormat-short": "dd.MM.yy",
+	"dateFormatItem-MMd": "d.MM.",
+	"dayPeriods-format-wide-afternoon": "nachmittags",
+	"field-second": "Sekunde",
+	"dateFormatItem-yMMMEd": "EEE, d. MMM y",
+	"dateFormatItem-Ed": "E, d.",
+	"field-week": "Woche",
+	"dateFormat-medium": "dd.MM.yyyy",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-yyyy": "y"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/de/islamic.js b/js/dojo-1.7.2/dojo/cldr/nls/de/islamic.js
new file mode 100644
index 0000000..8a89b53
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/de/islamic.js
@@ -0,0 +1,173 @@
+//>>built
+define(
+"dojo/cldr/nls/de/islamic", //begin v1.x content
+{
+	"dateFormatItem-yM": "M.y",
+	"dateFormatItem-yyyyMMMEd": "EEE, d. MMM y G",
+	"dateFormatItem-yyMMdd": "dd.MM.y G",
+	"dateFormatItem-yQ": "Q y",
+	"dayPeriods-format-wide-pm": "nachm.",
+	"eraNames": [
+		"AH"
+	],
+	"dateFormatItem-MMMEd": "E, d. MMM",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-MMdd": "dd.MM.",
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dayPeriods-format-wide-am": "vorm.",
+	"dateFormatItem-yyyy": "y G",
+	"months-standAlone-abbr": [
+		"Muh.",
+		"Saf.",
+		"Rab. I",
+		"Rab. II",
+		"Jum. I",
+		"Jum. II",
+		"Raj.",
+		"Sha.",
+		"Ram.",
+		"Shaw.",
+		"Dhuʻl-Q.",
+		"Dhuʻl-H."
+	],
+	"dateFormatItem-Ed": "E d.",
+	"dateFormatItem-yMMM": "MMM y",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"D",
+		"M",
+		"D",
+		"F",
+		"S"
+	],
+	"eraAbbr": [
+		"AH"
+	],
+	"dateFormatItem-yyyyMMMM": "MMMM y G",
+	"dateFormat-long": "d. MMMM y G",
+	"dateFormatItem-Hm": "HH:mm",
+	"dateFormatItem-MMd": "d.MM.",
+	"dateFormatItem-yyMM": "MM.y G",
+	"dateFormat-medium": "d. MMM y G",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-yyMMM": "MMM y G",
+	"dateFormatItem-yyQQQQ": "QQQQ y G",
+	"dateFormatItem-ms": "mm:ss",
+	"months-standAlone-wide": [
+		"Muharram",
+		"Safar",
+		"RabiÊ» I",
+		"RabiÊ» II",
+		"Jumada I",
+		"Jumada II",
+		"Rajab",
+		"Shaʻban",
+		"Ramadan",
+		"Shawwal",
+		"Dhuʻl-Qiʻdah",
+		"Dhuʻl-Hijjah"
+	],
+	"dateFormatItem-yyyyMEd": "EEE, d.M.y G",
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-yyQ": "Q y G",
+	"months-format-abbr": [
+		"Muh.",
+		"Saf.",
+		"Rab. I",
+		"Rab. II",
+		"Jum. I",
+		"Jum. II",
+		"Raj.",
+		"Sha.",
+		"Ram.",
+		"Shaw.",
+		"Dhuʻl-Q.",
+		"Dhuʻl-H."
+	],
+	"dateFormatItem-H": "HH 'Uhr'",
+	"dateFormatItem-MMMMdd": "dd. MMMM",
+	"days-format-abbr": [
+		"So.",
+		"Mo.",
+		"Di.",
+		"Mi.",
+		"Do.",
+		"Fr.",
+		"Sa."
+	],
+	"dateFormatItem-M": "L",
+	"dateFormatItem-MEd": "E, d.M.",
+	"dateFormatItem-yyyyQQQ": "QQQ y G",
+	"months-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateFormat-short": "d.M.y G",
+	"dateFormatItem-yyyyM": "M.y G",
+	"dateFormatItem-yMMMEd": "EEE, d. MMM y",
+	"dateFormat-full": "EEEE d. MMMM y G",
+	"dateFormatItem-Md": "d.M.",
+	"dateFormatItem-yyyyQ": "Q y G",
+	"dateFormatItem-yMEd": "EEE, d.M.y",
+	"months-format-wide": [
+		"Muharram",
+		"Safar",
+		"RabiÊ» I",
+		"RabiÊ» II",
+		"Jumada I",
+		"Jumada II",
+		"Rajab",
+		"Shaʻban",
+		"Ramadan",
+		"Shawwal",
+		"Dhuʻl-Qiʻdah",
+		"Dhuʻl-Hijjah"
+	],
+	"dateFormatItem-yyyyMMM": "MMM y G",
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"1. Quartal",
+		"2. Quartal",
+		"3. Quartal",
+		"4. Quartal"
+	],
+	"eraNarrow": [
+		"AH"
+	],
+	"days-format-wide": [
+		"Sonntag",
+		"Montag",
+		"Dienstag",
+		"Mittwoch",
+		"Donnerstag",
+		"Freitag",
+		"Samstag"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/de/number.js b/js/dojo-1.7.2/dojo/cldr/nls/de/number.js
new file mode 100644
index 0000000..306722a
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/de/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/de/number", //begin v1.x content
+{
+	"group": ".",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0 %",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/el/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/el/buddhist.js
new file mode 100644
index 0000000..3cc1918
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/el/buddhist.js
@@ -0,0 +1,121 @@
+//>>built
+define(
+"dojo/cldr/nls/el/buddhist", //begin v1.x content
+{
+	"quarters-format-abbr": [
+		"Τ1",
+		"Τ2",
+		"Τ3",
+		"Τ4"
+	],
+	"dateFormat-medium": "d MMM, y G",
+	"dateFormatItem-MMMEd": "E, d MMM",
+	"dateFormatItem-MEd": "E, d/M",
+	"dateFormatItem-yMEd": "EEE, d/M/yyyy",
+	"timeFormat-full": "h:mm:ss a zzzz",
+	"dateFormatItem-Md": "d/M",
+	"months-standAlone-narrow": [
+		"Ι",
+		"Φ",
+		"Μ",
+		"Α",
+		"Μ",
+		"Ι",
+		"Ι",
+		"Α",
+		"Σ",
+		"Ο",
+		"�",
+		"Δ"
+	],
+	"months-standAlone-wide": [
+		"Ιανουά�ιος",
+		"Φεβ�ουά�ιος",
+		"Μά�τιος",
+		"Απ�ίλιος",
+		"Μάιος",
+		"Ιο�νιος",
+		"Ιο�λιος",
+		"Α�γουστος",
+		"Σεπτέμβ�ιος",
+		"Οκτώβ�ιος",
+		"�οέμβ�ιος",
+		"Δεκέμβ�ιος"
+	],
+	"dateFormatItem-EEEd": "EEE d",
+	"days-standAlone-narrow": [
+		"Κ",
+		"Δ",
+		"Τ",
+		"Τ",
+		"Π",
+		"Π",
+		"Σ"
+	],
+	"dayPeriods-format-wide-pm": "μ.μ.",
+	"dayPeriods-format-wide-am": "π.μ.",
+	"timeFormat-medium": "h:mm:ss a",
+	"dateFormat-long": "d MMMM, y G",
+	"dateFormat-short": "d/M/yyyy",
+	"dateFormatItem-yMMMEd": "EEE, d MMM y",
+	"months-format-wide": [
+		"Ιανουα�ίου",
+		"Φεβ�ουα�ίου",
+		"Μα�τίου",
+		"Απ�ιλίου",
+		"Μα�ου",
+		"Ιουνίου",
+		"Ιουλίου",
+		"Αυγο�στου",
+		"Σεπτεμβ�ίου",
+		"Οκτωβ�ίου",
+		"�οεμβ�ίου",
+		"Δεκεμβ�ίου"
+	],
+	"dateFormatItem-yM": "M/yyyy",
+	"timeFormat-short": "h:mm a",
+	"months-format-abbr": [
+		"Ιαν",
+		"Φεβ",
+		"Μα�",
+		"Απ�",
+		"Μαϊ",
+		"Ιουν",
+		"Ιουλ",
+		"Αυγ",
+		"Σεπ",
+		"Οκτ",
+		"�οε",
+		"Δεκ"
+	],
+	"timeFormat-long": "h:mm:ss a z",
+	"days-format-wide": [
+		"Κυ�ιακή",
+		"Δευτέ�α",
+		"Τ�ίτη",
+		"Τετά�τη",
+		"Πέμπτη",
+		"Πα�ασκευή",
+		"Σάββατο"
+	],
+	"dateFormatItem-yMMM": "LLL y",
+	"quarters-format-wide": [
+		"1ο τ�ίμηνο",
+		"2ο τ�ίμηνο",
+		"3ο τ�ίμηνο",
+		"4ο τ�ίμηνο"
+	],
+	"dateFormat-full": "EEEE, d MMMM, y G",
+	"dateFormatItem-MMMd": "d MMM",
+	"days-format-abbr": [
+		"Κυ�",
+		"Δευ",
+		"Τ�ι",
+		"Τετ",
+		"Πεμ",
+		"Πα�",
+		"Σαβ"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/el/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/el/currency.js
new file mode 100644
index 0000000..75e040e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/el/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/el/currency", //begin v1.x content
+{
+	"HKD_displayName": "Δολά�ιο Χονγκ Κονγκ",
+	"CHF_displayName": "Φ�άγκο Ελβετίας",
+	"CAD_displayName": "Δολά�ιο Καναδά",
+	"CNY_displayName": "Γιουάν Ρενμίμπι Κίνας",
+	"AUD_displayName": "Δολά�ιο Αυστ�αλίας",
+	"JPY_displayName": "Γιεν Ιαπωνίας",
+	"USD_displayName": "Δολά�ιο ΗΠΑ",
+	"GBP_displayName": "Λί�α Στε�λίνα Β�ετανίας",
+	"EUR_displayName": "Ευ�ώ"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/el/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/el/gregorian.js
new file mode 100644
index 0000000..7124ae1
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/el/gregorian.js
@@ -0,0 +1,242 @@
+//>>built
+define(
+"dojo/cldr/nls/el/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"Ι",
+		"Φ",
+		"Μ",
+		"Α",
+		"Μ",
+		"Ι",
+		"Ι",
+		"Α",
+		"Σ",
+		"Ο",
+		"�",
+		"Δ"
+	],
+	"field-weekday": "Ημέ�α εβδομάδας",
+	"dateFormatItem-yyQQQQ": "QQQQ yy",
+	"dateFormatItem-yQQQ": "y QQQ",
+	"dateFormatItem-yMEd": "EEE, d/M/yyyy",
+	"dateFormatItem-MMMEd": "E, d MMM",
+	"eraNarrow": [
+		"π.Χ.",
+		"μ.Χ."
+	],
+	"dateFormat-long": "d MMMM y",
+	"months-format-wide": [
+		"Ιανουα�ίου",
+		"Φεβ�ουα�ίου",
+		"Μα�τίου",
+		"Απ�ιλίου",
+		"Μα�ου",
+		"Ιουνίου",
+		"Ιουλίου",
+		"Αυγο�στου",
+		"Σεπτεμβ�ίου",
+		"Οκτωβ�ίου",
+		"�οεμβ�ίου",
+		"Δεκεμβ�ίου"
+	],
+	"dateFormatItem-EEEd": "EEE d",
+	"dayPeriods-format-wide-pm": "μ.μ.",
+	"dateFormat-full": "EEEE, d MMMM y",
+	"dateFormatItem-Md": "d/M",
+	"field-era": "Πε�ίοδος",
+	"dateFormatItem-yM": "M/yyyy",
+	"months-standAlone-wide": [
+		"Ιανουά�ιος",
+		"Φεβ�ουά�ιος",
+		"Μά�τιος",
+		"Απ�ίλιος",
+		"Μάιος",
+		"Ιο�νιος",
+		"Ιο�λιος",
+		"Α�γουστος",
+		"Σεπτέμβ�ιος",
+		"Οκτώβ�ιος",
+		"�οέμβ�ιος",
+		"Δεκέμβ�ιος"
+	],
+	"timeFormat-short": "h:mm a",
+	"quarters-format-wide": [
+		"1ο τ�ίμηνο",
+		"2ο τ�ίμηνο",
+		"3ο τ�ίμηνο",
+		"4ο τ�ίμηνο"
+	],
+	"timeFormat-long": "h:mm:ss a z",
+	"field-year": "Έτος",
+	"dateFormatItem-yMMM": "LLL y",
+	"dateFormatItem-yQ": "y Q",
+	"dateFormatItem-yyyyMMMM": "LLLL y",
+	"field-hour": "��α",
+	"dateFormatItem-MMdd": "dd/MM",
+	"months-format-abbr": [
+		"Ιαν",
+		"Φεβ",
+		"Μα�",
+		"Απ�",
+		"Μαϊ",
+		"Ιουν",
+		"Ιουλ",
+		"Αυγ",
+		"Σεπ",
+		"Οκτ",
+		"�οε",
+		"Δεκ"
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "h:mm:ss a zzzz",
+	"field-day-relative+0": "Σήμε�α",
+	"field-day-relative+1": "Α��ιο",
+	"field-day-relative+2": "Μεθα��ιο",
+	"dateFormatItem-H": "HH",
+	"field-day-relative+3": "Σε τ�εις ημέ�ες από τώ�α",
+	"months-standAlone-abbr": [
+		"Ιαν",
+		"Φεβ",
+		"Μα�",
+		"Απ�",
+		"Μαϊ",
+		"Ιουν",
+		"Ιουλ",
+		"Αυγ",
+		"Σεπ",
+		"Οκτ",
+		"�οε",
+		"Δεκ"
+	],
+	"quarters-format-abbr": [
+		"Τ1",
+		"Τ2",
+		"Τ3",
+		"Τ4"
+	],
+	"quarters-standAlone-wide": [
+		"1ο τ�ίμηνο",
+		"2ο τ�ίμηνο",
+		"3ο τ�ίμηνο",
+		"4ο τ�ίμηνο"
+	],
+	"dateFormatItem-HHmmss": "HH:mm:ss",
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"Κυ�ιακή",
+		"Δευτέ�α",
+		"Τ�ίτη",
+		"Τετά�τη",
+		"Πέμπτη",
+		"Πα�ασκευή",
+		"Σάββατο"
+	],
+	"dateFormatItem-MMMMd": "d MMMM",
+	"dateFormatItem-yyMMM": "LLL yy",
+	"timeFormat-medium": "h:mm:ss a",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"Τ1",
+		"Τ2",
+		"Τ3",
+		"Τ4"
+	],
+	"eraAbbr": [
+		"π.Χ.",
+		"μ.Χ."
+	],
+	"field-minute": "Λεπτό",
+	"field-dayperiod": "π.μ./μ.μ.",
+	"days-standAlone-abbr": [
+		"Κυ�",
+		"Δευ",
+		"Τ�ι",
+		"Τετ",
+		"Πεμ",
+		"Πα�",
+		"Σαβ"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "Χθες",
+	"field-day-relative+-2": "Π�οχθές",
+	"field-day-relative+-3": "Π�ιν από τ�εις ημέ�ες",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-MEd": "E, d/M",
+	"field-day": "Ημέ�α",
+	"days-format-wide": [
+		"Κυ�ιακή",
+		"Δευτέ�α",
+		"Τ�ίτη",
+		"Τετά�τη",
+		"Πέμπτη",
+		"Πα�ασκευή",
+		"Σάββατο"
+	],
+	"field-zone": "Ζώνη",
+	"dateFormatItem-yyyyMM": "MM/yyyy",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"Ι",
+		"Φ",
+		"Μ",
+		"Α",
+		"Μ",
+		"Ι",
+		"Ι",
+		"Α",
+		"Σ",
+		"Ο",
+		"�",
+		"Δ"
+	],
+	"dateFormatItem-yyMM": "MM/yy",
+	"days-format-abbr": [
+		"Κυ�",
+		"Δευ",
+		"Τ�ι",
+		"Τετ",
+		"Πεμ",
+		"Πα�",
+		"Σαβ"
+	],
+	"eraNames": [
+		"π.Χ.",
+		"μ.Χ."
+	],
+	"days-format-narrow": [
+		"Κ",
+		"Δ",
+		"Τ",
+		"Τ",
+		"Π",
+		"Π",
+		"Σ"
+	],
+	"field-month": "Μήνας",
+	"days-standAlone-narrow": [
+		"Κ",
+		"Δ",
+		"Τ",
+		"Τ",
+		"Π",
+		"Π",
+		"Σ"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dateFormatItem-HHmm": "HH:mm",
+	"dayPeriods-format-wide-am": "π.μ.",
+	"dateFormatItem-MMMMEd": "E, d MMMM",
+	"dateFormatItem-MMMMdd": "dd MMMM",
+	"dateFormat-short": "d/M/yy",
+	"field-second": "Δευτε�όλεπτο",
+	"dateFormatItem-yMMMEd": "EEE, d MMM y",
+	"dateFormatItem-Ed": "E d",
+	"field-week": "Εβδομάδα",
+	"dateFormat-medium": "d MMM y",
+	"dateFormatItem-mmss": "mm:ss",
+	"dateFormatItem-yyyy": "y"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/el/hebrew.js b/js/dojo-1.7.2/dojo/cldr/nls/el/hebrew.js
new file mode 100644
index 0000000..d6aa413
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/el/hebrew.js
@@ -0,0 +1,74 @@
+//>>built
+define(
+"dojo/cldr/nls/el/hebrew", //begin v1.x content
+{
+	"quarters-format-abbr": [
+		"Τ1",
+		"Τ2",
+		"Τ3",
+		"Τ4"
+	],
+	"dateFormat-medium": "d MMM y",
+	"dateFormatItem-MMMEd": "E, d MMM",
+	"dateFormatItem-MEd": "E, d/M",
+	"dateFormatItem-yMEd": "EEE, d/M/yyyy",
+	"eraNarrow": [
+		"π.μ."
+	],
+	"timeFormat-full": "h:mm:ss a zzzz",
+	"dateFormatItem-Md": "d/M",
+	"dateFormatItem-EEEd": "EEE d",
+	"eraNames": [
+		"π.μ."
+	],
+	"days-standAlone-narrow": [
+		"Κ",
+		"Δ",
+		"Τ",
+		"Τ",
+		"Π",
+		"Π",
+		"Σ"
+	],
+	"dayPeriods-format-wide-pm": "μ.μ.",
+	"dayPeriods-format-wide-am": "π.μ.",
+	"timeFormat-medium": "h:mm:ss a",
+	"dateFormat-long": "d MMMM y",
+	"dateFormat-short": "d/M/yy",
+	"dateFormatItem-yMMMEd": "EEE, d MMM y",
+	"dateFormatItem-yM": "M/yyyy",
+	"timeFormat-short": "h:mm a",
+	"eraAbbr": [
+		"π.μ."
+	],
+	"timeFormat-long": "h:mm:ss a z",
+	"days-format-wide": [
+		"Κυ�ιακή",
+		"Δευτέ�α",
+		"Τ�ίτη",
+		"Τετά�τη",
+		"Πέμπτη",
+		"Πα�ασκευή",
+		"Σάββατο"
+	],
+	"dateFormatItem-yMMM": "LLL y",
+	"quarters-format-wide": [
+		"1ο τ�ίμηνο",
+		"2ο τ�ίμηνο",
+		"3ο τ�ίμηνο",
+		"4ο τ�ίμηνο"
+	],
+	"dateFormat-full": "EEEE, d MMMM y",
+	"dateFormatItem-MMMd": "d MMM",
+	"days-format-abbr": [
+		"Κυ�",
+		"Δευ",
+		"Τ�ι",
+		"Τετ",
+		"Πεμ",
+		"Πα�",
+		"Σαβ"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/el/number.js b/js/dojo-1.7.2/dojo/cldr/nls/el/number.js
new file mode 100644
index 0000000..140113d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/el/number.js
@@ -0,0 +1,21 @@
+//>>built
+define(
+"dojo/cldr/nls/el/number", //begin v1.x content
+{
+	"group": ".",
+	"percentSign": "%",
+	"exponential": "e",
+	"percentFormat": "#,##0%",
+	"list": ",",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en-au/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/en-au/currency.js
new file mode 100644
index 0000000..af0ee64
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en-au/currency.js
@@ -0,0 +1,9 @@
+//>>built
+define(
+"dojo/cldr/nls/en-au/currency", //begin v1.x content
+{
+	"AUD_symbol": "$",
+	"USD_symbol": "US$"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en-au/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/en-au/gregorian.js
new file mode 100644
index 0000000..1fc5459
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en-au/gregorian.js
@@ -0,0 +1,18 @@
+//>>built
+define(
+"dojo/cldr/nls/en-au/gregorian", //begin v1.x content
+{
+	"dateFormatItem-yMEd": "EEE, d/M/y",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"dateFormatItem-MEd": "E, d/M",
+	"dateFormat-medium": "dd/MM/yyyy",
+	"dateFormatItem-MMdd": "dd/MM",
+	"dateFormatItem-yyyyMM": "MM/yyyy",
+	"dateFormat-full": "EEEE, d MMMM y",
+	"dateFormatItem-MMMMd": "d MMMM",
+	"dateFormat-short": "d/MM/yy",
+	"dateFormat-long": "d MMMM y",
+	"dateFormatItem-MMMEd": "E, d MMM"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en-au/number.js b/js/dojo-1.7.2/dojo/cldr/nls/en-au/number.js
new file mode 100644
index 0000000..db8a96b
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en-au/number.js
@@ -0,0 +1,8 @@
+//>>built
+define(
+"dojo/cldr/nls/en-au/number", //begin v1.x content
+{
+	"currencyFormat": "¤#,##0.00"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en-ca/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/en-ca/currency.js
new file mode 100644
index 0000000..25d0179
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en-ca/currency.js
@@ -0,0 +1,9 @@
+//>>built
+define(
+"dojo/cldr/nls/en-ca/currency", //begin v1.x content
+{
+	"CAD_symbol": "$",
+	"USD_symbol": "US$"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en-ca/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/en-ca/gregorian.js
new file mode 100644
index 0000000..e00dfb2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en-ca/gregorian.js
@@ -0,0 +1,21 @@
+//>>built
+define(
+"dojo/cldr/nls/en-ca/gregorian", //begin v1.x content
+{
+	"dateFormatItem-yMMMEd": "EEE, d MMM, y",
+	"dateFormatItem-yyMMM": "MMM-yy",
+	"dateFormatItem-Md": "M-d",
+	"dateFormatItem-yMEd": "EEE, y-M-d",
+	"dateFormatItem-MEd": "E, M-d",
+	"dateFormatItem-MMMMEd": "E, d MMMM",
+	"dateFormat-medium": "yyyy-MM-dd",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-MMdd": "MM-dd",
+	"dateFormat-full": "EEEE, d MMMM, y",
+	"dateFormat-short": "yy-MM-dd",
+	"dateFormatItem-MMMMd": "d MMMM",
+	"dateFormat-long": "d MMMM, y",
+	"dateFormatItem-MMMEd": "E, d MMM"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en-gb/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/en-gb/buddhist.js
new file mode 100644
index 0000000..12bc0c8
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en-gb/buddhist.js
@@ -0,0 +1,102 @@
+//>>built
+define(
+"dojo/cldr/nls/en-gb/buddhist", //begin v1.x content
+{
+	"dateFormat-medium": "d MMM y G",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"dateFormatItem-MMdd": "dd/MM",
+	"dateFormatItem-MEd": "E, d/M",
+	"dateFormatItem-yMEd": "EEE, d/M/y G",
+	"dateFormatItem-yyMMM": "MMM y G",
+	"dateFormatItem-y": "y",
+	"dateFormatItem-Md": "d/M",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"W",
+		"T",
+		"F",
+		"S"
+	],
+	"dateFormatItem-yyyyMMMM": "MMMM y G",
+	"dateFormatItem-MMMMd": "d MMMM",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yyyyMM": "MM/y G",
+	"dateFormat-long": "d MMMM y G",
+	"dateFormat-short": "dd/MM/y G",
+	"dateFormatItem-yMMMEd": "EEE, MMM d, y",
+	"months-format-wide": [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	],
+	"dateFormatItem-yM": "M/y",
+	"months-format-abbr": [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	],
+	"days-format-wide": [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	],
+	"dateFormatItem-yQ": "Q y",
+	"dateFormatItem-yMMM": "MMM y",
+	"quarters-format-wide": [
+		"1st quarter",
+		"2nd quarter",
+		"3rd quarter",
+		"4th quarter"
+	],
+	"dateFormat-full": "EEEE, d MMMM y G",
+	"dateFormatItem-yyyyMd": "d/M/y G",
+	"days-format-abbr": [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en-gb/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/en-gb/gregorian.js
new file mode 100644
index 0000000..c094416
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en-gb/gregorian.js
@@ -0,0 +1,24 @@
+//>>built
+define(
+"dojo/cldr/nls/en-gb/gregorian", //begin v1.x content
+{
+	"dateFormatItem-yyMMM": "MMM yy",
+	"dateFormatItem-Md": "d/M",
+	"dateFormatItem-yMEd": "EEE, d/M/yyyy",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"dateFormatItem-MEd": "E, d/M",
+	"dateFormat-medium": "d MMM y",
+	"dateFormatItem-MMdd": "dd/MM",
+	"dateFormatItem-yyyyMM": "MM/yyyy",
+	"dateFormat-full": "EEEE, d MMMM y",
+	"timeFormat-long": "HH:mm:ss z",
+	"timeFormat-short": "HH:mm",
+	"dateFormat-short": "dd/MM/yyyy",
+	"dateFormatItem-MMMMd": "d MMMM",
+	"dateFormat-long": "d MMMM y",
+	"dateFormatItem-MMMEd": "E d MMM"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en-gb/islamic.js b/js/dojo-1.7.2/dojo/cldr/nls/en-gb/islamic.js
new file mode 100644
index 0000000..2de7796
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en-gb/islamic.js
@@ -0,0 +1,154 @@
+//>>built
+define(
+"dojo/cldr/nls/en-gb/islamic", //begin v1.x content
+{
+	"dateFormat-medium": "d MMM y G",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"dateFormatItem-MMdd": "dd/MM",
+	"dateFormatItem-MEd": "E, d/M",
+	"dateFormatItem-yMEd": "EEE, d/M/yyyy",
+	"dateFormatItem-yyyyMMM": "MMM y G",
+	"eraNarrow": [
+		"AH"
+	],
+	"months-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateFormatItem-yyMMM": "MMM y G",
+	"dateFormatItem-Md": "d/M",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"months-standAlone-wide": [
+		"Muharram",
+		"Safar",
+		"RabiÊ» I",
+		"RabiÊ» II",
+		"Jumada I",
+		"Jumada II",
+		"Rajab",
+		"Shaʻban",
+		"Ramadan",
+		"Shawwal",
+		"Dhuʻl-Qiʻdah",
+		"Dhuʻl-Hijjah"
+	],
+	"eraNames": [
+		"AH"
+	],
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"W",
+		"T",
+		"F",
+		"S"
+	],
+	"dateFormatItem-yyyyMEd": "EEE, d/M/y G",
+	"dateFormatItem-yyyyMMMM": "MMMM y G",
+	"dateFormatItem-MMMMd": "d MMMM",
+	"months-standAlone-abbr": [
+		"Muh.",
+		"Saf.",
+		"Rab. I",
+		"Rab. II",
+		"Jum. I",
+		"Jum. II",
+		"Raj.",
+		"Sha.",
+		"Ram.",
+		"Shaw.",
+		"Dhuʻl-Q.",
+		"Dhuʻl-H."
+	],
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yyyyMM": "MM/y G",
+	"dateFormat-long": "d MMMM y G",
+	"dateFormat-short": "dd/MM/y G",
+	"dateFormatItem-yMMMEd": "EEE, MMM d, y",
+	"months-format-wide": [
+		"Muharram",
+		"Safar",
+		"RabiÊ» I",
+		"RabiÊ» II",
+		"Jumada I",
+		"Jumada II",
+		"Rajab",
+		"Shaʻban",
+		"Ramadan",
+		"Shawwal",
+		"Dhuʻl-Qiʻdah",
+		"Dhuʻl-Hijjah"
+	],
+	"dateFormatItem-yM": "M/y",
+	"months-format-abbr": [
+		"Muh.",
+		"Saf.",
+		"Rab. I",
+		"Rab. II",
+		"Jum. I",
+		"Jum. II",
+		"Raj.",
+		"Sha.",
+		"Ram.",
+		"Shaw.",
+		"Dhuʻl-Q.",
+		"Dhuʻl-H."
+	],
+	"eraAbbr": [
+		"AH"
+	],
+	"days-format-wide": [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	],
+	"dateFormatItem-yQ": "Q y",
+	"dateFormatItem-yMMM": "MMM y",
+	"quarters-format-wide": [
+		"1st quarter",
+		"2nd quarter",
+		"3rd quarter",
+		"4th quarter"
+	],
+	"dateFormatItem-yyyyMd": "d/M/y G",
+	"dateFormat-full": "EEEE, d MMMM y G",
+	"days-format-abbr": [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en-gb/number.js b/js/dojo-1.7.2/dojo/cldr/nls/en-gb/number.js
new file mode 100644
index 0000000..b3e77ad
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en-gb/number.js
@@ -0,0 +1,8 @@
+//>>built
+define(
+"dojo/cldr/nls/en-gb/number", //begin v1.x content
+{
+	"currencyFormat": "¤#,##0.00"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/en/buddhist.js
new file mode 100644
index 0000000..9bb161c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en/buddhist.js
@@ -0,0 +1,110 @@
+//>>built
+define(
+"dojo/cldr/nls/en/buddhist", //begin v1.x content
+{
+	"dateFormat-medium": "MMM d, y G",
+	"dateFormatItem-MMMEd": "E, MMM d",
+	"dateFormatItem-MEd": "E, M/d",
+	"dateFormatItem-yMEd": "EEE, M/d/y G",
+	"dateFormatItem-Hm": "HH:mm",
+	"dateFormatItem-y": "y G",
+	"timeFormat-full": "h:mm:ss a zzzz",
+	"dateFormatItem-hm": "h:mm a",
+	"dateFormatItem-Md": "M/d",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-EEEd": "d EEE",
+	"dateFormatItem-M": "L",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"W",
+		"T",
+		"F",
+		"S"
+	],
+	"dateFormatItem-yQQQ": "QQQ y G",
+	"timeFormat-medium": "h:mm:ss a",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormat-long": "MMMM d, y G",
+	"dateFormatItem-ms": "mm:ss",
+	"dateFormat-short": "M/d/yy G",
+	"dateFormatItem-yMMMEd": "EEE, MMM d, y G",
+	"months-format-wide": [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-yM": "M/y G",
+	"timeFormat-short": "h:mm a",
+	"months-format-abbr": [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	],
+	"timeFormat-long": "h:mm:ss a z",
+	"days-format-wide": [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	],
+	"dateFormatItem-hms": "h:mm:ss a",
+	"dateFormatItem-yQ": "Q y G",
+	"dateFormatItem-MMM": "LLL",
+	"dateFormatItem-yMMM": "MMM y G",
+	"quarters-format-wide": [
+		"1st quarter",
+		"2nd quarter",
+		"3rd quarter",
+		"4th quarter"
+	],
+	"dateFormat-full": "EEEE, MMMM d, y G",
+	"dateFormatItem-MMMd": "MMM d",
+	"days-format-abbr": [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/en/currency.js
new file mode 100644
index 0000000..86ffac1
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en/currency.js
@@ -0,0 +1,18 @@
+//>>built
+define(
+"dojo/cldr/nls/en/currency", //begin v1.x content
+{
+	"HKD_displayName": "Hong Kong Dollar",
+	"CHF_displayName": "Swiss Franc",
+	"JPY_symbol": "Â¥",
+	"CAD_displayName": "Canadian Dollar",
+	"CNY_displayName": "Chinese Yuan",
+	"USD_symbol": "$",
+	"AUD_displayName": "Australian Dollar",
+	"JPY_displayName": "Japanese Yen",
+	"USD_displayName": "US Dollar",
+	"GBP_displayName": "British Pound Sterling",
+	"EUR_displayName": "Euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/en/gregorian.js
new file mode 100644
index 0000000..7c3e62e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en/gregorian.js
@@ -0,0 +1,230 @@
+//>>built
+define(
+"dojo/cldr/nls/en/gregorian", //begin v1.x content
+{
+	"dateFormatItem-yM": "M/y",
+	"field-dayperiod": "AM/PM",
+	"dateFormatItem-yQ": "Q y",
+	"dayPeriods-format-wide-pm": "PM",
+	"field-minute": "Minute",
+	"eraNames": [
+		"Before Christ",
+		"Anno Domini"
+	],
+	"dateFormatItem-MMMEd": "E, MMM d",
+	"dateTimeFormat-full": "{1} {0}",
+	"field-day-relative+-1": "Yesterday",
+	"field-weekday": "Day of the Week",
+	"dateFormatItem-hms": "h:mm:ss a",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"days-standAlone-wide": [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateTimeFormat-short": "{1} {0}",
+	"field-era": "Era",
+	"field-hour": "Hour",
+	"dayPeriods-format-wide-am": "AM",
+	"dateTimeFormat-medium": "{1} {0}",
+	"dateFormatItem-y": "y",
+	"timeFormat-full": "h:mm:ss a zzzz",
+	"months-standAlone-abbr": [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	],
+	"dateFormatItem-yMMM": "MMM y",
+	"field-day-relative+0": "Today",
+	"field-day-relative+1": "Tomorrow",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"W",
+		"T",
+		"F",
+		"S"
+	],
+	"eraAbbr": [
+		"BC",
+		"AD"
+	],
+	"dateFormat-long": "MMMM d, y",
+	"timeFormat-medium": "h:mm:ss a",
+	"dateFormatItem-EEEd": "d EEE",
+	"field-zone": "Zone",
+	"dateFormatItem-Hm": "HH:mm",
+	"dateFormat-medium": "MMM d, y",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"quarters-standAlone-wide": [
+		"1st quarter",
+		"2nd quarter",
+		"3rd quarter",
+		"4th quarter"
+	],
+	"dateFormatItem-ms": "mm:ss",
+	"field-year": "Year",
+	"quarters-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4"
+	],
+	"dateTimeFormat-long": "{1} {0}",
+	"field-week": "Week",
+	"months-standAlone-wide": [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	],
+	"dateFormatItem-MMMd": "MMM d",
+	"timeFormat-long": "h:mm:ss a z",
+	"months-format-abbr": [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	],
+	"dayPeriods-format-wide-noon": "noon",
+	"timeFormat-short": "h:mm a",
+	"field-month": "Month",
+	"quarters-format-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"days-format-abbr": [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	],
+	"dateFormatItem-M": "L",
+	"days-format-narrow": [
+		"S",
+		"M",
+		"T",
+		"W",
+		"T",
+		"F",
+		"S"
+	],
+	"field-second": "Second",
+	"field-day": "Day",
+	"dateFormatItem-MEd": "E, M/d",
+	"months-format-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-hm": "h:mm a",
+	"days-standAlone-abbr": [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	],
+	"dateFormat-short": "M/d/yy",
+	"dateFormatItem-yMMMEd": "EEE, MMM d, y",
+	"dateFormat-full": "EEEE, MMMM d, y",
+	"dateFormatItem-Md": "M/d",
+	"dateFormatItem-yMEd": "EEE, M/d/y",
+	"months-format-wide": [
+		"January",
+		"February",
+		"March",
+		"April",
+		"May",
+		"June",
+		"July",
+		"August",
+		"September",
+		"October",
+		"November",
+		"December"
+	],
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"1st quarter",
+		"2nd quarter",
+		"3rd quarter",
+		"4th quarter"
+	],
+	"days-format-wide": [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	],
+	"eraNarrow": [
+		"B",
+		"A"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en/islamic.js b/js/dojo-1.7.2/dojo/cldr/nls/en/islamic.js
new file mode 100644
index 0000000..5c78e08
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en/islamic.js
@@ -0,0 +1,167 @@
+//>>built
+define(
+"dojo/cldr/nls/en/islamic", //begin v1.x content
+{
+	"dateFormatItem-yM": "M/y",
+	"dateFormatItem-yyyyMMMEd": "EEE, MMM d, y G",
+	"dateFormatItem-yQ": "Q y",
+	"eraNames": [
+		"AH"
+	],
+	"dateFormatItem-MMMEd": "E, MMM d",
+	"dateFormatItem-hms": "h:mm:ss a",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"timeFormat-full": "h:mm:ss a zzzz",
+	"dateFormatItem-yyyy": "y G",
+	"months-standAlone-abbr": [
+		"Muh.",
+		"Saf.",
+		"Rab. I",
+		"Rab. II",
+		"Jum. I",
+		"Jum. II",
+		"Raj.",
+		"Sha.",
+		"Ram.",
+		"Shaw.",
+		"Dhuʻl-Q.",
+		"Dhuʻl-H."
+	],
+	"dateFormatItem-yMMM": "MMM y",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"W",
+		"T",
+		"F",
+		"S"
+	],
+	"eraAbbr": [
+		"AH"
+	],
+	"dateFormat-long": "MMMM d, y G",
+	"timeFormat-medium": "h:mm:ss a",
+	"dateFormatItem-EEEd": "d EEE",
+	"dateFormatItem-Hm": "HH:mm",
+	"dateFormat-medium": "MMM d, y G",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-ms": "mm:ss",
+	"months-standAlone-wide": [
+		"Muharram",
+		"Safar",
+		"RabiÊ» I",
+		"RabiÊ» II",
+		"Jumada I",
+		"Jumada II",
+		"Rajab",
+		"Shaʻban",
+		"Ramadan",
+		"Shawwal",
+		"Dhuʻl-Qiʻdah",
+		"Dhuʻl-Hijjah"
+	],
+	"dateFormatItem-yyyyMEd": "EEE, M/d/y G",
+	"dateFormatItem-MMMd": "MMM d",
+	"timeFormat-long": "h:mm:ss a z",
+	"months-format-abbr": [
+		"Muh.",
+		"Saf.",
+		"Rab. I",
+		"Rab. II",
+		"Jum. I",
+		"Jum. II",
+		"Raj.",
+		"Sha.",
+		"Ram.",
+		"Shaw.",
+		"Dhuʻl-Q.",
+		"Dhuʻl-H."
+	],
+	"timeFormat-short": "h:mm a",
+	"days-format-abbr": [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	],
+	"dateFormatItem-M": "L",
+	"dateFormatItem-yyyyQQQ": "QQQ y G",
+	"dateFormatItem-MEd": "E, M/d",
+	"months-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateFormatItem-hm": "h:mm a",
+	"dateFormat-short": "M/d/yy G",
+	"dateFormatItem-yyyyM": "M/y G",
+	"dateFormatItem-yMMMEd": "EEE, MMM d, y",
+	"dateFormat-full": "EEEE, MMMM d, y G",
+	"dateFormatItem-Md": "M/d",
+	"dateFormatItem-yyyyQ": "Q y G",
+	"dateFormatItem-yMEd": "EEE, M/d/y",
+	"months-format-wide": [
+		"Muharram",
+		"Safar",
+		"RabiÊ» I",
+		"RabiÊ» II",
+		"Jumada I",
+		"Jumada II",
+		"Rajab",
+		"Shaʻban",
+		"Ramadan",
+		"Shawwal",
+		"Dhuʻl-Qiʻdah",
+		"Dhuʻl-Hijjah"
+	],
+	"dateFormatItem-yyyyMMM": "MMM y G",
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"1st quarter",
+		"2nd quarter",
+		"3rd quarter",
+		"4th quarter"
+	],
+	"eraNarrow": [
+		"AH"
+	],
+	"days-format-wide": [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/en/number.js b/js/dojo-1.7.2/dojo/cldr/nls/en/number.js
new file mode 100644
index 0000000..7c34c18
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/en/number.js
@@ -0,0 +1,24 @@
+//>>built
+define(
+"dojo/cldr/nls/en/number", //begin v1.x content
+{
+	"group": ",",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ".",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "¤#,##0.00;(¤#,##0.00)",
+	"plusSign": "+",
+	"decimalFormat-short": "000T"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/es/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/es/buddhist.js
new file mode 100644
index 0000000..69a3196
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/es/buddhist.js
@@ -0,0 +1,126 @@
+//>>built
+define(
+"dojo/cldr/nls/es/buddhist", //begin v1.x content
+{
+	"dateFormatItem-yM": "M/y G",
+	"dateFormatItem-yQ": "Q y G",
+	"dayPeriods-format-wide-pm": "p.m.",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"dateFormatItem-hms": "hh:mm:ss a",
+	"dateFormatItem-yQQQ": "QQQ y G",
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"E",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dayPeriods-format-wide-am": "a.m.",
+	"dateFormatItem-y": "y G",
+	"dateFormatItem-MMMdd": "dd-MMM",
+	"dateFormatItem-yMMM": "MMM y G",
+	"days-standAlone-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"J",
+		"V",
+		"S"
+	],
+	"dateFormatItem-yyyyMM": "MM/y G",
+	"dateFormat-long": "d 'de' MMMM 'de' y G",
+	"dateFormatItem-EEEd": "EEE d",
+	"dateFormatItem-Hm": "HH:mm",
+	"dateFormatItem-MMd": "d/MM",
+	"dateFormatItem-yyMM": "MM/y G",
+	"dateFormat-medium": "dd/MM/y G",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-yyMMM": "MMM-y G",
+	"dateFormatItem-yyQQQQ": "QQQQ 'de' y G",
+	"dateFormatItem-yMd": "d/M/y G",
+	"dateFormatItem-yMMMM": "MMMM 'de' y G",
+	"dateFormatItem-ms": "mm:ss",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-yyQ": "Q y G",
+	"months-format-abbr": [
+		"ene",
+		"feb",
+		"mar",
+		"abr",
+		"may",
+		"jun",
+		"jul",
+		"ago",
+		"sep",
+		"oct",
+		"nov",
+		"dic"
+	],
+	"dateFormatItem-MMMMd": "d 'de' MMMM",
+	"quarters-format-abbr": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"days-format-abbr": [
+		"dom",
+		"lun",
+		"mar",
+		"mié",
+		"jue",
+		"vie",
+		"sáb"
+	],
+	"dateFormatItem-M": "L",
+	"dateFormatItem-yMMMd": "d MMM y G",
+	"dateFormatItem-MEd": "E, d/M",
+	"dateFormatItem-hm": "hh:mm a",
+	"dateFormat-short": "dd/MM/y G",
+	"dateFormatItem-yMMMEd": "EEE, d MMM y G",
+	"dateFormat-full": "EEEE d 'de' MMMM 'de' y G",
+	"dateFormatItem-Md": "d/M",
+	"dateFormatItem-yMEd": "EEE d/M/y G",
+	"months-format-wide": [
+		"enero",
+		"febrero",
+		"marzo",
+		"abril",
+		"mayo",
+		"junio",
+		"julio",
+		"agosto",
+		"septiembre",
+		"octubre",
+		"noviembre",
+		"diciembre"
+	],
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"1er trimestre",
+		"2º trimestre",
+		"3er trimestre",
+		"4º trimestre"
+	],
+	"days-format-wide": [
+		"domingo",
+		"lunes",
+		"martes",
+		"miércoles",
+		"jueves",
+		"viernes",
+		"sábado"
+	],
+	"dateFormatItem-h": "hh a"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/es/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/es/currency.js
new file mode 100644
index 0000000..0041d52
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/es/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/es/currency", //begin v1.x content
+{
+	"HKD_displayName": "dólar de Hong Kong",
+	"CHF_displayName": "franco suizo",
+	"CAD_displayName": "dólar canadiense",
+	"CNY_displayName": "yuan renminbi chino",
+	"AUD_displayName": "dólar australiano",
+	"JPY_displayName": "yen japonés",
+	"USD_displayName": "dólar estadounidense",
+	"GBP_displayName": "libra esterlina británica",
+	"EUR_displayName": "euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/es/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/es/gregorian.js
new file mode 100644
index 0000000..f9c65ec
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/es/gregorian.js
@@ -0,0 +1,239 @@
+//>>built
+define(
+"dojo/cldr/nls/es/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"E",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"field-weekday": "día de la semana",
+	"dateFormatItem-yyQQQQ": "QQQQ 'de' yy",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "EEE d/M/y",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"eraNarrow": [
+		"a.C.",
+		"d.C."
+	],
+	"dateFormatItem-MMMdd": "dd-MMM",
+	"dateFormat-long": "d 'de' MMMM 'de' y",
+	"months-format-wide": [
+		"enero",
+		"febrero",
+		"marzo",
+		"abril",
+		"mayo",
+		"junio",
+		"julio",
+		"agosto",
+		"septiembre",
+		"octubre",
+		"noviembre",
+		"diciembre"
+	],
+	"dateFormatItem-EEEd": "EEE d",
+	"dayPeriods-format-wide-pm": "p.m.",
+	"dateFormat-full": "EEEE d 'de' MMMM 'de' y",
+	"dateFormatItem-Md": "d/M",
+	"field-era": "era",
+	"dateFormatItem-yM": "M/y",
+	"months-standAlone-wide": [
+		"enero",
+		"febrero",
+		"marzo",
+		"abril",
+		"mayo",
+		"junio",
+		"julio",
+		"agosto",
+		"septiembre",
+		"octubre",
+		"noviembre",
+		"diciembre"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"1er trimestre",
+		"2º trimestre",
+		"3er trimestre",
+		"4º trimestre"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "año",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "Q y",
+	"field-hour": "hora",
+	"months-format-abbr": [
+		"ene",
+		"feb",
+		"mar",
+		"abr",
+		"may",
+		"jun",
+		"jul",
+		"ago",
+		"sep",
+		"oct",
+		"nov",
+		"dic"
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"field-day-relative+0": "hoy",
+	"field-day-relative+1": "mañana",
+	"field-day-relative+2": "pasado mañana",
+	"field-day-relative+3": "Dentro de tres días",
+	"months-standAlone-abbr": [
+		"ene",
+		"feb",
+		"mar",
+		"abr",
+		"may",
+		"jun",
+		"jul",
+		"ago",
+		"sep",
+		"oct",
+		"nov",
+		"dic"
+	],
+	"quarters-format-abbr": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"quarters-standAlone-wide": [
+		"1er trimestre",
+		"2º trimestre",
+		"3er trimestre",
+		"4º trimestre"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"domingo",
+		"lunes",
+		"martes",
+		"miércoles",
+		"jueves",
+		"viernes",
+		"sábado"
+	],
+	"dateFormatItem-MMMMd": "d 'de' MMMM",
+	"dateFormatItem-yyMMM": "MMM-yy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"eraAbbr": [
+		"a.C.",
+		"d.C."
+	],
+	"field-minute": "minuto",
+	"field-dayperiod": "periodo del día",
+	"days-standAlone-abbr": [
+		"dom",
+		"lun",
+		"mar",
+		"mié",
+		"jue",
+		"vie",
+		"sáb"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "ayer",
+	"dateFormatItem-h": "hh a",
+	"field-day-relative+-2": "antes de ayer",
+	"field-day-relative+-3": "Hace tres días",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-MEd": "E, d/M",
+	"dateFormatItem-yMMMM": "MMMM 'de' y",
+	"field-day": "día",
+	"days-format-wide": [
+		"domingo",
+		"lunes",
+		"martes",
+		"miércoles",
+		"jueves",
+		"viernes",
+		"sábado"
+	],
+	"field-zone": "zona",
+	"dateFormatItem-yyyyMM": "MM/yyyy",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"E",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-yyMM": "MM/yy",
+	"dateFormatItem-hm": "hh:mm a",
+	"days-format-abbr": [
+		"dom",
+		"lun",
+		"mar",
+		"mié",
+		"jue",
+		"vie",
+		"sáb"
+	],
+	"eraNames": [
+		"antes de Cristo",
+		"anno Dómini"
+	],
+	"days-format-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"J",
+		"V",
+		"S"
+	],
+	"field-month": "mes",
+	"days-standAlone-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"J",
+		"V",
+		"S"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "a.m.",
+	"dateFormat-short": "dd/MM/yy",
+	"dateFormatItem-MMd": "d/MM",
+	"field-second": "segundo",
+	"dateFormatItem-yMMMEd": "EEE, d MMM y",
+	"field-week": "semana",
+	"dateFormat-medium": "dd/MM/yyyy",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "hh:mm:ss a"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/es/islamic.js b/js/dojo-1.7.2/dojo/cldr/nls/es/islamic.js
new file mode 100644
index 0000000..ce9bf29
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/es/islamic.js
@@ -0,0 +1,180 @@
+//>>built
+define(
+"dojo/cldr/nls/es/islamic", //begin v1.x content
+{
+	"dateFormatItem-yM": "M/y",
+	"dateFormatItem-yyyyMMMEd": "EEE, d MMM y G",
+	"dateFormatItem-yQ": "Q y",
+	"dayPeriods-format-wide-pm": "p.m.",
+	"eraNames": [
+		"AH"
+	],
+	"dateFormatItem-MMMEd": "E d MMM",
+	"dateFormatItem-hms": "hh:mm:ss a",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dayPeriods-format-wide-am": "a.m.",
+	"dateFormatItem-MMMdd": "dd-MMM",
+	"dateFormatItem-yyyy": "y G",
+	"months-standAlone-abbr": [
+		"Muh.",
+		"Saf.",
+		"Rab. I",
+		"Rab. II",
+		"Jum. I",
+		"Jum. II",
+		"Raj.",
+		"Sha.",
+		"Ram.",
+		"Shaw.",
+		"Dhuʻl-Q.",
+		"Dhuʻl-H."
+	],
+	"dateFormatItem-yMMM": "MMM y",
+	"days-standAlone-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"J",
+		"V",
+		"S"
+	],
+	"eraAbbr": [
+		"AH"
+	],
+	"dateFormatItem-yyyyMMMM": "MMMM 'de' y G",
+	"dateFormat-long": "d 'de' MMMM 'de' y G",
+	"dateFormatItem-EEEd": "EEE d",
+	"dateFormatItem-Hm": "HH:mm",
+	"dateFormatItem-MMd": "d/MM",
+	"dateFormatItem-yyMM": "MM/y G",
+	"dateFormat-medium": "dd/MM/y G",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-yyMMM": "MMM-y G",
+	"dateFormatItem-yyQQQQ": "QQQQ 'de' y G",
+	"dateFormatItem-ms": "mm:ss",
+	"months-standAlone-wide": [
+		"Muharram",
+		"Safar",
+		"RabiÊ» I",
+		"RabiÊ» II",
+		"Jumada I",
+		"Jumada II",
+		"Rajab",
+		"Shaʻban",
+		"Ramadan",
+		"Shawwal",
+		"Dhuʻl-Qiʻdah",
+		"Dhuʻl-Hijjah"
+	],
+	"dateFormatItem-yyyyMEd": "EEE d/M/y G",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-yyQ": "Q y G",
+	"months-format-abbr": [
+		"Muh.",
+		"Saf.",
+		"Rab. I",
+		"Rab. II",
+		"Jum. I",
+		"Jum. II",
+		"Raj.",
+		"Sha.",
+		"Ram.",
+		"Shaw.",
+		"Dhuʻl-Q.",
+		"Dhuʻl-H."
+	],
+	"dateFormatItem-MMMMd": "d 'de' MMMM",
+	"quarters-format-abbr": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"days-format-abbr": [
+		"dom",
+		"lun",
+		"mar",
+		"mié",
+		"jue",
+		"vie",
+		"sáb"
+	],
+	"dateFormatItem-M": "L",
+	"dateFormatItem-MEd": "E, d/M",
+	"dateFormatItem-yyyyQQQ": "QQQ y G",
+	"months-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateFormatItem-hm": "hh:mm a",
+	"dateFormat-short": "dd/MM/y G",
+	"dateFormatItem-yyyyM": "M/y G",
+	"dateFormatItem-yMMMEd": "EEE, d MMM y",
+	"dateFormat-full": "EEEE d 'de' MMMM 'de' y G",
+	"dateFormatItem-Md": "d/M",
+	"dateFormatItem-yyyyQ": "Q y G",
+	"dateFormatItem-yMEd": "EEE d/M/y",
+	"months-format-wide": [
+		"Muharram",
+		"Safar",
+		"RabiÊ» I",
+		"RabiÊ» II",
+		"Jumada I",
+		"Jumada II",
+		"Rajab",
+		"Shaʻban",
+		"Ramadan",
+		"Shawwal",
+		"Dhuʻl-Qiʻdah",
+		"Dhuʻl-Hijjah"
+	],
+	"dateFormatItem-yyyyMMM": "MMM y G",
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"1er trimestre",
+		"2º trimestre",
+		"3er trimestre",
+		"4º trimestre"
+	],
+	"eraNarrow": [
+		"AH"
+	],
+	"days-format-wide": [
+		"domingo",
+		"lunes",
+		"martes",
+		"miércoles",
+		"jueves",
+		"viernes",
+		"sábado"
+	],
+	"dateFormatItem-h": "hh a"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/es/number.js b/js/dojo-1.7.2/dojo/cldr/nls/es/number.js
new file mode 100644
index 0000000..12572c7
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/es/number.js
@@ -0,0 +1,22 @@
+//>>built
+define(
+"dojo/cldr/nls/es/number", //begin v1.x content
+{
+	"group": ".",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "¤ #,##0.00",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fi/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/fi/buddhist.js
new file mode 100644
index 0000000..13cf735
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fi/buddhist.js
@@ -0,0 +1,167 @@
+//>>built
+define(
+"dojo/cldr/nls/fi/buddhist", //begin v1.x content
+{
+	"dateFormatItem-yM": "L.y G",
+	"dateFormatItem-yMMMMccccd": "cccc, d. MMMM y G",
+	"dateFormatItem-yQ": "Q/y G",
+	"dayPeriods-format-wide-pm": "ip.",
+	"dateFormatItem-MMMEd": "E d. MMM",
+	"dateFormatItem-hms": "h.mm.ss a",
+	"dateFormatItem-yQQQ": "QQQ y G",
+	"days-standAlone-wide": [
+		"sunnuntai",
+		"maanantai",
+		"tiistai",
+		"keskiviikko",
+		"torstai",
+		"perjantai",
+		"lauantai"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"T",
+		"H",
+		"M",
+		"H",
+		"T",
+		"K",
+		"H",
+		"E",
+		"S",
+		"L",
+		"M",
+		"J"
+	],
+	"dateFormatItem-Gy": "y G",
+	"dayPeriods-format-wide-am": "ap.",
+	"dateFormatItem-y": "y G",
+	"timeFormat-full": "H.mm.ss zzzz",
+	"months-standAlone-abbr": [
+		"tammi",
+		"helmi",
+		"maalis",
+		"huhti",
+		"touko",
+		"kesä",
+		"heinä",
+		"elo",
+		"syys",
+		"loka",
+		"marras",
+		"joulu"
+	],
+	"dateFormatItem-Ed": "ccc d.",
+	"dateFormatItem-yMMM": "LLLL y G",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"K",
+		"T",
+		"P",
+		"L"
+	],
+	"dateFormatItem-yyyyMMMM": "LLLL y G",
+	"dateFormat-long": "d. MMMM y G",
+	"timeFormat-medium": "H.mm.ss",
+	"dateFormatItem-Hm": "H.mm",
+	"dateFormatItem-yyyyMEEEd": "EEE d.M.y G",
+	"dateFormatItem-yyMM": "M.y G",
+	"dateFormat-medium": "d.M.y G",
+	"dateFormatItem-Hms": "H.mm.ss",
+	"dateFormatItem-yyMMM": "LLLL y G",
+	"dateFormatItem-ms": "mm.ss",
+	"dateFormatItem-yyyyQQQQ": "QQQQ y G",
+	"months-standAlone-wide": [
+		"tammikuu",
+		"helmikuu",
+		"maaliskuu",
+		"huhtikuu",
+		"toukokuu",
+		"kesäkuu",
+		"heinäkuu",
+		"elokuu",
+		"syyskuu",
+		"lokakuu",
+		"marraskuu",
+		"joulukuu"
+	],
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-yyQ": "Q/y G",
+	"timeFormat-long": "H.mm.ss z",
+	"months-format-abbr": [
+		"tammikuuta",
+		"helmikuuta",
+		"maaliskuuta",
+		"huhtikuuta",
+		"toukokuuta",
+		"kesäkuuta",
+		"heinäkuuta",
+		"elokuuta",
+		"syyskuuta",
+		"lokakuuta",
+		"marraskuuta",
+		"joulukuuta"
+	],
+	"dateFormatItem-H": "H",
+	"timeFormat-short": "H.mm",
+	"quarters-format-abbr": [
+		"1. nelj.",
+		"2. nelj.",
+		"3. nelj.",
+		"4. nelj."
+	],
+	"days-format-abbr": [
+		"su",
+		"ma",
+		"ti",
+		"ke",
+		"to",
+		"pe",
+		"la"
+	],
+	"dateFormatItem-M": "L",
+	"dateFormatItem-MEd": "E d.M.",
+	"dateFormatItem-hm": "h.mm a",
+	"dayPeriods-format-abbr-pm": "ip.",
+	"dateFormat-short": "d.M.y G",
+	"dateFormatItem-yyyyM": "M.y G",
+	"dateFormatItem-yMMMEd": "EEE d. MMM y G",
+	"dateFormat-full": "cccc d. MMMM y G",
+	"dateFormatItem-Md": "d.M.",
+	"dateFormatItem-yMEd": "EEE d.M.y G",
+	"months-format-wide": [
+		"tammikuuta",
+		"helmikuuta",
+		"maaliskuuta",
+		"huhtikuuta",
+		"toukokuuta",
+		"kesäkuuta",
+		"heinäkuuta",
+		"elokuuta",
+		"syyskuuta",
+		"lokakuuta",
+		"marraskuuta",
+		"joulukuuta"
+	],
+	"dayPeriods-format-abbr-am": "ap.",
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"1. neljännes",
+		"2. neljännes",
+		"3. neljännes",
+		"4. neljännes"
+	],
+	"days-format-wide": [
+		"sunnuntaina",
+		"maanantaina",
+		"tiistaina",
+		"keskiviikkona",
+		"torstaina",
+		"perjantaina",
+		"lauantaina"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fi/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/fi/currency.js
new file mode 100644
index 0000000..4808eca
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fi/currency.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/fi/currency", //begin v1.x content
+{
+	"HKD_displayName": "Hongkongin dollari",
+	"CHF_displayName": "Sveitsin frangi",
+	"CHF_symbol": "CHF",
+	"JPY_symbol": "Â¥",
+	"CAD_displayName": "Kanadan dollari",
+	"HKD_symbol": "HKD",
+	"CNY_displayName": "Kiinan yuan",
+	"USD_symbol": "$",
+	"AUD_displayName": "Australian dollari",
+	"JPY_displayName": "Japanin jeni",
+	"CAD_symbol": "CAD",
+	"USD_displayName": "Yhdysvaltain dollari",
+	"CNY_symbol": "CNY",
+	"GBP_displayName": "Englannin punta",
+	"AUD_symbol": "AUD",
+	"EUR_displayName": "euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fi/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/fi/gregorian.js
new file mode 100644
index 0000000..0076b29
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fi/gregorian.js
@@ -0,0 +1,240 @@
+//>>built
+define(
+"dojo/cldr/nls/fi/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"T",
+		"H",
+		"M",
+		"H",
+		"T",
+		"K",
+		"H",
+		"E",
+		"S",
+		"L",
+		"M",
+		"J"
+	],
+	"field-weekday": "viikonpäivä",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "EEE d.M.yyyy",
+	"dateFormatItem-MMMEd": "E d. MMM",
+	"eraNarrow": [
+		"eKr.",
+		"jKr."
+	],
+	"dateFormat-long": "d. MMMM y",
+	"months-format-wide": [
+		"tammikuuta",
+		"helmikuuta",
+		"maaliskuuta",
+		"huhtikuuta",
+		"toukokuuta",
+		"kesäkuuta",
+		"heinäkuuta",
+		"elokuuta",
+		"syyskuuta",
+		"lokakuuta",
+		"marraskuuta",
+		"joulukuuta"
+	],
+	"dayPeriods-format-wide-pm": "ip.",
+	"dateFormat-full": "cccc d. MMMM y",
+	"dateFormatItem-Md": "d.M.",
+	"dayPeriods-standAlone-wide-pm": "ip.",
+	"dayPeriods-format-abbr-am": "ap.",
+	"field-era": "aikakausi",
+	"dateFormatItem-yM": "L.yyyy",
+	"months-standAlone-wide": [
+		"tammikuu",
+		"helmikuu",
+		"maaliskuu",
+		"huhtikuu",
+		"toukokuu",
+		"kesäkuu",
+		"heinäkuu",
+		"elokuu",
+		"syyskuu",
+		"lokakuu",
+		"marraskuu",
+		"joulukuu"
+	],
+	"timeFormat-short": "H.mm",
+	"quarters-format-wide": [
+		"1. neljännes",
+		"2. neljännes",
+		"3. neljännes",
+		"4. neljännes"
+	],
+	"timeFormat-long": "H.mm.ss z",
+	"field-year": "vuosi",
+	"dateFormatItem-yMMM": "LLL y",
+	"dateFormatItem-yQ": "Q/yyyy",
+	"dateFormatItem-yyyyMMMM": "LLLL y",
+	"field-hour": "tunti",
+	"months-format-abbr": [
+		"tammikuuta",
+		"helmikuuta",
+		"maaliskuuta",
+		"huhtikuuta",
+		"toukokuuta",
+		"kesäkuuta",
+		"heinäkuuta",
+		"elokuuta",
+		"syyskuuta",
+		"lokakuuta",
+		"marraskuuta",
+		"joulukuuta"
+	],
+	"dateFormatItem-yyQ": "Q/yy",
+	"timeFormat-full": "H.mm.ss zzzz",
+	"dateFormatItem-yyyyMEEEd": "EEE d.M.yyyy",
+	"field-day-relative+0": "tänään",
+	"field-day-relative+1": "huomenna",
+	"field-day-relative+2": "ylihuomenna",
+	"dateFormatItem-H": "H",
+	"months-standAlone-abbr": [
+		"tammi",
+		"helmi",
+		"maalis",
+		"huhti",
+		"touko",
+		"kesä",
+		"heinä",
+		"elo",
+		"syys",
+		"loka",
+		"marras",
+		"joulu"
+	],
+	"quarters-format-abbr": [
+		"1. nelj.",
+		"2. nelj.",
+		"3. nelj.",
+		"4. nelj."
+	],
+	"quarters-standAlone-wide": [
+		"1. neljännes",
+		"2. neljännes",
+		"3. neljännes",
+		"4. neljännes"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"sunnuntai",
+		"maanantai",
+		"tiistai",
+		"keskiviikko",
+		"torstai",
+		"perjantai",
+		"lauantai"
+	],
+	"dateFormatItem-yyMMM": "LLLL yy",
+	"timeFormat-medium": "H.mm.ss",
+	"dateFormatItem-Hm": "H.mm",
+	"quarters-standAlone-abbr": [
+		"1. nelj.",
+		"2. nelj.",
+		"3. nelj.",
+		"4. nelj."
+	],
+	"eraAbbr": [
+		"eKr.",
+		"jKr."
+	],
+	"field-minute": "minuutti",
+	"field-dayperiod": "ap./ip.",
+	"days-standAlone-abbr": [
+		"su",
+		"ma",
+		"ti",
+		"ke",
+		"to",
+		"pe",
+		"la"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm.ss",
+	"field-day-relative+-1": "eilen",
+	"field-day-relative+-2": "toissapäivänä",
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-MEd": "E d.M.",
+	"field-day": "päivä",
+	"dateFormatItem-yMMMMccccd": "cccc, d. MMMM y",
+	"days-format-wide": [
+		"sunnuntaina",
+		"maanantaina",
+		"tiistaina",
+		"keskiviikkona",
+		"torstaina",
+		"perjantaina",
+		"lauantaina"
+	],
+	"field-zone": "aikavyöhyke",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"T",
+		"H",
+		"M",
+		"H",
+		"T",
+		"K",
+		"H",
+		"E",
+		"S",
+		"L",
+		"M",
+		"J"
+	],
+	"dateFormatItem-yyMM": "M/yy",
+	"dateFormatItem-hm": "h.mm a",
+	"dayPeriods-format-abbr-pm": "ip.",
+	"days-format-abbr": [
+		"su",
+		"ma",
+		"ti",
+		"ke",
+		"to",
+		"pe",
+		"la"
+	],
+	"eraNames": [
+		"ennen Kristuksen syntymää",
+		"jälkeen Kristuksen syntymän"
+	],
+	"days-format-narrow": [
+		"S",
+		"M",
+		"T",
+		"K",
+		"T",
+		"P",
+		"L"
+	],
+	"field-month": "kuukausi",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"K",
+		"T",
+		"P",
+		"L"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "ap.",
+	"dayPeriods-standAlone-wide-am": "ap.",
+	"dateFormat-short": "d.M.yyyy",
+	"field-second": "sekunti",
+	"dateFormatItem-yMMMEd": "EEE d. MMM y",
+	"dateFormatItem-Ed": "ccc d.",
+	"field-week": "viikko",
+	"dateFormat-medium": "d.M.yyyy",
+	"dateFormatItem-yyyyM": "M/yyyy",
+	"dateFormatItem-yyyyQQQQ": "QQQQ y",
+	"dateFormatItem-Hms": "H.mm.ss",
+	"dateFormatItem-hms": "h.mm.ss a"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fi/hebrew.js b/js/dojo-1.7.2/dojo/cldr/nls/fi/hebrew.js
new file mode 100644
index 0000000..c33314a
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fi/hebrew.js
@@ -0,0 +1,177 @@
+//>>built
+define(
+"dojo/cldr/nls/fi/hebrew", //begin v1.x content
+{
+	"dateFormatItem-yM": "L.yyyy",
+	"dateFormatItem-yQ": "Q/yyyy",
+	"months-standAlone-abbr-leap": "adár II",
+	"dayPeriods-format-wide-pm": "ip.",
+	"dateFormatItem-MMMEd": "E d. MMM",
+	"dateFormatItem-hms": "h.mm.ss a",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"days-standAlone-wide": [
+		"sunnuntai",
+		"maanantai",
+		"tiistai",
+		"keskiviikko",
+		"torstai",
+		"perjantai",
+		"lauantai"
+	],
+	"months-standAlone-narrow": [
+		"T",
+		"H",
+		"K",
+		"T",
+		"S",
+		"A",
+		"A",
+		"N",
+		"I",
+		"S",
+		"T",
+		"A",
+		"E"
+	],
+	"dayPeriods-format-wide-am": "ap.",
+	"timeFormat-full": "H.mm.ss zzzz",
+	"months-standAlone-narrow-leap": "A",
+	"months-standAlone-abbr": [
+		"tišrí",
+		"hešván",
+		"kislév",
+		"tevét",
+		"ševát",
+		"adár I",
+		"adár",
+		"nisán",
+		"ijjár",
+		"siván",
+		"tammúz",
+		"ab",
+		"elúl"
+	],
+	"dateFormatItem-yMMM": "LLL y",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"K",
+		"T",
+		"P",
+		"L"
+	],
+	"dateFormat-long": "d. MMMM y",
+	"timeFormat-medium": "H.mm.ss",
+	"dateFormatItem-Hm": "H.mm",
+	"dateFormat-medium": "d.M.yyyy",
+	"dateFormatItem-Hms": "H.mm.ss",
+	"dateFormatItem-ms": "mm.ss",
+	"months-standAlone-wide": [
+		"tišríkuu",
+		"hešvánkuu",
+		"kislévkuu",
+		"tevétkuu",
+		"ševátkuu",
+		"adárkuu I",
+		"adárkuu",
+		"nisánkuu",
+		"ijjárkuu",
+		"sivánkuu",
+		"tammúzkuu",
+		"abkuu",
+		"elúlkuu"
+	],
+	"dateFormatItem-MMMd": "d. MMM",
+	"timeFormat-long": "H.mm.ss z",
+	"months-format-abbr": [
+		"tišríkuuta",
+		"hešvánkuuta",
+		"kislévkuuta",
+		"tevétkuuta",
+		"ševátkuuta",
+		"adárkuuta I",
+		"adárkuuta",
+		"nisánkuuta",
+		"ijjárkuuta",
+		"sivánkuuta",
+		"tammúzkuuta",
+		"abkuuta",
+		"elúlkuuta"
+	],
+	"timeFormat-short": "H.mm",
+	"dateFormatItem-H": "H",
+	"quarters-format-abbr": [
+		"1. nelj.",
+		"2. nelj.",
+		"3. nelj.",
+		"4. nelj."
+	],
+	"days-format-abbr": [
+		"su",
+		"ma",
+		"ti",
+		"ke",
+		"to",
+		"pe",
+		"la"
+	],
+	"dateFormatItem-MEd": "E d.M.",
+	"months-format-narrow": [
+		"T",
+		"H",
+		"K",
+		"T",
+		"S",
+		"A",
+		"A",
+		"N",
+		"I",
+		"S",
+		"T",
+		"A",
+		"E"
+	],
+	"dateFormatItem-hm": "h.mm a",
+	"months-standAlone-wide-leap": "adárkuu II",
+	"dayPeriods-format-abbr-pm": "ip.",
+	"dateFormat-short": "d.M.yyyy",
+	"dateFormatItem-yMMMEd": "EEE d. MMM y",
+	"dateFormat-full": "cccc d. MMMM y",
+	"dateFormatItem-Md": "d.M.",
+	"dateFormatItem-yMEd": "EEE d.M.yyyy",
+	"months-format-wide": [
+		"tišríkuuta",
+		"hešvánkuuta",
+		"kislévkuuta",
+		"tevétkuuta",
+		"ševátkuuta",
+		"adárkuuta I",
+		"adárkuuta",
+		"nisánkuuta",
+		"ijjárkuuta",
+		"sivánkuuta",
+		"tammúzkuuta",
+		"abkuuta",
+		"elúlkuuta"
+	],
+	"dayPeriods-format-abbr-am": "ap.",
+	"quarters-format-wide": [
+		"1. neljännes",
+		"2. neljännes",
+		"3. neljännes",
+		"4. neljännes"
+	],
+	"months-format-wide-leap": "adárkuuta II",
+	"days-format-wide": [
+		"sunnuntaina",
+		"maanantaina",
+		"tiistaina",
+		"keskiviikkona",
+		"torstaina",
+		"perjantaina",
+		"lauantaina"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fi/islamic.js b/js/dojo-1.7.2/dojo/cldr/nls/fi/islamic.js
new file mode 100644
index 0000000..f4fb8ef
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fi/islamic.js
@@ -0,0 +1,156 @@
+//>>built
+define(
+"dojo/cldr/nls/fi/islamic", //begin v1.x content
+{
+	"dateFormatItem-yM": "L.yyyy",
+	"dateFormatItem-yyyyMMMEd": "EEE d. MMM y G",
+	"dateFormatItem-yQ": "Q/yyyy",
+	"dayPeriods-format-wide-pm": "ip.",
+	"dateFormatItem-MMMEd": "E d. MMM",
+	"dateFormatItem-hms": "h.mm.ss a",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"days-standAlone-wide": [
+		"sunnuntai",
+		"maanantai",
+		"tiistai",
+		"keskiviikko",
+		"torstai",
+		"perjantai",
+		"lauantai"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dateFormatItem-Gy": "y G",
+	"dayPeriods-format-wide-am": "ap.",
+	"dateFormatItem-y": "y G",
+	"timeFormat-full": "H.mm.ss zzzz",
+	"dateFormatItem-yyyy": "y G",
+	"months-standAlone-abbr": [
+		"muharram",
+		"safar",
+		"rabi’ al-awwal",
+		"rabi’ al-akhir",
+		"džumada-l-ula",
+		"džumada-l-akhira",
+		"radžab",
+		"ša’ban",
+		"ramadan",
+		"Å¡awwal",
+		"dhu-l-qa’da",
+		"dhu-l-hiddža"
+	],
+	"dateFormatItem-Ed": "ccc d.",
+	"dateFormatItem-yMMM": "LLL y",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"K",
+		"T",
+		"P",
+		"L"
+	],
+	"dateFormatItem-yyyyMMMMccccd": "cccc, d. MMMM y G",
+	"dateFormatItem-yyyyMM": "M.y G",
+	"dateFormatItem-yyyyMMMM": "LLLL y G",
+	"dateFormat-long": "d. MMMM y G",
+	"timeFormat-medium": "H.mm.ss",
+	"dateFormatItem-Hm": "H.mm",
+	"dateFormat-medium": "d.M.y G",
+	"dateFormatItem-Hms": "H.mm.ss",
+	"dateFormatItem-ms": "mm.ss",
+	"dateFormatItem-yyyyQQQQ": "QQQQ y G",
+	"months-standAlone-wide": [
+		"muharram",
+		"safar",
+		"rabi’ al-awwal",
+		"rabi’ al-akhir",
+		"džumada-l-ula",
+		"džumada-l-akhira",
+		"radžab",
+		"ša’ban",
+		"ramadan",
+		"Å¡awwal",
+		"dhu-l-qa’da",
+		"dhu-l-hiddža"
+	],
+	"dateFormatItem-yyyyMEd": "EEE d.M.y G",
+	"dateFormatItem-MMMd": "d. MMM",
+	"timeFormat-long": "H.mm.ss z",
+	"months-format-abbr": [
+		"muharram",
+		"safar",
+		"rabi’ al-awwal",
+		"rabi’ al-akhir",
+		"džumada-l-ula",
+		"džumada-l-akhira",
+		"radžab",
+		"ša’ban",
+		"ramadan",
+		"Å¡awwal",
+		"dhu-l-qa’da",
+		"dhu-l-hiddža"
+	],
+	"timeFormat-short": "H.mm",
+	"dateFormatItem-H": "H",
+	"quarters-format-abbr": [
+		"1. nelj.",
+		"2. nelj.",
+		"3. nelj.",
+		"4. nelj."
+	],
+	"days-format-abbr": [
+		"su",
+		"ma",
+		"ti",
+		"ke",
+		"to",
+		"pe",
+		"la"
+	],
+	"dateFormatItem-M": "L",
+	"dateFormatItem-yyyyQQQ": "QQQ y G",
+	"dateFormatItem-MEd": "E d.M.",
+	"dateFormatItem-hm": "h.mm a",
+	"dayPeriods-format-abbr-pm": "ip.",
+	"dateFormat-short": "d.M.y G",
+	"dateFormatItem-yyyyM": "M.y G",
+	"dateFormatItem-yMMMEd": "EEE d. MMM y",
+	"dateFormat-full": "cccc d. MMMM y G",
+	"dateFormatItem-Md": "d.M.",
+	"dateFormatItem-yyyyQ": "Q/y G",
+	"dateFormatItem-yMEd": "EEE d.M.yyyy",
+	"months-format-wide": [
+		"muharram",
+		"safar",
+		"rabi’ al-awwal",
+		"rabi’ al-akhir",
+		"džumada-l-ula",
+		"džumada-l-akhira",
+		"radžab",
+		"ša’ban",
+		"ramadan",
+		"Å¡awwal",
+		"dhu-l-qa’da",
+		"dhu-l-hiddža"
+	],
+	"dayPeriods-format-abbr-am": "ap.",
+	"dateFormatItem-yyyyMMM": "LLLL y G",
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"1. neljännes",
+		"2. neljännes",
+		"3. neljännes",
+		"4. neljännes"
+	],
+	"days-format-wide": [
+		"sunnuntaina",
+		"maanantaina",
+		"tiistaina",
+		"keskiviikkona",
+		"torstaina",
+		"perjantaina",
+		"lauantaina"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fi/number.js b/js/dojo-1.7.2/dojo/cldr/nls/fi/number.js
new file mode 100644
index 0000000..401bb40
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fi/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/fi/number", //begin v1.x content
+{
+	"group": " ",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0 %",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "epäluku",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fr-ch/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/fr-ch/gregorian.js
new file mode 100644
index 0000000..60f4fa1
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fr-ch/gregorian.js
@@ -0,0 +1,10 @@
+//>>built
+define(
+"dojo/cldr/nls/fr-ch/gregorian", //begin v1.x content
+{
+	"timeFormat-full": "HH.mm:ss 'h' zzzz",
+	"dateFormat-full": "EEEE, d MMMM y",
+	"dateFormat-short": "dd.MM.yy"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fr-ch/number.js b/js/dojo-1.7.2/dojo/cldr/nls/fr-ch/number.js
new file mode 100644
index 0000000..d89f741
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fr-ch/number.js
@@ -0,0 +1,10 @@
+//>>built
+define(
+"dojo/cldr/nls/fr-ch/number", //begin v1.x content
+{
+	"currencyFormat": "¤ #,##0.00;¤-#,##0.00",
+	"group": "'",
+	"decimal": "."
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fr/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/fr/currency.js
new file mode 100644
index 0000000..cdcc667
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fr/currency.js
@@ -0,0 +1,24 @@
+//>>built
+define(
+"dojo/cldr/nls/fr/currency", //begin v1.x content
+{
+	"HKD_displayName": "dollar de Hong Kong",
+	"CHF_displayName": "franc suisse",
+	"CHF_symbol": "CHF",
+	"JPY_symbol": "Â¥JP",
+	"CAD_displayName": "dollar canadien",
+	"HKD_symbol": "$HK",
+	"CNY_displayName": "yuan renminbi chinois",
+	"USD_symbol": "$US",
+	"AUD_displayName": "dollar australien",
+	"JPY_displayName": "yen japonais",
+	"CAD_symbol": "$CA",
+	"USD_displayName": "dollar des États-Unis",
+	"CNY_symbol": "Ò°",
+	"GBP_displayName": "livre sterling",
+	"GBP_symbol": "£UK",
+	"AUD_symbol": "$AU",
+	"EUR_displayName": "euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fr/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/fr/gregorian.js
new file mode 100644
index 0000000..40cea17
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fr/gregorian.js
@@ -0,0 +1,248 @@
+//>>built
+define(
+"dojo/cldr/nls/fr/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"field-weekday": "jour de la semaine",
+	"dateFormatItem-yyQQQQ": "QQQQ yy",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "EEE d/M/yyyy",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"eraNarrow": [
+		"av. J.-C.",
+		"ap. J.-C."
+	],
+	"dayPeriods-format-wide-morning": "matin",
+	"dateFormatItem-MMMdd": "dd MMM",
+	"dateFormat-long": "d MMMM y",
+	"months-format-wide": [
+		"janvier",
+		"février",
+		"mars",
+		"avril",
+		"mai",
+		"juin",
+		"juillet",
+		"août",
+		"septembre",
+		"octobre",
+		"novembre",
+		"décembre"
+	],
+	"dayPeriods-format-wide-pm": "PM",
+	"dateFormat-full": "EEEE d MMMM y",
+	"dateFormatItem-Md": "d/M",
+	"dayPeriods-format-wide-noon": "midi",
+	"field-era": "ère",
+	"dateFormatItem-yM": "M/yyyy",
+	"months-standAlone-wide": [
+		"janvier",
+		"février",
+		"mars",
+		"avril",
+		"mai",
+		"juin",
+		"juillet",
+		"août",
+		"septembre",
+		"octobre",
+		"novembre",
+		"décembre"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"1er trimestre",
+		"2e trimestre",
+		"3e trimestre",
+		"4e trimestre"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "année",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "'T'Q y",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"field-hour": "heure",
+	"dateFormatItem-MMdd": "dd/MM",
+	"months-format-abbr": [
+		"janv.",
+		"févr.",
+		"mars",
+		"avr.",
+		"mai",
+		"juin",
+		"juil.",
+		"août",
+		"sept.",
+		"oct.",
+		"nov.",
+		"déc."
+	],
+	"dateFormatItem-yyQ": "'T'Q yy",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"field-day-relative+0": "aujourd’hui",
+	"field-day-relative+1": "demain",
+	"field-day-relative+2": "après-demain",
+	"field-day-relative+3": "après-après-demain",
+	"months-standAlone-abbr": [
+		"janv.",
+		"févr.",
+		"mars",
+		"avr.",
+		"mai",
+		"juin",
+		"juil.",
+		"août",
+		"sept.",
+		"oct.",
+		"nov.",
+		"déc."
+	],
+	"quarters-format-abbr": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"quarters-standAlone-wide": [
+		"1er trimestre",
+		"2e trimestre",
+		"3e trimestre",
+		"4e trimestre"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"dimanche",
+		"lundi",
+		"mardi",
+		"mercredi",
+		"jeudi",
+		"vendredi",
+		"samedi"
+	],
+	"dateFormatItem-yyMMMEEEd": "EEE d MMM yy",
+	"dateFormatItem-yyMMM": "MMM yy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"eraAbbr": [
+		"av. J.-C.",
+		"ap. J.-C."
+	],
+	"field-minute": "minute",
+	"field-dayperiod": "cadran",
+	"days-standAlone-abbr": [
+		"dim.",
+		"lun.",
+		"mar.",
+		"mer.",
+		"jeu.",
+		"ven.",
+		"sam."
+	],
+	"dayPeriods-format-wide-night": "soir",
+	"dateFormatItem-yyMMMd": "d MMM yy",
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"quarters-format-narrow": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"field-day-relative+-1": "hier",
+	"field-day-relative+-2": "avant-hier",
+	"field-day-relative+-3": "avant-avant-hier",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-MEd": "EEE d/M",
+	"field-day": "jour",
+	"days-format-wide": [
+		"dimanche",
+		"lundi",
+		"mardi",
+		"mercredi",
+		"jeudi",
+		"vendredi",
+		"samedi"
+	],
+	"field-zone": "fuseau horaire",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-yyMM": "MM/yy",
+	"days-format-abbr": [
+		"dim.",
+		"lun.",
+		"mar.",
+		"mer.",
+		"jeu.",
+		"ven.",
+		"sam."
+	],
+	"eraNames": [
+		"avant Jésus-Christ",
+		"après Jésus-Christ"
+	],
+	"days-format-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"J",
+		"V",
+		"S"
+	],
+	"field-month": "mois",
+	"days-standAlone-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"J",
+		"V",
+		"S"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "AM",
+	"dateFormatItem-MMMMEd": "EEE d MMMM",
+	"dateFormat-short": "dd/MM/yy",
+	"dateFormatItem-MMd": "d/MM",
+	"dayPeriods-format-wide-afternoon": "après-midi",
+	"field-second": "seconde",
+	"dateFormatItem-yMMMEd": "EEE d MMM y",
+	"dateFormatItem-Ed": "E d",
+	"field-week": "semaine",
+	"dateFormat-medium": "d MMM y",
+	"dateFormatItem-Hms": "HH:mm:ss"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/fr/number.js b/js/dojo-1.7.2/dojo/cldr/nls/fr/number.js
new file mode 100644
index 0000000..20212b0
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/fr/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/fr/number", //begin v1.x content
+{
+	"group": " ",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0 %",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/gregorian.js
new file mode 100644
index 0000000..fabd726
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/gregorian.js
@@ -0,0 +1,295 @@
+//>>built
+define("dojo/cldr/nls/gregorian", { root:
+
+//begin v1.x content
+{
+	"months-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"quarters-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4"
+	],
+	"field-weekday": "Day of the Week",
+	"dateFormatItem-yQQQ": "y QQQ",
+	"dateFormatItem-yMEd": "EEE, y-M-d",
+	"dateFormatItem-MMMEd": "E MMM d",
+	"eraNarrow": [
+		"BCE",
+		"CE"
+	],
+	"dateTimeFormats-appendItem-Day-Of-Week": "{0} {1}",
+	"dateFormat-long": "y MMMM d",
+	"months-format-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateTimeFormat-medium": "{1} {0}",
+	"dateFormatItem-EEEd": "d EEE",
+	"dayPeriods-format-wide-pm": "PM",
+	"dateFormat-full": "EEEE, y MMMM dd",
+	"dateFormatItem-Md": "M-d",
+	"dayPeriods-format-abbr-am": "AM",
+	"dateTimeFormats-appendItem-Second": "{0} ({2}: {1})",
+	"field-era": "Era",
+	"dateFormatItem-yM": "y-M",
+	"months-standAlone-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "Year",
+	"dateFormatItem-yMMM": "y MMM",
+	"dateFormatItem-yQ": "y Q",
+	"dateTimeFormats-appendItem-Era": "{0} {1}",
+	"field-hour": "Hour",
+	"months-format-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"dateTimeFormats-appendItem-Week": "{0} ({2}: {1})",
+	"field-day-relative+0": "Today",
+	"field-day-relative+1": "Tomorrow",
+	"dateFormatItem-H": "HH",
+	"months-standAlone-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"quarters-format-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"quarters-standAlone-wide": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"eraAbbr": [
+		"BCE",
+		"CE"
+	],
+	"field-minute": "Minute",
+	"field-dayperiod": "Dayperiod",
+	"days-standAlone-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"quarters-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4"
+	],
+	"field-day-relative+-1": "Yesterday",
+	"dateFormatItem-h": "h a",
+	"dateTimeFormat-long": "{1} {0}",
+	"dayPeriods-format-narrow-am": "AM",
+	"dateFormatItem-MMMd": "MMM d",
+	"dateFormatItem-MEd": "E, M-d",
+	"dateTimeFormat-full": "{1} {0}",
+	"field-day": "Day",
+	"days-format-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"field-zone": "Zone",
+	"dateTimeFormats-appendItem-Day": "{0} ({2}: {1})",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateFormatItem-hm": "h:mm a",
+	"dateTimeFormats-appendItem-Year": "{0} {1}",
+	"dateTimeFormats-appendItem-Hour": "{0} ({2}: {1})",
+	"dayPeriods-format-abbr-pm": "PM",
+	"days-format-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"eraNames": [
+		"BCE",
+		"CE"
+	],
+	"days-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"days-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"field-month": "Month",
+	"dateTimeFormats-appendItem-Quarter": "{0} ({2}: {1})",
+	"dayPeriods-format-wide-am": "AM",
+	"dateTimeFormats-appendItem-Month": "{0} ({2}: {1})",
+	"dateTimeFormats-appendItem-Minute": "{0} ({2}: {1})",
+	"dateFormat-short": "yyyy-MM-dd",
+	"field-second": "Second",
+	"dateFormatItem-yMMMEd": "EEE, y MMM d",
+	"dateTimeFormats-appendItem-Timezone": "{0} {1}",
+	"field-week": "Week",
+	"dateFormat-medium": "y MMM d",
+	"dayPeriods-format-narrow-pm": "PM",
+	"dateTimeFormat-short": "{1} {0}",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "h:mm:ss a"
+}
+//end v1.x content
+,
+	"ar": true,
+	"ca": true,
+	"cs": true,
+	"da": true,
+	"de": true,
+	"el": true,
+	"en": true,
+	"en-au": true,
+	"en-ca": true,
+	"en-gb": true,
+	"es": true,
+	"fi": true,
+	"fr": true,
+	"fr-ch": true,
+	"he": true,
+	"hu": true,
+	"it": true,
+	"ja": true,
+	"ko": true,
+	"nb": true,
+	"nl": true,
+	"pl": true,
+	"pt": true,
+	"pt-pt": true,
+	"ro": true,
+	"ru": true,
+	"sk": true,
+	"sl": true,
+	"sv": true,
+	"th": true,
+	"tr": true,
+	"zh": true,
+	"zh-hant": true,
+	"zh-hk": true,
+	"zh-tw": true
+});
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/he/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/he/currency.js
new file mode 100644
index 0000000..00a8b35
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/he/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/he/currency", //begin v1.x content
+{
+	"HKD_displayName": "דולר הונג קונגי",
+	"CHF_displayName": "פרנק שוויצרי",
+	"CAD_displayName": "דולר קנדי",
+	"CNY_displayName": "יו�ן רנמינבי סיני",
+	"AUD_displayName": "דולר �וסטרלי",
+	"JPY_displayName": "ין יפני",
+	"USD_displayName": "דולר �מריק�י",
+	"GBP_displayName": "לירה שטרלינג",
+	"EUR_displayName": "�ירו"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/he/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/he/gregorian.js
new file mode 100644
index 0000000..8e88a85
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/he/gregorian.js
@@ -0,0 +1,214 @@
+//>>built
+define(
+"dojo/cldr/nls/he/gregorian", //begin v1.x content
+{
+	"field-weekday": "יו� בשבוע",
+	"dateFormatItem-yQQQ": "y QQQ",
+	"dateFormatItem-yMEd": "EEE, d.M.yyyy",
+	"dateFormatItem-MMMEd": "E, d בMMM",
+	"eraNarrow": [
+		"לפנה״ס",
+		"לסה״נ"
+	],
+	"dateFormat-long": "d בMMMM y",
+	"months-format-wide": [
+		"ינו�ר",
+		"פברו�ר",
+		"מרס",
+		"�פריל",
+		"מ�י",
+		"יוני",
+		"יולי",
+		"�וגוסט",
+		"ספטמבר",
+		"�וקטובר",
+		"נובמבר",
+		"דצמבר"
+	],
+	"dateFormatItem-EEEd": "EEE ×”-d",
+	"dayPeriods-format-wide-pm": "�חה״צ",
+	"dateFormat-full": "EEEE, d בMMMM y",
+	"dateFormatItem-Md": "d/M",
+	"field-era": "תקופה",
+	"dateFormatItem-yM": "M.yyyy",
+	"months-standAlone-wide": [
+		"ינו�ר",
+		"פברו�ר",
+		"מרס",
+		"�פריל",
+		"מ�י",
+		"יוני",
+		"יולי",
+		"�וגוסט",
+		"ספטמבר",
+		"�וקטובר",
+		"נובמבר",
+		"דצמבר"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"רבעון 1",
+		"רבעון 2",
+		"רבעון 3",
+		"רבעון 4"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "שנה",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "yyyy Q",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"field-hour": "שעה",
+	"dateFormatItem-MMdd": "dd/MM",
+	"months-format-abbr": [
+		"ינו",
+		"פבר",
+		"מרס",
+		"�פר",
+		"מ�י",
+		"יונ",
+		"יול",
+		"�וג",
+		"ספט",
+		"�וק",
+		"נוב",
+		"דצמ"
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"field-day-relative+0": "היו�",
+	"field-day-relative+1": "מחר",
+	"field-day-relative+2": "מחרתיי�",
+	"dateFormatItem-H": "HH",
+	"field-day-relative+3": "בעוד שלושה ימי�",
+	"months-standAlone-abbr": [
+		"ינו׳",
+		"פבר׳",
+		"מרס",
+		"�פר׳",
+		"מ�י",
+		"יונ׳",
+		"יול׳",
+		"�וג׳",
+		"ספט׳",
+		"�וק׳",
+		"נוב׳",
+		"דצמ׳"
+	],
+	"quarters-format-abbr": [
+		"רבעון 1",
+		"רבעון 2",
+		"רבעון 3",
+		"רבעון 4"
+	],
+	"quarters-standAlone-wide": [
+		"רבעון 1",
+		"רבעון 2",
+		"רבעון 3",
+		"רבעון 4"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"יו� ר�שון",
+		"יו� שני",
+		"יו� שלישי",
+		"יו� רביעי",
+		"יו� חמישי",
+		"יו� שישי",
+		"יו� שבת"
+	],
+	"dateFormatItem-MMMMd": "d בMMMM",
+	"dateFormatItem-yyMMM": "MMM yyyy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"רבעון 1",
+		"רבעון 2",
+		"רבעון 3",
+		"רבעון 4"
+	],
+	"eraAbbr": [
+		"לפנה״ס",
+		"לסה״נ"
+	],
+	"field-minute": "דקה",
+	"field-dayperiod": "לפה״צ/�חה״צ",
+	"days-standAlone-abbr": [
+		"יו� �׳",
+		"יו� ב׳",
+		"יו� ג׳",
+		"יו� ד׳",
+		"יו� ה׳",
+		"יו� ו׳",
+		"שבת"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "�תמול",
+	"field-day-relative+-2": "שלשו�",
+	"field-day-relative+-3": "לפני שלושה ימי�",
+	"dateFormatItem-MMMd": "d בMMM",
+	"dateFormatItem-MEd": "E, M-d",
+	"dateFormatItem-yMMMM": "MMMM y",
+	"field-day": "יו�",
+	"days-format-wide": [
+		"יו� ר�שון",
+		"יו� שני",
+		"יו� שלישי",
+		"יו� רביעי",
+		"יו� חמישי",
+		"יו� שישי",
+		"יו� שבת"
+	],
+	"field-zone": "�זור",
+	"dateFormatItem-yyyyMM": "MM/yyyy",
+	"dateFormatItem-y": "y",
+	"dateFormatItem-yyMM": "MM/yy",
+	"dateFormatItem-hm": "h:mm a",
+	"days-format-abbr": [
+		"יו� �׳",
+		"יו� ב׳",
+		"יו� ג׳",
+		"יו� ד׳",
+		"יו� ה׳",
+		"יו� ו׳",
+		"שבת"
+	],
+	"eraNames": [
+		"לפני הספירה",
+		"לספירה"
+	],
+	"days-format-narrow": [
+		"�",
+		"ב",
+		"×’",
+		"ד",
+		"×”",
+		"ו",
+		"ש"
+	],
+	"field-month": "חודש",
+	"days-standAlone-narrow": [
+		"�",
+		"ב",
+		"×’",
+		"ד",
+		"×”",
+		"ו",
+		"ש"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "לפנה״צ",
+	"dateFormatItem-MMMMEd": "E, d בMMMM",
+	"dateFormat-short": "dd/MM/yy",
+	"field-second": "שנייה",
+	"dateFormatItem-yMMMEd": "EEE, d בMMM y",
+	"dateFormatItem-Ed": "E ×”-d",
+	"field-week": "שבוע",
+	"dateFormat-medium": "d בMMM yyyy",
+	"dateFormatItem-mmss": "mm:ss",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "h:mm:ss a",
+	"dateFormatItem-yyyy": "y"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/he/hebrew.js b/js/dojo-1.7.2/dojo/cldr/nls/he/hebrew.js
new file mode 100644
index 0000000..66581ba
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/he/hebrew.js
@@ -0,0 +1,126 @@
+//>>built
+define(
+"dojo/cldr/nls/he/hebrew", //begin v1.x content
+{
+	"dateFormat-medium": "dd/MM/yyyy",
+	"dateFormatItem-MMMEd": "E, d בMMM",
+	"dateFormatItem-yMEd": "EEE, d.M.yyyy",
+	"eraNarrow": [
+		"לבה״ע"
+	],
+	"dateFormatItem-Md": "d/M",
+	"months-standAlone-wide": [
+		"תשרי",
+		"חשון",
+		"כסלו",
+		"טבת",
+		"שבט",
+		"�דר �׳",
+		"�דר",
+		"ניסן",
+		"�ייר",
+		"סיון",
+		"תמוז",
+		"�ב",
+		"�לול"
+	],
+	"months-format-wide-leap": "�דר ב׳",
+	"dateFormatItem-EEEd": "EEE ×”-d",
+	"eraNames": [
+		"לבה״ע"
+	],
+	"days-standAlone-narrow": [
+		"�",
+		"ב",
+		"×’",
+		"ד",
+		"×”",
+		"ו",
+		"ש"
+	],
+	"dateFormatItem-MMMMEd": "E, d בMMMM",
+	"dayPeriods-format-wide-pm": "�חה״צ",
+	"months-standAlone-abbr": [
+		"תשרי",
+		"חשון",
+		"כסלו",
+		"טבת",
+		"שבט",
+		"�דר �׳",
+		"�דר",
+		"ניסן",
+		"�ייר",
+		"סיון",
+		"תמוז",
+		"�ב",
+		"�לול"
+	],
+	"dayPeriods-format-wide-am": "לפנה״צ",
+	"dateFormat-long": "d בMMMM y",
+	"dateFormat-short": "dd/MM/yy",
+	"dateFormatItem-yMMMEd": "EEE, d בMMM y",
+	"months-format-wide": [
+		"תשרי",
+		"חשון",
+		"כסלו",
+		"טבת",
+		"שבט",
+		"�דר �׳",
+		"�דר",
+		"ניסן",
+		"�ייר",
+		"סיון",
+		"תמוז",
+		"�ב",
+		"�לול"
+	],
+	"dateFormatItem-yM": "M.yyyy",
+	"months-format-abbr": [
+		"תשרי",
+		"חשון",
+		"כסלו",
+		"טבת",
+		"שבט",
+		"�דר �׳",
+		"�דר",
+		"ניסן",
+		"�ייר",
+		"סיון",
+		"תמוז",
+		"�ב",
+		"�לול"
+	],
+	"eraAbbr": [
+		"לבה״ע"
+	],
+	"days-format-wide": [
+		"יו� ר�שון",
+		"יו� שני",
+		"יו� שלישי",
+		"יו� רביעי",
+		"יו� חמישי",
+		"יו� שישי",
+		"יו� שבת"
+	],
+	"dateFormatItem-yQ": "yyyy Q",
+	"dateFormatItem-yMMM": "MMM y",
+	"quarters-format-wide": [
+		"רבעון 1",
+		"רבעון 2",
+		"רבעון 3",
+		"רבעון 4"
+	],
+	"dateFormat-full": "EEEE, d בMMMM y",
+	"dateFormatItem-MMMd": "d בMMM",
+	"days-format-abbr": [
+		"יו� �׳",
+		"יו� ב׳",
+		"יו� ג׳",
+		"יו� ד׳",
+		"יו� ה׳",
+		"יו� ו׳",
+		"שבת"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/he/islamic.js b/js/dojo-1.7.2/dojo/cldr/nls/he/islamic.js
new file mode 100644
index 0000000..bc01039
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/he/islamic.js
@@ -0,0 +1,120 @@
+//>>built
+define(
+"dojo/cldr/nls/he/islamic", //begin v1.x content
+{
+	"dateFormat-medium": "d בMMM yyyy",
+	"dateFormatItem-MMMEd": "E, d בMMM",
+	"dateFormatItem-yMEd": "EEE, d.M.yyyy",
+	"eraNarrow": [
+		"שנת היג׳רה"
+	],
+	"dateFormatItem-Md": "d/M",
+	"months-standAlone-wide": [
+		"מוחר�",
+		"ספר",
+		"רביע �ל-�וו�ל",
+		"רביע �ל-תני",
+		"ג׳ומדה �ל-�וו�ל",
+		"ג׳ומדה �ל-תני",
+		"רג׳�ב",
+		"שעב�ן",
+		"ר�מדן",
+		"שוו�ל",
+		"זו �ל-QI'DAH",
+		"זו �ל-חיג׳ה"
+	],
+	"dateFormatItem-EEEd": "EEE ×”-d",
+	"eraNames": [
+		"שנת היג׳רה"
+	],
+	"days-standAlone-narrow": [
+		"�",
+		"ב",
+		"×’",
+		"ד",
+		"×”",
+		"ו",
+		"ש"
+	],
+	"dayPeriods-format-wide-pm": "�חה״צ",
+	"months-standAlone-abbr": [
+		"מוחר�",
+		"ספר",
+		"רביע �ל-�וו�ל",
+		"רביע �ל-תני",
+		"ג׳ומדה �ל-�וו�ל",
+		"ג׳ומדה �ל-תני",
+		"רג׳�ב",
+		"שעב�ן",
+		"ר�מדן",
+		"שוו�ל",
+		"זו �ל-QI'DAH",
+		"זו �ל-חיג׳ה"
+	],
+	"dayPeriods-format-wide-am": "לפנה״צ",
+	"dateFormat-long": "d בMMMM y",
+	"dateFormat-short": "dd/MM/yy",
+	"dateFormatItem-yMMMEd": "EEE, d בMMM y",
+	"months-format-wide": [
+		"מוחר�",
+		"ספר",
+		"רביע �ל-�וו�ל",
+		"רביע �ל-תני",
+		"ג׳ומדה �ל-�וו�ל",
+		"ג׳ומדה �ל-תני",
+		"רג׳�ב",
+		"שעב�ן",
+		"ר�מדן",
+		"שוו�ל",
+		"זו �ל-QI'DAH",
+		"זו �ל-חיג׳ה"
+	],
+	"dateFormatItem-yM": "M.yyyy",
+	"months-format-abbr": [
+		"מוחר�",
+		"ספר",
+		"רביע �ל-�וו�ל",
+		"רביע �ל-תני",
+		"ג׳ומדה �ל-�וו�ל",
+		"ג׳ומדה �ל-תני",
+		"רג׳�ב",
+		"שעב�ן",
+		"ר�מדן",
+		"שוו�ל",
+		"זו �ל-QI'DAH",
+		"זו �ל-חיג׳ה"
+	],
+	"eraAbbr": [
+		"שנת היג׳רה"
+	],
+	"days-format-wide": [
+		"יו� ר�שון",
+		"יו� שני",
+		"יו� שלישי",
+		"יו� רביעי",
+		"יו� חמישי",
+		"יו� שישי",
+		"יו� שבת"
+	],
+	"dateFormatItem-yQ": "yyyy Q",
+	"dateFormatItem-yMMM": "MMM y",
+	"quarters-format-wide": [
+		"רבעון 1",
+		"רבעון 2",
+		"רבעון 3",
+		"רבעון 4"
+	],
+	"dateFormat-full": "EEEE, d בMMMM y",
+	"dateFormatItem-MMMd": "d בMMM",
+	"days-format-abbr": [
+		"יו� �׳",
+		"יו� ב׳",
+		"יו� ג׳",
+		"יו� ד׳",
+		"יו� ה׳",
+		"יו� ו׳",
+		"שבת"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/he/number.js b/js/dojo-1.7.2/dojo/cldr/nls/he/number.js
new file mode 100644
index 0000000..9e40d17
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/he/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/he/number", //begin v1.x content
+{
+	"group": ",",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ".",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/hebrew.js b/js/dojo-1.7.2/dojo/cldr/nls/hebrew.js
new file mode 100644
index 0000000..e6f6c50
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/hebrew.js
@@ -0,0 +1,266 @@
+//>>built
+define("dojo/cldr/nls/hebrew", { root:
+
+//begin v1.x content
+{
+	"months-format-narrow": [
+		"Tishri",
+		"Heshvan",
+		"Kislev",
+		"Tevet",
+		"Shevat",
+		"Adar I",
+		"Adar",
+		"Nisan",
+		"Iyar",
+		"Sivan",
+		"Tamuz",
+		"Av",
+		"Elul"
+	],
+	"quarters-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4"
+	],
+	"dateFormatItem-yQQQ": "y QQQ",
+	"months-standAlone-narrow-leap": "Adar II",
+	"dateFormatItem-yMEd": "EEE, y-M-d",
+	"dateFormatItem-MMMEd": "E MMM d",
+	"eraNarrow": [
+		"AM"
+	],
+	"dateTimeFormats-appendItem-Day-Of-Week": "{0} {1}",
+	"dateFormat-long": "y MMMM d",
+	"months-format-wide": [
+		"Tishri",
+		"Heshvan",
+		"Kislev",
+		"Tevet",
+		"Shevat",
+		"Adar I",
+		"Adar",
+		"Nisan",
+		"Iyar",
+		"Sivan",
+		"Tamuz",
+		"Av",
+		"Elul"
+	],
+	"dateTimeFormat-medium": "{1} {0}",
+	"dateFormatItem-EEEd": "d EEE",
+	"dayPeriods-format-wide-pm": "PM",
+	"dateFormat-full": "EEEE, y MMMM dd",
+	"dateFormatItem-Md": "M-d",
+	"dayPeriods-format-abbr-am": "AM",
+	"dateTimeFormats-appendItem-Second": "{0} ({2}: {1})",
+	"dateFormatItem-yM": "y-M",
+	"months-standAlone-wide": [
+		"Tishri",
+		"Heshvan",
+		"Kislev",
+		"Tevet",
+		"Shevat",
+		"Adar I",
+		"Adar",
+		"Nisan",
+		"Iyar",
+		"Sivan",
+		"Tamuz",
+		"Av",
+		"Elul"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"dateFormatItem-yMMM": "y MMM",
+	"dateFormatItem-yQ": "y Q",
+	"dateTimeFormats-appendItem-Era": "{0} {1}",
+	"months-format-abbr-leap": "Adar II",
+	"months-format-abbr": [
+		"Tishri",
+		"Heshvan",
+		"Kislev",
+		"Tevet",
+		"Shevat",
+		"Adar I",
+		"Adar",
+		"Nisan",
+		"Iyar",
+		"Sivan",
+		"Tamuz",
+		"Av",
+		"Elul"
+	],
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"dateTimeFormats-appendItem-Week": "{0} ({2}: {1})",
+	"dateFormatItem-H": "HH",
+	"months-standAlone-abbr": [
+		"Tishri",
+		"Heshvan",
+		"Kislev",
+		"Tevet",
+		"Shevat",
+		"Adar I",
+		"Adar",
+		"Nisan",
+		"Iyar",
+		"Sivan",
+		"Tamuz",
+		"Av",
+		"Elul"
+	],
+	"quarters-format-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"quarters-standAlone-wide": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"months-standAlone-wide-leap": "Adar II",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"months-format-narrow-leap": "Adar II",
+	"eraAbbr": [
+		"AM"
+	],
+	"days-standAlone-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"quarters-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4"
+	],
+	"dateFormatItem-h": "h a",
+	"dateTimeFormat-long": "{1} {0}",
+	"dayPeriods-format-narrow-am": "AM",
+	"dateFormatItem-MMMd": "MMM d",
+	"dateFormatItem-MEd": "E, M-d",
+	"dateTimeFormat-full": "{1} {0}",
+	"days-format-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"months-standAlone-abbr-leap": "Adar II",
+	"dateTimeFormats-appendItem-Day": "{0} ({2}: {1})",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"Tishri",
+		"Heshvan",
+		"Kislev",
+		"Tevet",
+		"Shevat",
+		"Adar I",
+		"Adar",
+		"Nisan",
+		"Iyar",
+		"Sivan",
+		"Tamuz",
+		"Av",
+		"Elul"
+	],
+	"dateFormatItem-hm": "h:mm a",
+	"dateTimeFormats-appendItem-Year": "{0} {1}",
+	"dateTimeFormats-appendItem-Hour": "{0} ({2}: {1})",
+	"dayPeriods-format-abbr-pm": "PM",
+	"days-format-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"eraNames": [
+		"AM"
+	],
+	"days-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"days-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dateTimeFormats-appendItem-Quarter": "{0} ({2}: {1})",
+	"dayPeriods-format-wide-am": "AM",
+	"dateTimeFormats-appendItem-Month": "{0} ({2}: {1})",
+	"dateTimeFormats-appendItem-Minute": "{0} ({2}: {1})",
+	"dateFormat-short": "yyyy-MM-dd",
+	"dateFormatItem-yMMMEd": "EEE, y MMM d",
+	"dateTimeFormats-appendItem-Timezone": "{0} {1}",
+	"dateFormat-medium": "y MMM d",
+	"dayPeriods-format-narrow-pm": "PM",
+	"dateTimeFormat-short": "{1} {0}",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "h:mm:ss a",
+	"months-format-wide-leap": "Adar II"
+}
+//end v1.x content
+,
+	"ar": true,
+	"el": true,
+	"fi": true,
+	"fr": true,
+	"he": true,
+	"hu": true,
+	"nl": true,
+	"ru": true,
+	"sv": true,
+	"th": true,
+	"tr": true
+});
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/hu/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/hu/currency.js
new file mode 100644
index 0000000..7078a8d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/hu/currency.js
@@ -0,0 +1,18 @@
+//>>built
+define(
+"dojo/cldr/nls/hu/currency", //begin v1.x content
+{
+	"HKD_displayName": "Hongkongi dollár",
+	"CHF_displayName": "Svájci frank",
+	"JPY_symbol": "Â¥",
+	"CAD_displayName": "Kanadai dollár",
+	"CNY_displayName": "Kínai jüan renminbi",
+	"USD_symbol": "$",
+	"AUD_displayName": "Ausztrál dollár",
+	"JPY_displayName": "Japán jen",
+	"USD_displayName": "USA dollár",
+	"GBP_displayName": "Brit font sterling",
+	"EUR_displayName": "Euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/hu/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/hu/gregorian.js
new file mode 100644
index 0000000..d23204d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/hu/gregorian.js
@@ -0,0 +1,228 @@
+//>>built
+define(
+"dojo/cldr/nls/hu/gregorian", //begin v1.x content
+{
+	"field-dayperiod": "napszak",
+	"dayPeriods-format-wide-pm": "du.",
+	"field-minute": "perc",
+	"eraNames": [
+		"időszámításunk előtt",
+		"időszámításunk szerint"
+	],
+	"dateFormatItem-MMMEd": "MMM d., E",
+	"field-day-relative+-1": "tegnap",
+	"field-weekday": "hét napja",
+	"field-day-relative+-2": "tegnapelőtt",
+	"dateFormatItem-MMdd": "MM.dd.",
+	"field-day-relative+-3": "három nappal ezelőtt",
+	"days-standAlone-wide": [
+		"vasárnap",
+		"hétfő",
+		"kedd",
+		"szerda",
+		"csütörtök",
+		"péntek",
+		"szombat"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"�",
+		"M",
+		"J",
+		"J",
+		"A",
+		"Sz",
+		"O",
+		"N",
+		"D"
+	],
+	"field-era": "éra",
+	"field-hour": "óra",
+	"dayPeriods-format-wide-am": "de.",
+	"quarters-standAlone-abbr": [
+		"N1",
+		"N2",
+		"N3",
+		"N4"
+	],
+	"timeFormat-full": "H:mm:ss zzzz",
+	"months-standAlone-abbr": [
+		"jan.",
+		"febr.",
+		"márc.",
+		"ápr.",
+		"máj.",
+		"jún.",
+		"júl.",
+		"aug.",
+		"szept.",
+		"okt.",
+		"nov.",
+		"dec."
+	],
+	"dateFormatItem-Ed": "d., E",
+	"field-day-relative+0": "ma",
+	"field-day-relative+1": "holnap",
+	"days-standAlone-narrow": [
+		"V",
+		"H",
+		"K",
+		"Sz",
+		"Cs",
+		"P",
+		"Sz"
+	],
+	"eraAbbr": [
+		"i. e.",
+		"i. sz."
+	],
+	"field-day-relative+2": "holnapután",
+	"field-day-relative+3": "három nap múlva",
+	"dateFormatItem-yyyyMM": "yyyy.MM",
+	"dateFormatItem-yyyyMMMM": "y. MMMM",
+	"dateFormat-long": "y. MMMM d.",
+	"timeFormat-medium": "H:mm:ss",
+	"field-zone": "zóna",
+	"dateFormatItem-Hm": "H:mm",
+	"dateFormat-medium": "yyyy.MM.dd.",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"quarters-standAlone-wide": [
+		"I. negyedév",
+		"II. negyedév",
+		"III. negyedév",
+		"IV. negyedév"
+	],
+	"field-year": "év",
+	"field-week": "hét",
+	"months-standAlone-wide": [
+		"január",
+		"február",
+		"március",
+		"április",
+		"május",
+		"június",
+		"július",
+		"augusztus",
+		"szeptember",
+		"október",
+		"november",
+		"december"
+	],
+	"dateFormatItem-MMMd": "MMM d.",
+	"dateFormatItem-yyQ": "yy/Q",
+	"timeFormat-long": "H:mm:ss z",
+	"months-format-abbr": [
+		"jan.",
+		"febr.",
+		"márc.",
+		"ápr.",
+		"máj.",
+		"jún.",
+		"júl.",
+		"aug.",
+		"szept.",
+		"okt.",
+		"nov.",
+		"dec."
+	],
+	"timeFormat-short": "H:mm",
+	"dateFormatItem-H": "H",
+	"field-month": "hónap",
+	"dateFormatItem-MMMMd": "MMMM d.",
+	"quarters-format-abbr": [
+		"N1",
+		"N2",
+		"N3",
+		"N4"
+	],
+	"days-format-abbr": [
+		"V",
+		"H",
+		"K",
+		"Sze",
+		"Cs",
+		"P",
+		"Szo"
+	],
+	"dateFormatItem-mmss": "mm:ss",
+	"dateFormatItem-M": "L",
+	"days-format-narrow": [
+		"V",
+		"H",
+		"K",
+		"Sz",
+		"Cs",
+		"P",
+		"Sz"
+	],
+	"field-second": "másodperc",
+	"field-day": "nap",
+	"dateFormatItem-MEd": "M. d., E",
+	"months-format-narrow": [
+		"J",
+		"F",
+		"M",
+		"�",
+		"M",
+		"J",
+		"J",
+		"A",
+		"Sz",
+		"O",
+		"N",
+		"D"
+	],
+	"days-standAlone-abbr": [
+		"V",
+		"H",
+		"K",
+		"Sze",
+		"Cs",
+		"P",
+		"Szo"
+	],
+	"dateFormat-short": "yyyy.MM.dd.",
+	"dateFormatItem-yMMMEd": "y. MMM d., E",
+	"dateFormat-full": "y. MMMM d., EEEE",
+	"dateFormatItem-Md": "M. d.",
+	"dateFormatItem-yMEd": "yyyy.MM.dd., E",
+	"months-format-wide": [
+		"január",
+		"február",
+		"március",
+		"április",
+		"május",
+		"június",
+		"július",
+		"augusztus",
+		"szeptember",
+		"október",
+		"november",
+		"december"
+	],
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"I. negyedév",
+		"II. negyedév",
+		"III. negyedév",
+		"IV. negyedév"
+	],
+	"days-format-wide": [
+		"vasárnap",
+		"hétfő",
+		"kedd",
+		"szerda",
+		"csütörtök",
+		"péntek",
+		"szombat"
+	],
+	"eraNarrow": [
+		"i. e.",
+		"i. sz."
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/hu/number.js b/js/dojo-1.7.2/dojo/cldr/nls/hu/number.js
new file mode 100644
index 0000000..4d5cdef
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/hu/number.js
@@ -0,0 +1,22 @@
+//>>built
+define(
+"dojo/cldr/nls/hu/number", //begin v1.x content
+{
+	"group": " ",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/islamic.js b/js/dojo-1.7.2/dojo/cldr/nls/islamic.js
new file mode 100644
index 0000000..bf5bb89
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/islamic.js
@@ -0,0 +1,265 @@
+//>>built
+define("dojo/cldr/nls/islamic", { root:
+
+//begin v1.x content
+{
+	"months-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"quarters-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4"
+	],
+	"dateFormatItem-yQQQ": "y QQQ",
+	"dateFormatItem-yMEd": "EEE, y-M-d",
+	"dateFormatItem-MMMEd": "E MMM d",
+	"eraNarrow": [
+		"AH"
+	],
+	"dateTimeFormats-appendItem-Day-Of-Week": "{0} {1}",
+	"dateFormat-long": "y MMMM d",
+	"months-format-wide": [
+		"Muharram",
+		"Safar",
+		"RabiÊ» I",
+		"RabiÊ» II",
+		"Jumada I",
+		"Jumada II",
+		"Rajab",
+		"Shaʻban",
+		"Ramadan",
+		"Shawwal",
+		"Dhuʻl-Qiʻdah",
+		"Dhuʻl-Hijjah"
+	],
+	"dateTimeFormat-medium": "{1} {0}",
+	"dateFormatItem-EEEd": "d EEE",
+	"dayPeriods-format-wide-pm": "PM",
+	"dateFormat-full": "EEEE, y MMMM dd",
+	"dateFormatItem-Md": "M-d",
+	"dayPeriods-format-abbr-am": "AM",
+	"dateTimeFormats-appendItem-Second": "{0} ({2}: {1})",
+	"dateFormatItem-yM": "y-M",
+	"months-standAlone-wide": [
+		"Muharram",
+		"Safar",
+		"RabiÊ» I",
+		"RabiÊ» II",
+		"Jumada I",
+		"Jumada II",
+		"Rajab",
+		"Shaʻban",
+		"Ramadan",
+		"Shawwal",
+		"Dhuʻl-Qiʻdah",
+		"Dhuʻl-Hijjah"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"dateFormatItem-yMMM": "y MMM",
+	"dateFormatItem-yQ": "y Q",
+	"dateTimeFormats-appendItem-Era": "{0} {1}",
+	"months-format-abbr": [
+		"Muh.",
+		"Saf.",
+		"Rab. I",
+		"Rab. II",
+		"Jum. I",
+		"Jum. II",
+		"Raj.",
+		"Sha.",
+		"Ram.",
+		"Shaw.",
+		"Dhuʻl-Q.",
+		"Dhuʻl-H."
+	],
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"dateTimeFormats-appendItem-Week": "{0} ({2}: {1})",
+	"dateFormatItem-H": "HH",
+	"months-standAlone-abbr": [
+		"Muh.",
+		"Saf.",
+		"Rab. I",
+		"Rab. II",
+		"Jum. I",
+		"Jum. II",
+		"Raj.",
+		"Sha.",
+		"Ram.",
+		"Shaw.",
+		"Dhuʻl-Q.",
+		"Dhuʻl-H."
+	],
+	"quarters-format-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"quarters-standAlone-wide": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"eraAbbr": [
+		"AH"
+	],
+	"days-standAlone-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"quarters-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4"
+	],
+	"dateFormatItem-h": "h a",
+	"dateTimeFormat-long": "{1} {0}",
+	"dayPeriods-format-narrow-am": "AM",
+	"dateFormatItem-MMMd": "MMM d",
+	"dateFormatItem-MEd": "E, M-d",
+	"dateTimeFormat-full": "{1} {0}",
+	"days-format-wide": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"dateTimeFormats-appendItem-Day": "{0} ({2}: {1})",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateFormatItem-hm": "h:mm a",
+	"dateTimeFormats-appendItem-Year": "{0} {1}",
+	"dateTimeFormats-appendItem-Hour": "{0} ({2}: {1})",
+	"dayPeriods-format-abbr-pm": "PM",
+	"days-format-abbr": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"eraNames": [
+		"AH"
+	],
+	"days-format-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"days-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dateTimeFormats-appendItem-Quarter": "{0} ({2}: {1})",
+	"dayPeriods-format-wide-am": "AM",
+	"dateTimeFormats-appendItem-Month": "{0} ({2}: {1})",
+	"dateTimeFormats-appendItem-Minute": "{0} ({2}: {1})",
+	"dateFormat-short": "yyyy-MM-dd",
+	"dateFormatItem-yMMMEd": "EEE, y MMM d",
+	"dateTimeFormats-appendItem-Timezone": "{0} {1}",
+	"dateFormat-medium": "y MMM d",
+	"dayPeriods-format-narrow-pm": "PM",
+	"dateTimeFormat-short": "{1} {0}",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "h:mm:ss a"
+}
+//end v1.x content
+,
+	"ar": true,
+	"da": true,
+	"de": true,
+	"en": true,
+	"en-gb": true,
+	"es": true,
+	"fi": true,
+	"fr": true,
+	"he": true,
+	"hu": true,
+	"it": true,
+	"nb": true,
+	"nl": true,
+	"pl": true,
+	"pt": true,
+	"pt-pt": true,
+	"ru": true,
+	"sv": true,
+	"th": true,
+	"tr": true,
+	"zh": true,
+	"zh-hant": true
+});
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/it/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/it/currency.js
new file mode 100644
index 0000000..30dac5d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/it/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/it/currency", //begin v1.x content
+{
+	"HKD_displayName": "Dollaro di Hong Kong",
+	"CHF_displayName": "Franco Svizzero",
+	"CAD_displayName": "Dollaro Canadese",
+	"CNY_displayName": "Renmimbi Cinese",
+	"AUD_displayName": "Dollaro Australiano",
+	"JPY_displayName": "Yen Giapponese",
+	"USD_displayName": "Dollaro Statunitense",
+	"GBP_displayName": "Sterlina Inglese",
+	"EUR_displayName": "Euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/it/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/it/gregorian.js
new file mode 100644
index 0000000..b57cdfd
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/it/gregorian.js
@@ -0,0 +1,236 @@
+//>>built
+define(
+"dojo/cldr/nls/it/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"G",
+		"F",
+		"M",
+		"A",
+		"M",
+		"G",
+		"L",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"field-weekday": "giorno della settimana",
+	"dateFormatItem-yyQQQQ": "QQQQ yy",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "EEE, d/M/y",
+	"dateFormatItem-MMMEd": "EEE d MMM",
+	"eraNarrow": [
+		"aC",
+		"dC"
+	],
+	"dateFormat-long": "dd MMMM y",
+	"months-format-wide": [
+		"gennaio",
+		"febbraio",
+		"marzo",
+		"aprile",
+		"maggio",
+		"giugno",
+		"luglio",
+		"agosto",
+		"settembre",
+		"ottobre",
+		"novembre",
+		"dicembre"
+	],
+	"dayPeriods-format-wide-pm": "p.",
+	"dateFormat-full": "EEEE d MMMM y",
+	"dateFormatItem-Md": "d/M",
+	"field-era": "era",
+	"dateFormatItem-yM": "M/y",
+	"months-standAlone-wide": [
+		"Gennaio",
+		"Febbraio",
+		"Marzo",
+		"Aprile",
+		"Maggio",
+		"Giugno",
+		"Luglio",
+		"Agosto",
+		"Settembre",
+		"Ottobre",
+		"Novembre",
+		"Dicembre"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"1o trimestre",
+		"2o trimestre",
+		"3o trimestre",
+		"4o trimestre"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "anno",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "Q-yyyy",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"field-hour": "ora",
+	"dateFormatItem-MMdd": "dd/MM",
+	"months-format-abbr": [
+		"gen",
+		"feb",
+		"mar",
+		"apr",
+		"mag",
+		"giu",
+		"lug",
+		"ago",
+		"set",
+		"ott",
+		"nov",
+		"dic"
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"field-day-relative+0": "oggi",
+	"field-day-relative+1": "domani",
+	"field-day-relative+2": "dopodomani",
+	"field-day-relative+3": "tra tre giorni",
+	"months-standAlone-abbr": [
+		"gen",
+		"feb",
+		"mar",
+		"apr",
+		"mag",
+		"giu",
+		"lug",
+		"ago",
+		"set",
+		"ott",
+		"nov",
+		"dic"
+	],
+	"quarters-format-abbr": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"quarters-standAlone-wide": [
+		"1o trimestre",
+		"2o trimestre",
+		"3o trimestre",
+		"4o trimestre"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"Domenica",
+		"Lunedì",
+		"Martedì",
+		"Mercoledì",
+		"Giovedì",
+		"Venerdì",
+		"Sabato"
+	],
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"eraAbbr": [
+		"aC",
+		"dC"
+	],
+	"field-minute": "minuto",
+	"field-dayperiod": "periodo del giorno",
+	"days-standAlone-abbr": [
+		"dom",
+		"lun",
+		"mar",
+		"mer",
+		"gio",
+		"ven",
+		"sab"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "ieri",
+	"dateFormatItem-h": "hh a",
+	"field-day-relative+-2": "l'altro ieri",
+	"field-day-relative+-3": "tre giorni fa",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-MEd": "EEE d/M",
+	"field-day": "giorno",
+	"days-format-wide": [
+		"domenica",
+		"lunedì",
+		"martedì",
+		"mercoledì",
+		"giovedì",
+		"venerdì",
+		"sabato"
+	],
+	"field-zone": "zona",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"G",
+		"F",
+		"M",
+		"A",
+		"M",
+		"G",
+		"L",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-yyMM": "MM/yy",
+	"dateFormatItem-hm": "hh:mm a",
+	"days-format-abbr": [
+		"dom",
+		"lun",
+		"mar",
+		"mer",
+		"gio",
+		"ven",
+		"sab"
+	],
+	"eraNames": [
+		"a.C.",
+		"d.C"
+	],
+	"days-format-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"G",
+		"V",
+		"S"
+	],
+	"field-month": "mese",
+	"days-standAlone-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"G",
+		"V",
+		"S"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "m.",
+	"dateFormatItem-MMMMdd": "dd MMMM",
+	"dateFormat-short": "dd/MM/yy",
+	"field-second": "secondo",
+	"dateFormatItem-yMMMEd": "EEE d MMM y",
+	"dateFormatItem-Ed": "E d",
+	"field-week": "settimana",
+	"dateFormat-medium": "dd/MMM/y",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "hh:mm:ss a"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/it/number.js b/js/dojo-1.7.2/dojo/cldr/nls/it/number.js
new file mode 100644
index 0000000..90bed54
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/it/number.js
@@ -0,0 +1,13 @@
+//>>built
+define(
+"dojo/cldr/nls/it/number", //begin v1.x content
+{
+	"decimalFormat": "#,##0.###",
+	"group": ".",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"currencyFormat": "¤ #,##0.00",
+	"decimal": ","
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ja/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/ja/currency.js
new file mode 100644
index 0000000..1a5927f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ja/currency.js
@@ -0,0 +1,19 @@
+//>>built
+define(
+"dojo/cldr/nls/ja/currency", //begin v1.x content
+{
+	"HKD_displayName": "香港ドル",
+	"CHF_displayName": "スイス フラン",
+	"JPY_symbol": "ï¿¥",
+	"CAD_displayName": "カナダ ドル",
+	"CNY_displayName": "中国人民元",
+	"USD_symbol": "$",
+	"AUD_displayName": "オーストラリア ドル",
+	"JPY_displayName": "日本円",
+	"USD_displayName": "米ドル",
+	"CNY_symbol": "å…ƒ",
+	"GBP_displayName": "英国�ンド",
+	"EUR_displayName": "ユーロ"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ja/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/ja/gregorian.js
new file mode 100644
index 0000000..70d3322
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ja/gregorian.js
@@ -0,0 +1,223 @@
+//>>built
+define(
+"dojo/cldr/nls/ja/gregorian", //begin v1.x content
+{
+	"field-weekday": "曜日",
+	"dateFormatItem-yQQQ": "yQQQ",
+	"dateFormatItem-yMEd": "y/M/d(EEE)",
+	"dateFormatItem-MMMEd": "M月d日(E)",
+	"eraNarrow": [
+		"BC",
+		"AD"
+	],
+	"dateFormat-long": "y年M月d日",
+	"months-format-wide": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"dateTimeFormat-medium": "{1} {0}",
+	"dayPeriods-format-wide-pm": "�後",
+	"dateFormat-full": "y年M月d日EEEE",
+	"dateFormatItem-Md": "M/d",
+	"dateFormatItem-yMd": "y/M/d",
+	"field-era": "時代",
+	"dateFormatItem-yM": "y/M",
+	"months-standAlone-wide": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"timeFormat-short": "H:mm",
+	"quarters-format-wide": [
+		"第1四�期",
+		"第2四�期",
+		"第3四�期",
+		"第4四�期"
+	],
+	"timeFormat-long": "H:mm:ss z",
+	"field-year": "å¹´",
+	"dateFormatItem-yMMM": "y年M月",
+	"dateFormatItem-yQ": "y/Q",
+	"field-hour": "時",
+	"dateFormatItem-MMdd": "MM/dd",
+	"months-format-abbr": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"dateFormatItem-yyQ": "yy/Q",
+	"timeFormat-full": "H時mm分ss秒 zzzz",
+	"field-day-relative+0": "今日",
+	"field-day-relative+1": "明日",
+	"field-day-relative+2": "明後日",
+	"dateFormatItem-H": "H時",
+	"field-day-relative+3": "3日後",
+	"months-standAlone-abbr": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"quarters-format-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"quarters-standAlone-wide": [
+		"第1四�期",
+		"第2四�期",
+		"第3四�期",
+		"第4四�期"
+	],
+	"dateFormatItem-M": "M月",
+	"days-standAlone-wide": [
+		"日曜日",
+		"月曜日",
+		"�曜日",
+		"水曜日",
+		"木曜日",
+		"金曜日",
+		"土曜日"
+	],
+	"dateFormatItem-yyMMM": "y年M月",
+	"timeFormat-medium": "H:mm:ss",
+	"dateFormatItem-Hm": "H:mm",
+	"eraAbbr": [
+		"BC",
+		"AD"
+	],
+	"field-minute": "分",
+	"field-dayperiod": "��/�後",
+	"days-standAlone-abbr": [
+		"æ—¥",
+		"月",
+		"�",
+		"æ°´",
+		"木",
+		"金",
+		"土"
+	],
+	"dateFormatItem-d": "dæ—¥",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "昨日",
+	"dateFormatItem-h": "ah時",
+	"dateTimeFormat-long": "{1}{0}",
+	"field-day-relative+-2": "一昨日",
+	"field-day-relative+-3": "3日�",
+	"dateFormatItem-MMMd": "M月d日",
+	"dateFormatItem-MEd": "M/d(E)",
+	"dateTimeFormat-full": "{1}{0}",
+	"field-day": "æ—¥",
+	"days-format-wide": [
+		"日曜日",
+		"月曜日",
+		"�曜日",
+		"水曜日",
+		"木曜日",
+		"金曜日",
+		"土曜日"
+	],
+	"field-zone": "タイムゾーン",
+	"dateFormatItem-yyyyMM": "yyyy/MM",
+	"dateFormatItem-y": "yå¹´",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateFormatItem-hm": "ah:mm",
+	"dateFormatItem-GGGGyMd": "GGGGy年M月d日",
+	"days-format-abbr": [
+		"æ—¥",
+		"月",
+		"�",
+		"æ°´",
+		"木",
+		"金",
+		"土"
+	],
+	"dateFormatItem-yMMMd": "y年M月d日",
+	"eraNames": [
+		"紀元�",
+		"西暦"
+	],
+	"days-format-narrow": [
+		"æ—¥",
+		"月",
+		"�",
+		"æ°´",
+		"木",
+		"金",
+		"土"
+	],
+	"field-month": "月",
+	"days-standAlone-narrow": [
+		"æ—¥",
+		"月",
+		"�",
+		"æ°´",
+		"木",
+		"金",
+		"土"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "��",
+	"dateFormat-short": "yy/MM/dd",
+	"field-second": "秒",
+	"dateFormatItem-yMMMEd": "y年M月d日(EEE)",
+	"dateFormatItem-Ed": "dæ—¥(EEE)",
+	"field-week": "週",
+	"dateFormat-medium": "yyyy/MM/dd",
+	"dateTimeFormat-short": "{1} {0}",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"dateFormatItem-hms": "ah:mm:ss",
+	"dateFormatItem-yyyy": "yå¹´"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ja/number.js b/js/dojo-1.7.2/dojo/cldr/nls/ja/number.js
new file mode 100644
index 0000000..618b4ac
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ja/number.js
@@ -0,0 +1,13 @@
+//>>built
+define(
+"dojo/cldr/nls/ja/number", //begin v1.x content
+{
+	"decimalFormat": "#,##0.###",
+	"group": ",",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"currencyFormat": "¤#,##0.00",
+	"decimal": "."
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ko/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/ko/currency.js
new file mode 100644
index 0000000..7d3cb33
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ko/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/ko/currency", //begin v1.x content
+{
+	"HKD_displayName": "�콩 달러",
+	"CHF_displayName": "스위스 프랑",
+	"CAD_displayName": "�나다 달러",
+	"CNY_displayName": "중국 위안 �민�",
+	"AUD_displayName": "호주 달러",
+	"JPY_displayName": "�본 엔화",
+	"USD_displayName": "미국 달러",
+	"GBP_displayName": "�국령 파운드 스털�",
+	"EUR_displayName": "유로화"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ko/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/ko/gregorian.js
new file mode 100644
index 0000000..897f1ca
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ko/gregorian.js
@@ -0,0 +1,244 @@
+//>>built
+define(
+"dojo/cldr/nls/ko/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"1ì›”",
+		"2ì›”",
+		"3ì›”",
+		"4ì›”",
+		"5ì›”",
+		"6ì›”",
+		"7ì›”",
+		"8ì›”",
+		"9ì›”",
+		"10ì›”",
+		"11ì›”",
+		"12ì›”"
+	],
+	"field-weekday": "요�",
+	"dateFormatItem-yQQQ": "yë…„ QQQ",
+	"dateFormatItem-yMEd": "yyyy. M. d. EEE",
+	"dateFormatItem-MMMEd": "MMM d� (E)",
+	"eraNarrow": [
+		"기�전",
+		"서기"
+	],
+	"dateFormat-long": "y년 M월 d�",
+	"months-format-wide": [
+		"1ì›”",
+		"2ì›”",
+		"3ì›”",
+		"4ì›”",
+		"5ì›”",
+		"6ì›”",
+		"7ì›”",
+		"8ì›”",
+		"9ì›”",
+		"10ì›”",
+		"11ì›”",
+		"12ì›”"
+	],
+	"dateTimeFormat-medium": "{1} {0}",
+	"dateFormatItem-EEEd": "d� EEE",
+	"dayPeriods-format-wide-pm": "오후",
+	"dateFormat-full": "y년 M월 d� EEEE",
+	"dateFormatItem-Md": "M. d.",
+	"field-era": "연호",
+	"dateFormatItem-yM": "yyyy. M.",
+	"months-standAlone-wide": [
+		"1ì›”",
+		"2ì›”",
+		"3ì›”",
+		"4ì›”",
+		"5ì›”",
+		"6ì›”",
+		"7ì›”",
+		"8ì›”",
+		"9ì›”",
+		"10ì›”",
+		"11ì›”",
+		"12ì›”"
+	],
+	"timeFormat-short": "a h:mm",
+	"quarters-format-wide": [
+		"제 1/4분기",
+		"제 2/4분기",
+		"제 3/4분기",
+		"제 4/4분기"
+	],
+	"timeFormat-long": "a h시 m분 s초 z",
+	"field-year": "ë…„",
+	"dateFormatItem-yMMM": "yë…„ MMM",
+	"dateFormatItem-yQ": "y년 Q분기",
+	"field-hour": "시",
+	"dateFormatItem-MMdd": "MM. dd",
+	"months-format-abbr": [
+		"1ì›”",
+		"2ì›”",
+		"3ì›”",
+		"4ì›”",
+		"5ì›”",
+		"6ì›”",
+		"7ì›”",
+		"8ì›”",
+		"9ì›”",
+		"10ì›”",
+		"11ì›”",
+		"12ì›”"
+	],
+	"dateFormatItem-yyQ": "yy년 Q분기",
+	"timeFormat-full": "a h시 m분 s초 zzzz",
+	"field-day-relative+0": "오늘",
+	"field-day-relative+1": "내�",
+	"field-day-relative+2": "모레",
+	"dateFormatItem-H": "H시",
+	"field-day-relative+3": "3�후",
+	"months-standAlone-abbr": [
+		"1ì›”",
+		"2ì›”",
+		"3ì›”",
+		"4ì›”",
+		"5ì›”",
+		"6ì›”",
+		"7ì›”",
+		"8ì›”",
+		"9ì›”",
+		"10ì›”",
+		"11ì›”",
+		"12ì›”"
+	],
+	"quarters-format-abbr": [
+		"1분기",
+		"2분기",
+		"3분기",
+		"4분기"
+	],
+	"quarters-standAlone-wide": [
+		"제 1/4분기",
+		"제 2/4분기",
+		"제 3/4분기",
+		"제 4/4분기"
+	],
+	"dateFormatItem-HHmmss": "HH:mm:ss",
+	"dateFormatItem-M": "Mì›”",
+	"days-standAlone-wide": [
+		"�요�",
+		"월요�",
+		"화요�",
+		"수요�",
+		"목요�",
+		"금요�",
+		"토요�"
+	],
+	"dateFormatItem-yyMMM": "yyë…„ MMM",
+	"timeFormat-medium": "a h:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"1분기",
+		"2분기",
+		"3분기",
+		"4분기"
+	],
+	"eraAbbr": [
+		"기�전",
+		"서기"
+	],
+	"field-minute": "분",
+	"field-dayperiod": "오전/오후",
+	"days-standAlone-abbr": [
+		"�",
+		"ì›”",
+		"í™”",
+		"수",
+		"목",
+		"금",
+		"토"
+	],
+	"dateFormatItem-d": "d�",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "어제",
+	"dateFormatItem-h": "a h시",
+	"dateTimeFormat-long": "{1} {0}",
+	"field-day-relative+-2": "그저께",
+	"field-day-relative+-3": "그�제",
+	"dateFormatItem-MMMd": "MMM d�",
+	"dateFormatItem-MEd": "M. d. (E)",
+	"dateTimeFormat-full": "{1} {0}",
+	"field-day": "�",
+	"days-format-wide": [
+		"�요�",
+		"월요�",
+		"화요�",
+		"수요�",
+		"목요�",
+		"금요�",
+		"토요�"
+	],
+	"field-zone": "시간대",
+	"dateFormatItem-yyyyMM": "yyyy. MM",
+	"dateFormatItem-y": "yë…„",
+	"months-standAlone-narrow": [
+		"1ì›”",
+		"2ì›”",
+		"3ì›”",
+		"4ì›”",
+		"5ì›”",
+		"6ì›”",
+		"7ì›”",
+		"8ì›”",
+		"9ì›”",
+		"10ì›”",
+		"11ì›”",
+		"12ì›”"
+	],
+	"dateFormatItem-yyMM": "YY. M.",
+	"dateFormatItem-hm": "a h:mm",
+	"days-format-abbr": [
+		"�",
+		"ì›”",
+		"í™”",
+		"수",
+		"목",
+		"금",
+		"토"
+	],
+	"dateFormatItem-yMMMd": "y년 MMM d�",
+	"eraNames": [
+		"서력기�전",
+		"서력기�"
+	],
+	"days-format-narrow": [
+		"�",
+		"ì›”",
+		"í™”",
+		"수",
+		"목",
+		"금",
+		"토"
+	],
+	"field-month": "ì›”",
+	"days-standAlone-narrow": [
+		"�",
+		"ì›”",
+		"í™”",
+		"수",
+		"목",
+		"금",
+		"토"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "오전",
+	"dateFormat-short": "yy. M. d.",
+	"field-second": "ì´ˆ",
+	"dateFormatItem-yMMMEd": "y년 MMM d� EEE",
+	"dateFormatItem-Ed": "d� (E)",
+	"field-week": "주",
+	"dateFormat-medium": "yyyy. M. d.",
+	"dateFormatItem-mmss": "mm:ss",
+	"dateTimeFormat-short": "{1} {0}",
+	"dateFormatItem-Hms": "H시 m분 s초",
+	"dateFormatItem-hms": "a h:mm:ss"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ko/number.js b/js/dojo-1.7.2/dojo/cldr/nls/ko/number.js
new file mode 100644
index 0000000..752f082
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ko/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/ko/number", //begin v1.x content
+{
+	"group": ",",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ".",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "¤#,##0.00",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/nb/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/nb/currency.js
new file mode 100644
index 0000000..ea9bab1
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/nb/currency.js
@@ -0,0 +1,24 @@
+//>>built
+define(
+"dojo/cldr/nls/nb/currency", //begin v1.x content
+{
+	"HKD_displayName": "Hongkong-dollar",
+	"CHF_displayName": "sveitsiske franc",
+	"CHF_symbol": "CHF",
+	"JPY_symbol": "JPY",
+	"CAD_displayName": "kanadiske dollar",
+	"CNY_displayName": "kinesiske yuan renminbi",
+	"USD_symbol": "USD",
+	"AUD_displayName": "australske dollar",
+	"JPY_displayName": "japanske yen",
+	"CAD_symbol": "CAD",
+	"USD_displayName": "amerikanske dollar",
+	"EUR_symbol": "EUR",
+	"CNY_symbol": "CNY",
+	"GBP_displayName": "britiske pund sterling",
+	"GBP_symbol": "GBP",
+	"AUD_symbol": "AUD",
+	"EUR_displayName": "euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/nb/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/nb/gregorian.js
new file mode 100644
index 0000000..7392be5
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/nb/gregorian.js
@@ -0,0 +1,235 @@
+//>>built
+define(
+"dojo/cldr/nls/nb/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"field-weekday": "ukedag",
+	"dateFormatItem-yyQQQQ": "QQQQ yy",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "EEE d.M.yyyy",
+	"dateFormatItem-MMMEd": "E d. MMM",
+	"eraNarrow": [
+		"f.Kr.",
+		"e.Kr."
+	],
+	"dateFormat-long": "d. MMMM y",
+	"months-format-wide": [
+		"januar",
+		"februar",
+		"mars",
+		"april",
+		"mai",
+		"juni",
+		"juli",
+		"august",
+		"september",
+		"oktober",
+		"november",
+		"desember"
+	],
+	"dateFormatItem-EEEd": "EEE d.",
+	"dayPeriods-format-wide-pm": "PM",
+	"dateFormat-full": "EEEE d. MMMM y",
+	"dateFormatItem-Md": "d.M.",
+	"field-era": "tidsalder",
+	"dateFormatItem-yM": "M y",
+	"months-standAlone-wide": [
+		"januar",
+		"februar",
+		"mars",
+		"april",
+		"mai",
+		"juni",
+		"juli",
+		"august",
+		"september",
+		"oktober",
+		"november",
+		"desember"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"1. kvartal",
+		"2. kvartal",
+		"3. kvartal",
+		"4. kvartal"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "Ã¥r",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "Q yyyy",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"field-hour": "time",
+	"dateFormatItem-MMdd": "dd.MM",
+	"months-format-abbr": [
+		"jan.",
+		"feb.",
+		"mars",
+		"apr.",
+		"mai",
+		"juni",
+		"juli",
+		"aug.",
+		"sep.",
+		"okt.",
+		"nov.",
+		"des."
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "'kl'. HH:mm:ss zzzz",
+	"field-day-relative+0": "i dag",
+	"field-day-relative+1": "i morgen",
+	"field-day-relative+2": "i overmorgen",
+	"field-day-relative+3": "i overovermorgen",
+	"months-standAlone-abbr": [
+		"jan.",
+		"feb.",
+		"mars",
+		"apr.",
+		"mai",
+		"juni",
+		"juli",
+		"aug.",
+		"sep.",
+		"okt.",
+		"nov.",
+		"des."
+	],
+	"quarters-format-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"quarters-standAlone-wide": [
+		"1. kvartal",
+		"2. kvartal",
+		"3. kvartal",
+		"4. kvartal"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"søndag",
+		"mandag",
+		"tirsdag",
+		"onsdag",
+		"torsdag",
+		"fredag",
+		"lørdag"
+	],
+	"dateFormatItem-yyMMM": "MMM yy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"eraAbbr": [
+		"f.Kr.",
+		"e.Kr."
+	],
+	"field-minute": "minutt",
+	"field-dayperiod": "AM/PM",
+	"days-standAlone-abbr": [
+		"søn.",
+		"man.",
+		"tir.",
+		"ons.",
+		"tor.",
+		"fre.",
+		"lør."
+	],
+	"dateFormatItem-d": "d.",
+	"dateFormatItem-ms": "mm.ss",
+	"field-day-relative+-1": "i går",
+	"field-day-relative+-2": "i forgårs",
+	"field-day-relative+-3": "i forforgårs",
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-MEd": "E d.M",
+	"field-day": "dag",
+	"days-format-wide": [
+		"søndag",
+		"mandag",
+		"tirsdag",
+		"onsdag",
+		"torsdag",
+		"fredag",
+		"lørdag"
+	],
+	"field-zone": "sone",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-yyMM": "MM.yy",
+	"dateFormatItem-hm": "h:mm a",
+	"days-format-abbr": [
+		"søn.",
+		"man.",
+		"tir.",
+		"ons.",
+		"tor.",
+		"fre.",
+		"lør."
+	],
+	"eraNames": [
+		"f.Kr.",
+		"e.Kr."
+	],
+	"days-format-narrow": [
+		"S",
+		"M",
+		"T",
+		"O",
+		"T",
+		"F",
+		"L"
+	],
+	"field-month": "måned",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"O",
+		"T",
+		"F",
+		"L"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "AM",
+	"dateFormat-short": "dd.MM.yy",
+	"field-second": "sekund",
+	"dateFormatItem-yMMMEd": "EEE d. MMM y",
+	"field-week": "uke",
+	"dateFormat-medium": "d. MMM y",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "h:mm:ss a"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/nb/number.js b/js/dojo-1.7.2/dojo/cldr/nls/nb/number.js
new file mode 100644
index 0000000..95b125d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/nb/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/nb/number", //begin v1.x content
+{
+	"group": " ",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0 %",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "¤ #,##0.00",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/nl/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/nl/currency.js
new file mode 100644
index 0000000..4461fbd
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/nl/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/nl/currency", //begin v1.x content
+{
+	"HKD_displayName": "Hongkongse dollar",
+	"CHF_displayName": "Zwitserse franc",
+	"CAD_displayName": "Canadese dollar",
+	"CNY_displayName": "Chinese yuan renminbi",
+	"AUD_displayName": "Australische dollar",
+	"JPY_displayName": "Japanse yen",
+	"USD_displayName": "Amerikaanse dollar",
+	"GBP_displayName": "Brits pond sterling",
+	"EUR_displayName": "Euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/nl/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/nl/gregorian.js
new file mode 100644
index 0000000..3c15b7f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/nl/gregorian.js
@@ -0,0 +1,234 @@
+//>>built
+define(
+"dojo/cldr/nls/nl/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"field-weekday": "Dag van de week",
+	"dateFormatItem-yyQQQQ": "QQQQ yy",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "EEE d-M-y",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"eraNarrow": [
+		"v. Chr.",
+		"n. Chr."
+	],
+	"dateFormat-long": "d MMMM y",
+	"months-format-wide": [
+		"januari",
+		"februari",
+		"maart",
+		"april",
+		"mei",
+		"juni",
+		"juli",
+		"augustus",
+		"september",
+		"oktober",
+		"november",
+		"december"
+	],
+	"dayPeriods-format-wide-pm": "PM",
+	"dateFormat-full": "EEEE d MMMM y",
+	"dateFormatItem-Md": "d-M",
+	"field-era": "Tijdperk",
+	"dateFormatItem-yM": "M-y",
+	"months-standAlone-wide": [
+		"januari",
+		"februari",
+		"maart",
+		"april",
+		"mei",
+		"juni",
+		"juli",
+		"augustus",
+		"september",
+		"oktober",
+		"november",
+		"december"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"1e kwartaal",
+		"2e kwartaal",
+		"3e kwartaal",
+		"4e kwartaal"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "Jaar",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "Q yyyy",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"field-hour": "Uur",
+	"dateFormatItem-MMdd": "dd-MM",
+	"months-format-abbr": [
+		"jan.",
+		"feb.",
+		"mrt.",
+		"apr.",
+		"mei",
+		"jun.",
+		"jul.",
+		"aug.",
+		"sep.",
+		"okt.",
+		"nov.",
+		"dec."
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"field-day-relative+0": "vandaag",
+	"field-day-relative+1": "morgen",
+	"field-day-relative+2": "overmorgen",
+	"field-day-relative+3": "overovermorgen",
+	"months-standAlone-abbr": [
+		"jan.",
+		"feb.",
+		"mrt.",
+		"apr.",
+		"mei",
+		"jun.",
+		"jul.",
+		"aug.",
+		"sep.",
+		"okt.",
+		"nov.",
+		"dec."
+	],
+	"quarters-format-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"quarters-standAlone-wide": [
+		"1e kwartaal",
+		"2e kwartaal",
+		"3e kwartaal",
+		"4e kwartaal"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"zondag",
+		"maandag",
+		"dinsdag",
+		"woensdag",
+		"donderdag",
+		"vrijdag",
+		"zaterdag"
+	],
+	"dateFormatItem-MMMMd": "d MMMM",
+	"dateFormatItem-yyMMM": "MMM yy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"eraAbbr": [
+		"v. Chr.",
+		"n. Chr."
+	],
+	"field-minute": "Minuut",
+	"field-dayperiod": "AM/PM",
+	"days-standAlone-abbr": [
+		"zo",
+		"ma",
+		"di",
+		"wo",
+		"do",
+		"vr",
+		"za"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "gisteren",
+	"field-day-relative+-2": "eergisteren",
+	"field-day-relative+-3": "eereergisteren",
+	"dateFormatItem-MMMd": "d-MMM",
+	"dateFormatItem-MEd": "E d-M",
+	"field-day": "Dag",
+	"days-format-wide": [
+		"zondag",
+		"maandag",
+		"dinsdag",
+		"woensdag",
+		"donderdag",
+		"vrijdag",
+		"zaterdag"
+	],
+	"field-zone": "Zone",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-yyMM": "MM-yy",
+	"days-format-abbr": [
+		"zo",
+		"ma",
+		"di",
+		"wo",
+		"do",
+		"vr",
+		"za"
+	],
+	"eraNames": [
+		"Voor Christus",
+		"na Christus"
+	],
+	"days-format-narrow": [
+		"Z",
+		"M",
+		"D",
+		"W",
+		"D",
+		"V",
+		"Z"
+	],
+	"field-month": "Maand",
+	"days-standAlone-narrow": [
+		"Z",
+		"M",
+		"D",
+		"W",
+		"D",
+		"V",
+		"Z"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "AM",
+	"dateFormat-short": "dd-MM-yy",
+	"dateFormatItem-MMd": "d-MM",
+	"field-second": "Seconde",
+	"dateFormatItem-yMMMEd": "EEE d MMM y",
+	"dateFormatItem-Ed": "E d",
+	"field-week": "Week",
+	"dateFormat-medium": "d MMM y"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/nl/number.js b/js/dojo-1.7.2/dojo/cldr/nls/nl/number.js
new file mode 100644
index 0000000..9984f6d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/nl/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/nl/number", //begin v1.x content
+{
+	"group": ".",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "¤ #,##0.00;¤ #,##0.00-",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/number.js b/js/dojo-1.7.2/dojo/cldr/nls/number.js
new file mode 100644
index 0000000..5f077d0
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/number.js
@@ -0,0 +1,65 @@
+//>>built
+define("dojo/cldr/nls/number", { root:
+
+//begin v1.x content
+{
+	"scientificFormat": "#E0",
+	"currencySpacing-afterCurrency-currencyMatch": "[:letter:]",
+	"infinity": "∞",
+	"list": ";",
+	"percentSign": "%",
+	"minusSign": "-",
+	"currencySpacing-beforeCurrency-surroundingMatch": "[:digit:]",
+	"decimalFormat-short": "000T",
+	"currencySpacing-afterCurrency-insertBetween": " ",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"plusSign": "+",
+	"currencySpacing-afterCurrency-surroundingMatch": "[:digit:]",
+	"currencySpacing-beforeCurrency-currencyMatch": "[:letter:]",
+	"currencyFormat": "¤ #,##0.00",
+	"perMille": "‰",
+	"group": ",",
+	"percentFormat": "#,##0%",
+	"decimalFormat": "#,##0.###",
+	"decimal": ".",
+	"patternDigit": "#",
+	"currencySpacing-beforeCurrency-insertBetween": " ",
+	"exponential": "E"
+}
+//end v1.x content
+,
+	"ar": true,
+	"ca": true,
+	"cs": true,
+	"da": true,
+	"de": true,
+	"el": true,
+	"en": true,
+	"en-au": true,
+	"en-gb": true,
+	"es": true,
+	"fi": true,
+	"fr": true,
+	"fr-ch": true,
+	"he": true,
+	"hu": true,
+	"it": true,
+	"ja": true,
+	"ko": true,
+	"nb": true,
+	"nl": true,
+	"pl": true,
+	"pt": true,
+	"pt-pt": true,
+	"ro": true,
+	"ru": true,
+	"sk": true,
+	"sl": true,
+	"sv": true,
+	"th": true,
+	"tr": true,
+	"zh": true,
+	"zh-hant": true,
+	"zh-hk": true
+});
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/pl/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/pl/currency.js
new file mode 100644
index 0000000..67af05f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/pl/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/pl/currency", //begin v1.x content
+{
+	"HKD_displayName": "dolar hongkoński",
+	"CHF_displayName": "frank szwajcarski",
+	"CAD_displayName": "dolar kanadyjski",
+	"CNY_displayName": "juan renminbi",
+	"AUD_displayName": "dolar australijski",
+	"JPY_displayName": "jen japoński",
+	"USD_displayName": "dolar amerykański ",
+	"GBP_displayName": "funt szterling",
+	"EUR_displayName": "euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/pl/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/pl/gregorian.js
new file mode 100644
index 0000000..5aa9698
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/pl/gregorian.js
@@ -0,0 +1,243 @@
+//>>built
+define(
+"dojo/cldr/nls/pl/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"s",
+		"l",
+		"m",
+		"k",
+		"m",
+		"c",
+		"l",
+		"s",
+		"w",
+		"p",
+		"l",
+		"g"
+	],
+	"field-weekday": "Dzień tygodnia",
+	"dateFormatItem-yQQQ": "y QQQ",
+	"dateFormatItem-yMEd": "EEE, d.MM.yyyy",
+	"dateFormatItem-MMMEd": "E, d MMM",
+	"eraNarrow": [
+		"p.n.e.",
+		"n.e."
+	],
+	"dayPeriods-format-wide-earlyMorning": "nad ranem",
+	"dayPeriods-format-wide-morning": "rano",
+	"dateFormat-long": "d MMMM y",
+	"months-format-wide": [
+		"stycznia",
+		"lutego",
+		"marca",
+		"kwietnia",
+		"maja",
+		"czerwca",
+		"lipca",
+		"sierpnia",
+		"września",
+		"października",
+		"listopada",
+		"grudnia"
+	],
+	"dayPeriods-format-wide-evening": "wieczorem",
+	"dayPeriods-format-wide-pm": "PM",
+	"dateFormat-full": "EEEE, d MMMM y",
+	"dateFormatItem-Md": "d.MM",
+	"dayPeriods-format-wide-noon": "w południe",
+	"field-era": "Era",
+	"dateFormatItem-yM": "MM.yyyy",
+	"months-standAlone-wide": [
+		"styczeń",
+		"luty",
+		"marzec",
+		"kwiecień",
+		"maj",
+		"czerwiec",
+		"lipiec",
+		"sierpień",
+		"wrzesień",
+		"październik",
+		"listopad",
+		"grudzień"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"I kwartał",
+		"II kwartał",
+		"III kwartał",
+		"IV kwartał"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "Rok",
+	"dateFormatItem-yQ": "yyyy Q",
+	"dateFormatItem-yyyyMMMM": "LLLL y",
+	"field-hour": "Godzina",
+	"dateFormatItem-MMdd": "d.MM",
+	"months-format-abbr": [
+		"sty",
+		"lut",
+		"mar",
+		"kwi",
+		"maj",
+		"cze",
+		"lip",
+		"sie",
+		"wrz",
+		"paź",
+		"lis",
+		"gru"
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"field-day-relative+0": "Dzisiaj",
+	"field-day-relative+1": "Jutro",
+	"field-day-relative+2": "Pojutrze",
+	"field-day-relative+3": "Za trzy dni",
+	"months-standAlone-abbr": [
+		"sty",
+		"lut",
+		"mar",
+		"kwi",
+		"maj",
+		"cze",
+		"lip",
+		"sie",
+		"wrz",
+		"paź",
+		"lis",
+		"gru"
+	],
+	"quarters-format-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"quarters-standAlone-wide": [
+		"I kwartał",
+		"II kwartał",
+		"III kwartał",
+		"IV kwartał"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"niedziela",
+		"poniedziałek",
+		"wtorek",
+		"środa",
+		"czwartek",
+		"piÄ…tek",
+		"sobota"
+	],
+	"dateFormatItem-MMMMd": "d MMMM",
+	"dateFormatItem-yyMMM": "MMM yy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"1 kw.",
+		"2 kw.",
+		"3 kw.",
+		"4 kw."
+	],
+	"eraAbbr": [
+		"p.n.e.",
+		"n.e."
+	],
+	"field-minute": "Minuta",
+	"field-dayperiod": "Dayperiod",
+	"days-standAlone-abbr": [
+		"niedz.",
+		"pon.",
+		"wt.",
+		"śr.",
+		"czw.",
+		"pt.",
+		"sob."
+	],
+	"dayPeriods-format-wide-night": "w nocy",
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "Wczoraj",
+	"dateFormatItem-h": "hh a",
+	"field-day-relative+-2": "Przedwczoraj",
+	"field-day-relative+-3": "Trzy dni temu",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-MEd": "E, d.MM",
+	"dayPeriods-format-wide-lateMorning": "przed południem",
+	"dateFormatItem-yMMMM": "LLLL y",
+	"field-day": "Dzień",
+	"days-format-wide": [
+		"niedziela",
+		"poniedziałek",
+		"wtorek",
+		"środa",
+		"czwartek",
+		"piÄ…tek",
+		"sobota"
+	],
+	"field-zone": "Strefa",
+	"dateFormatItem-yyyyMM": "MM.yyyy",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"s",
+		"l",
+		"m",
+		"k",
+		"m",
+		"c",
+		"l",
+		"s",
+		"w",
+		"p",
+		"l",
+		"g"
+	],
+	"dateFormatItem-hm": "hh:mm a",
+	"days-format-abbr": [
+		"niedz.",
+		"pon.",
+		"wt.",
+		"śr.",
+		"czw.",
+		"pt.",
+		"sob."
+	],
+	"eraNames": [
+		"p.n.e.",
+		"n.e."
+	],
+	"days-format-narrow": [
+		"N",
+		"P",
+		"W",
+		"Åš",
+		"C",
+		"P",
+		"S"
+	],
+	"field-month": "MiesiÄ…c",
+	"days-standAlone-narrow": [
+		"N",
+		"P",
+		"W",
+		"Åš",
+		"C",
+		"P",
+		"S"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "AM",
+	"dateFormat-short": "dd.MM.yyyy",
+	"dayPeriods-format-wide-afternoon": "po południu",
+	"field-second": "Sekunda",
+	"dateFormatItem-yMMMEd": "EEE, d MMM y",
+	"dateFormatItem-Ed": "E, d",
+	"field-week": "Tydzień",
+	"dateFormat-medium": "d MMM y",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "hh:mm:ss a"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/pl/number.js b/js/dojo-1.7.2/dojo/cldr/nls/pl/number.js
new file mode 100644
index 0000000..7ca222d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/pl/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/pl/number", //begin v1.x content
+{
+	"group": " ",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/pt-pt/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/pt-pt/gregorian.js
new file mode 100644
index 0000000..5e534c9
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/pt-pt/gregorian.js
@@ -0,0 +1,142 @@
+//>>built
+define(
+"dojo/cldr/nls/pt-pt/gregorian", //begin v1.x content
+{
+	"quarters-standAlone-wide": [
+		"1.º trimestre",
+		"2.º trimestre",
+		"3.º trimestre",
+		"4.º trimestre"
+	],
+	"quarters-format-abbr": [
+		"1.º trimestre",
+		"2.º trimestre",
+		"3.º trimestre",
+		"4.º trimestre"
+	],
+	"dayPeriods-standAlone-wide-am": "a.m.",
+	"dateFormat-medium": "d 'de' MMM 'de' yyyy",
+	"quarters-standAlone-abbr": [
+		"1.º trimestre",
+		"2.º trimestre",
+		"3.º trimestre",
+		"4.º trimestre"
+	],
+	"dateFormatItem-Hm": "HH:mm",
+	"dayPeriods-standAlone-abbr-pm": "p.m.",
+	"dateFormatItem-HHmmss": "HH:mm:ss",
+	"dateFormatItem-hm": "h:mm a",
+	"months-standAlone-wide": [
+		"Janeiro",
+		"Fevereiro",
+		"Março",
+		"Abril",
+		"Maio",
+		"Junho",
+		"Julho",
+		"Agosto",
+		"Setembro",
+		"Outubro",
+		"Novembro",
+		"Dezembro"
+	],
+	"dayPeriods-standAlone-abbr-am": "a.m.",
+	"dayPeriods-format-wide-pm": "Depois do meio-dia",
+	"months-standAlone-abbr": [
+		"Jan",
+		"Fev",
+		"Mar",
+		"Abr",
+		"Mai",
+		"Jun",
+		"Jul",
+		"Ago",
+		"Set",
+		"Out",
+		"Nov",
+		"Dez"
+	],
+	"dateFormatItem-yQQQ": "QQQ 'de' y",
+	"dayPeriods-format-wide-am": "Antes do meio-dia",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dayPeriods-format-abbr-pm": "p.m.",
+	"dateFormatItem-yyQ": "QQQ 'de' yy",
+	"dateFormatItem-ms": "mm:ss",
+	"dayPeriods-format-abbr-am": "a.m.",
+	"months-format-wide": [
+		"Janeiro",
+		"Fevereiro",
+		"Março",
+		"Abril",
+		"Maio",
+		"Junho",
+		"Julho",
+		"Agosto",
+		"Setembro",
+		"Outubro",
+		"Novembro",
+		"Dezembro"
+	],
+	"days-standAlone-wide": [
+		"Domingo",
+		"Segunda-feira",
+		"Terça-feira",
+		"Quarta-feira",
+		"Quinta-feira",
+		"Sexta-feira",
+		"Sábado"
+	],
+	"dateFormatItem-HHmm": "HH:mm",
+	"months-format-abbr": [
+		"Jan",
+		"Fev",
+		"Mar",
+		"Abr",
+		"Mai",
+		"Jun",
+		"Jul",
+		"Ago",
+		"Set",
+		"Out",
+		"Nov",
+		"Dez"
+	],
+	"days-standAlone-abbr": [
+		"Domingo",
+		"Segunda-feira",
+		"Terça-feira",
+		"Quarta-feira",
+		"Quinta-feira",
+		"Sexta-feira",
+		"Sábado"
+	],
+	"days-format-wide": [
+		"Domingo",
+		"Segunda-feira",
+		"Terça-feira",
+		"Quarta-feira",
+		"Quinta-feira",
+		"Sexta-feira",
+		"Sábado"
+	],
+	"dateFormatItem-hms": "h:mm:ss a",
+	"dateFormatItem-yQ": "QQQ 'de' yyyy",
+	"quarters-format-wide": [
+		"1.º trimestre",
+		"2.º trimestre",
+		"3.º trimestre",
+		"4.º trimestre"
+	],
+	"dayPeriods-standAlone-wide-pm": "p.m.",
+	"days-format-abbr": [
+		"Domingo",
+		"Segunda-feira",
+		"Terça-feira",
+		"Quarta-feira",
+		"Quinta-feira",
+		"Sexta-feira",
+		"Sábado"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/pt-pt/number.js b/js/dojo-1.7.2/dojo/cldr/nls/pt-pt/number.js
new file mode 100644
index 0000000..3a7656d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/pt-pt/number.js
@@ -0,0 +1,9 @@
+//>>built
+define(
+"dojo/cldr/nls/pt-pt/number", //begin v1.x content
+{
+	"currencyFormat": "#,##0.00 ¤",
+	"group": " "
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/pt/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/pt/currency.js
new file mode 100644
index 0000000..5874fd7
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/pt/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/pt/currency", //begin v1.x content
+{
+	"HKD_displayName": "Dólar de Hong Kong",
+	"CHF_displayName": "Franco suíço",
+	"CAD_displayName": "Dólar canadense",
+	"CNY_displayName": "Yuan Renminbi chinês",
+	"AUD_displayName": "Dólar australiano",
+	"JPY_displayName": "Iene japonês",
+	"USD_displayName": "Dólar norte-americano",
+	"GBP_displayName": "Libra esterlina britânica",
+	"EUR_displayName": "Euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/pt/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/pt/gregorian.js
new file mode 100644
index 0000000..3d791de
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/pt/gregorian.js
@@ -0,0 +1,238 @@
+//>>built
+define(
+"dojo/cldr/nls/pt/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"field-weekday": "Dia da semana",
+	"dateFormatItem-yQQQ": "y QQQ",
+	"dateFormatItem-yMEd": "EEE, dd/MM/yyyy",
+	"dateFormatItem-MMMEd": "EEE, d 'de' MMM",
+	"eraNarrow": [
+		"a.C.",
+		"d.C."
+	],
+	"dayPeriods-format-wide-morning": "manhã",
+	"dateFormat-long": "d 'de' MMMM 'de' y",
+	"months-format-wide": [
+		"janeiro",
+		"fevereiro",
+		"março",
+		"abril",
+		"maio",
+		"junho",
+		"julho",
+		"agosto",
+		"setembro",
+		"outubro",
+		"novembro",
+		"dezembro"
+	],
+	"dateFormatItem-EEEd": "EEE, d",
+	"dateFormat-full": "EEEE, d 'de' MMMM 'de' y",
+	"dateFormatItem-Md": "d/M",
+	"dayPeriods-format-wide-noon": "meio-dia",
+	"field-era": "Era",
+	"dateFormatItem-yM": "MM/yyyy",
+	"months-standAlone-wide": [
+		"janeiro",
+		"fevereiro",
+		"março",
+		"abril",
+		"maio",
+		"junho",
+		"julho",
+		"agosto",
+		"setembro",
+		"outubro",
+		"novembro",
+		"dezembro"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"1º trimestre",
+		"2º trimestre",
+		"3º trimestre",
+		"4º trimestre"
+	],
+	"timeFormat-long": "HH'h'mm'min'ss's' z",
+	"field-year": "Ano",
+	"dateFormatItem-yMMM": "MMM 'de' y",
+	"dateFormatItem-yQ": "yyyy Q",
+	"field-hour": "Hora",
+	"dateFormatItem-MMdd": "dd/MM",
+	"months-format-abbr": [
+		"jan",
+		"fev",
+		"mar",
+		"abr",
+		"mai",
+		"jun",
+		"jul",
+		"ago",
+		"set",
+		"out",
+		"nov",
+		"dez"
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "HH'h'mm'min'ss's' zzzz",
+	"field-day-relative+0": "Hoje",
+	"field-day-relative+1": "Amanhã",
+	"field-day-relative+2": "Depois de amanhã",
+	"field-day-relative+3": "Daqui a três dias",
+	"months-standAlone-abbr": [
+		"jan",
+		"fev",
+		"mar",
+		"abr",
+		"mai",
+		"jun",
+		"jul",
+		"ago",
+		"set",
+		"out",
+		"nov",
+		"dez"
+	],
+	"quarters-format-abbr": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"quarters-standAlone-wide": [
+		"1º trimestre",
+		"2º trimestre",
+		"3º trimestre",
+		"4º trimestre"
+	],
+	"dateFormatItem-HHmmss": "HH'h'mm'min'ss's'",
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"domingo",
+		"segunda-feira",
+		"terça-feira",
+		"quarta-feira",
+		"quinta-feira",
+		"sexta-feira",
+		"sábado"
+	],
+	"dateFormatItem-yyyyMMM": "MMM 'de' y",
+	"dateFormatItem-yyMMMEEEd": "EEE, d 'de' MMM 'de' yy",
+	"dateFormatItem-yyMMM": "MMM 'de' yy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH'h'mm",
+	"quarters-standAlone-abbr": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"eraAbbr": [
+		"a.C.",
+		"d.C."
+	],
+	"field-minute": "Minuto",
+	"field-dayperiod": "Período do dia",
+	"days-standAlone-abbr": [
+		"dom",
+		"seg",
+		"ter",
+		"qua",
+		"qui",
+		"sex",
+		"sáb"
+	],
+	"dayPeriods-format-wide-night": "noite",
+	"dateFormatItem-yyMMMd": "d 'de' MMM 'de' yy",
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm'min'ss's'",
+	"field-day-relative+-1": "Ontem",
+	"field-day-relative+-2": "Anteontem",
+	"field-day-relative+-3": "Há três dias",
+	"dateFormatItem-MMMd": "d 'de' MMM",
+	"dateFormatItem-MEd": "EEE, dd/MM",
+	"field-day": "Dia",
+	"days-format-wide": [
+		"domingo",
+		"segunda-feira",
+		"terça-feira",
+		"quarta-feira",
+		"quinta-feira",
+		"sexta-feira",
+		"sábado"
+	],
+	"field-zone": "Fuso",
+	"dateFormatItem-yyyyMM": "MM/yyyy",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-yyMM": "MM/yy",
+	"days-format-abbr": [
+		"dom",
+		"seg",
+		"ter",
+		"qua",
+		"qui",
+		"sex",
+		"sáb"
+	],
+	"eraNames": [
+		"Antes de Cristo",
+		"Ano do Senhor"
+	],
+	"days-format-narrow": [
+		"D",
+		"S",
+		"T",
+		"Q",
+		"Q",
+		"S",
+		"S"
+	],
+	"field-month": "Mês",
+	"days-standAlone-narrow": [
+		"D",
+		"S",
+		"T",
+		"Q",
+		"Q",
+		"S",
+		"S"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dateFormatItem-HHmm": "HH'h'mm",
+	"dateFormat-short": "dd/MM/yy",
+	"dayPeriods-format-wide-afternoon": "tarde",
+	"field-second": "Segundo",
+	"dateFormatItem-yMMMEd": "EEE, d 'de' MMM 'de' y",
+	"field-week": "Semana",
+	"dateFormat-medium": "dd/MM/yyyy"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/pt/number.js b/js/dojo-1.7.2/dojo/cldr/nls/pt/number.js
new file mode 100644
index 0000000..832f6dc
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/pt/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/pt/number", //begin v1.x content
+{
+	"group": ".",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "¤#,##0.00;(¤#,##0.00)",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ro/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/ro/buddhist.js
new file mode 100644
index 0000000..be957fb
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ro/buddhist.js
@@ -0,0 +1,122 @@
+//>>built
+define(
+"dojo/cldr/nls/ro/buddhist", //begin v1.x content
+{
+	"quarters-format-abbr": [
+		"trim. I",
+		"trim. II",
+		"trim. III",
+		"trim. IV"
+	],
+	"dateFormat-medium": "d MMM y G",
+	"dateFormatItem-MMMEd": "E, d MMM",
+	"dateFormatItem-MEd": "E, d MMM",
+	"dateFormatItem-yMEd": "EEE, d/M/yyyy",
+	"eraNarrow": [
+		"e.b."
+	],
+	"dateTimeFormat-medium": "{1}, {0}",
+	"dateFormatItem-Md": "d.M",
+	"months-standAlone-narrow": [
+		"I",
+		"F",
+		"M",
+		"A",
+		"M",
+		"I",
+		"I",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-EEEd": "EEE d",
+	"eraNames": [
+		"era budistă"
+	],
+	"days-standAlone-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"J",
+		"V",
+		"S"
+	],
+	"dateTimeFormat-long": "{1}, {0}",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"quarters-standAlone-narrow": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"dateFormat-long": "d MMMM y G",
+	"dateFormat-short": "d/M/yyyy",
+	"dateFormatItem-yMMMEd": "EEE, d MMM y",
+	"dateTimeFormat-short": "{1}, {0}",
+	"months-format-wide": [
+		"ianuarie",
+		"februarie",
+		"martie",
+		"aprilie",
+		"mai",
+		"iunie",
+		"iulie",
+		"august",
+		"septembrie",
+		"octombrie",
+		"noiembrie",
+		"decembrie"
+	],
+	"dateTimeFormat-full": "{1}, {0}",
+	"dateFormatItem-yM": "M.yyyy",
+	"months-format-abbr": [
+		"ian.",
+		"feb.",
+		"mar.",
+		"apr.",
+		"mai",
+		"iun.",
+		"iul.",
+		"aug.",
+		"sept.",
+		"oct.",
+		"nov.",
+		"dec."
+	],
+	"eraAbbr": [
+		"e.b."
+	],
+	"days-format-wide": [
+		"duminică",
+		"luni",
+		"marți",
+		"miercuri",
+		"joi",
+		"vineri",
+		"sâmbătă"
+	],
+	"dateFormatItem-yQ": "'trimestrul' Q y",
+	"dateFormatItem-yMMM": "MMM y",
+	"quarters-format-wide": [
+		"trimestrul I",
+		"trimestrul al II-lea",
+		"trimestrul al III-lea",
+		"trimestrul al IV-lea"
+	],
+	"dateFormat-full": "EEEE, d MMMM, y G",
+	"dateFormatItem-MMMd": "d MMM",
+	"days-format-abbr": [
+		"Du",
+		"Lu",
+		"Ma",
+		"Mi",
+		"Jo",
+		"Vi",
+		"Sâ"
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ro/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/ro/currency.js
new file mode 100644
index 0000000..ed73c47
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ro/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/ro/currency", //begin v1.x content
+{
+	"HKD_displayName": "dolar Hong Kong",
+	"CHF_displayName": "franc elvețian",
+	"CAD_displayName": "dolar canadian",
+	"CNY_displayName": "yuan renminbi chinezesc",
+	"AUD_displayName": "dolar australian",
+	"JPY_displayName": "yen japonez",
+	"USD_displayName": "dolar american",
+	"GBP_displayName": "liră sterlină",
+	"EUR_displayName": "euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ro/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/ro/gregorian.js
new file mode 100644
index 0000000..d340721
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ro/gregorian.js
@@ -0,0 +1,252 @@
+//>>built
+define(
+"dojo/cldr/nls/ro/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"I",
+		"F",
+		"M",
+		"A",
+		"M",
+		"I",
+		"I",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"quarters-standAlone-narrow": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"field-weekday": "zi a săptămânii",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "EEE, d/M/yyyy",
+	"dateFormatItem-MMMEd": "E, d MMM",
+	"eraNarrow": [
+		"î.Hr.",
+		"d.Hr."
+	],
+	"dateFormat-long": "d MMMM y",
+	"months-format-wide": [
+		"ianuarie",
+		"februarie",
+		"martie",
+		"aprilie",
+		"mai",
+		"iunie",
+		"iulie",
+		"august",
+		"septembrie",
+		"octombrie",
+		"noiembrie",
+		"decembrie"
+	],
+	"dateTimeFormat-medium": "{1}, {0}",
+	"dateFormatItem-EEEd": "EEE d",
+	"dayPeriods-format-wide-pm": "PM",
+	"dateFormat-full": "EEEE, d MMMM y",
+	"dateFormatItem-Md": "d.M",
+	"field-era": "eră",
+	"dateFormatItem-yM": "M.yyyy",
+	"months-standAlone-wide": [
+		"ianuarie",
+		"februarie",
+		"martie",
+		"aprilie",
+		"mai",
+		"iunie",
+		"iulie",
+		"august",
+		"septembrie",
+		"octombrie",
+		"noiembrie",
+		"decembrie"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"trimestrul I",
+		"trimestrul al II-lea",
+		"trimestrul al III-lea",
+		"trimestrul al IV-lea"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "an",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "'trimestrul' Q y",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"field-hour": "oră",
+	"dateFormatItem-MMdd": "dd.MM",
+	"months-format-abbr": [
+		"ian.",
+		"feb.",
+		"mar.",
+		"apr.",
+		"mai",
+		"iun.",
+		"iul.",
+		"aug.",
+		"sept.",
+		"oct.",
+		"nov.",
+		"dec."
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"field-day-relative+0": "azi",
+	"field-day-relative+1": "mâine",
+	"field-day-relative+2": "poimâine",
+	"field-day-relative+3": "răspoimâine",
+	"months-standAlone-abbr": [
+		"ian.",
+		"feb.",
+		"mar.",
+		"apr.",
+		"mai",
+		"iun.",
+		"iul.",
+		"aug.",
+		"sept.",
+		"oct.",
+		"nov.",
+		"dec."
+	],
+	"quarters-format-abbr": [
+		"trim. I",
+		"trim. II",
+		"trim. III",
+		"trim. IV"
+	],
+	"quarters-standAlone-wide": [
+		"trimestrul I",
+		"trimestrul al II-lea",
+		"trimestrul al III-lea",
+		"trimestrul al IV-lea"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"duminică",
+		"luni",
+		"marți",
+		"miercuri",
+		"joi",
+		"vineri",
+		"sâmbătă"
+	],
+	"dateFormatItem-MMMMd": "d MMMM",
+	"dateFormatItem-yyMMM": "MMM yy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"trim. I",
+		"trim. II",
+		"trim. III",
+		"trim. IV"
+	],
+	"eraAbbr": [
+		"î.Hr.",
+		"d.Hr."
+	],
+	"field-minute": "minut",
+	"field-dayperiod": "perioada zilei",
+	"days-standAlone-abbr": [
+		"Du",
+		"Lu",
+		"Ma",
+		"Mi",
+		"Jo",
+		"Vi",
+		"Sâ"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"quarters-format-narrow": [
+		"T1",
+		"T2",
+		"T3",
+		"T4"
+	],
+	"field-day-relative+-1": "ieri",
+	"dateTimeFormat-long": "{1}, {0}",
+	"field-day-relative+-2": "alaltăieri",
+	"field-day-relative+-3": "răsalaltăieri",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-MEd": "E, d MMM",
+	"dateTimeFormat-full": "{1}, {0}",
+	"dateFormatItem-yMMMM": "MMMM y",
+	"field-day": "zi",
+	"days-format-wide": [
+		"duminică",
+		"luni",
+		"marți",
+		"miercuri",
+		"joi",
+		"vineri",
+		"sâmbătă"
+	],
+	"field-zone": "zonă",
+	"dateFormatItem-yyyyMM": "MM.yyyy",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"I",
+		"F",
+		"M",
+		"A",
+		"M",
+		"I",
+		"I",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-yyMM": "MM.yy",
+	"days-format-abbr": [
+		"Du",
+		"Lu",
+		"Ma",
+		"Mi",
+		"Jo",
+		"Vi",
+		"Sâ"
+	],
+	"eraNames": [
+		"înainte de Hristos",
+		"după Hristos"
+	],
+	"days-format-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"J",
+		"V",
+		"S"
+	],
+	"field-month": "lună",
+	"days-standAlone-narrow": [
+		"D",
+		"L",
+		"M",
+		"M",
+		"J",
+		"V",
+		"S"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "AM",
+	"dateFormatItem-MMMMEd": "E, d MMMM",
+	"dateFormat-short": "dd.MM.yyyy",
+	"field-second": "secundă",
+	"dateFormatItem-yMMMEd": "EEE, d MMM y",
+	"field-week": "săptămână",
+	"dateFormat-medium": "dd.MM.yyyy",
+	"dateTimeFormat-short": "{1}, {0}",
+	"dateFormatItem-MMMEEEd": "EEE, d MMM"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ro/number.js b/js/dojo-1.7.2/dojo/cldr/nls/ro/number.js
new file mode 100644
index 0000000..e0d5442
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ro/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/ro/number", //begin v1.x content
+{
+	"group": ".",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ru/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/ru/currency.js
new file mode 100644
index 0000000..2c1dcc2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ru/currency.js
@@ -0,0 +1,17 @@
+//>>built
+define(
+"dojo/cldr/nls/ru/currency", //begin v1.x content
+{
+	"HKD_displayName": "Гонконг�кий доллар",
+	"CHF_displayName": "Швейцар�кий франк",
+	"CAD_displayName": "Канад�кий доллар",
+	"CNY_displayName": "Юань Ренминби",
+	"USD_symbol": "$",
+	"AUD_displayName": "�в�тралий�кий доллар",
+	"JPY_displayName": "Япон�ка� иена",
+	"USD_displayName": "Доллар СШ�",
+	"GBP_displayName": "�нглий�кий фунт �терлингов",
+	"EUR_displayName": "Евро"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ru/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/ru/gregorian.js
new file mode 100644
index 0000000..6701f00
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ru/gregorian.js
@@ -0,0 +1,233 @@
+//>>built
+define(
+"dojo/cldr/nls/ru/gregorian", //begin v1.x content
+{
+	"dateFormatItem-yM": "M.y",
+	"field-dayperiod": "AM/PM",
+	"field-minute": "Минута",
+	"eraNames": [
+		"до н.�.",
+		"н.�."
+	],
+	"dateFormatItem-MMMEd": "ccc, d MMM",
+	"field-day-relative+-1": "Вчера",
+	"field-weekday": "День недели",
+	"dateFormatItem-yQQQ": "y QQQ",
+	"field-day-relative+-2": "Позавчера",
+	"dateFormatItem-MMdd": "dd.MM",
+	"days-standAlone-wide": [
+		"Во�кре�енье",
+		"Понедельник",
+		"Вторник",
+		"Среда",
+		"Четверг",
+		"П�тница",
+		"Суббота"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"months-standAlone-narrow": [
+		"Я",
+		"Ф",
+		"М",
+		"�",
+		"М",
+		"И",
+		"И",
+		"�",
+		"С",
+		"О",
+		"�",
+		"Д"
+	],
+	"field-era": "Эра",
+	"field-hour": "Ча�",
+	"quarters-standAlone-abbr": [
+		"1-й кв.",
+		"2-й кв.",
+		"3-й кв.",
+		"4-й кв."
+	],
+	"dateFormatItem-yyMMMEEEd": "EEE, d MMM yy",
+	"dateFormatItem-y": "y",
+	"timeFormat-full": "H:mm:ss zzzz",
+	"dateFormatItem-yyyy": "y",
+	"months-standAlone-abbr": [
+		"�нв.",
+		"февр.",
+		"март",
+		"апр.",
+		"май",
+		"июнь",
+		"июль",
+		"авг.",
+		"�ент.",
+		"окт.",
+		"но�б.",
+		"дек."
+	],
+	"dateFormatItem-Ed": "E, d",
+	"dateFormatItem-yMMM": "LLL y",
+	"field-day-relative+0": "Сегодн�",
+	"dateFormatItem-yyyyLLLL": "LLLL y",
+	"field-day-relative+1": "Завтра",
+	"days-standAlone-narrow": [
+		"Ð’",
+		"П",
+		"Ð’",
+		"С",
+		"Ч",
+		"П",
+		"С"
+	],
+	"eraAbbr": [
+		"до н.�.",
+		"н.�."
+	],
+	"field-day-relative+2": "По�лезавтра",
+	"dateFormatItem-yyyyMM": "MM.yyyy",
+	"dateFormatItem-yyyyMMMM": "LLLL y",
+	"dateFormat-long": "d MMMM y 'г'.",
+	"timeFormat-medium": "H:mm:ss",
+	"field-zone": "Ча�овой по��",
+	"dateFormatItem-Hm": "H:mm",
+	"dateFormat-medium": "dd.MM.yyyy",
+	"dateFormatItem-yyMM": "MM.yy",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"dateFormatItem-yyMMM": "LLL yy",
+	"quarters-standAlone-wide": [
+		"1-й квартал",
+		"2-й квартал",
+		"3-й квартал",
+		"4-й квартал"
+	],
+	"dateFormatItem-ms": "mm:ss",
+	"dateFormatItem-yyyyQQQQ": "QQQQ y 'г'.",
+	"field-year": "Год",
+	"months-standAlone-wide": [
+		"Январь",
+		"Февраль",
+		"Март",
+		"�прель",
+		"Май",
+		"Июнь",
+		"Июль",
+		"�вгу�т",
+		"Сент�брь",
+		"Окт�брь",
+		"�о�брь",
+		"Декабрь"
+	],
+	"field-week": "�едел�",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-long": "H:mm:ss z",
+	"months-format-abbr": [
+		"�нв.",
+		"февр.",
+		"марта",
+		"апр.",
+		"ма�",
+		"июн�",
+		"июл�",
+		"авг.",
+		"�ент.",
+		"окт.",
+		"но�б.",
+		"дек."
+	],
+	"timeFormat-short": "H:mm",
+	"dateFormatItem-H": "H",
+	"field-month": "Ме��ц",
+	"quarters-format-abbr": [
+		"1-й кв.",
+		"2-й кв.",
+		"3-й кв.",
+		"4-й кв."
+	],
+	"days-format-abbr": [
+		"в�",
+		"пн",
+		"вт",
+		"�р",
+		"чт",
+		"пт",
+		"�б"
+	],
+	"dateFormatItem-M": "L",
+	"days-format-narrow": [
+		"Ð’",
+		"П",
+		"Ð’",
+		"С",
+		"Ч",
+		"П",
+		"С"
+	],
+	"field-second": "Секунда",
+	"field-day": "День",
+	"dateFormatItem-MEd": "E, d.M",
+	"months-format-narrow": [
+		"Я",
+		"Ф",
+		"М",
+		"�",
+		"М",
+		"И",
+		"И",
+		"�",
+		"С",
+		"О",
+		"�",
+		"Д"
+	],
+	"days-standAlone-abbr": [
+		"В�",
+		"Пн",
+		"Ð’Ñ‚",
+		"Ср",
+		"Чт",
+		"Пт",
+		"Сб"
+	],
+	"dateFormat-short": "dd.MM.yy",
+	"dateFormatItem-yMMMEd": "E, d MMM y",
+	"dateFormat-full": "EEEE, d MMMM y 'г'.",
+	"dateFormatItem-Md": "d.M",
+	"dateFormatItem-yMEd": "EEE, d.M.y",
+	"months-format-wide": [
+		"�нвар�",
+		"феврал�",
+		"марта",
+		"апрел�",
+		"ма�",
+		"июн�",
+		"июл�",
+		"авгу�та",
+		"�ент�бр�",
+		"окт�бр�",
+		"но�бр�",
+		"декабр�"
+	],
+	"dateFormatItem-d": "d",
+	"quarters-format-wide": [
+		"1-й квартал",
+		"2-й квартал",
+		"3-й квартал",
+		"4-й квартал"
+	],
+	"days-format-wide": [
+		"во�кре�енье",
+		"понедельник",
+		"вторник",
+		"�реда",
+		"четверг",
+		"п�тница",
+		"�уббота"
+	],
+	"eraNarrow": [
+		"до н.�.",
+		"н.�."
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/ru/number.js b/js/dojo-1.7.2/dojo/cldr/nls/ru/number.js
new file mode 100644
index 0000000..90b359b
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/ru/number.js
@@ -0,0 +1,22 @@
+//>>built
+define(
+"dojo/cldr/nls/ru/number", //begin v1.x content
+{
+	"group": " ",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0 %",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/sk/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/sk/currency.js
new file mode 100644
index 0000000..a176747
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/sk/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/sk/currency", //begin v1.x content
+{
+	"HKD_displayName": "Hong Kongský dolár",
+	"CHF_displayName": "Švaj�iarský frank",
+	"CAD_displayName": "Kanadský dolár",
+	"CNY_displayName": "Čínsky Yuan Renminbi",
+	"AUD_displayName": "Austrálsky dolár",
+	"JPY_displayName": "Japonský yen",
+	"USD_displayName": "US dolár",
+	"GBP_displayName": "Britská libra",
+	"EUR_displayName": "Euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/sk/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/sk/gregorian.js
new file mode 100644
index 0000000..fcad5d2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/sk/gregorian.js
@@ -0,0 +1,226 @@
+//>>built
+define(
+"dojo/cldr/nls/sk/gregorian", //begin v1.x content
+{
+	"field-dayperiod": "Časť dňa",
+	"dateFormatItem-yQ": "Q yyyy",
+	"dayPeriods-format-wide-pm": "popoludní",
+	"field-minute": "Minúta",
+	"eraNames": [
+		"pred n.l.",
+		"n.l."
+	],
+	"dateFormatItem-MMMEd": "E, d. MMM",
+	"field-day-relative+-1": "V�era",
+	"field-weekday": "Deň v týždni",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"field-day-relative+-2": "Predv�erom",
+	"field-day-relative+-3": "Pred tromi dňami",
+	"days-standAlone-wide": [
+		"nedeľa",
+		"pondelok",
+		"utorok",
+		"streda",
+		"Å¡tvrtok",
+		"piatok",
+		"sobota"
+	],
+	"months-standAlone-narrow": [
+		"j",
+		"f",
+		"m",
+		"a",
+		"m",
+		"j",
+		"j",
+		"a",
+		"s",
+		"o",
+		"n",
+		"d"
+	],
+	"field-era": "Éra",
+	"field-hour": "Hodina",
+	"dayPeriods-format-wide-am": "dopoludnia",
+	"timeFormat-full": "H:mm:ss zzzz",
+	"months-standAlone-abbr": [
+		"jan",
+		"feb",
+		"mar",
+		"apr",
+		"máj",
+		"jún",
+		"júl",
+		"aug",
+		"sep",
+		"okt",
+		"nov",
+		"dec"
+	],
+	"dateFormatItem-yMMM": "LLL y",
+	"field-day-relative+0": "Dnes",
+	"field-day-relative+1": "Zajtra",
+	"days-standAlone-narrow": [
+		"N",
+		"P",
+		"U",
+		"S",
+		"Å ",
+		"P",
+		"S"
+	],
+	"eraAbbr": [
+		"pred n.l.",
+		"n.l."
+	],
+	"field-day-relative+2": "Pozajtra",
+	"field-day-relative+3": "O tri dni",
+	"dateFormatItem-yyyyMMMM": "LLLL y",
+	"dateFormat-long": "d. MMMM y",
+	"timeFormat-medium": "H:mm:ss",
+	"dateFormatItem-EEEd": "EEE, d.",
+	"field-zone": "Pásmo",
+	"dateFormatItem-Hm": "H:mm",
+	"dateFormat-medium": "d.M.yyyy",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"dateFormatItem-yyQQQQ": "QQQQ yy",
+	"quarters-standAlone-wide": [
+		"1. štvrťrok",
+		"2. štvrťrok",
+		"3. štvrťrok",
+		"4. štvrťrok"
+	],
+	"dateFormatItem-yMMMM": "LLLL y",
+	"dateFormatItem-ms": "mm:ss",
+	"field-year": "Rok",
+	"months-standAlone-wide": [
+		"január",
+		"február",
+		"marec",
+		"apríl",
+		"máj",
+		"jún",
+		"júl",
+		"august",
+		"september",
+		"október",
+		"november",
+		"december"
+	],
+	"field-week": "Týždeň",
+	"dateFormatItem-MMMMEd": "E, d. MMMM",
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-long": "H:mm:ss z",
+	"months-format-abbr": [
+		"jan",
+		"feb",
+		"mar",
+		"apr",
+		"máj",
+		"jún",
+		"júl",
+		"aug",
+		"sep",
+		"okt",
+		"nov",
+		"dec"
+	],
+	"timeFormat-short": "H:mm",
+	"dateFormatItem-H": "H",
+	"field-month": "Mesiac",
+	"dateFormatItem-MMMMd": "d. MMMM",
+	"quarters-format-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"days-format-abbr": [
+		"ne",
+		"po",
+		"ut",
+		"st",
+		"Å¡t",
+		"pi",
+		"so"
+	],
+	"dateFormatItem-mmss": "mm:ss",
+	"days-format-narrow": [
+		"N",
+		"P",
+		"U",
+		"S",
+		"Å ",
+		"P",
+		"S"
+	],
+	"field-second": "Sekunda",
+	"field-day": "Deň",
+	"dateFormatItem-MEd": "E, d.M.",
+	"months-format-narrow": [
+		"j",
+		"f",
+		"m",
+		"a",
+		"m",
+		"j",
+		"j",
+		"a",
+		"s",
+		"o",
+		"n",
+		"d"
+	],
+	"days-standAlone-abbr": [
+		"ne",
+		"po",
+		"ut",
+		"st",
+		"Å¡t",
+		"pi",
+		"so"
+	],
+	"dateFormat-short": "d.M.yyyy",
+	"dateFormatItem-yyyyM": "M.yyyy",
+	"dateFormatItem-yMMMEd": "EEE, d. MMM y",
+	"dateFormat-full": "EEEE, d. MMMM y",
+	"dateFormatItem-Md": "d.M.",
+	"dateFormatItem-yMEd": "EEE, d.M.yyyy",
+	"months-format-wide": [
+		"januára",
+		"februára",
+		"marca",
+		"apríla",
+		"mája",
+		"júna",
+		"júla",
+		"augusta",
+		"septembra",
+		"októbra",
+		"novembra",
+		"decembra"
+	],
+	"dateFormatItem-d": "d.",
+	"quarters-format-wide": [
+		"1. štvrťrok",
+		"2. štvrťrok",
+		"3. štvrťrok",
+		"4. štvrťrok"
+	],
+	"days-format-wide": [
+		"nedeľa",
+		"pondelok",
+		"utorok",
+		"streda",
+		"Å¡tvrtok",
+		"piatok",
+		"sobota"
+	],
+	"eraNarrow": [
+		"pred n.l.",
+		"n.l."
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/sk/number.js b/js/dojo-1.7.2/dojo/cldr/nls/sk/number.js
new file mode 100644
index 0000000..7fede5f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/sk/number.js
@@ -0,0 +1,10 @@
+//>>built
+define(
+"dojo/cldr/nls/sk/number", //begin v1.x content
+{
+	"currencyFormat": "#,##0.00 ¤",
+	"group": " ",
+	"decimal": ","
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/sl/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/sl/currency.js
new file mode 100644
index 0000000..c773125
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/sl/currency.js
@@ -0,0 +1,18 @@
+//>>built
+define(
+"dojo/cldr/nls/sl/currency", //begin v1.x content
+{
+	"HKD_displayName": "hongkonški dolar",
+	"CHF_displayName": "Å¡vicarski frank",
+	"JPY_symbol": "Â¥",
+	"CAD_displayName": "kanadski dolar",
+	"CNY_displayName": "kitajski juan renminbi",
+	"USD_symbol": "$",
+	"AUD_displayName": "avstralski dolar",
+	"JPY_displayName": "japonski jen",
+	"USD_displayName": "ameriški dolar",
+	"GBP_displayName": "britanski funt",
+	"EUR_displayName": "evro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/sl/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/sl/gregorian.js
new file mode 100644
index 0000000..9c8be6b
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/sl/gregorian.js
@@ -0,0 +1,219 @@
+//>>built
+define(
+"dojo/cldr/nls/sl/gregorian", //begin v1.x content
+{
+	"field-dayperiod": "ÄŒas dneva",
+	"dayPeriods-format-wide-pm": "pop.",
+	"field-minute": "Minuta",
+	"eraNames": [
+		"pred našim štetjem",
+		"naše štetje"
+	],
+	"dateFormatItem-MMMEd": "E., d. MMM",
+	"field-day-relative+-1": "V�eraj",
+	"field-weekday": "Dan v tednu",
+	"field-day-relative+-2": "Predv�erajšnjim",
+	"field-day-relative+-3": "Pred tremi dnevi",
+	"days-standAlone-wide": [
+		"nedelja",
+		"ponedeljek",
+		"torek",
+		"sreda",
+		"�etrtek",
+		"petek",
+		"sobota"
+	],
+	"months-standAlone-narrow": [
+		"j",
+		"f",
+		"m",
+		"a",
+		"m",
+		"j",
+		"j",
+		"a",
+		"s",
+		"o",
+		"n",
+		"d"
+	],
+	"field-era": "Doba",
+	"field-hour": "Ura",
+	"dayPeriods-format-wide-am": "dop.",
+	"dateFormatItem-y": "y",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"months-standAlone-abbr": [
+		"jan",
+		"feb",
+		"mar",
+		"apr",
+		"maj",
+		"jun",
+		"jul",
+		"avg",
+		"sep",
+		"okt",
+		"nov",
+		"dec"
+	],
+	"dateFormatItem-Ed": "E., d.",
+	"dateFormatItem-yMMM": "MMM y",
+	"field-day-relative+0": "Danes",
+	"field-day-relative+1": "Jutri",
+	"days-standAlone-narrow": [
+		"n",
+		"p",
+		"t",
+		"s",
+		"�",
+		"p",
+		"s"
+	],
+	"eraAbbr": [
+		"pr. n. Å¡t.",
+		"po Kr."
+	],
+	"field-day-relative+2": "Pojutrišnjem",
+	"field-day-relative+3": "ÄŒez tri dni",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"dateFormat-long": "dd. MMMM y",
+	"timeFormat-medium": "HH:mm:ss",
+	"field-zone": "Obmo�je",
+	"dateFormatItem-Hm": "HH:mm",
+	"dateFormat-medium": "d. MMM yyyy",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"quarters-standAlone-wide": [
+		"1. �etrtletje",
+		"2. �etrtletje",
+		"3. �etrtletje",
+		"4. �etrtletje"
+	],
+	"dateFormatItem-ms": "mm:ss",
+	"field-year": "Leto",
+	"field-week": "Teden",
+	"months-standAlone-wide": [
+		"januar",
+		"februar",
+		"marec",
+		"april",
+		"maj",
+		"junij",
+		"julij",
+		"avgust",
+		"september",
+		"oktober",
+		"november",
+		"december"
+	],
+	"dateFormatItem-MMMd": "d. MMM",
+	"dateFormatItem-yyQ": "Q/yy",
+	"timeFormat-long": "HH:mm:ss z",
+	"months-format-abbr": [
+		"jan.",
+		"feb.",
+		"mar.",
+		"apr.",
+		"maj",
+		"jun.",
+		"jul.",
+		"avg.",
+		"sep.",
+		"okt.",
+		"nov.",
+		"dec."
+	],
+	"timeFormat-short": "HH:mm",
+	"field-month": "Mesec",
+	"quarters-format-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"days-format-abbr": [
+		"ned",
+		"pon",
+		"tor",
+		"sre",
+		"�et",
+		"pet",
+		"sob"
+	],
+	"dateFormatItem-mmss": "mm:ss",
+	"days-format-narrow": [
+		"n",
+		"p",
+		"t",
+		"s",
+		"�",
+		"p",
+		"s"
+	],
+	"field-second": "Sekunda",
+	"field-day": "Dan",
+	"dateFormatItem-MEd": "E., d. MM.",
+	"months-format-narrow": [
+		"j",
+		"f",
+		"m",
+		"a",
+		"m",
+		"j",
+		"j",
+		"a",
+		"s",
+		"o",
+		"n",
+		"d"
+	],
+	"days-standAlone-abbr": [
+		"ned",
+		"pon",
+		"tor",
+		"sre",
+		"�et",
+		"pet",
+		"sob"
+	],
+	"dateFormat-short": "d. MM. yy",
+	"dateFormatItem-yyyyM": "M/yyyy",
+	"dateFormatItem-yMMMEd": "E., d. MMM y",
+	"dateFormat-full": "EEEE, dd. MMMM y",
+	"dateFormatItem-Md": "d. M.",
+	"dateFormatItem-yMEd": "E., d. M. y",
+	"months-format-wide": [
+		"januar",
+		"februar",
+		"marec",
+		"april",
+		"maj",
+		"junij",
+		"julij",
+		"avgust",
+		"september",
+		"oktober",
+		"november",
+		"december"
+	],
+	"quarters-format-wide": [
+		"1. �etrtletje",
+		"2. �etrtletje",
+		"3. �etrtletje",
+		"4. �etrtletje"
+	],
+	"days-format-wide": [
+		"nedelja",
+		"ponedeljek",
+		"torek",
+		"sreda",
+		"�etrtek",
+		"petek",
+		"sobota"
+	],
+	"eraNarrow": [
+		"pr. n. Å¡t.",
+		"po Kr."
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/sl/number.js b/js/dojo-1.7.2/dojo/cldr/nls/sl/number.js
new file mode 100644
index 0000000..04e7c31
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/sl/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/sl/number", //begin v1.x content
+{
+	"group": ".",
+	"percentSign": "%",
+	"exponential": "e",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/sv/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/sv/currency.js
new file mode 100644
index 0000000..a4324cb
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/sv/currency.js
@@ -0,0 +1,19 @@
+//>>built
+define(
+"dojo/cldr/nls/sv/currency", //begin v1.x content
+{
+	"HKD_displayName": "Hongkong-dollar",
+	"CHF_displayName": "schweizisk franc",
+	"CHF_symbol": "CHF",
+	"CAD_displayName": "kanadensisk dollar",
+	"CNY_displayName": "kinesisk yuan renminbi",
+	"AUD_displayName": "australisk dollar",
+	"JPY_displayName": "japansk yen",
+	"CAD_symbol": "CAD",
+	"USD_displayName": "US-dollar",
+	"CNY_symbol": "CNY",
+	"GBP_displayName": "brittiskt pund sterling",
+	"EUR_displayName": "euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/sv/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/sv/gregorian.js
new file mode 100644
index 0000000..903b296
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/sv/gregorian.js
@@ -0,0 +1,246 @@
+//>>built
+define(
+"dojo/cldr/nls/sv/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"quarters-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4"
+	],
+	"field-weekday": "veckodag",
+	"dateFormatItem-yQQQ": "y QQQ",
+	"dateFormatItem-yMEd": "EEE, yyyy-MM-dd",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"eraNarrow": [
+		"f.Kr.",
+		"e.Kr."
+	],
+	"dateFormat-long": "d MMMM y",
+	"months-format-wide": [
+		"januari",
+		"februari",
+		"mars",
+		"april",
+		"maj",
+		"juni",
+		"juli",
+		"augusti",
+		"september",
+		"oktober",
+		"november",
+		"december"
+	],
+	"dateFormatItem-EEEd": "EEE d",
+	"dayPeriods-format-wide-pm": "em",
+	"dateFormat-full": "EEEE'en' 'den' d:'e' MMMM y",
+	"dateFormatItem-Md": "d/M",
+	"dateFormatItem-MMMMEEEd": "EEE d MMMM",
+	"field-era": "era",
+	"dateFormatItem-yM": "yyyy-MM",
+	"months-standAlone-wide": [
+		"januari",
+		"februari",
+		"mars",
+		"april",
+		"maj",
+		"juni",
+		"juli",
+		"augusti",
+		"september",
+		"oktober",
+		"november",
+		"december"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"1:a kvartalet",
+		"2:a kvartalet",
+		"3:e kvartalet",
+		"4:e kvartalet"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "Ã¥r",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "yyyy Q",
+	"field-hour": "timme",
+	"dateFormatItem-MMdd": "dd/MM",
+	"months-format-abbr": [
+		"jan",
+		"feb",
+		"mar",
+		"apr",
+		"maj",
+		"jun",
+		"jul",
+		"aug",
+		"sep",
+		"okt",
+		"nov",
+		"dec"
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "'kl'. HH:mm:ss zzzz",
+	"field-day-relative+0": "i dag",
+	"field-day-relative+1": "i morgon",
+	"field-day-relative+2": "i övermorgon",
+	"field-day-relative+3": "i överövermorgon",
+	"months-standAlone-abbr": [
+		"jan",
+		"feb",
+		"mar",
+		"apr",
+		"maj",
+		"jun",
+		"jul",
+		"aug",
+		"sep",
+		"okt",
+		"nov",
+		"dec"
+	],
+	"quarters-format-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"quarters-standAlone-wide": [
+		"1:a kvartalet",
+		"2:a kvartalet",
+		"3:e kvartalet",
+		"4:e kvartalet"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"söndag",
+		"måndag",
+		"tisdag",
+		"onsdag",
+		"torsdag",
+		"fredag",
+		"lördag"
+	],
+	"dateFormatItem-yyyyMMM": "MMM y",
+	"dateFormatItem-MMMMd": "d:'e' MMMM",
+	"dateFormatItem-yyMMM": "MMM -yy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"K1",
+		"K2",
+		"K3",
+		"K4"
+	],
+	"eraAbbr": [
+		"f.Kr.",
+		"e.Kr."
+	],
+	"field-minute": "minut",
+	"field-dayperiod": "fm/em",
+	"days-standAlone-abbr": [
+		"sön",
+		"mån",
+		"tis",
+		"ons",
+		"tors",
+		"fre",
+		"lör"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "i går",
+	"field-day-relative+-2": "i förrgår",
+	"field-day-relative+-3": "i förrförrgår",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-MEd": "E d/M",
+	"field-day": "dag",
+	"days-format-wide": [
+		"söndag",
+		"måndag",
+		"tisdag",
+		"onsdag",
+		"torsdag",
+		"fredag",
+		"lördag"
+	],
+	"field-zone": "tidszon",
+	"dateFormatItem-yyyyMM": "yyyy-MM",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"J",
+		"F",
+		"M",
+		"A",
+		"M",
+		"J",
+		"J",
+		"A",
+		"S",
+		"O",
+		"N",
+		"D"
+	],
+	"dateFormatItem-yyMM": "yy-MM",
+	"dateFormatItem-hm": "h:mm a",
+	"days-format-abbr": [
+		"sön",
+		"mån",
+		"tis",
+		"ons",
+		"tors",
+		"fre",
+		"lör"
+	],
+	"eraNames": [
+		"före Kristus",
+		"efter Kristus"
+	],
+	"days-format-narrow": [
+		"S",
+		"M",
+		"T",
+		"O",
+		"T",
+		"F",
+		"L"
+	],
+	"field-month": "månad",
+	"days-standAlone-narrow": [
+		"S",
+		"M",
+		"T",
+		"O",
+		"T",
+		"F",
+		"L"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "fm",
+	"dateFormatItem-MMMMEd": "E d:'e' MMMM",
+	"dateFormat-short": "yyyy-MM-dd",
+	"dateFormatItem-MMd": "d/M",
+	"field-second": "sekund",
+	"dateFormatItem-yMMMEd": "EEE d MMM y",
+	"field-week": "vecka",
+	"dateFormat-medium": "d MMM y",
+	"dateFormatItem-yyyyQQQQ": "QQQQ y",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "h:mm:ss a"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/sv/number.js b/js/dojo-1.7.2/dojo/cldr/nls/sv/number.js
new file mode 100644
index 0000000..0254ce5
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/sv/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/sv/number", //begin v1.x content
+{
+	"group": " ",
+	"percentSign": "%",
+	"exponential": "×10^",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0 %",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "−",
+	"decimal": ",",
+	"nan": "¤¤¤",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/th/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/th/buddhist.js
new file mode 100644
index 0000000..7ca0b7c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/th/buddhist.js
@@ -0,0 +1,119 @@
+//>>built
+define(
+"dojo/cldr/nls/th/buddhist", //begin v1.x content
+{
+	"dateFormatItem-yM": "M/yyyy",
+	"dateFormatItem-yQ": "Q yyyy",
+	"dayPeriods-format-wide-pm": "หลังเที่ยง",
+	"eraNames": [
+		"พุทธศั�ราช"
+	],
+	"dateFormatItem-MMMEd": "E d MMM",
+	"dateTimeFormat-full": "{1}, {0}",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"months-standAlone-narrow": [
+		"ม.ค.",
+		"�.พ.",
+		"มี.ค.",
+		"เม.ย.",
+		"พ.ค.",
+		"มิ.ย.",
+		"�.ค.",
+		"ส.ค.",
+		"�.ย.",
+		"ต.ค.",
+		"พ.ย.",
+		"ธ.ค."
+	],
+	"dateTimeFormat-short": "{1}, {0}",
+	"dayPeriods-format-wide-am": "�่อนเที่ยง",
+	"dateTimeFormat-medium": "{1}, {0}",
+	"timeFormat-full": "H นาฬิ�า m นาที ss วินาที zzzz",
+	"dateFormatItem-yMMM": "MMM y",
+	"days-standAlone-narrow": [
+		"อ",
+		"จ",
+		"อ",
+		"พ",
+		"พ",
+		"ศ",
+		"ส"
+	],
+	"eraAbbr": [
+		"พ.ศ."
+	],
+	"dateFormat-long": "d MMMM y",
+	"timeFormat-medium": "H:mm:ss",
+	"dateFormatItem-EEEd": "EEE d",
+	"dateFormatItem-Hm": "H:mm",
+	"dateFormat-medium": "d MMM y",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"dateTimeFormat-long": "{1}, {0}",
+	"dateFormatItem-MMMd": "d MMM",
+	"timeFormat-long": "H นาฬิ�า m นาที ss วินาที z",
+	"months-format-abbr": [
+		"ม.ค.",
+		"�.พ.",
+		"มี.ค.",
+		"เม.ย.",
+		"พ.ค.",
+		"มิ.ย.",
+		"�.ค.",
+		"ส.ค.",
+		"�.ย.",
+		"ต.ค.",
+		"พ.ย.",
+		"ธ.ค."
+	],
+	"timeFormat-short": "H:mm",
+	"dateFormatItem-H": "H",
+	"days-format-abbr": [
+		"อา.",
+		"จ.",
+		"อ.",
+		"พ.",
+		"พฤ.",
+		"ศ.",
+		"ส."
+	],
+	"dateFormatItem-MEd": "E, d/M",
+	"dateFormat-short": "d/M/yyyy",
+	"dateFormatItem-yMMMEd": "EEE d MMM y",
+	"dateFormat-full": "EEEEที่ d MMMM G y",
+	"dateFormatItem-Md": "d/M",
+	"dateFormatItem-yMEd": "EEE d/M/yyyy",
+	"months-format-wide": [
+		"ม�ราคม",
+		"�ุมภาพันธ์",
+		"มีนาคม",
+		"เมษายน",
+		"พฤษภาคม",
+		"มิถุนายน",
+		"�ร�ฎาคม",
+		"สิงหาคม",
+		"�ันยายน",
+		"ตุลาคม",
+		"พฤศจิ�ายน",
+		"ธันวาคม"
+	],
+	"quarters-format-wide": [
+		"ไตรมาส 1",
+		"ไตรมาส 2",
+		"ไตรมาส 3",
+		"ไตรมาส 4"
+	],
+	"days-format-wide": [
+		"วันอาทิตย์",
+		"วันจันทร์",
+		"วันอังคาร",
+		"วันพุธ",
+		"วันพฤหัสบดี",
+		"วันศุ�ร์",
+		"วันเสาร์"
+	],
+	"eraNarrow": [
+		"พ.ศ."
+	]
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/th/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/th/currency.js
new file mode 100644
index 0000000..e7098a6
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/th/currency.js
@@ -0,0 +1,17 @@
+//>>built
+define(
+"dojo/cldr/nls/th/currency", //begin v1.x content
+{
+	"HKD_displayName": "ดอลลาร์ฮ่อง�ง",
+	"CHF_displayName": "ฟรัง�์สวิส",
+	"JPY_symbol": "Â¥",
+	"CAD_displayName": "ดอลลาร์�คนาดา",
+	"CNY_displayName": "หยวนเหรินหมินปี้ (สาธารณรั�ประชาชนจีน)",
+	"AUD_displayName": "ดอลลาร์ออสเตรเลีย",
+	"JPY_displayName": "เยน�ี่ปุ่น",
+	"USD_displayName": "ดอลลาร์สหรั�",
+	"GBP_displayName": "ปอนด์สเตอร์ลิง (สหราชอาณาจั�ร)",
+	"EUR_displayName": "ยูโร"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/th/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/th/gregorian.js
new file mode 100644
index 0000000..82389f5
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/th/gregorian.js
@@ -0,0 +1,233 @@
+//>>built
+define(
+"dojo/cldr/nls/th/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"ม.ค.",
+		"�.พ.",
+		"มี.ค.",
+		"เม.ย.",
+		"พ.ค.",
+		"มิ.ย.",
+		"�.ค.",
+		"ส.ค.",
+		"�.ย.",
+		"ต.ค.",
+		"พ.ย.",
+		"ธ.ค."
+	],
+	"field-weekday": "วันในสัปดาห์",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "EEE d/M/yyyy",
+	"dateFormatItem-MMMEd": "E d MMM",
+	"eraNarrow": [
+		"�่อน ค.ศ.",
+		"ค.ศ."
+	],
+	"dateFormat-long": "d MMMM y",
+	"months-format-wide": [
+		"ม�ราคม",
+		"�ุมภาพันธ์",
+		"มีนาคม",
+		"เมษายน",
+		"พฤษภาคม",
+		"มิถุนายน",
+		"�ร�ฎาคม",
+		"สิงหาคม",
+		"�ันยายน",
+		"ตุลาคม",
+		"พฤศจิ�ายน",
+		"ธันวาคม"
+	],
+	"dateTimeFormat-medium": "{1}, {0}",
+	"dateFormatItem-EEEd": "EEE d",
+	"dayPeriods-format-wide-pm": "หลังเที่ยง",
+	"dateFormat-full": "EEEEที่ d MMMM G y",
+	"dateFormatItem-Md": "d/M",
+	"field-era": "สมัย",
+	"dateFormatItem-yM": "M/yyyy",
+	"months-standAlone-wide": [
+		"ม�ราคม",
+		"�ุมภาพันธ์",
+		"มีนาคม",
+		"เมษายน",
+		"พฤษภาคม",
+		"มิถุนายน",
+		"�ร�ฎาคม",
+		"สิงหาคม",
+		"�ันยายน",
+		"ตุลาคม",
+		"พฤศจิ�ายน",
+		"ธันวาคม"
+	],
+	"timeFormat-short": "H:mm",
+	"quarters-format-wide": [
+		"ไตรมาส 1",
+		"ไตรมาส 2",
+		"ไตรมาส 3",
+		"ไตรมาส 4"
+	],
+	"timeFormat-long": "H นาฬิ�า m นาที ss วินาที z",
+	"field-year": "ปี",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "Q yyyy",
+	"dateFormatItem-yyyyMMMM": "MMMM y",
+	"field-hour": "ชั่วโมง",
+	"months-format-abbr": [
+		"ม.ค.",
+		"�.พ.",
+		"มี.ค.",
+		"เม.ย.",
+		"พ.ค.",
+		"มิ.ย.",
+		"�.ค.",
+		"ส.ค.",
+		"�.ย.",
+		"ต.ค.",
+		"พ.ย.",
+		"ธ.ค."
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "H นาฬิ�า m นาที ss วินาที zzzz",
+	"field-day-relative+0": "วันนี้",
+	"field-day-relative+1": "พรุ่งนี้",
+	"field-day-relative+2": "มะรืนนี้",
+	"dateFormatItem-H": "H",
+	"field-day-relative+3": "สามวันต่อจา�นี้",
+	"months-standAlone-abbr": [
+		"ม.ค.",
+		"�.พ.",
+		"มี.ค.",
+		"เม.ย.",
+		"พ.ค.",
+		"มิ.ย.",
+		"�.ค.",
+		"ส.ค.",
+		"�.ย.",
+		"ต.ค.",
+		"พ.ย.",
+		"ธ.ค."
+	],
+	"quarters-format-abbr": [
+		"Q1",
+		"Q2",
+		"Q3",
+		"Q4"
+	],
+	"quarters-standAlone-wide": [
+		"ไตรมาส 1",
+		"ไตรมาส 2",
+		"ไตรมาส 3",
+		"ไตรมาส 4"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"วันอาทิตย์",
+		"วันจันทร์",
+		"วันอังคาร",
+		"วันพุธ",
+		"วันพฤหัสบดี",
+		"วันศุ�ร์",
+		"วันเสาร์"
+	],
+	"dateFormatItem-MMMMd": "d MMMM",
+	"timeFormat-medium": "H:mm:ss",
+	"dateFormatItem-Hm": "H:mm",
+	"eraAbbr": [
+		"ปี�่อน ค.ศ.",
+		"ค.ศ."
+	],
+	"field-minute": "นาที",
+	"field-dayperiod": "ช่วงวัน",
+	"days-standAlone-abbr": [
+		"อา.",
+		"จ.",
+		"อ.",
+		"พ.",
+		"พฤ.",
+		"ศ.",
+		"ส."
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "เมื่อวาน",
+	"dateTimeFormat-long": "{1}, {0}",
+	"field-day-relative+-2": "เมื่อวานซืน",
+	"field-day-relative+-3": "สามวัน�่อน",
+	"dateFormatItem-MMMd": "d MMM",
+	"dateFormatItem-MEd": "E, d/M",
+	"dateTimeFormat-full": "{1}, {0}",
+	"dateFormatItem-yMMMM": "MMMM y",
+	"field-day": "วัน",
+	"days-format-wide": [
+		"วันอาทิตย์",
+		"วันจันทร์",
+		"วันอังคาร",
+		"วันพุธ",
+		"วันพฤหัสบดี",
+		"วันศุ�ร์",
+		"วันเสาร์"
+	],
+	"field-zone": "เขต",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"ม.ค.",
+		"�.พ.",
+		"มี.ค.",
+		"เม.ย.",
+		"พ.ค.",
+		"มิ.ย.",
+		"�.ค.",
+		"ส.ค.",
+		"�.ย.",
+		"ต.ค.",
+		"พ.ย.",
+		"ธ.ค."
+	],
+	"days-format-abbr": [
+		"อา.",
+		"จ.",
+		"อ.",
+		"พ.",
+		"พฤ.",
+		"ศ.",
+		"ส."
+	],
+	"eraNames": [
+		"ปี�่อนคริสต์ศั�ราช",
+		"คริสต์ศั�ราช"
+	],
+	"days-format-narrow": [
+		"อ",
+		"จ",
+		"อ",
+		"พ",
+		"พ",
+		"ศ",
+		"ส"
+	],
+	"field-month": "เดือน",
+	"days-standAlone-narrow": [
+		"อ",
+		"จ",
+		"อ",
+		"พ",
+		"พ",
+		"ศ",
+		"ส"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "�่อนเที่ยง",
+	"dateFormatItem-MMMMEd": "E d MMMM",
+	"dateFormat-short": "d/M/yyyy",
+	"field-second": "วินาที",
+	"dateFormatItem-yMMMEd": "EEE d MMM y",
+	"field-week": "สัปดาห์",
+	"dateFormat-medium": "d MMM y",
+	"dateFormatItem-yyyyM": "M/yyyy",
+	"dateFormatItem-mmss": "mm:ss",
+	"dateTimeFormat-short": "{1}, {0}",
+	"dateFormatItem-Hms": "H:mm:ss"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/th/number.js b/js/dojo-1.7.2/dojo/cldr/nls/th/number.js
new file mode 100644
index 0000000..6e6e9a9
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/th/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/th/number", //begin v1.x content
+{
+	"group": ",",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ".",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "¤#,##0.00;¤-#,##0.00",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/tr/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/tr/currency.js
new file mode 100644
index 0000000..0e665d5
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/tr/currency.js
@@ -0,0 +1,18 @@
+//>>built
+define(
+"dojo/cldr/nls/tr/currency", //begin v1.x content
+{
+	"HKD_displayName": "Hong Kong Doları",
+	"CHF_displayName": "İsviçre Frangı",
+	"JPY_symbol": "Â¥",
+	"CAD_displayName": "Kanada Doları",
+	"CNY_displayName": "Çin Yuanı Renminbi",
+	"USD_symbol": "$",
+	"AUD_displayName": "Avustralya Doları",
+	"JPY_displayName": "Japon Yeni",
+	"USD_displayName": "ABD Doları",
+	"GBP_displayName": "Ä°ngiliz Sterlini",
+	"EUR_displayName": "Euro"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/tr/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/tr/gregorian.js
new file mode 100644
index 0000000..304eac0
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/tr/gregorian.js
@@ -0,0 +1,240 @@
+//>>built
+define(
+"dojo/cldr/nls/tr/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"O",
+		"Åž",
+		"M",
+		"N",
+		"M",
+		"H",
+		"T",
+		"A",
+		"E",
+		"E",
+		"K",
+		"A"
+	],
+	"field-weekday": "Haftanın Günü",
+	"dateFormatItem-yyQQQQ": "QQQQ yy",
+	"dateFormatItem-yQQQ": "QQQ y",
+	"dateFormatItem-yMEd": "dd.MM.yyyy EEE",
+	"dateFormatItem-MMMEd": "dd MMM E",
+	"eraNarrow": [
+		"MÖ",
+		"MS"
+	],
+	"dateFormat-long": "dd MMMM y",
+	"months-format-wide": [
+		"Ocak",
+		"Åžubat",
+		"Mart",
+		"Nisan",
+		"Mayıs",
+		"Haziran",
+		"Temmuz",
+		"AÄŸustos",
+		"Eylül",
+		"Ekim",
+		"Kasım",
+		"Aralık"
+	],
+	"dateFormatItem-EEEd": "d EEE",
+	"dayPeriods-format-wide-pm": "PM",
+	"dateFormat-full": "dd MMMM y EEEE",
+	"dateFormatItem-Md": "dd/MM",
+	"field-era": "Miladi Dönem",
+	"dateFormatItem-yM": "M/yyyy",
+	"months-standAlone-wide": [
+		"Ocak",
+		"Åžubat",
+		"Mart",
+		"Nisan",
+		"Mayıs",
+		"Haziran",
+		"Temmuz",
+		"AÄŸustos",
+		"Eylül",
+		"Ekim",
+		"Kasım",
+		"Aralık"
+	],
+	"timeFormat-short": "HH:mm",
+	"quarters-format-wide": [
+		"1. çeyrek",
+		"2. çeyrek",
+		"3. çeyrek",
+		"4. çeyrek"
+	],
+	"timeFormat-long": "HH:mm:ss z",
+	"field-year": "Yıl",
+	"dateFormatItem-yMMM": "MMM y",
+	"dateFormatItem-yQ": "Q yyyy",
+	"field-hour": "Saat",
+	"months-format-abbr": [
+		"Oca",
+		"Åžub",
+		"Mar",
+		"Nis",
+		"May",
+		"Haz",
+		"Tem",
+		"AÄŸu",
+		"Eyl",
+		"Eki",
+		"Kas",
+		"Ara"
+	],
+	"dateFormatItem-yyQ": "Q yy",
+	"timeFormat-full": "HH:mm:ss zzzz",
+	"field-day-relative+0": "Bugün",
+	"field-day-relative+1": "Yarın",
+	"field-day-relative+2": "Yarından sonraki gün",
+	"dateFormatItem-H": "HH",
+	"field-day-relative+3": "Üç gün sonra",
+	"months-standAlone-abbr": [
+		"Oca",
+		"Åžub",
+		"Mar",
+		"Nis",
+		"May",
+		"Haz",
+		"Tem",
+		"AÄŸu",
+		"Eyl",
+		"Eki",
+		"Kas",
+		"Ara"
+	],
+	"quarters-format-abbr": [
+		"Ç1",
+		"Ç2",
+		"Ç3",
+		"Ç4"
+	],
+	"quarters-standAlone-wide": [
+		"1. çeyrek",
+		"2. çeyrek",
+		"3. çeyrek",
+		"4. çeyrek"
+	],
+	"dateFormatItem-M": "L",
+	"days-standAlone-wide": [
+		"Pazar",
+		"Pazartesi",
+		"Salı",
+		"Çarşamba",
+		"PerÅŸembe",
+		"Cuma",
+		"Cumartesi"
+	],
+	"dateFormatItem-MMMMd": "dd MMMM",
+	"dateFormatItem-yyMMM": "MMM yy",
+	"timeFormat-medium": "HH:mm:ss",
+	"dateFormatItem-Hm": "HH:mm",
+	"quarters-standAlone-abbr": [
+		"Ç1",
+		"Ç2",
+		"Ç3",
+		"Ç4"
+	],
+	"eraAbbr": [
+		"MÖ",
+		"MS"
+	],
+	"field-minute": "Dakika",
+	"field-dayperiod": "AM/PM",
+	"days-standAlone-abbr": [
+		"Paz",
+		"Pzt",
+		"Sal",
+		"Çar",
+		"Per",
+		"Cum",
+		"Cmt"
+	],
+	"dateFormatItem-d": "d",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "Dün",
+	"field-day-relative+-2": "Evvelsi gün",
+	"field-day-relative+-3": "Üç gün önce",
+	"dateFormatItem-MMMd": "dd MMM",
+	"dateFormatItem-MEd": "dd/MM E",
+	"dateFormatItem-yMMMM": "MMMM y",
+	"field-day": "Gün",
+	"days-format-wide": [
+		"Pazar",
+		"Pazartesi",
+		"Salı",
+		"Çarşamba",
+		"PerÅŸembe",
+		"Cuma",
+		"Cumartesi"
+	],
+	"field-zone": "Saat Dilimi",
+	"dateFormatItem-y": "y",
+	"months-standAlone-narrow": [
+		"O",
+		"Åž",
+		"M",
+		"N",
+		"M",
+		"H",
+		"T",
+		"A",
+		"E",
+		"E",
+		"K",
+		"A"
+	],
+	"dateFormatItem-yyMM": "MM/yy",
+	"dateFormatItem-hm": "h:mm a",
+	"days-format-abbr": [
+		"Paz",
+		"Pzt",
+		"Sal",
+		"Çar",
+		"Per",
+		"Cum",
+		"Cmt"
+	],
+	"eraNames": [
+		"Milattan Önce",
+		"Milattan Sonra"
+	],
+	"days-format-narrow": [
+		"P",
+		"P",
+		"S",
+		"Ç",
+		"P",
+		"C",
+		"C"
+	],
+	"field-month": "Ay",
+	"days-standAlone-narrow": [
+		"P",
+		"P",
+		"S",
+		"Ç",
+		"P",
+		"C",
+		"C"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "AM",
+	"dateFormatItem-MMMMEd": "dd MMMM E",
+	"dateFormat-short": "dd.MM.yyyy",
+	"field-second": "Saniye",
+	"dateFormatItem-yMMMEd": "dd MMM y EEE",
+	"dateFormatItem-Ed": "d E",
+	"field-week": "Hafta",
+	"dateFormat-medium": "dd MMM y",
+	"dateFormatItem-mmss": "mm:ss",
+	"dateFormatItem-Hms": "HH:mm:ss",
+	"dateFormatItem-hms": "h:mm:ss a",
+	"dateFormatItem-yyyy": "y"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/tr/number.js b/js/dojo-1.7.2/dojo/cldr/nls/tr/number.js
new file mode 100644
index 0000000..0843a54
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/tr/number.js
@@ -0,0 +1,23 @@
+//>>built
+define(
+"dojo/cldr/nls/tr/number", //begin v1.x content
+{
+	"group": ".",
+	"percentSign": "%",
+	"exponential": "E",
+	"scientificFormat": "#E0",
+	"percentFormat": "% #,##0",
+	"list": ";",
+	"infinity": "∞",
+	"patternDigit": "#",
+	"minusSign": "-",
+	"decimal": ",",
+	"nan": "NaN",
+	"nativeZeroDigit": "0",
+	"perMille": "‰",
+	"decimalFormat": "#,##0.###",
+	"currencyFormat": "#,##0.00 ¤",
+	"plusSign": "+"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/buddhist.js b/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/buddhist.js
new file mode 100644
index 0000000..e676ed3
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/buddhist.js
@@ -0,0 +1,147 @@
+//>>built
+define(
+"dojo/cldr/nls/zh-hant/buddhist", //begin v1.x content
+{
+	"dateFormatItem-yM": "Gy/M",
+	"dateFormatItem-yQ": "Gyå¹´QQQ",
+	"dayPeriods-format-wide-pm": "下�",
+	"dateFormatItem-MMMEd": "MMMdæ—¥E",
+	"dateTimeFormat-full": "{1}{0}",
+	"dateFormatItem-hms": "ah:mm:ss",
+	"dateFormatItem-yQQQ": "Gyå¹´QQQ",
+	"dateFormatItem-MMdd": "MM/dd",
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "上�",
+	"dateFormatItem-y": "Gyå¹´",
+	"timeFormat-full": "zzzzah時mm分ss秒",
+	"dateFormatItem-yyyy": "yå¹´",
+	"months-standAlone-abbr": [
+		"一月",
+		"二月",
+		"三月",
+		"四月",
+		"五月",
+		"六月",
+		"七月",
+		"八月",
+		"�月",
+		"�月",
+		"�一月",
+		"�二月"
+	],
+	"dateFormatItem-Ed": "dæ—¥(E)",
+	"dateFormatItem-yMMM": "Gy年M月",
+	"days-standAlone-narrow": [
+		"æ—¥",
+		"一",
+		"二",
+		"三",
+		"å››",
+		"五",
+		"å…­"
+	],
+	"dateFormatItem-yyyyMMMM": "yå¹´MMMM",
+	"dateFormat-long": "Gy年M月d日",
+	"timeFormat-medium": "ah:mm:ss",
+	"dateFormatItem-EEEd": "d EEE",
+	"dateFormatItem-Hm": "H:mm",
+	"dateFormatItem-yyMM": "Gyy/MM",
+	"dateFormat-medium": "Gy/M/d",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"dateFormatItem-yyMMM": "Gyyå¹´MMM",
+	"dateFormatItem-yMd": "Gy/M/d",
+	"dateFormatItem-ms": "mm:ss",
+	"dateTimeFormat-long": "{1}{0}",
+	"months-standAlone-wide": [
+		"一月",
+		"二月",
+		"三月",
+		"四月",
+		"五月",
+		"六月",
+		"七月",
+		"八月",
+		"�月",
+		"�月",
+		"�一月",
+		"�二月"
+	],
+	"dateFormatItem-MMMd": "MMMdæ—¥",
+	"dateFormatItem-yyQ": "Gyy年第Q季度",
+	"timeFormat-long": "zah時mm分ss秒",
+	"months-format-abbr": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"dateFormatItem-H": "H時",
+	"timeFormat-short": "ah:mm",
+	"quarters-format-abbr": [
+		"1å­£",
+		"2å­£",
+		"3å­£",
+		"4å­£"
+	],
+	"dateFormatItem-MMMMdd": "MMMMddæ—¥",
+	"days-format-abbr": [
+		"週日",
+		"週一",
+		"週二",
+		"週三",
+		"週四",
+		"週五",
+		"週六"
+	],
+	"dateFormatItem-M": "M月",
+	"dateFormatItem-yMMMd": "Gyå¹´MMMdæ—¥",
+	"dateFormatItem-MEd": "M/d（E）",
+	"dateFormatItem-hm": "ah:mm",
+	"dateFormat-short": "Gy/M/d",
+	"dateFormatItem-yyyyM": "y年M月",
+	"dateFormatItem-yMMMEd": "Gy年M月d日EEE",
+	"dateFormat-full": "Gy年M月d日EEEE",
+	"dateFormatItem-Md": "M/d",
+	"dateFormatItem-yMEd": "Gy/M/d（EEE）",
+	"months-format-wide": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"dateFormatItem-d": "dæ—¥",
+	"quarters-format-wide": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"days-format-wide": [
+		"星期日",
+		"星期一",
+		"星期二",
+		"星期三",
+		"星期四",
+		"星期五",
+		"星期六"
+	],
+	"dateFormatItem-h": "ah時"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/currency.js
new file mode 100644
index 0000000..fb8c235
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/currency.js
@@ -0,0 +1,17 @@
+//>>built
+define(
+"dojo/cldr/nls/zh-hant/currency", //begin v1.x content
+{
+	"HKD_displayName": "港幣",
+	"CHF_displayName": "瑞士法郎",
+	"CAD_displayName": "加幣",
+	"CNY_displayName": "人民幣",
+	"USD_symbol": "$",
+	"AUD_displayName": "澳幣",
+	"JPY_displayName": "日圓",
+	"CNY_symbol": "ï¿¥",
+	"GBP_displayName": "英鎊",
+	"EUR_displayName": "�元"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/gregorian.js
new file mode 100644
index 0000000..d1626ae
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/gregorian.js
@@ -0,0 +1,229 @@
+//>>built
+define(
+"dojo/cldr/nls/zh-hant/gregorian", //begin v1.x content
+{
+	"field-weekday": "週天",
+	"dateFormatItem-yQQQ": "yå¹´QQQ",
+	"dateFormatItem-yMEd": "yyyy/M/d（EEE）",
+	"dateFormatItem-MMMEd": "MMMdæ—¥E",
+	"eraNarrow": [
+		"西元�",
+		"西元"
+	],
+	"dateFormat-long": "y年M月d日",
+	"months-format-wide": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"dateTimeFormat-medium": "{1} {0}",
+	"dayPeriods-format-wide-pm": "下�",
+	"dateFormat-full": "y年M月d日EEEE",
+	"dateFormatItem-Md": "M/d",
+	"field-era": "年代",
+	"dateFormatItem-yM": "yyyy/M",
+	"months-standAlone-wide": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"timeFormat-short": "ah:mm",
+	"quarters-format-wide": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"timeFormat-long": "zah時mm分ss秒",
+	"field-year": "å¹´",
+	"dateFormatItem-yMMM": "y年M月",
+	"dateFormatItem-yQ": "yå¹´QQQ",
+	"field-hour": "�時",
+	"dateFormatItem-MMdd": "MM/dd",
+	"months-format-abbr": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"dateFormatItem-yyQ": "yy年第Q季度",
+	"timeFormat-full": "zzzzah時mm分ss秒",
+	"field-day-relative+0": "今天",
+	"field-day-relative+1": "明天",
+	"field-day-relative+2": "後天",
+	"dateFormatItem-H": "H時",
+	"field-day-relative+3": "大後天",
+	"months-standAlone-abbr": [
+		"一月",
+		"二月",
+		"三月",
+		"四月",
+		"五月",
+		"六月",
+		"七月",
+		"八月",
+		"�月",
+		"�月",
+		"�一月",
+		"�二月"
+	],
+	"quarters-format-abbr": [
+		"1å­£",
+		"2å­£",
+		"3å­£",
+		"4å­£"
+	],
+	"quarters-standAlone-wide": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"dateFormatItem-M": "M月",
+	"days-standAlone-wide": [
+		"星期日",
+		"星期一",
+		"星期二",
+		"星期三",
+		"星期四",
+		"星期五",
+		"星期六"
+	],
+	"dateFormatItem-yyMMM": "yyå¹´MMM",
+	"timeFormat-medium": "ah:mm:ss",
+	"dateFormatItem-Hm": "H:mm",
+	"quarters-standAlone-abbr": [
+		"1å­£",
+		"2å­£",
+		"3å­£",
+		"4å­£"
+	],
+	"eraAbbr": [
+		"西元�",
+		"西元"
+	],
+	"field-minute": "分�",
+	"field-dayperiod": "上�/下�",
+	"days-standAlone-abbr": [
+		"週日",
+		"週一",
+		"週二",
+		"週三",
+		"週四",
+		"週五",
+		"週六"
+	],
+	"dateFormatItem-d": "dæ—¥",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "昨天",
+	"dateFormatItem-h": "ah時",
+	"dateTimeFormat-long": "{1}{0}",
+	"field-day-relative+-2": "�天",
+	"field-day-relative+-3": "大�天",
+	"dateFormatItem-MMMd": "MMMdæ—¥",
+	"dateFormatItem-MEd": "M/d（E）",
+	"dateTimeFormat-full": "{1}{0}",
+	"field-day": "æ—¥",
+	"days-format-wide": [
+		"星期日",
+		"星期一",
+		"星期二",
+		"星期三",
+		"星期四",
+		"星期五",
+		"星期六"
+	],
+	"field-zone": "�域",
+	"dateFormatItem-y": "yå¹´",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateFormatItem-yyMM": "yy-MM",
+	"dateFormatItem-hm": "ah:mm",
+	"days-format-abbr": [
+		"週日",
+		"週一",
+		"週二",
+		"週三",
+		"週四",
+		"週五",
+		"週六"
+	],
+	"dateFormatItem-yMMMd": "yå¹´MMMdæ—¥",
+	"eraNames": [
+		"西元�",
+		"西元"
+	],
+	"days-format-narrow": [
+		"æ—¥",
+		"一",
+		"二",
+		"三",
+		"å››",
+		"五",
+		"å…­"
+	],
+	"field-month": "月",
+	"days-standAlone-narrow": [
+		"æ—¥",
+		"一",
+		"二",
+		"三",
+		"å››",
+		"五",
+		"å…­"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "上�",
+	"dateFormatItem-MMMMdd": "MMMMddæ—¥",
+	"dateFormat-short": "yy/M/d",
+	"field-second": "秒",
+	"dateFormatItem-yMMMEd": "y年M月d日EEE",
+	"dateFormatItem-Ed": "dæ—¥(E)",
+	"field-week": "週",
+	"dateFormat-medium": "yyyy/M/d",
+	"dateFormatItem-yyyyM": "y年M月",
+	"dateTimeFormat-short": "{1} {0}",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"dateFormatItem-hms": "ah:mm:ss",
+	"dateFormatItem-yyyy": "yå¹´"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/islamic.js b/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/islamic.js
new file mode 100644
index 0000000..918ccbb
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/islamic.js
@@ -0,0 +1,88 @@
+//>>built
+define(
+"dojo/cldr/nls/zh-hant/islamic", //begin v1.x content
+{
+	"dateFormatItem-yM": "yyyy/M",
+	"dateFormatItem-yQ": "yå¹´QQQ",
+	"dayPeriods-format-wide-pm": "下�",
+	"dateFormatItem-MMMEd": "MMMdæ—¥E",
+	"dateTimeFormat-full": "{1}{0}",
+	"dateFormatItem-hms": "ah:mm:ss",
+	"dateFormatItem-yQQQ": "yå¹´QQQ",
+	"dateFormatItem-MMdd": "MM/dd",
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "上�",
+	"dateFormatItem-y": "yå¹´",
+	"timeFormat-full": "zzzzah時mm分ss秒",
+	"dateFormatItem-yyyy": "Gyå¹´",
+	"dateFormatItem-Ed": "dæ—¥(E)",
+	"dateFormatItem-yMMM": "y年M月",
+	"days-standAlone-narrow": [
+		"æ—¥",
+		"一",
+		"二",
+		"三",
+		"å››",
+		"五",
+		"å…­"
+	],
+	"dateFormat-long": "Gy年M月d日",
+	"timeFormat-medium": "ah:mm:ss",
+	"dateFormatItem-Hm": "H:mm",
+	"dateFormat-medium": "Gy/M/d",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"dateFormatItem-ms": "mm:ss",
+	"dateTimeFormat-long": "{1}{0}",
+	"dateFormatItem-yyyyMd": "Gy/M/d",
+	"dateFormatItem-yyyyMMMd": "Gy年M月d日",
+	"dateFormatItem-MMMd": "MMMdæ—¥",
+	"timeFormat-long": "zah時mm分ss秒",
+	"timeFormat-short": "ah:mm",
+	"dateFormatItem-H": "H時",
+	"quarters-format-abbr": [
+		"1å­£",
+		"2å­£",
+		"3å­£",
+		"4å­£"
+	],
+	"days-format-abbr": [
+		"週日",
+		"週一",
+		"週二",
+		"週三",
+		"週四",
+		"週五",
+		"週六"
+	],
+	"dateFormatItem-MMMMdd": "MMMMddæ—¥",
+	"dateFormatItem-M": "M月",
+	"dateFormatItem-MEd": "M/d（E）",
+	"dateFormatItem-hm": "ah:mm",
+	"dateFormat-short": "Gy/M/d",
+	"dateFormatItem-yyyyM": "Gy/M",
+	"dateFormatItem-yMMMEd": "y年M月d日EEE",
+	"dateFormat-full": "Gy年M月d日EEEE",
+	"dateFormatItem-Md": "M/d",
+	"dateFormatItem-yyyyQ": "Gyå¹´QQQ",
+	"dateFormatItem-yMEd": "yyyy/M/d（EEE）",
+	"dateFormatItem-yyyyMMM": "Gy年M月",
+	"dateFormatItem-d": "dæ—¥",
+	"quarters-format-wide": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"days-format-wide": [
+		"星期日",
+		"星期一",
+		"星期二",
+		"星期三",
+		"星期四",
+		"星期五",
+		"星期六"
+	],
+	"dateFormatItem-h": "ah時"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/number.js b/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/number.js
new file mode 100644
index 0000000..4e833e5
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh-hant/number.js
@@ -0,0 +1,8 @@
+//>>built
+define(
+"dojo/cldr/nls/zh-hant/number", //begin v1.x content
+{
+	"currencyFormat": "¤#,##0.00"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh-hk/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/zh-hk/currency.js
new file mode 100644
index 0000000..b5396d2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh-hk/currency.js
@@ -0,0 +1,16 @@
+//>>built
+define(
+"dojo/cldr/nls/zh-hk/currency", //begin v1.x content
+{
+	"HKD_displayName": "港幣",
+	"HKD_symbol": "HK$",
+	"CAD_displayName": "加幣",
+	"CNY_displayName": "人民幣",
+	"USD_symbol": "$",
+	"AUD_displayName": "澳幣",
+	"JPY_displayName": "日圓",
+	"GBP_displayName": "英鎊",
+	"EUR_displayName": "�元"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh-hk/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/zh-hk/gregorian.js
new file mode 100644
index 0000000..2caeba9
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh-hk/gregorian.js
@@ -0,0 +1,86 @@
+//>>built
+define(
+"dojo/cldr/nls/zh-hk/gregorian", //begin v1.x content
+{
+	"dateFormatItem-yM": "yyyy/M",
+	"field-minute": "分�",
+	"eraNames": [
+		"西元�",
+		"西元"
+	],
+	"field-weekday": "週天",
+	"dateFormatItem-MMdd": "MM/dd",
+	"field-day-relative+-3": "大�天",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"dateTimeFormat-short": "{1} {0}",
+	"field-era": "年代",
+	"field-hour": "�時",
+	"dateTimeFormat-medium": "{1} {0}",
+	"quarters-standAlone-abbr": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"timeFormat-full": "zzzzah時mm分ss秒",
+	"dateFormatItem-Ed": "dæ—¥(E)",
+	"dateFormatItem-yMMM": "y年M月",
+	"eraAbbr": [
+		"西元�",
+		"西元"
+	],
+	"field-day-relative+2": "後天",
+	"field-day-relative+3": "大後天",
+	"dateFormat-long": "y年M月d日",
+	"timeFormat-medium": "ah:mm:ss",
+	"field-zone": "�域",
+	"dateFormat-medium": "yyyy/M/d",
+	"quarters-standAlone-wide": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"field-week": "週",
+	"timeFormat-long": "zah時mm分ss秒",
+	"dateFormatItem-H": "H時",
+	"quarters-format-abbr": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"field-second": "秒",
+	"dateFormatItem-MEd": "M/d（E）",
+	"dateFormat-short": "yy/M/d",
+	"dateFormatItem-yMMMEd": "y年M月d日EEE",
+	"dateFormat-full": "y年M月d日EEEE",
+	"dateFormatItem-Md": "M/d",
+	"dateFormatItem-yMEd": "yyyy/M/d（EEE）",
+	"quarters-format-wide": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"eraNarrow": [
+		"西元�",
+		"西元"
+	],
+	"dateFormatItem-h": "ah時"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh-hk/number.js b/js/dojo-1.7.2/dojo/cldr/nls/zh-hk/number.js
new file mode 100644
index 0000000..1ddda70
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh-hk/number.js
@@ -0,0 +1,8 @@
+//>>built
+define(
+"dojo/cldr/nls/zh-hk/number", //begin v1.x content
+{
+	"currencyFormat": "¤#,##0.00"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh-tw/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/zh-tw/currency.js
new file mode 100644
index 0000000..7a07c21
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh-tw/currency.js
@@ -0,0 +1,15 @@
+//>>built
+define(
+"dojo/cldr/nls/zh-tw/currency", //begin v1.x content
+{
+	"USD_symbol": "$",
+	"EUR_displayName": "�元",
+	"HKD_displayName": "港幣",
+	"CAD_displayName": "加幣",
+	"JPY_displayName": "日圓",
+	"GBP_displayName": "英鎊",
+	"AUD_displayName": "澳幣",
+	"CNY_displayName": "人民幣"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh-tw/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/zh-tw/gregorian.js
new file mode 100644
index 0000000..76f8737
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh-tw/gregorian.js
@@ -0,0 +1,81 @@
+//>>built
+define(
+"dojo/cldr/nls/zh-tw/gregorian", //begin v1.x content
+{
+	"quarters-standAlone-wide": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"quarters-format-abbr": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"dateFormat-medium": "yyyy/M/d",
+	"field-second": "秒",
+	"quarters-standAlone-abbr": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"dateFormatItem-MMdd": "MM/dd",
+	"dateFormatItem-MEd": "M/d（E）",
+	"dateFormatItem-yMEd": "yyyy/M/d（EEE）",
+	"field-week": "週",
+	"dateFormatItem-H": "H時",
+	"eraNarrow": [
+		"西元�",
+		"西元"
+	],
+	"field-day-relative+-3": "大�天",
+	"timeFormat-full": "zzzzah時mm分ss秒",
+	"dateFormatItem-Md": "M/d",
+	"months-standAlone-narrow": [
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"10",
+		"11",
+		"12"
+	],
+	"eraNames": [
+		"西元�",
+		"西元"
+	],
+	"field-minute": "分�",
+	"field-hour": "�時",
+	"field-day-relative+2": "後天",
+	"field-day-relative+3": "大後天",
+	"dateFormat-short": "yy/M/d",
+	"dateFormatItem-yMMMEd": "y年M月d日EEE",
+	"field-era": "年代",
+	"dateFormatItem-yM": "yyyy/M",
+	"timeFormat-long": "zah時mm分ss秒",
+	"eraAbbr": [
+		"西元�",
+		"西元"
+	],
+	"dateFormatItem-h": "ah時",
+	"dateFormatItem-yMMM": "y年M月",
+	"quarters-format-wide": [
+		"第1季",
+		"第2季",
+		"第3季",
+		"第4季"
+	],
+	"field-weekday": "週天",
+	"field-zone": "�域",
+	"dateFormatItem-Ed": "dæ—¥(E)"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh/currency.js b/js/dojo-1.7.2/dojo/cldr/nls/zh/currency.js
new file mode 100644
index 0000000..4275a74
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh/currency.js
@@ -0,0 +1,17 @@
+//>>built
+define(
+"dojo/cldr/nls/zh/currency", //begin v1.x content
+{
+	"HKD_displayName": "港元",
+	"CHF_displayName": "瑞士法郎",
+	"CAD_displayName": "加拿大元",
+	"CNY_displayName": "人民�",
+	"AUD_displayName": "澳大利亚元",
+	"JPY_displayName": "日元",
+	"USD_displayName": "美元",
+	"CNY_symbol": "ï¿¥",
+	"GBP_displayName": "英镑",
+	"EUR_displayName": "欧元"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh/gregorian.js b/js/dojo-1.7.2/dojo/cldr/nls/zh/gregorian.js
new file mode 100644
index 0000000..0112d60
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh/gregorian.js
@@ -0,0 +1,248 @@
+//>>built
+define(
+"dojo/cldr/nls/zh/gregorian", //begin v1.x content
+{
+	"months-format-narrow": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"field-weekday": "周天",
+	"dateFormatItem-yQQQ": "yå¹´QQQ",
+	"dateFormatItem-yMEd": "y年M月d日，E",
+	"dateFormatItem-MMMEd": "MMMdæ—¥E",
+	"eraNarrow": [
+		"公元�",
+		"公元"
+	],
+	"dayPeriods-format-wide-earlyMorning": "清晨",
+	"dayPeriods-format-wide-morning": "上�",
+	"dateFormat-long": "y年M月d日",
+	"months-format-wide": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"dateTimeFormat-medium": "{1} {0}",
+	"dayPeriods-format-wide-pm": "下�",
+	"dateFormat-full": "y年M月d日EEEE",
+	"dateFormatItem-Md": "M-d",
+	"field-era": "时期",
+	"dateFormatItem-yM": "yyyy-M",
+	"months-standAlone-wide": [
+		"一月",
+		"二月",
+		"三月",
+		"四月",
+		"五月",
+		"六月",
+		"七月",
+		"八月",
+		"�月",
+		"�月",
+		"�一月",
+		"�二月"
+	],
+	"timeFormat-short": "ah:mm",
+	"quarters-format-wide": [
+		"第1季度",
+		"第2季度",
+		"第3季度",
+		"第4季度"
+	],
+	"timeFormat-long": "zah时mm分ss秒",
+	"field-year": "å¹´",
+	"dateFormatItem-yMMM": "yå¹´MMM",
+	"dateFormatItem-yQ": "yå¹´QQQ",
+	"dateFormatItem-yyyyMMMM": "yå¹´MMMM",
+	"field-hour": "�时",
+	"dateFormatItem-MMdd": "MM-dd",
+	"months-format-abbr": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"dateFormatItem-yyQ": "yy年第Q季度",
+	"timeFormat-full": "zzzzah时mm分ss秒",
+	"field-day-relative+0": "今天",
+	"field-day-relative+1": "明天",
+	"field-day-relative+2": "�天",
+	"dateFormatItem-H": "Hæ—¶",
+	"months-standAlone-abbr": [
+		"一月",
+		"二月",
+		"三月",
+		"四月",
+		"五月",
+		"六月",
+		"七月",
+		"八月",
+		"�月",
+		"�月",
+		"�一月",
+		"�二月"
+	],
+	"quarters-format-abbr": [
+		"1å­£",
+		"2å­£",
+		"3å­£",
+		"4å­£"
+	],
+	"quarters-standAlone-wide": [
+		"第1季度",
+		"第2季度",
+		"第3季度",
+		"第4季度"
+	],
+	"dateFormatItem-M": "M月",
+	"days-standAlone-wide": [
+		"星期日",
+		"星期一",
+		"星期二",
+		"星期三",
+		"星期四",
+		"星期五",
+		"星期六"
+	],
+	"dateFormatItem-yyMMM": "yyå¹´MMM",
+	"timeFormat-medium": "ah:mm:ss",
+	"dateFormatItem-Hm": "H:mm",
+	"quarters-standAlone-abbr": [
+		"1å­£",
+		"2å­£",
+		"3å­£",
+		"4å­£"
+	],
+	"eraAbbr": [
+		"公元�",
+		"公元"
+	],
+	"field-minute": "分钟",
+	"field-dayperiod": "上�/下�",
+	"days-standAlone-abbr": [
+		"周日",
+		"周一",
+		"周二",
+		"周三",
+		"周四",
+		"周五",
+		"周六"
+	],
+	"dayPeriods-format-wide-night": "晚上",
+	"dateFormatItem-d": "dæ—¥",
+	"dateFormatItem-ms": "mm:ss",
+	"field-day-relative+-1": "昨天",
+	"dateFormatItem-h": "ahæ—¶",
+	"dateTimeFormat-long": "{1}{0}",
+	"field-day-relative+-2": "�天",
+	"dateFormatItem-MMMd": "MMMdæ—¥",
+	"dayPeriods-format-wide-midDay": "中�",
+	"dateFormatItem-MEd": "M-dE",
+	"dateTimeFormat-full": "{1}{0}",
+	"field-day": "æ—¥",
+	"days-format-wide": [
+		"星期日",
+		"星期一",
+		"星期二",
+		"星期三",
+		"星期四",
+		"星期五",
+		"星期六"
+	],
+	"field-zone": "区域",
+	"dateFormatItem-y": "yå¹´",
+	"months-standAlone-narrow": [
+		"1月",
+		"2月",
+		"3月",
+		"4月",
+		"5月",
+		"6月",
+		"7月",
+		"8月",
+		"9月",
+		"10月",
+		"11月",
+		"12月"
+	],
+	"dateFormatItem-yyMM": "yy-MM",
+	"dateFormatItem-hm": "ah:mm",
+	"days-format-abbr": [
+		"周日",
+		"周一",
+		"周二",
+		"周三",
+		"周四",
+		"周五",
+		"周六"
+	],
+	"dateFormatItem-yMMMd": "yå¹´MMMdæ—¥",
+	"eraNames": [
+		"公元�",
+		"公元"
+	],
+	"days-format-narrow": [
+		"æ—¥",
+		"一",
+		"二",
+		"三",
+		"å››",
+		"五",
+		"å…­"
+	],
+	"field-month": "月",
+	"days-standAlone-narrow": [
+		"æ—¥",
+		"一",
+		"二",
+		"三",
+		"å››",
+		"五",
+		"å…­"
+	],
+	"dateFormatItem-MMM": "LLL",
+	"dayPeriods-format-wide-am": "上�",
+	"dateFormatItem-MMMMdd": "MMMMddæ—¥",
+	"dayPeriods-format-wide-weeHours": "凌晨",
+	"dateFormat-short": "yy-M-d",
+	"dayPeriods-format-wide-afternoon": "下�",
+	"field-second": "秒钟",
+	"dateFormatItem-yMMMEd": "yå¹´MMMdæ—¥EEE",
+	"dateFormatItem-Ed": "dæ—¥E",
+	"field-week": "周",
+	"dateFormat-medium": "yyyy-M-d",
+	"dateFormatItem-yyyyM": "y年M月",
+	"dateTimeFormat-short": "{1} {0}",
+	"dateFormatItem-Hms": "H:mm:ss",
+	"dateFormatItem-hms": "ah:mm:ss",
+	"dateFormatItem-yyyy": "yå¹´"
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/nls/zh/number.js b/js/dojo-1.7.2/dojo/cldr/nls/zh/number.js
new file mode 100644
index 0000000..17aa214
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/nls/zh/number.js
@@ -0,0 +1,13 @@
+//>>built
+define(
+"dojo/cldr/nls/zh/number", //begin v1.x content
+{
+	"decimalFormat": "#,##0.###",
+	"group": ",",
+	"scientificFormat": "#E0",
+	"percentFormat": "#,##0%",
+	"currencyFormat": "¤#,##0.00",
+	"decimal": "."
+}
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/cldr/supplemental.js b/js/dojo-1.7.2/dojo/cldr/supplemental.js
new file mode 100644
index 0000000..2d50339
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cldr/supplemental.js
@@ -0,0 +1,78 @@
+//>>built
+define("dojo/cldr/supplemental", ["../_base/kernel", "../_base/lang", "../i18n"], function(dojo, lang) {
+	// module:
+	//		dojo/cldr/supplemental
+	// summary:
+	//		TODOC
+
+lang.getObject("cldr.supplemental", true, dojo);
+
+dojo.cldr.supplemental.getFirstDayOfWeek = function(/*String?*/locale){
+// summary: Returns a zero-based index for first day of the week
+// description:
+//		Returns a zero-based index for first day of the week, as used by the local (Gregorian) calendar.
+//		e.g. Sunday (returns 0), or Monday (returns 1)
+
+	// from http://www.unicode.org/cldr/data/common/supplemental/supplementalData.xml:supplementalData/weekData/firstDay
+	var firstDay = {/*default is 1=Monday*/
+		mv:5,
+		ae:6,af:6,bh:6,dj:6,dz:6,eg:6,er:6,et:6,iq:6,ir:6,jo:6,ke:6,kw:6,
+		ly:6,ma:6,om:6,qa:6,sa:6,sd:6,so:6,sy:6,tn:6,ye:6,
+		ar:0,as:0,az:0,bw:0,ca:0,cn:0,fo:0,ge:0,gl:0,gu:0,hk:0,
+		il:0,'in':0,jm:0,jp:0,kg:0,kr:0,la:0,mh:0,mn:0,mo:0,mp:0,
+		mt:0,nz:0,ph:0,pk:0,sg:0,th:0,tt:0,tw:0,um:0,us:0,uz:0,
+		vi:0,zw:0
+// variant. do not use?		gb:0,
+	};
+
+	var country = dojo.cldr.supplemental._region(locale);
+	var dow = firstDay[country];
+	return (dow === undefined) ? 1 : dow; /*Number*/
+};
+
+dojo.cldr.supplemental._region = function(/*String?*/locale){
+	locale = dojo.i18n.normalizeLocale(locale);
+	var tags = locale.split('-');
+	var region = tags[1];
+	if(!region){
+		// IE often gives language only (#2269)
+		// Arbitrary mappings of language-only locales to a country:
+		region = {de:"de", en:"us", es:"es", fi:"fi", fr:"fr", he:"il", hu:"hu", it:"it",
+			ja:"jp", ko:"kr", nl:"nl", pt:"br", sv:"se", zh:"cn"}[tags[0]];
+	}else if(region.length == 4){
+		// The ISO 3166 country code is usually in the second position, unless a
+		// 4-letter script is given. See http://www.ietf.org/rfc/rfc4646.txt
+		region = tags[2];
+	}
+	return region;
+};
+
+dojo.cldr.supplemental.getWeekend = function(/*String?*/locale){
+// summary: Returns a hash containing the start and end days of the weekend
+// description:
+//		Returns a hash containing the start and end days of the weekend according to local custom using locale,
+//		or by default in the user's locale.
+//		e.g. {start:6, end:0}
+
+	// from http://www.unicode.org/cldr/data/common/supplemental/supplementalData.xml:supplementalData/weekData/weekend{Start,End}
+	var weekendStart = {/*default is 6=Saturday*/
+		'in':0,
+		af:4,dz:4,ir:4,om:4,sa:4,ye:4,
+		ae:5,bh:5,eg:5,il:5,iq:5,jo:5,kw:5,ly:5,ma:5,qa:5,sd:5,sy:5,tn:5
+	};
+
+	var weekendEnd = {/*default is 0=Sunday*/
+		af:5,dz:5,ir:5,om:5,sa:5,ye:5,
+		ae:6,bh:5,eg:6,il:6,iq:6,jo:6,kw:6,ly:6,ma:6,qa:6,sd:6,sy:6,tn:6
+	};
+
+	var country = dojo.cldr.supplemental._region(locale);
+	var start = weekendStart[country];
+	var end = weekendEnd[country];
+	if(start === undefined){start=6;}
+	if(end === undefined){end=0;}
+	return {start:start, end:end}; /*Object {start,end}*/
+};
+
+return dojo.cldr.supplemental;
+});
diff --git a/js/dojo-1.7.2/dojo/colors.js b/js/dojo-1.7.2/dojo/colors.js
new file mode 100644
index 0000000..9cc0ef0
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/colors.js
@@ -0,0 +1,233 @@
+//>>built
+define("dojo/colors", ["./_base/kernel", "./_base/lang", "./_base/Color", "./_base/array"], function(dojo, lang, Color, ArrayUtil) {
+	// module:
+	//		dojo/colors
+	// summary:
+	//		TODOC
+
+	var ColorExt = lang.getObject("dojo.colors", true);
+
+//TODO: this module appears to break naming conventions
+
+/*=====
+	lang.mixin(dojo, {
+		colors: {
+			// summary: Color utilities, extending Base dojo.Color
+		}
+	});
+=====*/
+
+	// this is a standard conversion prescribed by the CSS3 Color Module
+	var hue2rgb = function(m1, m2, h){
+		if(h < 0){ ++h; }
+		if(h > 1){ --h; }
+		var h6 = 6 * h;
+		if(h6 < 1){ return m1 + (m2 - m1) * h6; }
+		if(2 * h < 1){ return m2; }
+		if(3 * h < 2){ return m1 + (m2 - m1) * (2 / 3 - h) * 6; }
+		return m1;
+	};
+	// Override base Color.fromRgb with the impl in this module
+	dojo.colorFromRgb = Color.fromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){
+		// summary:
+		//		get rgb(a) array from css-style color declarations
+		// description:
+		//		this function can handle all 4 CSS3 Color Module formats: rgb,
+		//		rgba, hsl, hsla, including rgb(a) with percentage values.
+		var m = color.toLowerCase().match(/^(rgba?|hsla?)\(([\s\.\-,%0-9]+)\)/);
+		if(m){
+			var c = m[2].split(/\s*,\s*/), l = c.length, t = m[1], a;
+			if((t == "rgb" && l == 3) || (t == "rgba" && l == 4)){
+				var r = c[0];
+				if(r.charAt(r.length - 1) == "%"){
+					// 3 rgb percentage values
+					a = ArrayUtil.map(c, function(x){
+						return parseFloat(x) * 2.56;
+					});
+					if(l == 4){ a[3] = c[3]; }
+					return Color.fromArray(a, obj); // dojo.Color
+				}
+				return Color.fromArray(c, obj); // dojo.Color
+			}
+			if((t == "hsl" && l == 3) || (t == "hsla" && l == 4)){
+				// normalize hsl values
+				var H = ((parseFloat(c[0]) % 360) + 360) % 360 / 360,
+					S = parseFloat(c[1]) / 100,
+					L = parseFloat(c[2]) / 100,
+					// calculate rgb according to the algorithm
+					// recommended by the CSS3 Color Module
+					m2 = L <= 0.5 ? L * (S + 1) : L + S - L * S,
+					m1 = 2 * L - m2;
+				a = [
+					hue2rgb(m1, m2, H + 1 / 3) * 256,
+					hue2rgb(m1, m2, H) * 256,
+					hue2rgb(m1, m2, H - 1 / 3) * 256,
+					1
+				];
+				if(l == 4){ a[3] = c[3]; }
+				return Color.fromArray(a, obj); // dojo.Color
+			}
+		}
+		return null;	// dojo.Color
+	};
+
+	var confine = function(c, low, high){
+		// summary:
+		//		sanitize a color component by making sure it is a number,
+		//		and clamping it to valid values
+		c = Number(c);
+		return isNaN(c) ? high : c < low ? low : c > high ? high : c;	// Number
+	};
+
+	Color.prototype.sanitize = function(){
+		// summary: makes sure that the object has correct attributes
+		var t = this;
+		t.r = Math.round(confine(t.r, 0, 255));
+		t.g = Math.round(confine(t.g, 0, 255));
+		t.b = Math.round(confine(t.b, 0, 255));
+		t.a = confine(t.a, 0, 1);
+		return this;	// dojo.Color
+	};
+
+	ColorExt.makeGrey = Color.makeGrey = function(/*Number*/ g, /*Number?*/ a){
+		// summary: creates a greyscale color with an optional alpha
+		return Color.fromArray([g, g, g, a]);	// dojo.Color
+	};
+
+	// mixin all CSS3 named colors not already in _base, along with SVG 1.0 variant spellings
+	lang.mixin(Color.named, {
+		"aliceblue":	[240,248,255],
+		"antiquewhite": [250,235,215],
+		"aquamarine":	[127,255,212],
+		"azure":	[240,255,255],
+		"beige":	[245,245,220],
+		"bisque":	[255,228,196],
+		"blanchedalmond":	[255,235,205],
+		"blueviolet":	[138,43,226],
+		"brown":	[165,42,42],
+		"burlywood":	[222,184,135],
+		"cadetblue":	[95,158,160],
+		"chartreuse":	[127,255,0],
+		"chocolate":	[210,105,30],
+		"coral":	[255,127,80],
+		"cornflowerblue":	[100,149,237],
+		"cornsilk": [255,248,220],
+		"crimson":	[220,20,60],
+		"cyan": [0,255,255],
+		"darkblue": [0,0,139],
+		"darkcyan": [0,139,139],
+		"darkgoldenrod":	[184,134,11],
+		"darkgray": [169,169,169],
+		"darkgreen":	[0,100,0],
+		"darkgrey": [169,169,169],
+		"darkkhaki":	[189,183,107],
+		"darkmagenta":	[139,0,139],
+		"darkolivegreen":	[85,107,47],
+		"darkorange":	[255,140,0],
+		"darkorchid":	[153,50,204],
+		"darkred":	[139,0,0],
+		"darksalmon":	[233,150,122],
+		"darkseagreen": [143,188,143],
+		"darkslateblue":	[72,61,139],
+		"darkslategray":	[47,79,79],
+		"darkslategrey":	[47,79,79],
+		"darkturquoise":	[0,206,209],
+		"darkviolet":	[148,0,211],
+		"deeppink": [255,20,147],
+		"deepskyblue":	[0,191,255],
+		"dimgray":	[105,105,105],
+		"dimgrey":	[105,105,105],
+		"dodgerblue":	[30,144,255],
+		"firebrick":	[178,34,34],
+		"floralwhite":	[255,250,240],
+		"forestgreen":	[34,139,34],
+		"gainsboro":	[220,220,220],
+		"ghostwhite":	[248,248,255],
+		"gold": [255,215,0],
+		"goldenrod":	[218,165,32],
+		"greenyellow":	[173,255,47],
+		"grey": [128,128,128],
+		"honeydew": [240,255,240],
+		"hotpink":	[255,105,180],
+		"indianred":	[205,92,92],
+		"indigo":	[75,0,130],
+		"ivory":	[255,255,240],
+		"khaki":	[240,230,140],
+		"lavender": [230,230,250],
+		"lavenderblush":	[255,240,245],
+		"lawngreen":	[124,252,0],
+		"lemonchiffon": [255,250,205],
+		"lightblue":	[173,216,230],
+		"lightcoral":	[240,128,128],
+		"lightcyan":	[224,255,255],
+		"lightgoldenrodyellow": [250,250,210],
+		"lightgray":	[211,211,211],
+		"lightgreen":	[144,238,144],
+		"lightgrey":	[211,211,211],
+		"lightpink":	[255,182,193],
+		"lightsalmon":	[255,160,122],
+		"lightseagreen":	[32,178,170],
+		"lightskyblue": [135,206,250],
+		"lightslategray":	[119,136,153],
+		"lightslategrey":	[119,136,153],
+		"lightsteelblue":	[176,196,222],
+		"lightyellow":	[255,255,224],
+		"limegreen":	[50,205,50],
+		"linen":	[250,240,230],
+		"magenta":	[255,0,255],
+		"mediumaquamarine": [102,205,170],
+		"mediumblue":	[0,0,205],
+		"mediumorchid": [186,85,211],
+		"mediumpurple": [147,112,219],
+		"mediumseagreen":	[60,179,113],
+		"mediumslateblue":	[123,104,238],
+		"mediumspringgreen":	[0,250,154],
+		"mediumturquoise":	[72,209,204],
+		"mediumvioletred":	[199,21,133],
+		"midnightblue": [25,25,112],
+		"mintcream":	[245,255,250],
+		"mistyrose":	[255,228,225],
+		"moccasin": [255,228,181],
+		"navajowhite":	[255,222,173],
+		"oldlace":	[253,245,230],
+		"olivedrab":	[107,142,35],
+		"orange":	[255,165,0],
+		"orangered":	[255,69,0],
+		"orchid":	[218,112,214],
+		"palegoldenrod":	[238,232,170],
+		"palegreen":	[152,251,152],
+		"paleturquoise":	[175,238,238],
+		"palevioletred":	[219,112,147],
+		"papayawhip":	[255,239,213],
+		"peachpuff":	[255,218,185],
+		"peru": [205,133,63],
+		"pink": [255,192,203],
+		"plum": [221,160,221],
+		"powderblue":	[176,224,230],
+		"rosybrown":	[188,143,143],
+		"royalblue":	[65,105,225],
+		"saddlebrown":	[139,69,19],
+		"salmon":	[250,128,114],
+		"sandybrown":	[244,164,96],
+		"seagreen": [46,139,87],
+		"seashell": [255,245,238],
+		"sienna":	[160,82,45],
+		"skyblue":	[135,206,235],
+		"slateblue":	[106,90,205],
+		"slategray":	[112,128,144],
+		"slategrey":	[112,128,144],
+		"snow": [255,250,250],
+		"springgreen":	[0,255,127],
+		"steelblue":	[70,130,180],
+		"tan":	[210,180,140],
+		"thistle":	[216,191,216],
+		"tomato":	[255,99,71],
+		"turquoise":	[64,224,208],
+		"violet":	[238,130,238],
+		"wheat":	[245,222,179],
+		"whitesmoke":	[245,245,245],
+		"yellowgreen":	[154,205,50]
+	});
+
+	return Color;
+});
diff --git a/js/dojo-1.7.2/dojo/cookie.js b/js/dojo-1.7.2/dojo/cookie.js
new file mode 100644
index 0000000..e13808a
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/cookie.js
@@ -0,0 +1,99 @@
+//>>built
+define("dojo/cookie", ["./_base/kernel", "./regexp"], function(dojo, regexp) {
+	// module:
+	//		dojo/cookie
+	// summary:
+	//		TODOC
+
+
+/*=====
+dojo.__cookieProps = function(){
+	//	expires: Date|String|Number?
+	//		If a number, the number of days from today at which the cookie
+	//		will expire. If a date, the date past which the cookie will expire.
+	//		If expires is in the past, the cookie will be deleted.
+	//		If expires is omitted or is 0, the cookie will expire when the browser closes.
+	//	path: String?
+	//		The path to use for the cookie.
+	//	domain: String?
+	//		The domain to use for the cookie.
+	//	secure: Boolean?
+	//		Whether to only send the cookie on secure connections
+	this.expires = expires;
+	this.path = path;
+	this.domain = domain;
+	this.secure = secure;
+}
+=====*/
+
+
+dojo.cookie = function(/*String*/name, /*String?*/value, /*dojo.__cookieProps?*/props){
+	//	summary:
+	//		Get or set a cookie.
+	//	description:
+	// 		If one argument is passed, returns the value of the cookie
+	// 		For two or more arguments, acts as a setter.
+	//	name:
+	//		Name of the cookie
+	//	value:
+	//		Value for the cookie
+	//	props:
+	//		Properties for the cookie
+	//	example:
+	//		set a cookie with the JSON-serialized contents of an object which
+	//		will expire 5 days from now:
+	//	|	dojo.cookie("configObj", dojo.toJson(config), { expires: 5 });
+	//
+	//	example:
+	//		de-serialize a cookie back into a JavaScript object:
+	//	|	var config = dojo.fromJson(dojo.cookie("configObj"));
+	//
+	//	example:
+	//		delete a cookie:
+	//	|	dojo.cookie("configObj", null, {expires: -1});
+	var c = document.cookie, ret;
+	if(arguments.length == 1){
+		var matches = c.match(new RegExp("(?:^|; )" + regexp.escapeString(name) + "=([^;]*)"));
+		ret = matches ? decodeURIComponent(matches[1]) : undefined; 
+	}else{
+		props = props || {};
+// FIXME: expires=0 seems to disappear right away, not on close? (FF3)  Change docs?
+		var exp = props.expires;
+		if(typeof exp == "number"){
+			var d = new Date();
+			d.setTime(d.getTime() + exp*24*60*60*1000);
+			exp = props.expires = d;
+		}
+		if(exp && exp.toUTCString){ props.expires = exp.toUTCString(); }
+
+		value = encodeURIComponent(value);
+		var updatedCookie = name + "=" + value, propName;
+		for(propName in props){
+			updatedCookie += "; " + propName;
+			var propValue = props[propName];
+			if(propValue !== true){ updatedCookie += "=" + propValue; }
+		}
+		document.cookie = updatedCookie;
+	}
+	return ret; // String|undefined
+};
+
+dojo.cookie.isSupported = function(){
+	//	summary:
+	//		Use to determine if the current browser supports cookies or not.
+	//
+	//		Returns true if user allows cookies.
+	//		Returns false if user doesn't allow cookies.
+
+	if(!("cookieEnabled" in navigator)){
+		this("__djCookieTest__", "CookiesAllowed");
+		navigator.cookieEnabled = this("__djCookieTest__") == "CookiesAllowed";
+		if(navigator.cookieEnabled){
+			this("__djCookieTest__", "", {expires: -1});
+		}
+	}
+	return navigator.cookieEnabled;
+};
+
+return dojo.cookie;
+});
diff --git a/js/dojo-1.7.2/dojo/currency.js b/js/dojo-1.7.2/dojo/currency.js
new file mode 100644
index 0000000..ea219c0
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/currency.js
@@ -0,0 +1,133 @@
+//>>built
+define("dojo/currency", ["./_base/kernel", "./_base/lang", "./_base/array", "./number", "./i18n", "./i18n!./cldr/nls/currency", "./cldr/monetary"], function(dojo, lang, darray, dnumber, i18n, nlsCurrency, cldrMonetary) {
+	// module:
+	//		dojo/currency
+	// summary:
+	//		TODOC
+
+lang.getObject("currency", true, dojo);
+
+/*=====
+dojo.currency = {
+	// summary: localized formatting and parsing routines for currencies
+	//
+	// description: extends dojo.number to provide culturally-appropriate formatting of values
+	//	in various world currencies, including use of a currency symbol.  The currencies are specified
+	//	by a three-letter international symbol in all uppercase, and support for the currencies is
+	//	provided by the data in `dojo.cldr`.  The scripts generating dojo.cldr specify which
+	//	currency support is included.  A fixed number of decimal places is determined based
+	//	on the currency type and is not determined by the 'pattern' argument.  The fractional
+	//	portion is optional, by default, and variable length decimals are not supported.
+}
+=====*/
+
+dojo.currency._mixInDefaults = function(options){
+	options = options || {};
+	options.type = "currency";
+
+	// Get locale-dependent currency data, like the symbol
+	var bundle = i18n.getLocalization("dojo.cldr", "currency", options.locale) || {};
+
+	// Mixin locale-independent currency data, like # of places
+	var iso = options.currency;
+	var data = cldrMonetary.getData(iso);
+
+	darray.forEach(["displayName","symbol","group","decimal"], function(prop){
+		data[prop] = bundle[iso+"_"+prop];
+	});
+
+	data.fractional = [true, false];
+
+	// Mixin with provided options
+	return lang.mixin(data, options);
+};
+
+/*=====
+dojo.declare("dojo.currency.__FormatOptions", [dojo.number.__FormatOptions], {
+	//	type: String?
+	//		Should not be set.  Value is assumed to be "currency".
+	//	symbol: String?
+	//		localized currency symbol. The default will be looked up in table of supported currencies in `dojo.cldr`
+	//		A [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code will be used if not found.
+	//	currency: String?
+	//		an [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD".
+	//		For use with dojo.currency only.
+	//	places: Number?
+	//		number of decimal places to show.  Default is defined based on which currency is used.
+	type: "",
+	symbol: "",
+	currency: "",
+	places: ""
+});
+=====*/
+
+dojo.currency.format = function(/*Number*/value, /*dojo.currency.__FormatOptions?*/options){
+// summary:
+//		Format a Number as a currency, using locale-specific settings
+//
+// description:
+//		Create a string from a Number using a known, localized pattern.
+//		[Formatting patterns](http://www.unicode.org/reports/tr35/#Number_Elements)
+//		appropriate to the locale are chosen from the [CLDR](http://unicode.org/cldr)
+//		as well as the appropriate symbols and delimiters and number of decimal places.
+//
+// value:
+//		the number to be formatted.
+
+	return dnumber.format(value, dojo.currency._mixInDefaults(options));
+};
+
+dojo.currency.regexp = function(/*dojo.number.__RegexpOptions?*/options){
+//
+// summary:
+//		Builds the regular needed to parse a currency value
+//
+// description:
+//		Returns regular expression with positive and negative match, group and decimal separators
+//		Note: the options.places default, the number of decimal places to accept, is defined by the currency type.
+	return dnumber.regexp(dojo.currency._mixInDefaults(options)); // String
+};
+
+/*=====
+dojo.declare("dojo.currency.__ParseOptions", [dojo.number.__ParseOptions], {
+	//	type: String?
+	//		Should not be set.  Value is assumed to be currency.
+	//	currency: String?
+	//		an [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code, a three letter sequence like "USD".
+	//		For use with dojo.currency only.
+	//	symbol: String?
+	//		localized currency symbol. The default will be looked up in table of supported currencies in `dojo.cldr`
+	//		A [ISO4217](http://en.wikipedia.org/wiki/ISO_4217) currency code will be used if not found.
+	//	places: Number?
+	//		fixed number of decimal places to accept.  The default is determined based on which currency is used.
+	//	fractional: Boolean?|Array?
+	//		Whether to include the fractional portion, where the number of decimal places are implied by the currency
+	//		or explicit 'places' parameter.  The value [true,false] makes the fractional portion optional.
+	//		By default for currencies, it the fractional portion is optional.
+	type: "",
+	currency: "",
+	symbol: "",
+	places: "",
+	fractional: ""
+});
+=====*/
+
+dojo.currency.parse = function(/*String*/expression, /*dojo.currency.__ParseOptions?*/options){
+	//
+	// summary:
+	//		Convert a properly formatted currency string to a primitive Number,
+	//		using locale-specific settings.
+	//
+	// description:
+	//		Create a Number from a string using a known, localized pattern.
+	//		[Formatting patterns](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
+	//		are chosen appropriate to the locale, as well as the appropriate symbols and delimiters
+	//		and number of decimal places.
+	//
+	// expression: A string representation of a currency value
+
+	return dnumber.parse(expression, dojo.currency._mixInDefaults(options));
+};
+
+return dojo.currency;
+});
diff --git a/js/dojo-1.7.2/dojo/data/ItemFileReadStore.js b/js/dojo-1.7.2/dojo/data/ItemFileReadStore.js
new file mode 100644
index 0000000..f9993ff
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/ItemFileReadStore.js
@@ -0,0 +1,946 @@
+//>>built
+define("dojo/data/ItemFileReadStore", ["../_base/kernel", "../_base/lang", "../_base/declare", "../_base/array", "../_base/xhr", 
+	"../Evented", "../_base/window", "./util/filter", "./util/simpleFetch", "../date/stamp"
+], function(kernel, lang, declare, array, xhr, Evented, window, filterUtil, simpleFetch, dateStamp) {
+	// module:
+	//		dojo/data/ItemFileReadStore
+	// summary:
+	//		TODOC
+
+
+var ItemFileReadStore = declare("dojo.data.ItemFileReadStore", [Evented],{
+	//	summary:
+	//		The ItemFileReadStore implements the dojo.data.api.Read API and reads
+	//		data from JSON files that have contents in this format --
+	//		{ items: [
+	//			{ name:'Kermit', color:'green', age:12, friends:['Gonzo', {_reference:{name:'Fozzie Bear'}}]},
+	//			{ name:'Fozzie Bear', wears:['hat', 'tie']},
+	//			{ name:'Miss Piggy', pets:'Foo-Foo'}
+	//		]}
+	//		Note that it can also contain an 'identifer' property that specified which attribute on the items
+	//		in the array of items that acts as the unique identifier for that item.
+	//
+	constructor: function(/* Object */ keywordParameters){
+		//	summary: constructor
+		//	keywordParameters: {url: String}
+		//	keywordParameters: {data: jsonObject}
+		//	keywordParameters: {typeMap: object)
+		//		The structure of the typeMap object is as follows:
+		//		{
+		//			type0: function || object,
+		//			type1: function || object,
+		//			...
+		//			typeN: function || object
+		//		}
+		//		Where if it is a function, it is assumed to be an object constructor that takes the
+		//		value of _value as the initialization parameters.  If it is an object, then it is assumed
+		//		to be an object of general form:
+		//		{
+		//			type: function, //constructor.
+		//			deserialize:	function(value) //The function that parses the value and constructs the object defined by type appropriately.
+		//		}
+
+		this._arrayOfAllItems = [];
+		this._arrayOfTopLevelItems = [];
+		this._loadFinished = false;
+		this._jsonFileUrl = keywordParameters.url;
+		this._ccUrl = keywordParameters.url;
+		this.url = keywordParameters.url;
+		this._jsonData = keywordParameters.data;
+		this.data = null;
+		this._datatypeMap = keywordParameters.typeMap || {};
+		if(!this._datatypeMap['Date']){
+			//If no default mapping for dates, then set this as default.
+			//We use the dojo.date.stamp here because the ISO format is the 'dojo way'
+			//of generically representing dates.
+			this._datatypeMap['Date'] = {
+											type: Date,
+											deserialize: function(value){
+												return dateStamp.fromISOString(value);
+											}
+										};
+		}
+		this._features = {'dojo.data.api.Read':true, 'dojo.data.api.Identity':true};
+		this._itemsByIdentity = null;
+		this._storeRefPropName = "_S"; // Default name for the store reference to attach to every item.
+		this._itemNumPropName = "_0"; // Default Item Id for isItem to attach to every item.
+		this._rootItemPropName = "_RI"; // Default Item Id for isItem to attach to every item.
+		this._reverseRefMap = "_RRM"; // Default attribute for constructing a reverse reference map for use with reference integrity
+		this._loadInProgress = false; //Got to track the initial load to prevent duelling loads of the dataset.
+		this._queuedFetches = [];
+		if(keywordParameters.urlPreventCache !== undefined){
+			this.urlPreventCache = keywordParameters.urlPreventCache?true:false;
+		}
+		if(keywordParameters.hierarchical !== undefined){
+			this.hierarchical = keywordParameters.hierarchical?true:false;
+		}
+		if(keywordParameters.clearOnClose){
+			this.clearOnClose = true;
+		}
+		if("failOk" in keywordParameters){
+			this.failOk = keywordParameters.failOk?true:false;
+		}
+	},
+
+	url: "",	// use "" rather than undefined for the benefit of the parser (#3539)
+
+	//Internal var, crossCheckUrl.  Used so that setting either url or _jsonFileUrl, can still trigger a reload
+	//when clearOnClose and close is used.
+	_ccUrl: "",
+
+	data: null,	// define this so that the parser can populate it
+
+	typeMap: null, //Define so parser can populate.
+
+	//Parameter to allow users to specify if a close call should force a reload or not.
+	//By default, it retains the old behavior of not clearing if close is called.  But
+	//if set true, the store will be reset to default state.  Note that by doing this,
+	//all item handles will become invalid and a new fetch must be issued.
+	clearOnClose: false,
+
+	//Parameter to allow specifying if preventCache should be passed to the xhrGet call or not when loading data from a url.
+	//Note this does not mean the store calls the server on each fetch, only that the data load has preventCache set as an option.
+	//Added for tracker: #6072
+	urlPreventCache: false,
+
+	//Parameter for specifying that it is OK for the xhrGet call to fail silently.
+	failOk: false,
+
+	//Parameter to indicate to process data from the url as hierarchical
+	//(data items can contain other data items in js form).  Default is true
+	//for backwards compatibility.  False means only root items are processed
+	//as items, all child objects outside of type-mapped objects and those in
+	//specific reference format, are left straight JS data objects.
+	hierarchical: true,
+
+	_assertIsItem: function(/* item */ item){
+		//	summary:
+		//		This function tests whether the item passed in is indeed an item in the store.
+		//	item:
+		//		The item to test for being contained by the store.
+		if(!this.isItem(item)){
+			throw new Error("dojo.data.ItemFileReadStore: Invalid item argument.");
+		}
+	},
+
+	_assertIsAttribute: function(/* attribute-name-string */ attribute){
+		//	summary:
+		//		This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.
+		//	attribute:
+		//		The attribute to test for being contained by the store.
+		if(typeof attribute !== "string"){
+			throw new Error("dojo.data.ItemFileReadStore: Invalid attribute argument.");
+		}
+	},
+
+	getValue: function(	/* item */ item,
+						/* attribute-name-string */ attribute,
+						/* value? */ defaultValue){
+		//	summary:
+		//		See dojo.data.api.Read.getValue()
+		var values = this.getValues(item, attribute);
+		return (values.length > 0)?values[0]:defaultValue; // mixed
+	},
+
+	getValues: function(/* item */ item,
+						/* attribute-name-string */ attribute){
+		//	summary:
+		//		See dojo.data.api.Read.getValues()
+
+		this._assertIsItem(item);
+		this._assertIsAttribute(attribute);
+		// Clone it before returning.  refs: #10474
+		return (item[attribute] || []).slice(0); // Array
+	},
+
+	getAttributes: function(/* item */ item){
+		//	summary:
+		//		See dojo.data.api.Read.getAttributes()
+		this._assertIsItem(item);
+		var attributes = [];
+		for(var key in item){
+			// Save off only the real item attributes, not the special id marks for O(1) isItem.
+			if((key !== this._storeRefPropName) && (key !== this._itemNumPropName) && (key !== this._rootItemPropName) && (key !== this._reverseRefMap)){
+				attributes.push(key);
+			}
+		}
+		return attributes; // Array
+	},
+
+	hasAttribute: function(	/* item */ item,
+							/* attribute-name-string */ attribute){
+		//	summary:
+		//		See dojo.data.api.Read.hasAttribute()
+		this._assertIsItem(item);
+		this._assertIsAttribute(attribute);
+		return (attribute in item);
+	},
+
+	containsValue: function(/* item */ item,
+							/* attribute-name-string */ attribute,
+							/* anything */ value){
+		//	summary:
+		//		See dojo.data.api.Read.containsValue()
+		var regexp = undefined;
+		if(typeof value === "string"){
+			regexp = filterUtil.patternToRegExp(value, false);
+		}
+		return this._containsValue(item, attribute, value, regexp); //boolean.
+	},
+
+	_containsValue: function(	/* item */ item,
+								/* attribute-name-string */ attribute,
+								/* anything */ value,
+								/* RegExp?*/ regexp){
+		//	summary:
+		//		Internal function for looking at the values contained by the item.
+		//	description:
+		//		Internal function for looking at the values contained by the item.  This
+		//		function allows for denoting if the comparison should be case sensitive for
+		//		strings or not (for handling filtering cases where string case should not matter)
+		//
+		//	item:
+		//		The data item to examine for attribute values.
+		//	attribute:
+		//		The attribute to inspect.
+		//	value:
+		//		The value to match.
+		//	regexp:
+		//		Optional regular expression generated off value if value was of string type to handle wildcarding.
+		//		If present and attribute values are string, then it can be used for comparison instead of 'value'
+		return array.some(this.getValues(item, attribute), function(possibleValue){
+			if(possibleValue !== null && !lang.isObject(possibleValue) && regexp){
+				if(possibleValue.toString().match(regexp)){
+					return true; // Boolean
+				}
+			}else if(value === possibleValue){
+				return true; // Boolean
+			}
+		});
+	},
+
+	isItem: function(/* anything */ something){
+		//	summary:
+		//		See dojo.data.api.Read.isItem()
+		if(something && something[this._storeRefPropName] === this){
+			if(this._arrayOfAllItems[something[this._itemNumPropName]] === something){
+				return true;
+			}
+		}
+		return false; // Boolean
+	},
+
+	isItemLoaded: function(/* anything */ something){
+		//	summary:
+		//		See dojo.data.api.Read.isItemLoaded()
+		return this.isItem(something); //boolean
+	},
+
+	loadItem: function(/* object */ keywordArgs){
+		//	summary:
+		//		See dojo.data.api.Read.loadItem()
+		this._assertIsItem(keywordArgs.item);
+	},
+
+	getFeatures: function(){
+		//	summary:
+		//		See dojo.data.api.Read.getFeatures()
+		return this._features; //Object
+	},
+
+	getLabel: function(/* item */ item){
+		//	summary:
+		//		See dojo.data.api.Read.getLabel()
+		if(this._labelAttr && this.isItem(item)){
+			return this.getValue(item,this._labelAttr); //String
+		}
+		return undefined; //undefined
+	},
+
+	getLabelAttributes: function(/* item */ item){
+		//	summary:
+		//		See dojo.data.api.Read.getLabelAttributes()
+		if(this._labelAttr){
+			return [this._labelAttr]; //array
+		}
+		return null; //null
+	},
+
+	_fetchItems: function(	/* Object */ keywordArgs,
+							/* Function */ findCallback,
+							/* Function */ errorCallback){
+		//	summary:
+		//		See dojo.data.util.simpleFetch.fetch()
+		var self = this,
+		    filter = function(requestArgs, arrayOfItems){
+			var items = [],
+			    i, key;
+			if(requestArgs.query){
+				var value,
+				    ignoreCase = requestArgs.queryOptions ? requestArgs.queryOptions.ignoreCase : false;
+
+				//See if there are any string values that can be regexp parsed first to avoid multiple regexp gens on the
+				//same value for each item examined.  Much more efficient.
+				var regexpList = {};
+				for(key in requestArgs.query){
+					value = requestArgs.query[key];
+					if(typeof value === "string"){
+						regexpList[key] = filterUtil.patternToRegExp(value, ignoreCase);
+					}else if(value instanceof RegExp){
+						regexpList[key] = value;
+					}
+				}
+				for(i = 0; i < arrayOfItems.length; ++i){
+					var match = true;
+					var candidateItem = arrayOfItems[i];
+					if(candidateItem === null){
+						match = false;
+					}else{
+						for(key in requestArgs.query){
+							value = requestArgs.query[key];
+							if(!self._containsValue(candidateItem, key, value, regexpList[key])){
+								match = false;
+							}
+						}
+					}
+					if(match){
+						items.push(candidateItem);
+					}
+				}
+				findCallback(items, requestArgs);
+			}else{
+				// We want a copy to pass back in case the parent wishes to sort the array.
+				// We shouldn't allow resort of the internal list, so that multiple callers
+				// can get lists and sort without affecting each other.  We also need to
+				// filter out any null values that have been left as a result of deleteItem()
+				// calls in ItemFileWriteStore.
+				for(i = 0; i < arrayOfItems.length; ++i){
+					var item = arrayOfItems[i];
+					if(item !== null){
+						items.push(item);
+					}
+				}
+				findCallback(items, requestArgs);
+			}
+		};
+
+		if(this._loadFinished){
+			filter(keywordArgs, this._getItemsArray(keywordArgs.queryOptions));
+		}else{
+			//Do a check on the JsonFileUrl and crosscheck it.
+			//If it doesn't match the cross-check, it needs to be updated
+			//This allows for either url or _jsonFileUrl to he changed to
+			//reset the store load location.  Done this way for backwards
+			//compatibility.  People use _jsonFileUrl (even though officially
+			//private.
+			if(this._jsonFileUrl !== this._ccUrl){
+				kernel.deprecated("dojo.data.ItemFileReadStore: ",
+					"To change the url, set the url property of the store," +
+					" not _jsonFileUrl.  _jsonFileUrl support will be removed in 2.0");
+				this._ccUrl = this._jsonFileUrl;
+				this.url = this._jsonFileUrl;
+			}else if(this.url !== this._ccUrl){
+				this._jsonFileUrl = this.url;
+				this._ccUrl = this.url;
+			}
+
+			//See if there was any forced reset of data.
+			if(this.data != null){
+				this._jsonData = this.data;
+				this.data = null;
+			}
+
+			if(this._jsonFileUrl){
+				//If fetches come in before the loading has finished, but while
+				//a load is in progress, we have to defer the fetching to be
+				//invoked in the callback.
+				if(this._loadInProgress){
+					this._queuedFetches.push({args: keywordArgs, filter: filter});
+				}else{
+					this._loadInProgress = true;
+					var getArgs = {
+							url: self._jsonFileUrl,
+							handleAs: "json-comment-optional",
+							preventCache: this.urlPreventCache,
+							failOk: this.failOk
+						};
+					var getHandler = xhr.get(getArgs);
+					getHandler.addCallback(function(data){
+						try{
+							self._getItemsFromLoadedData(data);
+							self._loadFinished = true;
+							self._loadInProgress = false;
+
+							filter(keywordArgs, self._getItemsArray(keywordArgs.queryOptions));
+							self._handleQueuedFetches();
+						}catch(e){
+							self._loadFinished = true;
+							self._loadInProgress = false;
+							errorCallback(e, keywordArgs);
+						}
+					});
+					getHandler.addErrback(function(error){
+						self._loadInProgress = false;
+						errorCallback(error, keywordArgs);
+					});
+
+					//Wire up the cancel to abort of the request
+					//This call cancel on the deferred if it hasn't been called
+					//yet and then will chain to the simple abort of the
+					//simpleFetch keywordArgs
+					var oldAbort = null;
+					if(keywordArgs.abort){
+						oldAbort = keywordArgs.abort;
+					}
+					keywordArgs.abort = function(){
+						var df = getHandler;
+						if(df && df.fired === -1){
+							df.cancel();
+							df = null;
+						}
+						if(oldAbort){
+							oldAbort.call(keywordArgs);
+						}
+					};
+				}
+			}else if(this._jsonData){
+				try{
+					this._loadFinished = true;
+					this._getItemsFromLoadedData(this._jsonData);
+					this._jsonData = null;
+					filter(keywordArgs, this._getItemsArray(keywordArgs.queryOptions));
+				}catch(e){
+					errorCallback(e, keywordArgs);
+				}
+			}else{
+				errorCallback(new Error("dojo.data.ItemFileReadStore: No JSON source data was provided as either URL or a nested Javascript object."), keywordArgs);
+			}
+		}
+	},
+
+	_handleQueuedFetches: function(){
+		//	summary:
+		//		Internal function to execute delayed request in the store.
+		//Execute any deferred fetches now.
+		if(this._queuedFetches.length > 0){
+			for(var i = 0; i < this._queuedFetches.length; i++){
+				var fData = this._queuedFetches[i],
+				    delayedQuery = fData.args,
+				    delayedFilter = fData.filter;
+				if(delayedFilter){
+					delayedFilter(delayedQuery, this._getItemsArray(delayedQuery.queryOptions));
+				}else{
+					this.fetchItemByIdentity(delayedQuery);
+				}
+			}
+			this._queuedFetches = [];
+		}
+	},
+
+	_getItemsArray: function(/*object?*/queryOptions){
+		//	summary:
+		//		Internal function to determine which list of items to search over.
+		//	queryOptions: The query options parameter, if any.
+		if(queryOptions && queryOptions.deep){
+			return this._arrayOfAllItems;
+		}
+		return this._arrayOfTopLevelItems;
+	},
+
+	close: function(/*dojo.data.api.Request || keywordArgs || null */ request){
+		 //	summary:
+		 //		See dojo.data.api.Read.close()
+		 if(this.clearOnClose &&
+			this._loadFinished &&
+			!this._loadInProgress){
+			 //Reset all internalsback to default state.  This will force a reload
+			 //on next fetch.  This also checks that the data or url param was set
+			 //so that the store knows it can get data.  Without one of those being set,
+			 //the next fetch will trigger an error.
+
+			 if(((this._jsonFileUrl == "" || this._jsonFileUrl == null) &&
+				 (this.url == "" || this.url == null)
+				) && this.data == null){
+				 console.debug("dojo.data.ItemFileReadStore: WARNING!  Data reload " +
+					" information has not been provided." +
+					"  Please set 'url' or 'data' to the appropriate value before" +
+					" the next fetch");
+			 }
+			 this._arrayOfAllItems = [];
+			 this._arrayOfTopLevelItems = [];
+			 this._loadFinished = false;
+			 this._itemsByIdentity = null;
+			 this._loadInProgress = false;
+			 this._queuedFetches = [];
+		 }
+	},
+
+	_getItemsFromLoadedData: function(/* Object */ dataObject){
+		//	summary:
+		//		Function to parse the loaded data into item format and build the internal items array.
+		//	description:
+		//		Function to parse the loaded data into item format and build the internal items array.
+		//
+		//	dataObject:
+		//		The JS data object containing the raw data to convery into item format.
+		//
+		// 	returns: array
+		//		Array of items in store item format.
+
+		// First, we define a couple little utility functions...
+		var addingArrays = false,
+		    self = this;
+
+		function valueIsAnItem(/* anything */ aValue){
+			// summary:
+			//		Given any sort of value that could be in the raw json data,
+			//		return true if we should interpret the value as being an
+			//		item itself, rather than a literal value or a reference.
+			// example:
+			// 	|	false == valueIsAnItem("Kermit");
+			// 	|	false == valueIsAnItem(42);
+			// 	|	false == valueIsAnItem(new Date());
+			// 	|	false == valueIsAnItem({_type:'Date', _value:'1802-05-14'});
+			// 	|	false == valueIsAnItem({_reference:'Kermit'});
+			// 	|	true == valueIsAnItem({name:'Kermit', color:'green'});
+			// 	|	true == valueIsAnItem({iggy:'pop'});
+			// 	|	true == valueIsAnItem({foo:42});
+			return (aValue !== null) &&
+				(typeof aValue === "object") &&
+				(!lang.isArray(aValue) || addingArrays) &&
+				(!lang.isFunction(aValue)) &&
+				(aValue.constructor == Object || lang.isArray(aValue)) &&
+				(typeof aValue._reference === "undefined") &&
+				(typeof aValue._type === "undefined") &&
+				(typeof aValue._value === "undefined") &&
+				self.hierarchical;
+		}
+
+		function addItemAndSubItemsToArrayOfAllItems(/* Item */ anItem){
+			self._arrayOfAllItems.push(anItem);
+			for(var attribute in anItem){
+				var valueForAttribute = anItem[attribute];
+				if(valueForAttribute){
+					if(lang.isArray(valueForAttribute)){
+						var valueArray = valueForAttribute;
+						for(var k = 0; k < valueArray.length; ++k){
+							var singleValue = valueArray[k];
+							if(valueIsAnItem(singleValue)){
+								addItemAndSubItemsToArrayOfAllItems(singleValue);
+							}
+						}
+					}else{
+						if(valueIsAnItem(valueForAttribute)){
+							addItemAndSubItemsToArrayOfAllItems(valueForAttribute);
+						}
+					}
+				}
+			}
+		}
+
+		this._labelAttr = dataObject.label;
+
+		// We need to do some transformations to convert the data structure
+		// that we read from the file into a format that will be convenient
+		// to work with in memory.
+
+		// Step 1: Walk through the object hierarchy and build a list of all items
+		var i,
+		    item;
+		this._arrayOfAllItems = [];
+		this._arrayOfTopLevelItems = dataObject.items;
+
+		for(i = 0; i < this._arrayOfTopLevelItems.length; ++i){
+			item = this._arrayOfTopLevelItems[i];
+			if(lang.isArray(item)){
+				addingArrays = true;
+			}
+			addItemAndSubItemsToArrayOfAllItems(item);
+			item[this._rootItemPropName]=true;
+		}
+
+		// Step 2: Walk through all the attribute values of all the items,
+		// and replace single values with arrays.  For example, we change this:
+		//		{ name:'Miss Piggy', pets:'Foo-Foo'}
+		// into this:
+		//		{ name:['Miss Piggy'], pets:['Foo-Foo']}
+		//
+		// We also store the attribute names so we can validate our store
+		// reference and item id special properties for the O(1) isItem
+		var allAttributeNames = {},
+		    key;
+
+		for(i = 0; i < this._arrayOfAllItems.length; ++i){
+			item = this._arrayOfAllItems[i];
+			for(key in item){
+				if(key !== this._rootItemPropName){
+					var value = item[key];
+					if(value !== null){
+						if(!lang.isArray(value)){
+							item[key] = [value];
+						}
+					}else{
+						item[key] = [null];
+					}
+				}
+				allAttributeNames[key]=key;
+			}
+		}
+
+		// Step 3: Build unique property names to use for the _storeRefPropName and _itemNumPropName
+		// This should go really fast, it will generally never even run the loop.
+		while(allAttributeNames[this._storeRefPropName]){
+			this._storeRefPropName += "_";
+		}
+		while(allAttributeNames[this._itemNumPropName]){
+			this._itemNumPropName += "_";
+		}
+		while(allAttributeNames[this._reverseRefMap]){
+			this._reverseRefMap += "_";
+		}
+
+		// Step 4: Some data files specify an optional 'identifier', which is
+		// the name of an attribute that holds the identity of each item.
+		// If this data file specified an identifier attribute, then build a
+		// hash table of items keyed by the identity of the items.
+		var arrayOfValues;
+
+		var identifier = dataObject.identifier;
+		if(identifier){
+			this._itemsByIdentity = {};
+			this._features['dojo.data.api.Identity'] = identifier;
+			for(i = 0; i < this._arrayOfAllItems.length; ++i){
+				item = this._arrayOfAllItems[i];
+				arrayOfValues = item[identifier];
+				var identity = arrayOfValues[0];
+				if(!Object.hasOwnProperty.call(this._itemsByIdentity, identity)){
+					this._itemsByIdentity[identity] = item;
+				}else{
+					if(this._jsonFileUrl){
+						throw new Error("dojo.data.ItemFileReadStore:  The json data as specified by: [" + this._jsonFileUrl + "] is malformed.  Items within the list have identifier: [" + identifier + "].  Value collided: [" + identity + "]");
+					}else if(this._jsonData){
+						throw new Error("dojo.data.ItemFileReadStore:  The json data provided by the creation arguments is malformed.  Items within the list have identifier: [" + identifier + "].  Value collided: [" + identity + "]");
+					}
+				}
+			}
+		}else{
+			this._features['dojo.data.api.Identity'] = Number;
+		}
+
+		// Step 5: Walk through all the items, and set each item's properties
+		// for _storeRefPropName and _itemNumPropName, so that store.isItem() will return true.
+		for(i = 0; i < this._arrayOfAllItems.length; ++i){
+			item = this._arrayOfAllItems[i];
+			item[this._storeRefPropName] = this;
+			item[this._itemNumPropName] = i;
+		}
+
+		// Step 6: We walk through all the attribute values of all the items,
+		// looking for type/value literals and item-references.
+		//
+		// We replace item-references with pointers to items.  For example, we change:
+		//		{ name:['Kermit'], friends:[{_reference:{name:'Miss Piggy'}}] }
+		// into this:
+		//		{ name:['Kermit'], friends:[miss_piggy] }
+		// (where miss_piggy is the object representing the 'Miss Piggy' item).
+		//
+		// We replace type/value pairs with typed-literals.  For example, we change:
+		//		{ name:['Nelson Mandela'], born:[{_type:'Date', _value:'1918-07-18'}] }
+		// into this:
+		//		{ name:['Kermit'], born:(new Date(1918, 6, 18)) }
+		//
+		// We also generate the associate map for all items for the O(1) isItem function.
+		for(i = 0; i < this._arrayOfAllItems.length; ++i){
+			item = this._arrayOfAllItems[i]; // example: { name:['Kermit'], friends:[{_reference:{name:'Miss Piggy'}}] }
+			for(key in item){
+				arrayOfValues = item[key]; // example: [{_reference:{name:'Miss Piggy'}}]
+				for(var j = 0; j < arrayOfValues.length; ++j){
+					value = arrayOfValues[j]; // example: {_reference:{name:'Miss Piggy'}}
+					if(value !== null && typeof value == "object"){
+						if(("_type" in value) && ("_value" in value)){
+							var type = value._type; // examples: 'Date', 'Color', or 'ComplexNumber'
+							var mappingObj = this._datatypeMap[type]; // examples: Date, dojo.Color, foo.math.ComplexNumber, {type: dojo.Color, deserialize(value){ return new dojo.Color(value)}}
+							if(!mappingObj){
+								throw new Error("dojo.data.ItemFileReadStore: in the typeMap constructor arg, no object class was specified for the datatype '" + type + "'");
+							}else if(lang.isFunction(mappingObj)){
+								arrayOfValues[j] = new mappingObj(value._value);
+							}else if(lang.isFunction(mappingObj.deserialize)){
+								arrayOfValues[j] = mappingObj.deserialize(value._value);
+							}else{
+								throw new Error("dojo.data.ItemFileReadStore: Value provided in typeMap was neither a constructor, nor a an object with a deserialize function");
+							}
+						}
+						if(value._reference){
+							var referenceDescription = value._reference; // example: {name:'Miss Piggy'}
+							if(!lang.isObject(referenceDescription)){
+								// example: 'Miss Piggy'
+								// from an item like: { name:['Kermit'], friends:[{_reference:'Miss Piggy'}]}
+								arrayOfValues[j] = this._getItemByIdentity(referenceDescription);
+							}else{
+								// example: {name:'Miss Piggy'}
+								// from an item like: { name:['Kermit'], friends:[{_reference:{name:'Miss Piggy'}}] }
+								for(var k = 0; k < this._arrayOfAllItems.length; ++k){
+									var candidateItem = this._arrayOfAllItems[k],
+									    found = true;
+									for(var refKey in referenceDescription){
+										if(candidateItem[refKey] != referenceDescription[refKey]){
+											found = false;
+										}
+									}
+									if(found){
+										arrayOfValues[j] = candidateItem;
+									}
+								}
+							}
+							if(this.referenceIntegrity){
+								var refItem = arrayOfValues[j];
+								if(this.isItem(refItem)){
+									this._addReferenceToMap(refItem, item, key);
+								}
+							}
+						}else if(this.isItem(value)){
+							//It's a child item (not one referenced through _reference).
+							//We need to treat this as a referenced item, so it can be cleaned up
+							//in a write store easily.
+							if(this.referenceIntegrity){
+								this._addReferenceToMap(value, item, key);
+							}
+						}
+					}
+				}
+			}
+		}
+	},
+
+	_addReferenceToMap: function(/*item*/ refItem, /*item*/ parentItem, /*string*/ attribute){
+		 //	summary:
+		 //		Method to add an reference map entry for an item and attribute.
+		 //	description:
+		 //		Method to add an reference map entry for an item and attribute. 		 //
+		 //	refItem:
+		 //		The item that is referenced.
+		 //	parentItem:
+		 //		The item that holds the new reference to refItem.
+		 //	attribute:
+		 //		The attribute on parentItem that contains the new reference.
+
+		 //Stub function, does nothing.  Real processing is in ItemFileWriteStore.
+	},
+
+	getIdentity: function(/* item */ item){
+		//	summary:
+		//		See dojo.data.api.Identity.getIdentity()
+		var identifier = this._features['dojo.data.api.Identity'];
+		if(identifier === Number){
+			return item[this._itemNumPropName]; // Number
+		}else{
+			var arrayOfValues = item[identifier];
+			if(arrayOfValues){
+				return arrayOfValues[0]; // Object || String
+			}
+		}
+		return null; // null
+	},
+
+	fetchItemByIdentity: function(/* Object */ keywordArgs){
+		//	summary:
+		//		See dojo.data.api.Identity.fetchItemByIdentity()
+
+		// Hasn't loaded yet, we have to trigger the load.
+		var item,
+		    scope;
+		if(!this._loadFinished){
+			var self = this;
+			//Do a check on the JsonFileUrl and crosscheck it.
+			//If it doesn't match the cross-check, it needs to be updated
+			//This allows for either url or _jsonFileUrl to he changed to
+			//reset the store load location.  Done this way for backwards
+			//compatibility.  People use _jsonFileUrl (even though officially
+			//private.
+			if(this._jsonFileUrl !== this._ccUrl){
+				kernel.deprecated("dojo.data.ItemFileReadStore: ",
+					"To change the url, set the url property of the store," +
+					" not _jsonFileUrl.  _jsonFileUrl support will be removed in 2.0");
+				this._ccUrl = this._jsonFileUrl;
+				this.url = this._jsonFileUrl;
+			}else if(this.url !== this._ccUrl){
+				this._jsonFileUrl = this.url;
+				this._ccUrl = this.url;
+			}
+
+			//See if there was any forced reset of data.
+			if(this.data != null && this._jsonData == null){
+				this._jsonData = this.data;
+				this.data = null;
+			}
+
+			if(this._jsonFileUrl){
+
+				if(this._loadInProgress){
+					this._queuedFetches.push({args: keywordArgs});
+				}else{
+					this._loadInProgress = true;
+					var getArgs = {
+							url: self._jsonFileUrl,
+							handleAs: "json-comment-optional",
+							preventCache: this.urlPreventCache,
+							failOk: this.failOk
+					};
+					var getHandler = xhr.get(getArgs);
+					getHandler.addCallback(function(data){
+						var scope = keywordArgs.scope?keywordArgs.scope:window.global;
+						try{
+							self._getItemsFromLoadedData(data);
+							self._loadFinished = true;
+							self._loadInProgress = false;
+							item = self._getItemByIdentity(keywordArgs.identity);
+							if(keywordArgs.onItem){
+								keywordArgs.onItem.call(scope, item);
+							}
+							self._handleQueuedFetches();
+						}catch(error){
+							self._loadInProgress = false;
+							if(keywordArgs.onError){
+								keywordArgs.onError.call(scope, error);
+							}
+						}
+					});
+					getHandler.addErrback(function(error){
+						self._loadInProgress = false;
+						if(keywordArgs.onError){
+							var scope = keywordArgs.scope?keywordArgs.scope:window.global;
+							keywordArgs.onError.call(scope, error);
+						}
+					});
+				}
+
+			}else if(this._jsonData){
+				// Passed in data, no need to xhr.
+				self._getItemsFromLoadedData(self._jsonData);
+				self._jsonData = null;
+				self._loadFinished = true;
+				item = self._getItemByIdentity(keywordArgs.identity);
+				if(keywordArgs.onItem){
+					scope = keywordArgs.scope?keywordArgs.scope:window.global;
+					keywordArgs.onItem.call(scope, item);
+				}
+			}
+		}else{
+			// Already loaded.  We can just look it up and call back.
+			item = this._getItemByIdentity(keywordArgs.identity);
+			if(keywordArgs.onItem){
+				scope = keywordArgs.scope?keywordArgs.scope:window.global;
+				keywordArgs.onItem.call(scope, item);
+			}
+		}
+	},
+
+	_getItemByIdentity: function(/* Object */ identity){
+		//	summary:
+		//		Internal function to look an item up by its identity map.
+		var item = null;
+		if(this._itemsByIdentity){
+			// If this map is defined, we need to just try to get it.  If it fails
+			// the item does not exist.
+			if(Object.hasOwnProperty.call(this._itemsByIdentity, identity)){
+				item = this._itemsByIdentity[identity];
+			}
+		}else if (Object.hasOwnProperty.call(this._arrayOfAllItems, identity)){
+			item = this._arrayOfAllItems[identity];
+		}
+		if(item === undefined){
+			item = null;
+		}
+		return item; // Object
+	},
+
+	getIdentityAttributes: function(/* item */ item){
+		//	summary:
+		//		See dojo.data.api.Identity.getIdentityAttributes()
+
+		var identifier = this._features['dojo.data.api.Identity'];
+		if(identifier === Number){
+			// If (identifier === Number) it means getIdentity() just returns
+			// an integer item-number for each item.  The dojo.data.api.Identity
+			// spec says we need to return null if the identity is not composed
+			// of attributes
+			return null; // null
+		}else{
+			return [identifier]; // Array
+		}
+	},
+
+	_forceLoad: function(){
+		//	summary:
+		//		Internal function to force a load of the store if it hasn't occurred yet.  This is required
+		//		for specific functions to work properly.
+		var self = this;
+		//Do a check on the JsonFileUrl and crosscheck it.
+		//If it doesn't match the cross-check, it needs to be updated
+		//This allows for either url or _jsonFileUrl to he changed to
+		//reset the store load location.  Done this way for backwards
+		//compatibility.  People use _jsonFileUrl (even though officially
+		//private.
+		if(this._jsonFileUrl !== this._ccUrl){
+			kernel.deprecated("dojo.data.ItemFileReadStore: ",
+				"To change the url, set the url property of the store," +
+				" not _jsonFileUrl.  _jsonFileUrl support will be removed in 2.0");
+			this._ccUrl = this._jsonFileUrl;
+			this.url = this._jsonFileUrl;
+		}else if(this.url !== this._ccUrl){
+			this._jsonFileUrl = this.url;
+			this._ccUrl = this.url;
+		}
+
+		//See if there was any forced reset of data.
+		if(this.data != null){
+			this._jsonData = this.data;
+			this.data = null;
+		}
+
+		if(this._jsonFileUrl){
+				var getArgs = {
+					url: this._jsonFileUrl,
+					handleAs: "json-comment-optional",
+					preventCache: this.urlPreventCache,
+					failOk: this.failOk,
+					sync: true
+				};
+			var getHandler = xhr.get(getArgs);
+			getHandler.addCallback(function(data){
+				try{
+					//Check to be sure there wasn't another load going on concurrently
+					//So we don't clobber data that comes in on it.  If there is a load going on
+					//then do not save this data.  It will potentially clobber current data.
+					//We mainly wanted to sync/wait here.
+					//TODO:  Revisit the loading scheme of this store to improve multi-initial
+					//request handling.
+					if(self._loadInProgress !== true && !self._loadFinished){
+						self._getItemsFromLoadedData(data);
+						self._loadFinished = true;
+					}else if(self._loadInProgress){
+						//Okay, we hit an error state we can't recover from.  A forced load occurred
+						//while an async load was occurring.  Since we cannot block at this point, the best
+						//that can be managed is to throw an error.
+						throw new Error("dojo.data.ItemFileReadStore:  Unable to perform a synchronous load, an async load is in progress.");
+					}
+				}catch(e){
+					console.log(e);
+					throw e;
+				}
+			});
+			getHandler.addErrback(function(error){
+				throw error;
+			});
+		}else if(this._jsonData){
+			self._getItemsFromLoadedData(self._jsonData);
+			self._jsonData = null;
+			self._loadFinished = true;
+		}
+	}
+});
+//Mix in the simple fetch implementation to this class.
+lang.extend(ItemFileReadStore,simpleFetch);
+
+return ItemFileReadStore;
+});
diff --git a/js/dojo-1.7.2/dojo/data/ItemFileWriteStore.js b/js/dojo-1.7.2/dojo/data/ItemFileWriteStore.js
new file mode 100644
index 0000000..da109d6
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/ItemFileWriteStore.js
@@ -0,0 +1,806 @@
+//>>built
+define("dojo/data/ItemFileWriteStore", ["../_base/lang", "../_base/declare", "../_base/array", "../_base/json", "../_base/window", 
+	"./ItemFileReadStore", "../date/stamp"
+], function(lang, declare, arrayUtil, jsonUtil, window, ItemFileReadStore, dateStamp) {
+	// module:
+	//		dojo/data/ItemFileWriteStore
+	// summary:
+	//		TODOC
+
+/*===== var ItemFileReadStore = dojo.data.ItemFileReadStore; =====*/
+return declare("dojo.data.ItemFileWriteStore", ItemFileReadStore, {
+	constructor: function(/* object */ keywordParameters){
+		//	keywordParameters: {typeMap: object)
+		//		The structure of the typeMap object is as follows:
+		//		{
+		//			type0: function || object,
+		//			type1: function || object,
+		//			...
+		//			typeN: function || object
+		//		}
+		//		Where if it is a function, it is assumed to be an object constructor that takes the
+		//		value of _value as the initialization parameters.  It is serialized assuming object.toString()
+		//		serialization.  If it is an object, then it is assumed
+		//		to be an object of general form:
+		//		{
+		//			type: function, //constructor.
+		//			deserialize:	function(value) //The function that parses the value and constructs the object defined by type appropriately.
+		//			serialize:	function(object) //The function that converts the object back into the proper file format form.
+		//		}
+
+		// ItemFileWriteStore extends ItemFileReadStore to implement these additional dojo.data APIs
+		this._features['dojo.data.api.Write'] = true;
+		this._features['dojo.data.api.Notification'] = true;
+
+		// For keeping track of changes so that we can implement isDirty and revert
+		this._pending = {
+			_newItems:{},
+			_modifiedItems:{},
+			_deletedItems:{}
+		};
+
+		if(!this._datatypeMap['Date'].serialize){
+			this._datatypeMap['Date'].serialize = function(obj){
+				return dateStamp.toISOString(obj, {zulu:true});
+			};
+		}
+		//Disable only if explicitly set to false.
+		if(keywordParameters && (keywordParameters.referenceIntegrity === false)){
+			this.referenceIntegrity = false;
+		}
+
+		// this._saveInProgress is set to true, briefly, from when save() is first called to when it completes
+		this._saveInProgress = false;
+	},
+
+	referenceIntegrity: true, //Flag that defaultly enabled reference integrity tracking.  This way it can also be disabled pogrammatially or declaratively.
+
+	_assert: function(/* boolean */ condition){
+		if(!condition){
+			throw new Error("assertion failed in ItemFileWriteStore");
+		}
+	},
+
+	_getIdentifierAttribute: function(){
+		// this._assert((identifierAttribute === Number) || (dojo.isString(identifierAttribute)));
+		return this.getFeatures()['dojo.data.api.Identity'];
+	},
+
+
+/* dojo.data.api.Write */
+
+	newItem: function(/* Object? */ keywordArgs, /* Object? */ parentInfo){
+		// summary: See dojo.data.api.Write.newItem()
+
+		this._assert(!this._saveInProgress);
+
+		if(!this._loadFinished){
+			// We need to do this here so that we'll be able to find out what
+			// identifierAttribute was specified in the data file.
+			this._forceLoad();
+		}
+
+		if(typeof keywordArgs != "object" && typeof keywordArgs != "undefined"){
+			throw new Error("newItem() was passed something other than an object");
+		}
+		var newIdentity = null;
+		var identifierAttribute = this._getIdentifierAttribute();
+		if(identifierAttribute === Number){
+			newIdentity = this._arrayOfAllItems.length;
+		}else{
+			newIdentity = keywordArgs[identifierAttribute];
+			if(typeof newIdentity === "undefined"){
+				throw new Error("newItem() was not passed an identity for the new item");
+			}
+			if(lang.isArray(newIdentity)){
+				throw new Error("newItem() was not passed an single-valued identity");
+			}
+		}
+
+		// make sure this identity is not already in use by another item, if identifiers were
+		// defined in the file.  Otherwise it would be the item count,
+		// which should always be unique in this case.
+		if(this._itemsByIdentity){
+			this._assert(typeof this._itemsByIdentity[newIdentity] === "undefined");
+		}
+		this._assert(typeof this._pending._newItems[newIdentity] === "undefined");
+		this._assert(typeof this._pending._deletedItems[newIdentity] === "undefined");
+
+		var newItem = {};
+		newItem[this._storeRefPropName] = this;
+		newItem[this._itemNumPropName] = this._arrayOfAllItems.length;
+		if(this._itemsByIdentity){
+			this._itemsByIdentity[newIdentity] = newItem;
+			//We have to set the identifier now, otherwise we can't look it
+			//up at calls to setValueorValues in parentInfo handling.
+			newItem[identifierAttribute] = [newIdentity];
+		}
+		this._arrayOfAllItems.push(newItem);
+
+		//We need to construct some data for the onNew call too...
+		var pInfo = null;
+
+		// Now we need to check to see where we want to assign this thingm if any.
+		if(parentInfo && parentInfo.parent && parentInfo.attribute){
+			pInfo = {
+				item: parentInfo.parent,
+				attribute: parentInfo.attribute,
+				oldValue: undefined
+			};
+
+			//See if it is multi-valued or not and handle appropriately
+			//Generally, all attributes are multi-valued for this store
+			//So, we only need to append if there are already values present.
+			var values = this.getValues(parentInfo.parent, parentInfo.attribute);
+			if(values && values.length > 0){
+				var tempValues = values.slice(0, values.length);
+				if(values.length === 1){
+					pInfo.oldValue = values[0];
+				}else{
+					pInfo.oldValue = values.slice(0, values.length);
+				}
+				tempValues.push(newItem);
+				this._setValueOrValues(parentInfo.parent, parentInfo.attribute, tempValues, false);
+				pInfo.newValue = this.getValues(parentInfo.parent, parentInfo.attribute);
+			}else{
+				this._setValueOrValues(parentInfo.parent, parentInfo.attribute, newItem, false);
+				pInfo.newValue = newItem;
+			}
+		}else{
+			//Toplevel item, add to both top list as well as all list.
+			newItem[this._rootItemPropName]=true;
+			this._arrayOfTopLevelItems.push(newItem);
+		}
+
+		this._pending._newItems[newIdentity] = newItem;
+
+		//Clone over the properties to the new item
+		for(var key in keywordArgs){
+			if(key === this._storeRefPropName || key === this._itemNumPropName){
+				// Bummer, the user is trying to do something like
+				// newItem({_S:"foo"}).  Unfortunately, our superclass,
+				// ItemFileReadStore, is already using _S in each of our items
+				// to hold private info.  To avoid a naming collision, we
+				// need to move all our private info to some other property
+				// of all the items/objects.  So, we need to iterate over all
+				// the items and do something like:
+				//    item.__S = item._S;
+				//    item._S = undefined;
+				// But first we have to make sure the new "__S" variable is
+				// not in use, which means we have to iterate over all the
+				// items checking for that.
+				throw new Error("encountered bug in ItemFileWriteStore.newItem");
+			}
+			var value = keywordArgs[key];
+			if(!lang.isArray(value)){
+				value = [value];
+			}
+			newItem[key] = value;
+			if(this.referenceIntegrity){
+				for(var i = 0; i < value.length; i++){
+					var val = value[i];
+					if(this.isItem(val)){
+						this._addReferenceToMap(val, newItem, key);
+					}
+				}
+			}
+		}
+		this.onNew(newItem, pInfo); // dojo.data.api.Notification call
+		return newItem; // item
+	},
+
+	_removeArrayElement: function(/* Array */ array, /* anything */ element){
+		var index = arrayUtil.indexOf(array, element);
+		if(index != -1){
+			array.splice(index, 1);
+			return true;
+		}
+		return false;
+	},
+
+	deleteItem: function(/* item */ item){
+		// summary: See dojo.data.api.Write.deleteItem()
+		this._assert(!this._saveInProgress);
+		this._assertIsItem(item);
+
+		// Remove this item from the _arrayOfAllItems, but leave a null value in place
+		// of the item, so as not to change the length of the array, so that in newItem()
+		// we can still safely do: newIdentity = this._arrayOfAllItems.length;
+		var indexInArrayOfAllItems = item[this._itemNumPropName];
+		var identity = this.getIdentity(item);
+
+		//If we have reference integrity on, we need to do reference cleanup for the deleted item
+		if(this.referenceIntegrity){
+			//First scan all the attributes of this items for references and clean them up in the map
+			//As this item is going away, no need to track its references anymore.
+
+			//Get the attributes list before we generate the backup so it
+			//doesn't pollute the attributes list.
+			var attributes = this.getAttributes(item);
+
+			//Backup the map, we'll have to restore it potentially, in a revert.
+			if(item[this._reverseRefMap]){
+				item["backup_" + this._reverseRefMap] = lang.clone(item[this._reverseRefMap]);
+			}
+
+			//TODO:  This causes a reversion problem.  This list won't be restored on revert since it is
+			//attached to the 'value'. item, not ours.  Need to back tese up somehow too.
+			//Maybe build a map of the backup of the entries and attach it to the deleted item to be restored
+			//later.  Or just record them and call _addReferenceToMap on them in revert.
+			arrayUtil.forEach(attributes, function(attribute){
+				arrayUtil.forEach(this.getValues(item, attribute), function(value){
+					if(this.isItem(value)){
+						//We have to back up all the references we had to others so they can be restored on a revert.
+						if(!item["backupRefs_" + this._reverseRefMap]){
+							item["backupRefs_" + this._reverseRefMap] = [];
+						}
+						item["backupRefs_" + this._reverseRefMap].push({id: this.getIdentity(value), attr: attribute});
+						this._removeReferenceFromMap(value, item, attribute);
+					}
+				}, this);
+			}, this);
+
+			//Next, see if we have references to this item, if we do, we have to clean them up too.
+			var references = item[this._reverseRefMap];
+			if(references){
+				//Look through all the items noted as references to clean them up.
+				for(var itemId in references){
+					var containingItem = null;
+					if(this._itemsByIdentity){
+						containingItem = this._itemsByIdentity[itemId];
+					}else{
+						containingItem = this._arrayOfAllItems[itemId];
+					}
+					//We have a reference to a containing item, now we have to process the
+					//attributes and clear all references to the item being deleted.
+					if(containingItem){
+						for(var attribute in references[itemId]){
+							var oldValues = this.getValues(containingItem, attribute) || [];
+							var newValues = arrayUtil.filter(oldValues, function(possibleItem){
+								return !(this.isItem(possibleItem) && this.getIdentity(possibleItem) == identity);
+							}, this);
+							//Remove the note of the reference to the item and set the values on the modified attribute.
+							this._removeReferenceFromMap(item, containingItem, attribute);
+							if(newValues.length < oldValues.length){
+								this._setValueOrValues(containingItem, attribute, newValues, true);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		this._arrayOfAllItems[indexInArrayOfAllItems] = null;
+
+		item[this._storeRefPropName] = null;
+		if(this._itemsByIdentity){
+			delete this._itemsByIdentity[identity];
+		}
+		this._pending._deletedItems[identity] = item;
+
+		//Remove from the toplevel items, if necessary...
+		if(item[this._rootItemPropName]){
+			this._removeArrayElement(this._arrayOfTopLevelItems, item);
+		}
+		this.onDelete(item); // dojo.data.api.Notification call
+		return true;
+	},
+
+	setValue: function(/* item */ item, /* attribute-name-string */ attribute, /* almost anything */ value){
+		// summary: See dojo.data.api.Write.set()
+		return this._setValueOrValues(item, attribute, value, true); // boolean
+	},
+
+	setValues: function(/* item */ item, /* attribute-name-string */ attribute, /* array */ values){
+		// summary: See dojo.data.api.Write.setValues()
+		return this._setValueOrValues(item, attribute, values, true); // boolean
+	},
+
+	unsetAttribute: function(/* item */ item, /* attribute-name-string */ attribute){
+		// summary: See dojo.data.api.Write.unsetAttribute()
+		return this._setValueOrValues(item, attribute, [], true);
+	},
+
+	_setValueOrValues: function(/* item */ item, /* attribute-name-string */ attribute, /* anything */ newValueOrValues, /*boolean?*/ callOnSet){
+		this._assert(!this._saveInProgress);
+
+		// Check for valid arguments
+		this._assertIsItem(item);
+		this._assert(lang.isString(attribute));
+		this._assert(typeof newValueOrValues !== "undefined");
+
+		// Make sure the user isn't trying to change the item's identity
+		var identifierAttribute = this._getIdentifierAttribute();
+		if(attribute == identifierAttribute){
+			throw new Error("ItemFileWriteStore does not have support for changing the value of an item's identifier.");
+		}
+
+		// To implement the Notification API, we need to make a note of what
+		// the old attribute value was, so that we can pass that info when
+		// we call the onSet method.
+		var oldValueOrValues = this._getValueOrValues(item, attribute);
+
+		var identity = this.getIdentity(item);
+		if(!this._pending._modifiedItems[identity]){
+			// Before we actually change the item, we make a copy of it to
+			// record the original state, so that we'll be able to revert if
+			// the revert method gets called.  If the item has already been
+			// modified then there's no need to do this now, since we already
+			// have a record of the original state.
+			var copyOfItemState = {};
+			for(var key in item){
+				if((key === this._storeRefPropName) || (key === this._itemNumPropName) || (key === this._rootItemPropName)){
+					copyOfItemState[key] = item[key];
+				}else if(key === this._reverseRefMap){
+					copyOfItemState[key] = lang.clone(item[key]);
+				}else{
+					copyOfItemState[key] = item[key].slice(0, item[key].length);
+				}
+			}
+			// Now mark the item as dirty, and save the copy of the original state
+			this._pending._modifiedItems[identity] = copyOfItemState;
+		}
+
+		// Okay, now we can actually change this attribute on the item
+		var success = false;
+
+		if(lang.isArray(newValueOrValues) && newValueOrValues.length === 0){
+
+			// If we were passed an empty array as the value, that counts
+			// as "unsetting" the attribute, so we need to remove this
+			// attribute from the item.
+			success = delete item[attribute];
+			newValueOrValues = undefined; // used in the onSet Notification call below
+
+			if(this.referenceIntegrity && oldValueOrValues){
+				var oldValues = oldValueOrValues;
+				if(!lang.isArray(oldValues)){
+					oldValues = [oldValues];
+				}
+				for(var i = 0; i < oldValues.length; i++){
+					var value = oldValues[i];
+					if(this.isItem(value)){
+						this._removeReferenceFromMap(value, item, attribute);
+					}
+				}
+			}
+		}else{
+			var newValueArray;
+			if(lang.isArray(newValueOrValues)){
+				// Unfortunately, it's not safe to just do this:
+				//    newValueArray = newValueOrValues;
+				// Instead, we need to copy the array, which slice() does very nicely.
+				// This is so that our internal data structure won't
+				// get corrupted if the user mucks with the values array *after*
+				// calling setValues().
+				newValueArray = newValueOrValues.slice(0, newValueOrValues.length);
+			}else{
+				newValueArray = [newValueOrValues];
+			}
+
+			//We need to handle reference integrity if this is on.
+			//In the case of set, we need to see if references were added or removed
+			//and update the reference tracking map accordingly.
+			if(this.referenceIntegrity){
+				if(oldValueOrValues){
+					var oldValues = oldValueOrValues;
+					if(!lang.isArray(oldValues)){
+						oldValues = [oldValues];
+					}
+					//Use an associative map to determine what was added/removed from the list.
+					//Should be O(n) performant.  First look at all the old values and make a list of them
+					//Then for any item not in the old list, we add it.  If it was already present, we remove it.
+					//Then we pass over the map and any references left it it need to be removed (IE, no match in
+					//the new values list).
+					var map = {};
+					arrayUtil.forEach(oldValues, function(possibleItem){
+						if(this.isItem(possibleItem)){
+							var id = this.getIdentity(possibleItem);
+							map[id.toString()] = true;
+						}
+					}, this);
+					arrayUtil.forEach(newValueArray, function(possibleItem){
+						if(this.isItem(possibleItem)){
+							var id = this.getIdentity(possibleItem);
+							if(map[id.toString()]){
+								delete map[id.toString()];
+							}else{
+								this._addReferenceToMap(possibleItem, item, attribute);
+							}
+						}
+					}, this);
+					for(var rId in map){
+						var removedItem;
+						if(this._itemsByIdentity){
+							removedItem = this._itemsByIdentity[rId];
+						}else{
+							removedItem = this._arrayOfAllItems[rId];
+						}
+						this._removeReferenceFromMap(removedItem, item, attribute);
+					}
+				}else{
+					//Everything is new (no old values) so we have to just
+					//insert all the references, if any.
+					for(var i = 0; i < newValueArray.length; i++){
+						var value = newValueArray[i];
+						if(this.isItem(value)){
+							this._addReferenceToMap(value, item, attribute);
+						}
+					}
+				}
+			}
+			item[attribute] = newValueArray;
+			success = true;
+		}
+
+		// Now we make the dojo.data.api.Notification call
+		if(callOnSet){
+			this.onSet(item, attribute, oldValueOrValues, newValueOrValues);
+		}
+		return success; // boolean
+	},
+
+	_addReferenceToMap: function(/* item */ refItem, /* item */ parentItem, /* string */ attribute){
+		//	summary:
+		//		Method to add an reference map entry for an item and attribute.
+		//	description:
+		//		Method to add an reference map entry for an item and attribute. 		 //
+		//	refItem:
+		//		The item that is referenced.
+		//	parentItem:
+		//		The item that holds the new reference to refItem.
+		//	attribute:
+		//		The attribute on parentItem that contains the new reference.
+
+		var parentId = this.getIdentity(parentItem);
+		var references = refItem[this._reverseRefMap];
+
+		if(!references){
+			references = refItem[this._reverseRefMap] = {};
+		}
+		var itemRef = references[parentId];
+		if(!itemRef){
+			itemRef = references[parentId] = {};
+		}
+		itemRef[attribute] = true;
+	},
+
+	_removeReferenceFromMap: function(/* item */ refItem, /* item */ parentItem, /* string */ attribute){
+		//	summary:
+		//		Method to remove an reference map entry for an item and attribute.
+		//	description:
+		//		Method to remove an reference map entry for an item and attribute.  This will
+		//		also perform cleanup on the map such that if there are no more references at all to
+		//		the item, its reference object and entry are removed.
+		//
+		//	refItem:
+		//		The item that is referenced.
+		//	parentItem:
+		//		The item holding a reference to refItem.
+		//	attribute:
+		//		The attribute on parentItem that contains the reference.
+		var identity = this.getIdentity(parentItem);
+		var references = refItem[this._reverseRefMap];
+		var itemId;
+		if(references){
+			for(itemId in references){
+				if(itemId == identity){
+					delete references[itemId][attribute];
+					if(this._isEmpty(references[itemId])){
+						delete references[itemId];
+					}
+				}
+			}
+			if(this._isEmpty(references)){
+				delete refItem[this._reverseRefMap];
+			}
+		}
+	},
+
+	_dumpReferenceMap: function(){
+		//	summary:
+		//		Function to dump the reverse reference map of all items in the store for debug purposes.
+		//	description:
+		//		Function to dump the reverse reference map of all items in the store for debug purposes.
+		var i;
+		for(i = 0; i < this._arrayOfAllItems.length; i++){
+			var item = this._arrayOfAllItems[i];
+			if(item && item[this._reverseRefMap]){
+				console.log("Item: [" + this.getIdentity(item) + "] is referenced by: " + jsonUtil.toJson(item[this._reverseRefMap]));
+			}
+		}
+	},
+
+	_getValueOrValues: function(/* item */ item, /* attribute-name-string */ attribute){
+		var valueOrValues = undefined;
+		if(this.hasAttribute(item, attribute)){
+			var valueArray = this.getValues(item, attribute);
+			if(valueArray.length == 1){
+				valueOrValues = valueArray[0];
+			}else{
+				valueOrValues = valueArray;
+			}
+		}
+		return valueOrValues;
+	},
+
+	_flatten: function(/* anything */ value){
+		if(this.isItem(value)){
+			// Given an item, return an serializable object that provides a
+			// reference to the item.
+			// For example, given kermit:
+			//    var kermit = store.newItem({id:2, name:"Kermit"});
+			// we want to return
+			//    {_reference:2}
+			return {_reference: this.getIdentity(value)};
+		}else{
+			if(typeof value === "object"){
+				for(var type in this._datatypeMap){
+					var typeMap = this._datatypeMap[type];
+					if(lang.isObject(typeMap) && !lang.isFunction(typeMap)){
+						if(value instanceof typeMap.type){
+							if(!typeMap.serialize){
+								throw new Error("ItemFileWriteStore:  No serializer defined for type mapping: [" + type + "]");
+							}
+							return {_type: type, _value: typeMap.serialize(value)};
+						}
+					} else if(value instanceof typeMap){
+						//SImple mapping, therefore, return as a toString serialization.
+						return {_type: type, _value: value.toString()};
+					}
+				}
+			}
+			return value;
+		}
+	},
+
+	_getNewFileContentString: function(){
+		// summary:
+		//		Generate a string that can be saved to a file.
+		//		The result should look similar to:
+		//		http://trac.dojotoolkit.org/browser/dojo/trunk/tests/data/countries.json
+		var serializableStructure = {};
+
+		var identifierAttribute = this._getIdentifierAttribute();
+		if(identifierAttribute !== Number){
+			serializableStructure.identifier = identifierAttribute;
+		}
+		if(this._labelAttr){
+			serializableStructure.label = this._labelAttr;
+		}
+		serializableStructure.items = [];
+		for(var i = 0; i < this._arrayOfAllItems.length; ++i){
+			var item = this._arrayOfAllItems[i];
+			if(item !== null){
+				var serializableItem = {};
+				for(var key in item){
+					if(key !== this._storeRefPropName && key !== this._itemNumPropName && key !== this._reverseRefMap && key !== this._rootItemPropName){
+						var valueArray = this.getValues(item, key);
+						if(valueArray.length == 1){
+							serializableItem[key] = this._flatten(valueArray[0]);
+						}else{
+							var serializableArray = [];
+							for(var j = 0; j < valueArray.length; ++j){
+								serializableArray.push(this._flatten(valueArray[j]));
+								serializableItem[key] = serializableArray;
+							}
+						}
+					}
+				}
+				serializableStructure.items.push(serializableItem);
+			}
+		}
+		var prettyPrint = true;
+		return jsonUtil.toJson(serializableStructure, prettyPrint);
+	},
+
+	_isEmpty: function(something){
+		//	summary:
+		//		Function to determine if an array or object has no properties or values.
+		//	something:
+		//		The array or object to examine.
+		var empty = true;
+		if(lang.isObject(something)){
+			var i;
+			for(i in something){
+				empty = false;
+				break;
+			}
+		}else if(lang.isArray(something)){
+			if(something.length > 0){
+				empty = false;
+			}
+		}
+		return empty; //boolean
+	},
+
+	save: function(/* object */ keywordArgs){
+		// summary: See dojo.data.api.Write.save()
+		this._assert(!this._saveInProgress);
+
+		// this._saveInProgress is set to true, briefly, from when save is first called to when it completes
+		this._saveInProgress = true;
+
+		var self = this;
+		var saveCompleteCallback = function(){
+			self._pending = {
+				_newItems:{},
+				_modifiedItems:{},
+				_deletedItems:{}
+			};
+
+			self._saveInProgress = false; // must come after this._pending is cleared, but before any callbacks
+			if(keywordArgs && keywordArgs.onComplete){
+				var scope = keywordArgs.scope || window.global;
+				keywordArgs.onComplete.call(scope);
+			}
+		};
+		var saveFailedCallback = function(err){
+			self._saveInProgress = false;
+			if(keywordArgs && keywordArgs.onError){
+				var scope = keywordArgs.scope || window.global;
+				keywordArgs.onError.call(scope, err);
+			}
+		};
+
+		if(this._saveEverything){
+			var newFileContentString = this._getNewFileContentString();
+			this._saveEverything(saveCompleteCallback, saveFailedCallback, newFileContentString);
+		}
+		if(this._saveCustom){
+			this._saveCustom(saveCompleteCallback, saveFailedCallback);
+		}
+		if(!this._saveEverything && !this._saveCustom){
+			// Looks like there is no user-defined save-handler function.
+			// That's fine, it just means the datastore is acting as a "mock-write"
+			// store -- changes get saved in memory but don't get saved to disk.
+			saveCompleteCallback();
+		}
+	},
+
+	revert: function(){
+		// summary: See dojo.data.api.Write.revert()
+		this._assert(!this._saveInProgress);
+
+		var identity;
+		for(identity in this._pending._modifiedItems){
+			// find the original item and the modified item that replaced it
+			var copyOfItemState = this._pending._modifiedItems[identity];
+			var modifiedItem = null;
+			if(this._itemsByIdentity){
+				modifiedItem = this._itemsByIdentity[identity];
+			}else{
+				modifiedItem = this._arrayOfAllItems[identity];
+			}
+
+			// Restore the original item into a full-fledged item again, we want to try to
+			// keep the same object instance as if we don't it, causes bugs like #9022.
+			copyOfItemState[this._storeRefPropName] = this;
+			for(var key in modifiedItem){
+				delete modifiedItem[key];
+			}
+			lang.mixin(modifiedItem, copyOfItemState);
+		}
+		var deletedItem;
+		for(identity in this._pending._deletedItems){
+			deletedItem = this._pending._deletedItems[identity];
+			deletedItem[this._storeRefPropName] = this;
+			var index = deletedItem[this._itemNumPropName];
+
+			//Restore the reverse refererence map, if any.
+			if(deletedItem["backup_" + this._reverseRefMap]){
+				deletedItem[this._reverseRefMap] = deletedItem["backup_" + this._reverseRefMap];
+				delete deletedItem["backup_" + this._reverseRefMap];
+			}
+			this._arrayOfAllItems[index] = deletedItem;
+			if(this._itemsByIdentity){
+				this._itemsByIdentity[identity] = deletedItem;
+			}
+			if(deletedItem[this._rootItemPropName]){
+				this._arrayOfTopLevelItems.push(deletedItem);
+			}
+		}
+		//We have to pass through it again and restore the reference maps after all the
+		//undeletes have occurred.
+		for(identity in this._pending._deletedItems){
+			deletedItem = this._pending._deletedItems[identity];
+			if(deletedItem["backupRefs_" + this._reverseRefMap]){
+				arrayUtil.forEach(deletedItem["backupRefs_" + this._reverseRefMap], function(reference){
+					var refItem;
+					if(this._itemsByIdentity){
+						refItem = this._itemsByIdentity[reference.id];
+					}else{
+						refItem = this._arrayOfAllItems[reference.id];
+					}
+					this._addReferenceToMap(refItem, deletedItem, reference.attr);
+				}, this);
+				delete deletedItem["backupRefs_" + this._reverseRefMap];
+			}
+		}
+
+		for(identity in this._pending._newItems){
+			var newItem = this._pending._newItems[identity];
+			newItem[this._storeRefPropName] = null;
+			// null out the new item, but don't change the array index so
+			// so we can keep using _arrayOfAllItems.length.
+			this._arrayOfAllItems[newItem[this._itemNumPropName]] = null;
+			if(newItem[this._rootItemPropName]){
+				this._removeArrayElement(this._arrayOfTopLevelItems, newItem);
+			}
+			if(this._itemsByIdentity){
+				delete this._itemsByIdentity[identity];
+			}
+		}
+
+		this._pending = {
+			_newItems:{},
+			_modifiedItems:{},
+			_deletedItems:{}
+		};
+		return true; // boolean
+	},
+
+	isDirty: function(/* item? */ item){
+		// summary: See dojo.data.api.Write.isDirty()
+		if(item){
+			// return true if the item is dirty
+			var identity = this.getIdentity(item);
+			return new Boolean(this._pending._newItems[identity] ||
+				this._pending._modifiedItems[identity] ||
+				this._pending._deletedItems[identity]).valueOf(); // boolean
+		}else{
+			// return true if the store is dirty -- which means return true
+			// if there are any new items, dirty items, or modified items
+			return !this._isEmpty(this._pending._newItems) ||
+				!this._isEmpty(this._pending._modifiedItems) ||
+				!this._isEmpty(this._pending._deletedItems); // boolean
+		}
+	},
+
+/* dojo.data.api.Notification */
+
+	onSet: function(/* item */ item,
+					/*attribute-name-string*/ attribute,
+					/*object|array*/ oldValue,
+					/*object|array*/ newValue){
+		// summary: See dojo.data.api.Notification.onSet()
+
+		// No need to do anything. This method is here just so that the
+		// client code can connect observers to it.
+	},
+
+	onNew: function(/* item */ newItem, /*object?*/ parentInfo){
+		// summary: See dojo.data.api.Notification.onNew()
+
+		// No need to do anything. This method is here just so that the
+		// client code can connect observers to it.
+	},
+
+	onDelete: function(/* item */ deletedItem){
+		// summary: See dojo.data.api.Notification.onDelete()
+
+		// No need to do anything. This method is here just so that the
+		// client code can connect observers to it.
+	},
+
+	close: function(/* object? */ request){
+		 // summary:
+		 //		Over-ride of base close function of ItemFileReadStore to add in check for store state.
+		 // description:
+		 //		Over-ride of base close function of ItemFileReadStore to add in check for store state.
+		 //		If the store is still dirty (unsaved changes), then an error will be thrown instead of
+		 //		clearing the internal state for reload from the url.
+
+		 //Clear if not dirty ... or throw an error
+		 if(this.clearOnClose){
+			 if(!this.isDirty()){
+				 this.inherited(arguments);
+			 }else{
+				 //Only throw an error if the store was dirty and we were loading from a url (cannot reload from url until state is saved).
+				 throw new Error("dojo.data.ItemFileWriteStore: There are unsaved changes present in the store.  Please save or revert the changes before invoking close.");
+			 }
+		 }
+	}
+});
+
+});
diff --git a/js/dojo-1.7.2/dojo/data/ObjectStore.js b/js/dojo-1.7.2/dojo/data/ObjectStore.js
new file mode 100644
index 0000000..29ec372
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/ObjectStore.js
@@ -0,0 +1,506 @@
+//>>built
+define("dojo/data/ObjectStore", ["../_base/lang", "../Evented", "../_base/declare", "../_base/Deferred", "../_base/array", 
+	"../_base/connect", "../regexp"
+], function(lang, Evented, declare, Deferred, array, connect, regexp) {
+	// module:
+	//		dojo/data/ObjectStore
+	// summary:
+	//		TODOC
+
+
+return declare("dojo.data.ObjectStore", [Evented],{
+		objectStore: null,
+		constructor: function(options){
+			// summary:
+			//		A Dojo Data implementation that wraps Dojo object stores for backwards
+			//		compatibility.
+			//	options:
+			//		The configuration information to pass into the data store.
+			//	options.objectStore:
+			//		The object store to use as the source provider for this data store
+			lang.mixin(this, options);
+		},
+		labelProperty: "label",
+
+		getValue: function(/*Object*/ item, /*String*/property, /*value?*/defaultValue){
+			// summary:
+			//	Gets the value of an item's 'property'
+			//
+			//	item:
+			//		The item to get the value from
+			//	property:
+			//		property to look up value for
+			//	defaultValue:
+			//		the default value
+
+			return typeof item.get === "function" ? item.get(property) :
+				property in item ?
+					item[property] : defaultValue;
+		},
+		getValues: function(item, property){
+			// summary:
+			//		Gets the value of an item's 'property' and returns
+			//		it. If this value is an array it is just returned,
+			//		if not, the value is added to an array and that is returned.
+			//
+			//	item: /* object */
+			//	property: /* string */
+			//		property to look up value for
+
+			var val = this.getValue(item,property);
+			return val instanceof Array ? val : val === undefined ? [] : [val];
+		},
+
+		getAttributes: function(item){
+			// summary:
+			//	Gets the available attributes of an item's 'property' and returns
+			//	it as an array.
+			//
+			//	item: /* object */
+
+			var res = [];
+			for(var i in item){
+				if(item.hasOwnProperty(i) && !(i.charAt(0) == '_' && i.charAt(1) == '_')){
+					res.push(i);
+				}
+			}
+			return res;
+		},
+
+		hasAttribute: function(item,attribute){
+			// summary:
+			//		Checks to see if item has attribute
+			//
+			//	item: /* object */
+			//	attribute: /* string */
+			return attribute in item;
+		},
+
+		containsValue: function(item, attribute, value){
+			// summary:
+			//		Checks to see if 'item' has 'value' at 'attribute'
+			//
+			//	item: /* object */
+			//	attribute: /* string */
+			//	value: /* anything */
+			return array.indexOf(this.getValues(item,attribute),value) > -1;
+		},
+
+
+		isItem: function(item){
+			// summary:
+			//		Checks to see if the argument is an item
+			//
+			//	item: /* object */
+			//	attribute: /* string */
+
+			// we have no way of determining if it belongs, we just have object returned from
+			//	service queries
+			return (typeof item == 'object') && item && !(item instanceof Date);
+		},
+
+		isItemLoaded: function(item){
+			// summary:
+			//		Checks to see if the item is loaded.
+			//
+			//		item: /* object */
+
+			return item && typeof item.load !== "function";
+		},
+
+		loadItem: function(args){
+			// summary:
+			//		Loads an item and calls the callback handler. Note, that this will call the callback
+			//		handler even if the item is loaded. Consequently, you can use loadItem to ensure
+			//		that an item is loaded is situations when the item may or may not be loaded yet.
+			//		If you access a value directly through property access, you can use this to load
+			//		a lazy value as well (doesn't need to be an item).
+			//
+			//	example:
+			//		store.loadItem({
+			//			item: item, // this item may or may not be loaded
+			//			onItem: function(item){
+			//				// do something with the item
+			//			}
+			//		});
+
+			var item;
+			if(typeof args.item.load === "function"){
+				Deferred.when(args.item.load(), function(result){
+					item = result; // in synchronous mode this can allow loadItem to return the value
+					var func = result instanceof Error ? args.onError : args.onItem;
+					if(func){
+						func.call(args.scope, result);
+					}
+				});
+			}else if(args.onItem){
+				// even if it is already loaded, we will use call the callback, this makes it easier to
+				// use when it is not known if the item is loaded (you can always safely call loadItem).
+				args.onItem.call(args.scope, args.item);
+			}
+			return item;
+		},
+		close: function(request){
+			return request && request.abort && request.abort();
+		},
+		fetch: function(args){
+			// summary:
+			//		See dojo.data.api.Read.fetch
+			//
+
+			args = lang.delegate(args, args && args.queryOptions);
+			var self = this;
+			var scope = args.scope || self;
+			var query = args.query;
+			if(typeof query == "object"){ // can be null, but that is ignore by for-in
+				query = lang.delegate(query); // don't modify the original
+				for(var i in query){
+					// find any strings and convert them to regular expressions for wildcard support
+					var required = query[i];
+					if(typeof required == "string"){
+						query[i] = RegExp("^" + regexp.escapeString(required, "*?").replace(/\*/g, '.*').replace(/\?/g, '.') + "$", args.ignoreCase ? "mi" : "m");
+						query[i].toString = (function(original){
+							return function(){
+								return original;
+							}
+						})(required);
+					}
+				}
+			}
+
+			var results = this.objectStore.query(query, args);
+			Deferred.when(results.total, function(totalCount){
+				Deferred.when(results, function(results){
+					if(args.onBegin){
+						args.onBegin.call(scope, totalCount || results.length, args);
+					}
+					if(args.onItem){
+						for(var i=0; i<results.length;i++){
+							args.onItem.call(scope, results[i], args);
+						}
+					}
+					if(args.onComplete){
+						args.onComplete.call(scope, args.onItem ? null : results, args);
+					}
+					return results;
+				}, errorHandler);
+			}, errorHandler);
+			function errorHandler(error){
+				if(args.onError){
+					args.onError.call(scope, error, args);
+				}
+			}
+			args.abort = function(){
+				// abort the request
+				if(results.cancel){
+					results.cancel();
+				}
+			};
+			if(results.observe){
+				if(this.observing){
+					// if we were previously observing, cancel the last time to avoid multiple notifications. Just the best we can do for the impedance mismatch between APIs
+					this.observing.cancel();
+				}
+				this.observing = results.observe(function(object, removedFrom, insertedInto){
+					if(array.indexOf(self._dirtyObjects, object) == -1){
+						if(removedFrom == -1){
+							self.onNew(object);
+						}
+						else if(insertedInto == -1){
+							self.onDelete(object);
+						}
+						else{
+							for(var i in object){
+								if(i != self.objectStore.idProperty){
+									self.onSet(object, i, null, object[i]);
+								}
+							}
+						}
+					}
+				}, true);
+			}
+			this.onFetch(results);
+			args.store = this;
+			return args;
+		},
+		getFeatures: function(){
+			// summary:
+			//		return the store feature set
+
+			return {
+				"dojo.data.api.Read": !!this.objectStore.get,
+				"dojo.data.api.Identity": true,
+				"dojo.data.api.Write": !!this.objectStore.put,
+				"dojo.data.api.Notification": true
+			};
+		},
+
+		getLabel: function(/* item */ item){
+			//	summary:
+			//		See dojo.data.api.Read.getLabel()
+			if(this.isItem(item)){
+				return this.getValue(item,this.labelProperty); //String
+			}
+			return undefined; //undefined
+		},
+
+		getLabelAttributes: function(/* item */ item){
+			//	summary:
+			//		See dojo.data.api.Read.getLabelAttributes()
+			return [this.labelProperty]; //array
+		},
+
+		//Identity API Support
+
+
+		getIdentity: function(item){
+			return this.objectStore.getIdentity ? this.objectStore.getIdentity(item) : item[this.objectStore.idProperty || "id"];
+		},
+
+		getIdentityAttributes: function(item){
+			// summary:
+			//		returns the attributes which are used to make up the
+			//		identity of an item.	Basically returns this.objectStore.idProperty
+
+			return [this.objectStore.idProperty];
+		},
+
+		fetchItemByIdentity: function(args){
+			// summary:
+			//		fetch an item by its identity, by looking in our index of what we have loaded
+			var item;
+			Deferred.when(this.objectStore.get(args.identity),
+				function(result){
+					item = result;
+					args.onItem.call(args.scope, result);
+				},
+				function(error){
+					args.onError.call(args.scope, error);
+				}
+			);
+			return item;
+		},
+
+		newItem: function(data, parentInfo){
+			// summary:
+			//		adds a new item to the store at the specified point.
+			//		Takes two parameters, data, and options.
+			//
+			//	data: Object
+			//		The data to be added in as an item.
+			
+			// TODOC: parentInfo
+			if(parentInfo){
+				// get the previous value or any empty array
+				var values = this.getValue(parentInfo.parent,parentInfo.attribute,[]);
+				// set the new value
+				values = values.concat([data]);
+				data.__parent = values;
+				this.setValue(parentInfo.parent, parentInfo.attribute, values);
+			}
+			this._dirtyObjects.push({object:data, save: true});
+			this.onNew(data);
+			return data;
+		},
+		deleteItem: function(item){
+			// summary:
+			//		deletes item and any references to that item from the store.
+			//
+			//	item:
+			//		item to delete
+			//
+
+			//	If the desire is to delete only one reference, unsetAttribute or
+			//	setValue is the way to go.
+			this.changing(item, true);
+
+			this.onDelete(item);
+		},
+		setValue: function(item, attribute, value){
+			// summary:
+			//		sets 'attribute' on 'item' to 'value'
+
+			var old = item[attribute];
+			this.changing(item);
+			item[attribute]=value;
+			this.onSet(item,attribute,old,value);
+		},
+		setValues: function(item, attribute, values){
+			// summary:
+			//	sets 'attribute' on 'item' to 'value' value
+			//	must be an array.
+
+			if(!lang.isArray(values)){
+				throw new Error("setValues expects to be passed an Array object as its value");
+			}
+			this.setValue(item,attribute,values);
+		},
+
+		unsetAttribute: function(item, attribute){
+			// summary:
+			//		unsets 'attribute' on 'item'
+
+			this.changing(item);
+			var old = item[attribute];
+			delete item[attribute];
+			this.onSet(item,attribute,old,undefined);
+		},
+
+		_dirtyObjects: [],
+
+		changing: function(object,_deleting){
+			// summary:
+			//		adds an object to the list of dirty objects.  This object
+			//		contains a reference to the object itself as well as a
+			//		cloned and trimmed version of old object for use with
+			//		revert.
+			object.__isDirty = true;
+			//if an object is already in the list of dirty objects, don't add it again
+			//or it will overwrite the premodification data set.
+			for(var i=0; i<this._dirtyObjects.length; i++){
+				var dirty = this._dirtyObjects[i];
+				if(object==dirty.object){
+					if(_deleting){
+						// we are deleting, no object is an indicator of deletiong
+						dirty.object = false;
+						if(!this._saveNotNeeded){
+							dirty.save = true;
+						}
+					}
+					return;
+				}
+			}
+			var old = object instanceof Array ? [] : {};
+			for(i in object){
+				if(object.hasOwnProperty(i)){
+					old[i] = object[i];
+				}
+			}
+			this._dirtyObjects.push({object: !_deleting && object, old: old, save: !this._saveNotNeeded});
+		},
+
+		save: function(kwArgs){
+			// summary:
+			//		Saves the dirty data using object store provider. See dojo.data.api.Write for API.
+			//
+			//	kwArgs.global:
+			//		This will cause the save to commit the dirty data for all
+			//		ObjectStores as a single transaction.
+			//
+			//	kwArgs.revertOnError
+			//		This will cause the changes to be reverted if there is an
+			//		error on the save. By default a revert is executed unless
+			//		a value of false is provide for this parameter.
+
+			// TODOC: kwArgs pseudo
+			kwArgs = kwArgs || {};
+			var result, actions = [];
+			var savingObjects = [];
+			var self = this;
+			var dirtyObjects = this._dirtyObjects;
+			var left = dirtyObjects.length;// this is how many changes are remaining to be received from the server
+			try{
+				connect.connect(kwArgs,"onError",function(){
+					if(kwArgs.revertOnError !== false){
+						var postCommitDirtyObjects = dirtyObjects;
+						dirtyObjects = savingObjects;
+						self.revert(); // revert if there was an error
+						self._dirtyObjects = postCommitDirtyObjects;
+					}
+					else{
+						self._dirtyObjects = dirtyObjects.concat(savingObjects);
+					}
+				});
+				if(this.objectStore.transaction){
+					var transaction = this.objectStore.transaction();
+				}
+				for(var i = 0; i < dirtyObjects.length; i++){
+					var dirty = dirtyObjects[i];
+					var object = dirty.object;
+					var old = dirty.old;
+					delete object.__isDirty;
+					if(object){
+						result = this.objectStore.put(object, {overwrite: !!old});
+					}
+					else if(typeof old != "undefined"){
+						result = this.objectStore.remove(this.getIdentity(old));
+					}
+					savingObjects.push(dirty);
+					dirtyObjects.splice(i--,1);
+					Deferred.when(result, function(value){
+						if(!(--left)){
+							if(kwArgs.onComplete){
+								kwArgs.onComplete.call(kwArgs.scope, actions);
+							}
+						}
+					},function(value){
+
+						// on an error we want to revert, first we want to separate any changes that were made since the commit
+						left = -1; // first make sure that success isn't called
+						kwArgs.onError.call(kwArgs.scope, value);
+					});
+
+				}
+				if(transaction){
+					transaction.commit();
+				}
+			}catch(e){
+				kwArgs.onError.call(kwArgs.scope, value);
+			}
+		},
+
+		revert: function(kwArgs){
+			// summary:
+			//		returns any modified data to its original state prior to a save();
+			//
+			var dirtyObjects = this._dirtyObjects;
+			for(var i = dirtyObjects.length; i > 0;){
+				i--;
+				var dirty = dirtyObjects[i];
+				var object = dirty.object;
+				var old = dirty.old;
+				if(object && old){
+					// changed
+					for(var j in old){
+						if(old.hasOwnProperty(j) && object[j] !== old[j]){
+							this.onSet(object, j, object[j], old[j]);
+							object[j] = old[j];
+						}
+					}
+					for(j in object){
+						if(!old.hasOwnProperty(j)){
+							this.onSet(object, j, object[j]);
+							delete object[j];
+						}
+					}
+				}else if(!old){
+					// was an addition, remove it
+					this.onDelete(object);
+				}else{
+					// was a deletion, we will add it back
+					this.onNew(old);
+				}
+				delete (object || old).__isDirty;
+				dirtyObjects.splice(i, 1);
+			}
+
+		},
+		isDirty: function(item){
+			// summary:
+			//		returns true if the item is marked as dirty or true if there are any dirty items
+			if(!item){
+				return !!this._dirtyObjects.length;
+			}
+			return item.__isDirty;
+		},
+		//Notifcation Support
+
+		onSet: function(){},
+		onNew: function(){},
+		onDelete:	function(){},
+		// an extra to get result sets
+		onFetch: function(results){}
+
+	}
+);
+});
diff --git a/js/dojo-1.7.2/dojo/data/api/Identity.js b/js/dojo-1.7.2/dojo/data/api/Identity.js
new file mode 100644
index 0000000..f6e9662
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/api/Identity.js
@@ -0,0 +1,108 @@
+//>>built
+define("dojo/data/api/Identity", ["../..", "./Read"], function(dojo) {
+	// module:
+	//		dojo/data/api/Identity
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.data.api.Identity", dojo.data.api.Read, {
+	//	summary:
+	//		This is an abstract API that data provider implementations conform to.
+	//		This file defines methods signatures and intentionally leaves all the
+	//		methods unimplemented.
+
+	getFeatures: function(){
+		//	summary:
+		//		See dojo.data.api.Read.getFeatures()
+		return {
+			 'dojo.data.api.Read': true,
+			 'dojo.data.api.Identity': true
+		};
+	},
+
+	getIdentity: function(/* item */ item){
+		//	summary:
+		//		Returns a unique identifier for an item.  The return value will be
+		//		either a string or something that has a toString() method (such as,
+		//		for example, a dojox.uuid.Uuid object).
+		//	item:
+		//		The item from the store from which to obtain its identifier.
+		//	exceptions:
+		//		Conforming implementations may throw an exception or return null if
+		//		item is not an item.
+		//	example:
+		//	|	var itemId = store.getIdentity(kermit);
+		//	|	assert(kermit === store.findByIdentity(store.getIdentity(kermit)));
+		throw new Error('Unimplemented API: dojo.data.api.Identity.getIdentity');
+	},
+
+	getIdentityAttributes: function(/* item */ item){
+		//	summary:
+		//		Returns an array of attribute names that are used to generate the identity.
+		//		For most stores, this is a single attribute, but for some complex stores
+		//		such as RDB backed stores that use compound (multi-attribute) identifiers
+		//		it can be more than one.  If the identity is not composed of attributes
+		//		on the item, it will return null.  This function is intended to identify
+		//		the attributes that comprise the identity so that so that during a render
+		//		of all attributes, the UI can hide the the identity information if it
+		//		chooses.
+		//	item:
+		//		The item from the store from which to obtain the array of public attributes that
+		//		compose the identifier, if any.
+		//	example:
+		//	|	var itemId = store.getIdentity(kermit);
+		//	|	var identifiers = store.getIdentityAttributes(itemId);
+		//	|	assert(typeof identifiers === "array" || identifiers === null);
+		throw new Error('Unimplemented API: dojo.data.api.Identity.getIdentityAttributes');
+	},
+
+
+	fetchItemByIdentity: function(/* object */ keywordArgs){
+		//	summary:
+		//		Given the identity of an item, this method returns the item that has
+		//		that identity through the onItem callback.  Conforming implementations
+		//		should return null if there is no item with the given identity.
+		//		Implementations of fetchItemByIdentity() may sometimes return an item
+		//		from a local cache and may sometimes fetch an item from a remote server,
+		//
+		// 	keywordArgs:
+		//		An anonymous object that defines the item to locate and callbacks to invoke when the
+		//		item has been located and load has completed.  The format of the object is as follows:
+		//		{
+		//			identity: string|object,
+		//			onItem: Function,
+		//			onError: Function,
+		//			scope: object
+		//		}
+		//	The *identity* parameter.
+		//		The identity parameter is the identity of the item you wish to locate and load
+		//		This attribute is required.  It should be a string or an object that toString()
+		//		can be called on.
+		//
+		//	The *onItem* parameter.
+		//		Function(item)
+		//		The onItem parameter is the callback to invoke when the item has been loaded.  It takes only one
+		//		parameter, the item located, or null if none found.
+		//
+		//	The *onError* parameter.
+		//		Function(error)
+		//		The onError parameter is the callback to invoke when the item load encountered an error.  It takes only one
+		//		parameter, the error object
+		//
+		//	The *scope* parameter.
+		//		If a scope object is provided, all of the callback functions (onItem,
+		//		onError, etc) will be invoked in the context of the scope object.
+		//		In the body of the callback function, the value of the "this"
+		//		keyword will be the scope object.   If no scope object is provided,
+		//		the callback functions will be called in the context of dojo.global.
+		//		For example, onItem.call(scope, item, request) vs.
+		//		onItem.call(dojo.global, item, request)
+		if(!this.isItemLoaded(keywordArgs.item)){
+			throw new Error('Unimplemented API: dojo.data.api.Identity.fetchItemByIdentity');
+		}
+	}
+});
+
+return dojo.data.api.Identity;
+});
diff --git a/js/dojo-1.7.2/dojo/data/api/Notification.js b/js/dojo-1.7.2/dojo/data/api/Notification.js
new file mode 100644
index 0000000..e85f5b2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/api/Notification.js
@@ -0,0 +1,123 @@
+//>>built
+define("dojo/data/api/Notification", ["../..", "./Read"], function(dojo) {
+	// module:
+	//		dojo/data/api/Notification
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.data.api.Notification", dojo.data.api.Read, {
+	//	summary:
+	//		This is an abstract API that data provider implementations conform to.
+	//		This file defines functions signatures and intentionally leaves all the
+	//		functions unimplemented.
+	//
+	//	description:
+	//		This API defines a set of APIs that all datastores that conform to the
+	//		Notifications API must implement.  In general, most stores will implement
+	//		these APIs as no-op functions for users who wish to monitor them to be able
+	//		to connect to then via dojo.connect().  For non-users of dojo.connect,
+	//		they should be able to just replace the function on the store to obtain
+	//		 notifications.  Both read-only and read-write stores may implement
+	//		this feature.  In the case of a read-only store, this feature makes sense if
+	//		the store itself does internal polling to a back-end server and periodically updates
+	//		its cache of items (deletes, adds, and updates).
+	//
+	//	example:
+	//
+	//	|	function onSet(item, attribute, oldValue, newValue) {
+	//	|		//Do something with the information...
+	//	|	};
+	//	|	var store = new some.newStore();
+	//	|	dojo.connect(store, "onSet", onSet);
+
+	getFeatures: function(){
+		//	summary:
+		//		See dojo.data.api.Read.getFeatures()
+		return {
+			'dojo.data.api.Read': true,
+			'dojo.data.api.Notification': true
+		};
+	},
+
+	onSet: function(/* item */ item,
+					/* attribute-name-string */ attribute,
+					/* object|array */ oldValue,
+					/* object|array */ newValue){
+		//	summary:
+		//		This function is called any time an item is modified via setValue, setValues, unsetAttribute, etc.
+		//	description:
+		//		This function is called any time an item is modified via setValue, setValues, unsetAttribute, etc.
+		//		Its purpose is to provide a hook point for those who wish to monitor actions on items in the store
+		//		in a simple manner.  The general expected usage is to dojo.connect() to the store's
+		//		implementation and be called after the store function is called.
+		//
+		//	item:
+		//		The item being modified.
+		//	attribute:
+		//		The attribute being changed represented as a string name.
+		//	oldValue:
+		//		The old value of the attribute.  In the case of single value calls, such as setValue, unsetAttribute, etc,
+		//		this value will be generally be an atomic value of some sort (string, int, etc, object).  In the case of
+		//		multi-valued attributes, it will be an array.
+		//	newValue:
+		//		The new value of the attribute.  In the case of single value calls, such as setValue, this value will be
+		//		generally be an atomic value of some sort (string, int, etc, object).  In the case of multi-valued attributes,
+		//		it will be an array.  In the case of unsetAttribute, the new value will be 'undefined'.
+		//
+		//	returns:
+		//		Nothing.
+		throw new Error('Unimplemented API: dojo.data.api.Notification.onSet');
+	},
+
+	onNew: function(/* item */ newItem, /*object?*/ parentInfo){
+		//	summary:
+		//		This function is called any time a new item is created in the store.
+		//		It is called immediately after the store newItem processing has completed.
+		//	description:
+		//		This function is called any time a new item is created in the store.
+		//		It is called immediately after the store newItem processing has completed.
+		//
+		//	newItem:
+		//		The item created.
+		//	parentInfo:
+		//		An optional javascript object that is passed when the item created was placed in the store
+		//		hierarchy as a value f another item's attribute, instead of a root level item.  Note that if this
+		//		function is invoked with a value for parentInfo, then onSet is not invoked stating the attribute of
+		//		the parent item was modified.  This is to avoid getting two notification  events occurring when a new item
+		//		with a parent is created.  The structure passed in is as follows:
+		//		{
+		//			item: someItem,							//The parent item
+		//			attribute:	"attribute-name-string",	//The attribute the new item was assigned to.
+		//			oldValue: something	//Whatever was the previous value for the attribute.
+		//						//If it is a single-value attribute only, then this value will be a single value.
+		//						//If it was a multi-valued attribute, then this will be an array of all the values minues the new one.
+		//			newValue: something	//The new value of the attribute.  In the case of single value calls, such as setValue, this value will be
+		//						//generally be an atomic value of some sort (string, int, etc, object).  In the case of multi-valued attributes,
+		//						//it will be an array.
+		//		}
+		//
+		//	returns:
+		//		Nothing.
+		throw new Error('Unimplemented API: dojo.data.api.Notification.onNew');
+	},
+
+	onDelete: function(/* item */ deletedItem){
+		//	summary:
+		//		This function is called any time an item is deleted from the store.
+		//		It is called immediately after the store deleteItem processing has completed.
+		//	description:
+		//		This function is called any time an item is deleted from the store.
+		//		It is called immediately after the store deleteItem processing has completed.
+		//
+		//	deletedItem:
+		//		The item deleted.
+		//
+		//	returns:
+		//		Nothing.
+		throw new Error('Unimplemented API: dojo.data.api.Notification.onDelete');
+	}
+});
+
+return dojo.data.api.Notification;
+});
diff --git a/js/dojo-1.7.2/dojo/data/api/Read.js b/js/dojo-1.7.2/dojo/data/api/Read.js
new file mode 100644
index 0000000..538888f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/api/Read.js
@@ -0,0 +1,486 @@
+//>>built
+define("dojo/data/api/Read", ["../..", "./Request"], function(dojo) {
+	// module:
+	//		dojo/data/api/Read
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.data.api.Read", null, {
+	// summary:
+	//		This is an abstract API that data provider implementations conform to.
+	//		This file defines methods signatures and intentionally leaves all the
+	//		methods unimplemented.  For more information on the dojo.data APIs,
+	//		please visit: http://www.dojotoolkit.org/node/98
+
+	getValue: function(	/* item */ item,
+						/* attribute-name-string */ attribute,
+						/* value? */ defaultValue){
+		// summary:
+		//		Returns a single attribute value.
+		//		Returns defaultValue if and only if *item* does not have a value for *attribute*.
+		//		Returns null if and only if null was explicitly set as the attribute value.
+		//		Returns undefined if and only if the item does not have a value for the
+		//		given attribute (which is the same as saying the item does not have the attribute).
+		// description:
+		//		Saying that an "item x does not have a value for an attribute y"
+		//		is identical to saying that an "item x does not have attribute y".
+		//		It is an oxymoron to say "that attribute is present but has no values"
+		//		or "the item has that attribute but does not have any attribute values".
+		//		If store.hasAttribute(item, attribute) returns false, then
+		//		store.getValue(item, attribute) will return undefined.
+		// item:
+		//		The item to access values on.
+		// attribute:
+		//		The attribute to access represented as a string.
+		// defaultValue:
+		//		Optional.  A default value to use for the getValue return in the attribute does not exist or has no value.
+		// returns:
+		//		a literal, an item, null, or undefined (never an array)
+		// exceptions:
+		//		Throws an exception if *item* is not an item, or *attribute* is not a string
+		// example:
+		//	|	var darthVader = store.getValue(lukeSkywalker, "father");
+		throw new Error('Unimplemented API: dojo.data.api.Read.getValue');
+	},
+
+	getValues: function(/* item */ item,
+						/* attribute-name-string */ attribute){
+		// summary:
+		// 		This getValues() method works just like the getValue() method, but getValues()
+		//		always returns an array rather than a single attribute value.  The array
+		//		may be empty, may contain a single attribute value, or may contain
+		//		many attribute values.
+		//		If the item does not have a value for the given attribute, then getValues()
+		//		will return an empty array: [].  (So, if store.hasAttribute(item, attribute)
+		//		has a return of false, then store.getValues(item, attribute) will return [].)
+		// item:
+		//		The item to access values on.
+		// attribute:
+		//		The attribute to access represented as a string.
+		// returns:
+		//		an array that may contain literals and items
+		// exceptions:
+		//		Throws an exception if *item* is not an item, or *attribute* is not a string
+		// example:
+		//	|	var friendsOfLuke = store.getValues(lukeSkywalker, "friends");
+		throw new Error('Unimplemented API: dojo.data.api.Read.getValues');
+	},
+
+	getAttributes: function(/* item */ item){
+		// summary:
+		//		Returns an array with all the attributes that this item has.  This
+		//		method will always return an array; if the item has no attributes
+		//		at all, getAttributes() will return an empty array: [].
+		// item:
+		//		The item to access attributes on.
+		// exceptions:
+		//		Throws an exception if *item* is not an item, or *attribute* is not a string
+		// example:
+		//	|	var array = store.getAttributes(kermit);
+		throw new Error('Unimplemented API: dojo.data.api.Read.getAttributes');
+	},
+
+	hasAttribute: function(	/* item */ item,
+							/* attribute-name-string */ attribute){
+		// summary:
+		//		Returns true if the given *item* has a value for the given *attribute*.
+		// item:
+		//		The item to access attributes on.
+		// attribute:
+		//		The attribute to access represented as a string.
+		// exceptions:
+		//		Throws an exception if *item* is not an item, or *attribute* is not a string
+		// example:
+		//	|	var trueOrFalse = store.hasAttribute(kermit, "color");
+		throw new Error('Unimplemented API: dojo.data.api.Read.hasAttribute');
+	},
+
+	containsValue: function(/* item */ item,
+							/* attribute-name-string */ attribute,
+							/* anything */ value){
+		// summary:
+		//		Returns true if the given *value* is one of the values that getValues()
+		//		would return.
+		// item:
+		//		The item to access values on.
+		// attribute:
+		//		The attribute to access represented as a string.
+		// value:
+		//		The value to match as a value for the attribute.
+		// exceptions:
+		//		Throws an exception if *item* is not an item, or *attribute* is not a string
+		// example:
+		//	|	var trueOrFalse = store.containsValue(kermit, "color", "green");
+		throw new Error('Unimplemented API: dojo.data.api.Read.containsValue');
+	},
+
+	isItem: function(/* anything */ something){
+		// summary:
+		//		Returns true if *something* is an item and came from the store instance.
+		//		Returns false if *something* is a literal, an item from another store instance,
+		//		or is any object other than an item.
+		// something:
+		//		Can be anything.
+		// example:
+		//	|	var yes = store.isItem(store.newItem());
+		//	|	var no  = store.isItem("green");
+		throw new Error('Unimplemented API: dojo.data.api.Read.isItem');
+	},
+
+	isItemLoaded: function(/* anything */ something){
+		// summary:
+		//		Returns false if isItem(something) is false.  Returns false if
+		//		if isItem(something) is true but the the item is not yet loaded
+		//		in local memory (for example, if the item has not yet been read
+		//		from the server).
+		// something:
+		//		Can be anything.
+		// example:
+		//	|	var yes = store.isItemLoaded(store.newItem());
+		//	|	var no  = store.isItemLoaded("green");
+		throw new Error('Unimplemented API: dojo.data.api.Read.isItemLoaded');
+	},
+
+	loadItem: function(/* object */ keywordArgs){
+		// summary:
+		//		Given an item, this method loads the item so that a subsequent call
+		//		to store.isItemLoaded(item) will return true.  If a call to
+		//		isItemLoaded() returns true before loadItem() is even called,
+		//		then loadItem() need not do any work at all and will not even invoke
+		//		the callback handlers.  So, before invoking this method, check that
+		//		the item has not already been loaded.
+		// 	keywordArgs:
+		//		An anonymous object that defines the item to load and callbacks to invoke when the
+		//		load has completed.  The format of the object is as follows:
+		//		{
+		//			item: object,
+		//			onItem: Function,
+		//			onError: Function,
+		//			scope: object
+		//		}
+		//	The *item* parameter.
+		//		The item parameter is an object that represents the item in question that should be
+		//		contained by the store.  This attribute is required.
+		//
+		//	The *onItem* parameter.
+		//		Function(item)
+		//		The onItem parameter is the callback to invoke when the item has been loaded.  It takes only one
+		//		parameter, the fully loaded item.
+		//
+		//	The *onError* parameter.
+		//		Function(error)
+		//		The onError parameter is the callback to invoke when the item load encountered an error.  It takes only one
+		//		parameter, the error object
+		//
+		//	The *scope* parameter.
+		//		If a scope object is provided, all of the callback functions (onItem,
+		//		onError, etc) will be invoked in the context of the scope object.
+		//		In the body of the callback function, the value of the "this"
+		//		keyword will be the scope object.   If no scope object is provided,
+		//		the callback functions will be called in the context of dojo.global().
+		//		For example, onItem.call(scope, item, request) vs.
+		//		onItem.call(dojo.global(), item, request)
+		if(!this.isItemLoaded(keywordArgs.item)){
+			throw new Error('Unimplemented API: dojo.data.api.Read.loadItem');
+		}
+	},
+
+	fetch: function(/* Object */ keywordArgs){
+		// summary:
+		//		Given a query and set of defined options, such as a start and count of items to return,
+		//		this method executes the query and makes the results available as data items.
+		//		The format and expectations of stores is that they operate in a generally asynchronous
+		//		manner, therefore callbacks are always used to return items located by the fetch parameters.
+		//
+		// description:
+		//		A Request object will always be returned and is returned immediately.
+		//		The basic request is nothing more than the keyword args passed to fetch and
+		//		an additional function attached, abort().  The returned request object may then be used
+		//		to cancel a fetch.  All data items returns are passed through the callbacks defined in the
+		//		fetch parameters and are not present on the 'request' object.
+		//
+		//		This does not mean that custom stores can not add methods and properties to the request object
+		//		returned, only that the API does not require it.  For more info about the Request API,
+		//		see dojo.data.api.Request
+		//
+		// keywordArgs:
+		//		The keywordArgs parameter may either be an instance of
+		//		conforming to dojo.data.api.Request or may be a simple anonymous object
+		//		that may contain any of the following:
+		//		{
+		//			query: query-object or query-string,
+		//			queryOptions: object,
+		//			onBegin: Function,
+		//			onItem: Function,
+		//			onComplete: Function,
+		//			onError: Function,
+		//			scope: object,
+		//			start: int
+		//			count: int
+		//			sort: array
+		//		}
+		//		All implementations should accept keywordArgs objects with any of
+		//		the 9 standard properties: query, onBegin, onItem, onComplete, onError
+		//		scope, sort, start, and count.  Some implementations may accept additional
+		//		properties in the keywordArgs object as valid parameters, such as
+		//		{includeOutliers:true}.
+		//
+		//	The *query* parameter.
+		//		The query may be optional in some data store implementations.
+		//		The dojo.data.api.Read API does not specify the syntax or semantics
+		//		of the query itself -- each different data store implementation
+		//		may have its own notion of what a query should look like.
+		//		However, as of dojo 0.9, 1.0, and 1.1, all the provided datastores in dojo.data
+		//		and dojox.data support an object structure query, where the object is a set of
+		//		name/value parameters such as { attrFoo: valueBar, attrFoo1: valueBar1}.  Most of the
+		//		dijit widgets, such as ComboBox assume this to be the case when working with a datastore
+		//		when they dynamically update the query.  Therefore, for maximum compatibility with dijit
+		//		widgets the recommended query parameter is a key/value object.  That does not mean that the
+		//		the datastore may not take alternative query forms, such as a simple string, a Date, a number,
+		//		or a mix of such.  Ultimately, The dojo.data.api.Read API is agnostic about what the query
+		//		format.
+		//		Further note:  In general for query objects that accept strings as attribute
+		//		value matches, the store should also support basic filtering capability, such as *
+		//		(match any character) and ? (match single character).  An example query that is a query object
+		//		would be like: { attrFoo: "value*"}.  Which generally means match all items where they have
+		//		an attribute named attrFoo, with a value that starts with 'value'.
+		//
+		//	The *queryOptions* parameter
+		//		The queryOptions parameter is an optional parameter used to specify optiosn that may modify
+		//		the query in some fashion, such as doing a case insensitive search, or doing a deep search
+		//		where all items in a hierarchical representation of data are scanned instead of just the root
+		//		items.  It currently defines two options that all datastores should attempt to honor if possible:
+		//		{
+		//			ignoreCase: boolean, //Whether or not the query should match case sensitively or not.  Default behaviour is false.
+		//			deep: boolean 	//Whether or not a fetch should do a deep search of items and all child
+		//							//items instead of just root-level items in a datastore.  Default is false.
+		//		}
+		//
+		//	The *onBegin* parameter.
+		//		function(size, request);
+		//		If an onBegin callback function is provided, the callback function
+		//		will be called just once, before the first onItem callback is called.
+		//		The onBegin callback function will be passed two arguments, the
+		//		the total number of items identified and the Request object.  If the total number is
+		//		unknown, then size will be -1.  Note that size is not necessarily the size of the
+		//		collection of items returned from the query, as the request may have specified to return only a
+		//		subset of the total set of items through the use of the start and count parameters.
+		//
+		//	The *onItem* parameter.
+		//		function(item, request);
+		//		If an onItem callback function is provided, the callback function
+		//		will be called as each item in the result is received. The callback
+		//		function will be passed two arguments: the item itself, and the
+		//		Request object.
+		//
+		//	The *onComplete* parameter.
+		//		function(items, request);
+		//
+		//		If an onComplete callback function is provided, the callback function
+		//		will be called just once, after the last onItem callback is called.
+		//		Note that if the onItem callback is not present, then onComplete will be passed
+		//		an array containing all items which matched the query and the request object.
+		//		If the onItem callback is present, then onComplete is called as:
+		//		onComplete(null, request).
+		//
+		//	The *onError* parameter.
+		//		function(errorData, request);
+		//		If an onError callback function is provided, the callback function
+		//		will be called if there is any sort of error while attempting to
+		//		execute the query.
+		//		The onError callback function will be passed two arguments:
+		//		an Error object and the Request object.
+		//
+		//	The *scope* parameter.
+		//		If a scope object is provided, all of the callback functions (onItem,
+		//		onComplete, onError, etc) will be invoked in the context of the scope
+		//		object.  In the body of the callback function, the value of the "this"
+		//		keyword will be the scope object.   If no scope object is provided,
+		//		the callback functions will be called in the context of dojo.global().
+		//		For example, onItem.call(scope, item, request) vs.
+		//		onItem.call(dojo.global(), item, request)
+		//
+		//	The *start* parameter.
+		//		If a start parameter is specified, this is a indication to the datastore to
+		//		only start returning items once the start number of items have been located and
+		//		skipped.  When this parameter is paired with 'count', the store should be able
+		//		to page across queries with millions of hits by only returning subsets of the
+		//		hits for each query
+		//
+		//	The *count* parameter.
+		//		If a count parameter is specified, this is a indication to the datastore to
+		//		only return up to that many items.  This allows a fetch call that may have
+		//		millions of item matches to be paired down to something reasonable.
+		//
+		//	The *sort* parameter.
+		//		If a sort parameter is specified, this is a indication to the datastore to
+		//		sort the items in some manner before returning the items.  The array is an array of
+		//		javascript objects that must conform to the following format to be applied to the
+		//		fetching of items:
+		//		{
+		//			attribute: attribute || attribute-name-string,
+		//			descending: true|false;   // Optional.  Default is false.
+		//		}
+		//		Note that when comparing attributes, if an item contains no value for the attribute
+		//		(undefined), then it the default ascending sort logic should push it to the bottom
+		//		of the list.  In the descending order case, it such items should appear at the top of the list.
+		//
+		// returns:
+		//		The fetch() method will return a javascript object conforming to the API
+		//		defined in dojo.data.api.Request.  In general, it will be the keywordArgs
+		//		object returned with the required functions in Request.js attached.
+		//		Its general purpose is to provide a convenient way for a caller to abort an
+		//		ongoing fetch.
+		//
+		//		The Request object may also have additional properties when it is returned
+		//		such as request.store property, which is a pointer to the datastore object that
+		//		fetch() is a method of.
+		//
+		// exceptions:
+		//		Throws an exception if the query is not valid, or if the query
+		//		is required but was not supplied.
+		//
+		// example:
+		//		Fetch all books identified by the query and call 'showBooks' when complete
+		//		|	var request = store.fetch({query:"all books", onComplete: showBooks});
+		// example:
+		//		Fetch all items in the story and call 'showEverything' when complete.
+		//		|	var request = store.fetch(onComplete: showEverything);
+		// example:
+		//		Fetch only 10 books that match the query 'all books', starting at the fifth book found during the search.
+		//		This demonstrates how paging can be done for specific queries.
+		//		|	var request = store.fetch({query:"all books", start: 4, count: 10, onComplete: showBooks});
+		// example:
+		//		Fetch all items that match the query, calling 'callback' each time an item is located.
+		//		|	var request = store.fetch({query:"foo/bar", onItem:callback});
+		// example:
+		//		Fetch the first 100 books by author King, call showKing when up to 100 items have been located.
+		//		|	var request = store.fetch({query:{author:"King"}, start: 0, count:100, onComplete: showKing});
+		// example:
+		//		Locate the books written by Author King, sort it on title and publisher, then return the first 100 items from the sorted items.
+		//		|	var request = store.fetch({query:{author:"King"}, sort: [{ attribute: "title", descending: true}, {attribute: "publisher"}], ,start: 0, count:100, onComplete: 'showKing'});
+		// example:
+		//		Fetch the first 100 books by authors starting with the name King, then call showKing when up to 100 items have been located.
+		//		|	var request = store.fetch({query:{author:"King*"}, start: 0, count:100, onComplete: showKing});
+		// example:
+		//		Fetch the first 100 books by authors ending with 'ing', but only have one character before it (King, Bing, Ling, Sing, etc.), then call showBooks when up to 100 items have been located.
+		//		|	var request = store.fetch({query:{author:"?ing"}, start: 0, count:100, onComplete: showBooks});
+		// example:
+		//		Fetch the first 100 books by author King, where the name may appear as King, king, KING, kInG, and so on, then call showKing when up to 100 items have been located.
+		//		|	var request = store.fetch({query:{author:"King"}, queryOptions:(ignoreCase: true}, start: 0, count:100, onComplete: showKing});
+		// example:
+		//		Paging
+		//		|	var store = new dojo.data.LargeRdbmsStore({url:"jdbc:odbc:foobar"});
+		//		|	var fetchArgs = {
+		//		|		query: {type:"employees", name:"Hillary *"}, // string matching
+		//		|		sort: [{attribute:"department", descending:true}],
+		//		|		start: 0,
+		//		|		count: 20,
+		//		|		scope: displayer,
+		//		|		onBegin: showThrobber,
+		//		|		onItem: displayItem,
+		//		|		onComplete: stopThrobber,
+		//		|		onError: handleFetchError,
+		//		|	};
+		//		|	store.fetch(fetchArgs);
+		//		|	...
+		//		and then when the user presses the "Next Page" button...
+		//		|	fetchArgs.start += 20;
+		//		|	store.fetch(fetchArgs);  // get the next 20 items
+		throw new Error('Unimplemented API: dojo.data.api.Read.fetch');
+	},
+
+	getFeatures: function(){
+		// summary:
+		//		The getFeatures() method returns an simple keyword values object
+		//		that specifies what interface features the datastore implements.
+		//		A simple CsvStore may be read-only, and the only feature it
+		//		implements will be the 'dojo.data.api.Read' interface, so the
+		//		getFeatures() method will return an object like this one:
+		//		{'dojo.data.api.Read': true}.
+		//		A more sophisticated datastore might implement a variety of
+		//		interface features, like 'dojo.data.api.Read', 'dojo.data.api.Write',
+		//		'dojo.data.api.Identity', and 'dojo.data.api.Attribution'.
+		return {
+			'dojo.data.api.Read': true
+		};
+	},
+
+	close: function(/*dojo.data.api.Request || keywordArgs || null */ request){
+		// summary:
+		//		The close() method is intended for instructing the store to 'close' out
+		//		any information associated with a particular request.
+		//
+		// description:
+		//		The close() method is intended for instructing the store to 'close' out
+		//		any information associated with a particular request.  In general, this API
+		//		expects to recieve as a parameter a request object returned from a fetch.
+		//		It will then close out anything associated with that request, such as
+		//		clearing any internal datastore caches and closing any 'open' connections.
+		//		For some store implementations, this call may be a no-op.
+		//
+		// request:
+		//		An instance of a request for the store to use to identify what to close out.
+		//		If no request is passed, then the store should clear all internal caches (if any)
+		//		and close out all 'open' connections.  It does not render the store unusable from
+		//		there on, it merely cleans out any current data and resets the store to initial
+		//		state.
+		//
+		// example:
+		//	|	var request = store.fetch({onComplete: doSomething});
+		//	|	...
+		//	|	store.close(request);
+		throw new Error('Unimplemented API: dojo.data.api.Read.close');
+	},
+
+	getLabel: function(/* item */ item){
+		// summary:
+		//		Method to inspect the item and return a user-readable 'label' for the item
+		//		that provides a general/adequate description of what the item is.
+		//
+		// description:
+		//		Method to inspect the item and return a user-readable 'label' for the item
+		//		that provides a general/adequate description of what the item is.  In general
+		//		most labels will be a specific attribute value or collection of the attribute
+		//		values that combine to label the item in some manner.  For example for an item
+		//		that represents a person it may return the label as:  "firstname lastlame" where
+		//		the firstname and lastname are attributes on the item.  If the store is unable
+		//		to determine an adequate human readable label, it should return undefined.  Users that wish
+		//		to customize how a store instance labels items should replace the getLabel() function on
+		//		their instance of the store, or extend the store and replace the function in
+		//		the extension class.
+		//
+		// item:
+		//		The item to return the label for.
+		//
+		// returns:
+		//		A user-readable string representing the item or undefined if no user-readable label can
+		//		be generated.
+		throw new Error('Unimplemented API: dojo.data.api.Read.getLabel');
+	},
+
+	getLabelAttributes: function(/* item */ item){
+		// summary:
+		//		Method to inspect the item and return an array of what attributes of the item were used
+		//		to generate its label, if any.
+		//
+		// description:
+		//		Method to inspect the item and return an array of what attributes of the item were used
+		//		to generate its label, if any.  This function is to assist UI developers in knowing what
+		//		attributes can be ignored out of the attributes an item has when displaying it, in cases
+		//		where the UI is using the label as an overall identifer should they wish to hide
+		//		redundant information.
+		//
+		// item:
+		//		The item to return the list of label attributes for.
+		//
+		// returns:
+		//		An array of attribute names that were used to generate the label, or null if public attributes
+		//		were not used to generate the label.
+		throw new Error('Unimplemented API: dojo.data.api.Read.getLabelAttributes');
+	}
+});
+
+return dojo.data.api.Read;
+});
diff --git a/js/dojo-1.7.2/dojo/data/api/Request.js b/js/dojo-1.7.2/dojo/data/api/Request.js
new file mode 100644
index 0000000..aab1668
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/api/Request.js
@@ -0,0 +1,37 @@
+//>>built
+define("dojo/data/api/Request", ["../.."], function(dojo) {
+	// module:
+	//		dojo/data/api/Request
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.data.api.Request", null, {
+	//	summary:
+	//		This class defines out the semantics of what a 'Request' object looks like
+	//		when returned from a fetch() method.  In general, a request object is
+	//		nothing more than the original keywordArgs from fetch with an abort function
+	//		attached to it to allow users to abort a particular request if they so choose.
+	//		No other functions are required on a general Request object return.  That does not
+	//		inhibit other store implementations from adding extentions to it, of course.
+	//
+	//		This is an abstract API that data provider implementations conform to.
+	//		This file defines methods signatures and intentionally leaves all the
+	//		methods unimplemented.
+	//
+	//		For more details on fetch, see dojo.data.api.Read.fetch().
+
+	abort: function(){
+		//	summary:
+		//		This function is a hook point for stores to provide as a way for
+		//		a fetch to be halted mid-processing.
+		//	description:
+		//		This function is a hook point for stores to provide as a way for
+		//		a fetch to be halted mid-processing.  For more details on the fetch() api,
+		//		please see dojo.data.api.Read.fetch().
+		throw new Error('Unimplemented API: dojo.data.api.Request.abort');
+	}
+});
+
+return dojo.data.api.Request;
+});
diff --git a/js/dojo-1.7.2/dojo/data/api/Write.js b/js/dojo-1.7.2/dojo/data/api/Write.js
new file mode 100644
index 0000000..12a4763
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/api/Write.js
@@ -0,0 +1,222 @@
+//>>built
+define("dojo/data/api/Write", ["../..", "./Read"], function(dojo) {
+	// module:
+	//		dojo/data/api/Write
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
+	// summary:
+	//		This is an abstract API that data provider implementations conform to.
+	//		This file defines function signatures and intentionally leaves all the
+	//		functionss unimplemented.
+
+	getFeatures: function(){
+		// summary:
+		//		See dojo.data.api.Read.getFeatures()
+		return {
+			'dojo.data.api.Read': true,
+			'dojo.data.api.Write': true
+		};
+	},
+
+	newItem: function(/* Object? */ keywordArgs, /*Object?*/ parentInfo){
+		// summary:
+		//		Returns a newly created item.  Sets the attributes of the new
+		//		item based on the *keywordArgs* provided.  In general, the attribute
+		//		names in the keywords become the attributes in the new item and as for
+		//		the attribute values in keywordArgs, they become the values of the attributes
+		//		in the new item.  In addition, for stores that support hierarchical item
+		//		creation, an optional second parameter is accepted that defines what item is the parent
+		//		of the new item and what attribute of that item should the new item be assigned to.
+		//		In general, this will assume that the attribute targetted is multi-valued and a new item
+		//		is appended onto the list of values for that attribute.
+		//
+		// keywordArgs:
+		//		A javascript object defining the initial content of the item as a set of JavaScript 'property name: value' pairs.
+		// parentInfo:
+		//		An optional javascript object defining what item is the parent of this item (in a hierarchical store.  Not all stores do hierarchical items),
+		//		and what attribute of that parent to assign the new item to.  If this is present, and the attribute specified
+		//		is a multi-valued attribute, it will append this item into the array of values for that attribute.  The structure
+		//		of the object is as follows:
+		//		{
+		//			parent: someItem,
+		//			attribute: "attribute-name-string"
+		//		}
+		//
+		// exceptions:
+		//		Throws an exception if *keywordArgs* is a string or a number or
+		//		anything other than a simple anonymous object.
+		//		Throws an exception if the item in parentInfo is not an item from the store
+		//		or if the attribute isn't an attribute name string.
+		// example:
+		//	|	var kermit = store.newItem({name: "Kermit", color:[blue, green]});
+
+		throw new Error('Unimplemented API: dojo.data.api.Write.newItem');
+	},
+
+	deleteItem: function(/* item */ item){
+		// summary:
+		//		Deletes an item from the store.
+		//
+		// item:
+		//		The item to delete.
+		//
+		// exceptions:
+		//		Throws an exception if the argument *item* is not an item
+		//		(if store.isItem(item) returns false).
+		// example:
+		//	|	var success = store.deleteItem(kermit);
+		throw new Error('Unimplemented API: dojo.data.api.Write.deleteItem');
+	},
+
+	setValue: function(	/* item */ item,
+						/* string */ attribute,
+						/* almost anything */ value){
+		// summary:
+		//		Sets the value of an attribute on an item.
+		//		Replaces any previous value or values.
+		//
+		// item:
+		//		The item to modify.
+		// attribute:
+		//		The attribute of the item to change represented as a string name.
+		// value:
+		//		The value to assign to the item.
+		//
+		// exceptions:
+		//		Throws an exception if *item* is not an item, or if *attribute*
+		//		is neither an attribute object or a string.
+		//		Throws an exception if *value* is undefined.
+		// example:
+		//	|	var success = store.set(kermit, "color", "green");
+		throw new Error('Unimplemented API: dojo.data.api.Write.setValue');
+	},
+
+	setValues: function(/* item */ item,
+						/* string */ attribute,
+						/* array */ values){
+		// summary:
+		//		Adds each value in the *values* array as a value of the given
+		//		attribute on the given item.
+		//		Replaces any previous value or values.
+		//		Calling store.setValues(x, y, []) (with *values* as an empty array) has
+		//		the same effect as calling store.unsetAttribute(x, y).
+		//
+		// item:
+		//		The item to modify.
+		// attribute:
+		//		The attribute of the item to change represented as a string name.
+		// values:
+		//		An array of values to assign to the attribute..
+		//
+		// exceptions:
+		//		Throws an exception if *values* is not an array, if *item* is not an
+		//		item, or if *attribute* is neither an attribute object or a string.
+		// example:
+		//	|	var success = store.setValues(kermit, "color", ["green", "aqua"]);
+		//	|	success = store.setValues(kermit, "color", []);
+		//	|	if (success) {assert(!store.hasAttribute(kermit, "color"));}
+		throw new Error('Unimplemented API: dojo.data.api.Write.setValues');
+	},
+
+	unsetAttribute: function(	/* item */ item,
+								/* string */ attribute){
+		// summary:
+		//		Deletes all the values of an attribute on an item.
+		//
+		// item:
+		//		The item to modify.
+		// attribute:
+		//		The attribute of the item to unset represented as a string.
+		//
+		// exceptions:
+		//		Throws an exception if *item* is not an item, or if *attribute*
+		//		is neither an attribute object or a string.
+		// example:
+		//	|	var success = store.unsetAttribute(kermit, "color");
+		//	|	if (success) {assert(!store.hasAttribute(kermit, "color"));}
+		throw new Error('Unimplemented API: dojo.data.api.Write.clear');
+	},
+
+	save: function(/* object */ keywordArgs){
+		// summary:
+		//		Saves to the server all the changes that have been made locally.
+		//		The save operation may take some time and is generally performed
+		//		in an asynchronous fashion.  The outcome of the save action is
+		//		is passed into the set of supported callbacks for the save.
+		//
+		// keywordArgs:
+		//		{
+		//			onComplete: function
+		//			onError: function
+		//			scope: object
+		//		}
+		//
+		//	The *onComplete* parameter.
+		//		function();
+		//
+		//		If an onComplete callback function is provided, the callback function
+		//		will be called just once, after the save has completed.  No parameters
+		//		are generally passed to the onComplete.
+		//
+		//	The *onError* parameter.
+		//		function(errorData);
+		//
+		//		If an onError callback function is provided, the callback function
+		//		will be called if there is any sort of error while attempting to
+		//		execute the save.  The onError function will be based one parameter, the
+		//		error.
+		//
+		//	The *scope* parameter.
+		//		If a scope object is provided, all of the callback function (
+		//		onComplete, onError, etc) will be invoked in the context of the scope
+		//		object.  In the body of the callback function, the value of the "this"
+		//		keyword will be the scope object.   If no scope object is provided,
+		//		the callback functions will be called in the context of dojo.global.
+		//		For example, onComplete.call(scope) vs.
+		//		onComplete.call(dojo.global)
+		//
+		// returns:
+		//		Nothing.  Since the saves are generally asynchronous, there is
+		//		no need to return anything.  All results are passed via callbacks.
+		// example:
+		//	|	store.save({onComplete: onSave});
+		//	|	store.save({scope: fooObj, onComplete: onSave, onError: saveFailed});
+		throw new Error('Unimplemented API: dojo.data.api.Write.save');
+	},
+
+	revert: function(){
+		// summary:
+		//		Discards any unsaved changes.
+		// description:
+		//		Discards any unsaved changes.
+		//
+		// example:
+		//	|	var success = store.revert();
+		throw new Error('Unimplemented API: dojo.data.api.Write.revert');
+	},
+
+	isDirty: function(/* item? */ item){
+		// summary:
+		//		Given an item, isDirty() returns true if the item has been modified
+		//		since the last save().  If isDirty() is called with no *item* argument,
+		//		then this function returns true if any item has been modified since
+		//		the last save().
+		//
+		// item:
+		//		The item to check.
+		//
+		// exceptions:
+		//		Throws an exception if isDirty() is passed an argument and the
+		//		argument is not an item.
+		// example:
+		//	|	var trueOrFalse = store.isDirty(kermit); // true if kermit is dirty
+		//	|	var trueOrFalse = store.isDirty();       // true if any item is dirty
+		throw new Error('Unimplemented API: dojo.data.api.Write.isDirty');
+	}
+});
+
+return dojo.data.api.Write;
+});
diff --git a/js/dojo-1.7.2/dojo/data/util/filter.js b/js/dojo-1.7.2/dojo/data/util/filter.js
new file mode 100644
index 0000000..95f63d5
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/util/filter.js
@@ -0,0 +1,75 @@
+//>>built
+define("dojo/data/util/filter", ["dojo/_base/lang"], function(lang) {
+	// module:
+	//		dojo/data/util/filter
+	// summary:
+	//		TODOC
+
+var filter = lang.getObject("dojo.data.util.filter", true);
+
+filter.patternToRegExp = function(/*String*/pattern, /*boolean?*/ ignoreCase){
+	//	summary:
+	//		Helper function to convert a simple pattern to a regular expression for matching.
+	//	description:
+	//		Returns a regular expression object that conforms to the defined conversion rules.
+	//		For example:
+	//			ca*   -> /^ca.*$/
+	//			*ca*  -> /^.*ca.*$/
+	//			*c\*a*  -> /^.*c\*a.*$/
+	//			*c\*a?*  -> /^.*c\*a..*$/
+	//			and so on.
+	//
+	//	pattern: string
+	//		A simple matching pattern to convert that follows basic rules:
+	//			* Means match anything, so ca* means match anything starting with ca
+	//			? Means match single character.  So, b?b will match to bob and bab, and so on.
+	//      	\ is an escape character.  So for example, \* means do not treat * as a match, but literal character *.
+	//				To use a \ as a character in the string, it must be escaped.  So in the pattern it should be
+	//				represented by \\ to be treated as an ordinary \ character instead of an escape.
+	//
+	//	ignoreCase:
+	//		An optional flag to indicate if the pattern matching should be treated as case-sensitive or not when comparing
+	//		By default, it is assumed case sensitive.
+
+	var rxp = "^";
+	var c = null;
+	for(var i = 0; i < pattern.length; i++){
+		c = pattern.charAt(i);
+		switch(c){
+			case '\\':
+				rxp += c;
+				i++;
+				rxp += pattern.charAt(i);
+				break;
+			case '*':
+				rxp += ".*"; break;
+			case '?':
+				rxp += "."; break;
+			case '$':
+			case '^':
+			case '/':
+			case '+':
+			case '.':
+			case '|':
+			case '(':
+			case ')':
+			case '{':
+			case '}':
+			case '[':
+			case ']':
+				rxp += "\\"; //fallthrough
+			default:
+				rxp += c;
+		}
+	}
+	rxp += "$";
+	if(ignoreCase){
+		return new RegExp(rxp,"mi"); //RegExp
+	}else{
+		return new RegExp(rxp,"m"); //RegExp
+	}
+
+};
+
+return filter;
+});
diff --git a/js/dojo-1.7.2/dojo/data/util/simpleFetch.js b/js/dojo-1.7.2/dojo/data/util/simpleFetch.js
new file mode 100644
index 0000000..e041ac1
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/util/simpleFetch.js
@@ -0,0 +1,96 @@
+//>>built
+define("dojo/data/util/simpleFetch", ["dojo/_base/lang", "dojo/_base/window", "./sorter"], 
+  function(lang, winUtil, sorter) {
+	// module:
+	//		dojo/data/util/simpleFetch
+	// summary:
+	//		TODOC
+
+var simpleFetch = lang.getObject("dojo.data.util.simpleFetch", true);
+
+simpleFetch.fetch = function(/* Object? */ request){
+	//	summary:
+	//		The simpleFetch mixin is designed to serve as a set of function(s) that can
+	//		be mixed into other datastore implementations to accelerate their development.
+	//		The simpleFetch mixin should work well for any datastore that can respond to a _fetchItems()
+	//		call by returning an array of all the found items that matched the query.  The simpleFetch mixin
+	//		is not designed to work for datastores that respond to a fetch() call by incrementally
+	//		loading items, or sequentially loading partial batches of the result
+	//		set.  For datastores that mixin simpleFetch, simpleFetch
+	//		implements a fetch method that automatically handles eight of the fetch()
+	//		arguments -- onBegin, onItem, onComplete, onError, start, count, sort and scope
+	//		The class mixing in simpleFetch should not implement fetch(),
+	//		but should instead implement a _fetchItems() method.  The _fetchItems()
+	//		method takes three arguments, the keywordArgs object that was passed
+	//		to fetch(), a callback function to be called when the result array is
+	//		available, and an error callback to be called if something goes wrong.
+	//		The _fetchItems() method should ignore any keywordArgs parameters for
+	//		start, count, onBegin, onItem, onComplete, onError, sort, and scope.
+	//		The _fetchItems() method needs to correctly handle any other keywordArgs
+	//		parameters, including the query parameter and any optional parameters
+	//		(such as includeChildren).  The _fetchItems() method should create an array of
+	//		result items and pass it to the fetchHandler along with the original request object
+	//		-- or, the _fetchItems() method may, if it wants to, create an new request object
+	//		with other specifics about the request that are specific to the datastore and pass
+	//		that as the request object to the handler.
+	//
+	//		For more information on this specific function, see dojo.data.api.Read.fetch()
+	request = request || {};
+	if(!request.store){
+		request.store = this;
+	}
+	var self = this;
+
+	var _errorHandler = function(errorData, requestObject){
+		if(requestObject.onError){
+			var scope = requestObject.scope || winUtil.global;
+			requestObject.onError.call(scope, errorData, requestObject);
+		}
+	};
+
+	var _fetchHandler = function(items, requestObject){
+		var oldAbortFunction = requestObject.abort || null;
+		var aborted = false;
+
+		var startIndex = requestObject.start?requestObject.start:0;
+		var endIndex = (requestObject.count && (requestObject.count !== Infinity))?(startIndex + requestObject.count):items.length;
+
+		requestObject.abort = function(){
+			aborted = true;
+			if(oldAbortFunction){
+				oldAbortFunction.call(requestObject);
+			}
+		};
+
+		var scope = requestObject.scope || winUtil.global;
+		if(!requestObject.store){
+			requestObject.store = self;
+		}
+		if(requestObject.onBegin){
+			requestObject.onBegin.call(scope, items.length, requestObject);
+		}
+		if(requestObject.sort){
+			items.sort(sorter.createSortFunction(requestObject.sort, self));
+		}
+		if(requestObject.onItem){
+			for(var i = startIndex; (i < items.length) && (i < endIndex); ++i){
+				var item = items[i];
+				if(!aborted){
+					requestObject.onItem.call(scope, item, requestObject);
+				}
+			}
+		}
+		if(requestObject.onComplete && !aborted){
+			var subset = null;
+			if(!requestObject.onItem){
+				subset = items.slice(startIndex, endIndex);
+			}
+			requestObject.onComplete.call(scope, subset, requestObject);
+		}
+	};
+	this._fetchItems(request, _fetchHandler, _errorHandler);
+	return request;	// Object
+};
+
+return simpleFetch;
+});
diff --git a/js/dojo-1.7.2/dojo/data/util/sorter.js b/js/dojo-1.7.2/dojo/data/util/sorter.js
new file mode 100644
index 0000000..ecb7557
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/data/util/sorter.js
@@ -0,0 +1,100 @@
+//>>built
+define("dojo/data/util/sorter", ["dojo/_base/lang"], function(lang) {
+	// module:
+	//		dojo/data/util/sorter
+	// summary:
+	//		TODOC
+
+var sorter = lang.getObject("dojo.data.util.sorter", true);
+
+sorter.basicComparator = function(	/*anything*/ a,
+													/*anything*/ b){
+	//	summary:
+	//		Basic comparision function that compares if an item is greater or less than another item
+	//	description:
+	//		returns 1 if a > b, -1 if a < b, 0 if equal.
+	//		'null' values (null, undefined) are treated as larger values so that they're pushed to the end of the list.
+	//		And compared to each other, null is equivalent to undefined.
+
+	//null is a problematic compare, so if null, we set to undefined.
+	//Makes the check logic simple, compact, and consistent
+	//And (null == undefined) === true, so the check later against null
+	//works for undefined and is less bytes.
+	var r = -1;
+	if(a === null){
+		a = undefined;
+	}
+	if(b === null){
+		b = undefined;
+	}
+	if(a == b){
+		r = 0;
+	}else if(a > b || a == null){
+		r = 1;
+	}
+	return r; //int {-1,0,1}
+};
+
+sorter.createSortFunction = function(	/* attributes array */sortSpec, /*dojo.data.core.Read*/ store){
+	//	summary:
+	//		Helper function to generate the sorting function based off the list of sort attributes.
+	//	description:
+	//		The sort function creation will look for a property on the store called 'comparatorMap'.  If it exists
+	//		it will look in the mapping for comparisons function for the attributes.  If one is found, it will
+	//		use it instead of the basic comparator, which is typically used for strings, ints, booleans, and dates.
+	//		Returns the sorting function for this particular list of attributes and sorting directions.
+	//
+	//	sortSpec: array
+	//		A JS object that array that defines out what attribute names to sort on and whether it should be descenting or asending.
+	//		The objects should be formatted as follows:
+	//		{
+	//			attribute: "attributeName-string" || attribute,
+	//			descending: true|false;   // Default is false.
+	//		}
+	//	store: object
+	//		The datastore object to look up item values from.
+	//
+	var sortFunctions=[];
+
+	function createSortFunction(attr, dir, comp, s){
+		//Passing in comp and s (comparator and store), makes this
+		//function much faster.
+		return function(itemA, itemB){
+			var a = s.getValue(itemA, attr);
+			var b = s.getValue(itemB, attr);
+			return dir * comp(a,b); //int
+		};
+	}
+	var sortAttribute;
+	var map = store.comparatorMap;
+	var bc = sorter.basicComparator;
+	for(var i = 0; i < sortSpec.length; i++){
+		sortAttribute = sortSpec[i];
+		var attr = sortAttribute.attribute;
+		if(attr){
+			var dir = (sortAttribute.descending) ? -1 : 1;
+			var comp = bc;
+			if(map){
+				if(typeof attr !== "string" && ("toString" in attr)){
+					 attr = attr.toString();
+				}
+				comp = map[attr] || bc;
+			}
+			sortFunctions.push(createSortFunction(attr,
+				dir, comp, store));
+		}
+	}
+	return function(rowA, rowB){
+		var i=0;
+		while(i < sortFunctions.length){
+			var ret = sortFunctions[i++](rowA, rowB);
+			if(ret !== 0){
+				return ret;//int
+			}
+		}
+		return 0; //int
+	}; // Function
+};
+
+return sorter;
+});
diff --git a/js/dojo-1.7.2/dojo/date.js b/js/dojo-1.7.2/dojo/date.js
new file mode 100644
index 0000000..f8238d0
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/date.js
@@ -0,0 +1,348 @@
+//>>built
+define("dojo/date", ["./_base/kernel", "./_base/lang"], function(dojo, lang) {
+	// module:
+	//		dojo/date
+	// summary:
+	//		TODOC
+
+lang.getObject("date", true, dojo);
+
+/*=====
+dojo.date = {
+	// summary: Date manipulation utilities
+}
+=====*/
+
+dojo.date.getDaysInMonth = function(/*Date*/dateObject){
+	//	summary:
+	//		Returns the number of days in the month used by dateObject
+	var month = dateObject.getMonth();
+	var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+	if(month == 1 && dojo.date.isLeapYear(dateObject)){ return 29; } // Number
+	return days[month]; // Number
+};
+
+dojo.date.isLeapYear = function(/*Date*/dateObject){
+	//	summary:
+	//		Determines if the year of the dateObject is a leap year
+	//	description:
+	//		Leap years are years with an additional day YYYY-02-29, where the
+	//		year number is a multiple of four with the following exception: If
+	//		a year is a multiple of 100, then it is only a leap year if it is
+	//		also a multiple of 400. For example, 1900 was not a leap year, but
+	//		2000 is one.
+
+	var year = dateObject.getFullYear();
+	return !(year%400) || (!(year%4) && !!(year%100)); // Boolean
+};
+
+// FIXME: This is not localized
+dojo.date.getTimezoneName = function(/*Date*/dateObject){
+	//	summary:
+	//		Get the user's time zone as provided by the browser
+	// dateObject:
+	//		Needed because the timezone may vary with time (daylight savings)
+	//	description:
+	//		Try to get time zone info from toString or toLocaleString method of
+	//		the Date object -- UTC offset is not a time zone.  See
+	//		http://www.twinsun.com/tz/tz-link.htm Note: results may be
+	//		inconsistent across browsers.
+
+	var str = dateObject.toString(); // Start looking in toString
+	var tz = ''; // The result -- return empty string if nothing found
+	var match;
+
+	// First look for something in parentheses -- fast lookup, no regex
+	var pos = str.indexOf('(');
+	if(pos > -1){
+		tz = str.substring(++pos, str.indexOf(')'));
+	}else{
+		// If at first you don't succeed ...
+		// If IE knows about the TZ, it appears before the year
+		// Capital letters or slash before a 4-digit year
+		// at the end of string
+		var pat = /([A-Z\/]+) \d{4}$/;
+		if((match = str.match(pat))){
+			tz = match[1];
+		}else{
+		// Some browsers (e.g. Safari) glue the TZ on the end
+		// of toLocaleString instead of putting it in toString
+			str = dateObject.toLocaleString();
+			// Capital letters or slash -- end of string,
+			// after space
+			pat = / ([A-Z\/]+)$/;
+			if((match = str.match(pat))){
+				tz = match[1];
+			}
+		}
+	}
+
+	// Make sure it doesn't somehow end up return AM or PM
+	return (tz == 'AM' || tz == 'PM') ? '' : tz; // String
+};
+
+// Utility methods to do arithmetic calculations with Dates
+
+dojo.date.compare = function(/*Date*/date1, /*Date?*/date2, /*String?*/portion){
+	//	summary:
+	//		Compare two date objects by date, time, or both.
+	//	description:
+	//  	Returns 0 if equal, positive if a > b, else negative.
+	//	date1:
+	//		Date object
+	//	date2:
+	//		Date object.  If not specified, the current Date is used.
+	//	portion:
+	//		A string indicating the "date" or "time" portion of a Date object.
+	//		Compares both "date" and "time" by default.  One of the following:
+	//		"date", "time", "datetime"
+
+	// Extra step required in copy for IE - see #3112
+	date1 = new Date(+date1);
+	date2 = new Date(+(date2 || new Date()));
+
+	if(portion == "date"){
+		// Ignore times and compare dates.
+		date1.setHours(0, 0, 0, 0);
+		date2.setHours(0, 0, 0, 0);
+	}else if(portion == "time"){
+		// Ignore dates and compare times.
+		date1.setFullYear(0, 0, 0);
+		date2.setFullYear(0, 0, 0);
+	}
+
+	if(date1 > date2){ return 1; } // int
+	if(date1 < date2){ return -1; } // int
+	return 0; // int
+};
+
+dojo.date.add = function(/*Date*/date, /*String*/interval, /*int*/amount){
+	//	summary:
+	//		Add to a Date in intervals of different size, from milliseconds to years
+	//	date: Date
+	//		Date object to start with
+	//	interval:
+	//		A string representing the interval.  One of the following:
+	//			"year", "month", "day", "hour", "minute", "second",
+	//			"millisecond", "quarter", "week", "weekday"
+	//	amount:
+	//		How much to add to the date.
+
+	var sum = new Date(+date); // convert to Number before copying to accomodate IE (#3112)
+	var fixOvershoot = false;
+	var property = "Date";
+
+	switch(interval){
+		case "day":
+			break;
+		case "weekday":
+			//i18n FIXME: assumes Saturday/Sunday weekend, but this is not always true.  see dojo.cldr.supplemental
+
+			// Divide the increment time span into weekspans plus leftover days
+			// e.g., 8 days is one 5-day weekspan / and two leftover days
+			// Can't have zero leftover days, so numbers divisible by 5 get
+			// a days value of 5, and the remaining days make up the number of weeks
+			var days, weeks;
+			var mod = amount % 5;
+			if(!mod){
+				days = (amount > 0) ? 5 : -5;
+				weeks = (amount > 0) ? ((amount-5)/5) : ((amount+5)/5);
+			}else{
+				days = mod;
+				weeks = parseInt(amount/5);
+			}
+			// Get weekday value for orig date param
+			var strt = date.getDay();
+			// Orig date is Sat / positive incrementer
+			// Jump over Sun
+			var adj = 0;
+			if(strt == 6 && amount > 0){
+				adj = 1;
+			}else if(strt == 0 && amount < 0){
+			// Orig date is Sun / negative incrementer
+			// Jump back over Sat
+				adj = -1;
+			}
+			// Get weekday val for the new date
+			var trgt = strt + days;
+			// New date is on Sat or Sun
+			if(trgt == 0 || trgt == 6){
+				adj = (amount > 0) ? 2 : -2;
+			}
+			// Increment by number of weeks plus leftover days plus
+			// weekend adjustments
+			amount = (7 * weeks) + days + adj;
+			break;
+		case "year":
+			property = "FullYear";
+			// Keep increment/decrement from 2/29 out of March
+			fixOvershoot = true;
+			break;
+		case "week":
+			amount *= 7;
+			break;
+		case "quarter":
+			// Naive quarter is just three months
+			amount *= 3;
+			// fallthrough...
+		case "month":
+			// Reset to last day of month if you overshoot
+			fixOvershoot = true;
+			property = "Month";
+			break;
+//		case "hour":
+//		case "minute":
+//		case "second":
+//		case "millisecond":
+		default:
+			property = "UTC"+interval.charAt(0).toUpperCase() + interval.substring(1) + "s";
+	}
+
+	if(property){
+		sum["set"+property](sum["get"+property]()+amount);
+	}
+
+	if(fixOvershoot && (sum.getDate() < date.getDate())){
+		sum.setDate(0);
+	}
+
+	return sum; // Date
+};
+
+dojo.date.difference = function(/*Date*/date1, /*Date?*/date2, /*String?*/interval){
+	//	summary:
+	//		Get the difference in a specific unit of time (e.g., number of
+	//		months, weeks, days, etc.) between two dates, rounded to the
+	//		nearest integer.
+	//	date1:
+	//		Date object
+	//	date2:
+	//		Date object.  If not specified, the current Date is used.
+	//	interval:
+	//		A string representing the interval.  One of the following:
+	//			"year", "month", "day", "hour", "minute", "second",
+	//			"millisecond", "quarter", "week", "weekday"
+	//		Defaults to "day".
+
+	date2 = date2 || new Date();
+	interval = interval || "day";
+	var yearDiff = date2.getFullYear() - date1.getFullYear();
+	var delta = 1; // Integer return value
+
+	switch(interval){
+		case "quarter":
+			var m1 = date1.getMonth();
+			var m2 = date2.getMonth();
+			// Figure out which quarter the months are in
+			var q1 = Math.floor(m1/3) + 1;
+			var q2 = Math.floor(m2/3) + 1;
+			// Add quarters for any year difference between the dates
+			q2 += (yearDiff * 4);
+			delta = q2 - q1;
+			break;
+		case "weekday":
+			var days = Math.round(dojo.date.difference(date1, date2, "day"));
+			var weeks = parseInt(dojo.date.difference(date1, date2, "week"));
+			var mod = days % 7;
+
+			// Even number of weeks
+			if(mod == 0){
+				days = weeks*5;
+			}else{
+				// Weeks plus spare change (< 7 days)
+				var adj = 0;
+				var aDay = date1.getDay();
+				var bDay = date2.getDay();
+
+				weeks = parseInt(days/7);
+				mod = days % 7;
+				// Mark the date advanced by the number of
+				// round weeks (may be zero)
+				var dtMark = new Date(date1);
+				dtMark.setDate(dtMark.getDate()+(weeks*7));
+				var dayMark = dtMark.getDay();
+
+				// Spare change days -- 6 or less
+				if(days > 0){
+					switch(true){
+						// Range starts on Sat
+						case aDay == 6:
+							adj = -1;
+							break;
+						// Range starts on Sun
+						case aDay == 0:
+							adj = 0;
+							break;
+						// Range ends on Sat
+						case bDay == 6:
+							adj = -1;
+							break;
+						// Range ends on Sun
+						case bDay == 0:
+							adj = -2;
+							break;
+						// Range contains weekend
+						case (dayMark + mod) > 5:
+							adj = -2;
+					}
+				}else if(days < 0){
+					switch(true){
+						// Range starts on Sat
+						case aDay == 6:
+							adj = 0;
+							break;
+						// Range starts on Sun
+						case aDay == 0:
+							adj = 1;
+							break;
+						// Range ends on Sat
+						case bDay == 6:
+							adj = 2;
+							break;
+						// Range ends on Sun
+						case bDay == 0:
+							adj = 1;
+							break;
+						// Range contains weekend
+						case (dayMark + mod) < 0:
+							adj = 2;
+					}
+				}
+				days += adj;
+				days -= (weeks*2);
+			}
+			delta = days;
+			break;
+		case "year":
+			delta = yearDiff;
+			break;
+		case "month":
+			delta = (date2.getMonth() - date1.getMonth()) + (yearDiff * 12);
+			break;
+		case "week":
+			// Truncate instead of rounding
+			// Don't use Math.floor -- value may be negative
+			delta = parseInt(dojo.date.difference(date1, date2, "day")/7);
+			break;
+		case "day":
+			delta /= 24;
+			// fallthrough
+		case "hour":
+			delta /= 60;
+			// fallthrough
+		case "minute":
+			delta /= 60;
+			// fallthrough
+		case "second":
+			delta /= 1000;
+			// fallthrough
+		case "millisecond":
+			delta *= date2.getTime() - date1.getTime();
+	}
+
+	// Round for fractional values and DST leaps
+	return Math.round(delta); // Number (integer)
+};
+
+return dojo.date;
+});
diff --git a/js/dojo-1.7.2/dojo/date/locale.js b/js/dojo-1.7.2/dojo/date/locale.js
new file mode 100644
index 0000000..0bebc5c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/date/locale.js
@@ -0,0 +1,671 @@
+//>>built
+define("dojo/date/locale", [
+	"../_base/kernel",
+	"../_base/lang",
+	"../_base/array",
+	"../date",
+	"../cldr/supplemental",
+	"../regexp",
+	"../string",
+	"../i18n!../cldr/nls/gregorian"
+], function(dojo, lang, array, date, cldr, regexp, string, gregorian) {
+	// module:
+	//		dojo/date/locale
+	// summary:
+	//		This modules defines dojo.date.locale, localization methods for Date.
+
+lang.getObject("date.locale", true, dojo);
+
+// Localization methods for Date.   Honor local customs using locale-dependent dojo.cldr data.
+
+// Load the bundles containing localization information for
+// names and formats
+
+//NOTE: Everything in this module assumes Gregorian calendars.
+// Other calendars will be implemented in separate modules.
+
+	// Format a pattern without literals
+	function formatPattern(dateObject, bundle, options, pattern){
+		return pattern.replace(/([a-z])\1*/ig, function(match){
+			var s, pad,
+				c = match.charAt(0),
+				l = match.length,
+				widthList = ["abbr", "wide", "narrow"];
+			switch(c){
+				case 'G':
+					s = bundle[(l < 4) ? "eraAbbr" : "eraNames"][dateObject.getFullYear() < 0 ? 0 : 1];
+					break;
+				case 'y':
+					s = dateObject.getFullYear();
+					switch(l){
+						case 1:
+							break;
+						case 2:
+							if(!options.fullYear){
+								s = String(s); s = s.substr(s.length - 2);
+								break;
+							}
+							// fallthrough
+						default:
+							pad = true;
+					}
+					break;
+				case 'Q':
+				case 'q':
+					s = Math.ceil((dateObject.getMonth()+1)/3);
+//					switch(l){
+//						case 1: case 2:
+							pad = true;
+//							break;
+//						case 3: case 4: // unimplemented
+//					}
+					break;
+				case 'M':
+					var m = dateObject.getMonth();
+					if(l<3){
+						s = m+1; pad = true;
+					}else{
+						var propM = ["months", "format", widthList[l-3]].join("-");
+						s = bundle[propM][m];
+					}
+					break;
+				case 'w':
+					var firstDay = 0;
+					s = dojo.date.locale._getWeekOfYear(dateObject, firstDay); pad = true;
+					break;
+				case 'd':
+					s = dateObject.getDate(); pad = true;
+					break;
+				case 'D':
+					s = dojo.date.locale._getDayOfYear(dateObject); pad = true;
+					break;
+				case 'E':
+					var d = dateObject.getDay();
+					if(l<3){
+						s = d+1; pad = true;
+					}else{
+						var propD = ["days", "format", widthList[l-3]].join("-");
+						s = bundle[propD][d];
+					}
+					break;
+				case 'a':
+					var timePeriod = (dateObject.getHours() < 12) ? 'am' : 'pm';
+					s = options[timePeriod] || bundle['dayPeriods-format-wide-' + timePeriod];
+					break;
+				case 'h':
+				case 'H':
+				case 'K':
+				case 'k':
+					var h = dateObject.getHours();
+					// strange choices in the date format make it impossible to write this succinctly
+					switch (c){
+						case 'h': // 1-12
+							s = (h % 12) || 12;
+							break;
+						case 'H': // 0-23
+							s = h;
+							break;
+						case 'K': // 0-11
+							s = (h % 12);
+							break;
+						case 'k': // 1-24
+							s = h || 24;
+							break;
+					}
+					pad = true;
+					break;
+				case 'm':
+					s = dateObject.getMinutes(); pad = true;
+					break;
+				case 's':
+					s = dateObject.getSeconds(); pad = true;
+					break;
+				case 'S':
+					s = Math.round(dateObject.getMilliseconds() * Math.pow(10, l-3)); pad = true;
+					break;
+				case 'v': // FIXME: don't know what this is. seems to be same as z?
+				case 'z':
+					// We only have one timezone to offer; the one from the browser
+					s = dojo.date.locale._getZone(dateObject, true, options);
+					if(s){break;}
+					l=4;
+					// fallthrough... use GMT if tz not available
+				case 'Z':
+					var offset = dojo.date.locale._getZone(dateObject, false, options);
+					var tz = [
+						(offset<=0 ? "+" : "-"),
+						string.pad(Math.floor(Math.abs(offset)/60), 2),
+						string.pad(Math.abs(offset)% 60, 2)
+					];
+					if(l==4){
+						tz.splice(0, 0, "GMT");
+						tz.splice(3, 0, ":");
+					}
+					s = tz.join("");
+					break;
+//				case 'Y': case 'u': case 'W': case 'F': case 'g': case 'A': case 'e':
+//					console.log(match+" modifier unimplemented");
+				default:
+					throw new Error("dojo.date.locale.format: invalid pattern char: "+pattern);
+			}
+			if(pad){ s = string.pad(s, l); }
+			return s;
+		});
+	}
+
+/*=====
+	dojo.date.locale.__FormatOptions = function(){
+	//	selector: String
+	//		choice of 'time','date' (default: date and time)
+	//	formatLength: String
+	//		choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'
+	//	datePattern:String
+	//		override pattern with this string
+	//	timePattern:String
+	//		override pattern with this string
+	//	am: String
+	//		override strings for am in times
+	//	pm: String
+	//		override strings for pm in times
+	//	locale: String
+	//		override the locale used to determine formatting rules
+	//	fullYear: Boolean
+	//		(format only) use 4 digit years whenever 2 digit years are called for
+	//	strict: Boolean
+	//		(parse only) strict parsing, off by default
+		this.selector = selector;
+		this.formatLength = formatLength;
+		this.datePattern = datePattern;
+		this.timePattern = timePattern;
+		this.am = am;
+		this.pm = pm;
+		this.locale = locale;
+		this.fullYear = fullYear;
+		this.strict = strict;
+	}
+=====*/
+
+dojo.date.locale._getZone = function(/*Date*/dateObject, /*boolean*/getName, /*dojo.date.locale.__FormatOptions?*/options){
+	// summary:
+	//		Returns the zone (or offset) for the given date and options.  This
+	//		is broken out into a separate function so that it can be overridden
+	//		by timezone-aware code.
+	//
+	// dateObject:
+	//		the date and/or time being formatted.
+	//
+	// getName:
+	//		Whether to return the timezone string (if true), or the offset (if false)
+	//
+	// options:
+	//		The options being used for formatting
+	if(getName){
+		return date.getTimezoneName(dateObject);
+	}else{
+		return dateObject.getTimezoneOffset();
+	}
+};
+
+
+dojo.date.locale.format = function(/*Date*/dateObject, /*dojo.date.locale.__FormatOptions?*/options){
+	// summary:
+	//		Format a Date object as a String, using locale-specific settings.
+	//
+	// description:
+	//		Create a string from a Date object using a known localized pattern.
+	//		By default, this method formats both date and time from dateObject.
+	//		Formatting patterns are chosen appropriate to the locale.  Different
+	//		formatting lengths may be chosen, with "full" used by default.
+	//		Custom patterns may be used or registered with translations using
+	//		the dojo.date.locale.addCustomFormats method.
+	//		Formatting patterns are implemented using [the syntax described at
+	//		unicode.org](http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns)
+	//
+	// dateObject:
+	//		the date and/or time to be formatted.  If a time only is formatted,
+	//		the values in the year, month, and day fields are irrelevant.  The
+	//		opposite is true when formatting only dates.
+
+	options = options || {};
+
+	var locale = dojo.i18n.normalizeLocale(options.locale),
+		formatLength = options.formatLength || 'short',
+		bundle = dojo.date.locale._getGregorianBundle(locale),
+		str = [],
+		sauce = lang.hitch(this, formatPattern, dateObject, bundle, options);
+	if(options.selector == "year"){
+		return _processPattern(bundle["dateFormatItem-yyyy"] || "yyyy", sauce);
+	}
+	var pattern;
+	if(options.selector != "date"){
+		pattern = options.timePattern || bundle["timeFormat-"+formatLength];
+		if(pattern){str.push(_processPattern(pattern, sauce));}
+	}
+	if(options.selector != "time"){
+		pattern = options.datePattern || bundle["dateFormat-"+formatLength];
+		if(pattern){str.push(_processPattern(pattern, sauce));}
+	}
+
+	return str.length == 1 ? str[0] : bundle["dateTimeFormat-"+formatLength].replace(/\{(\d+)\}/g,
+		function(match, key){ return str[key]; }); // String
+};
+
+dojo.date.locale.regexp = function(/*dojo.date.locale.__FormatOptions?*/options){
+	// summary:
+	//		Builds the regular needed to parse a localized date
+
+	return dojo.date.locale._parseInfo(options).regexp; // String
+};
+
+dojo.date.locale._parseInfo = function(/*dojo.date.locale.__FormatOptions?*/options){
+	options = options || {};
+	var locale = dojo.i18n.normalizeLocale(options.locale),
+		bundle = dojo.date.locale._getGregorianBundle(locale),
+		formatLength = options.formatLength || 'short',
+		datePattern = options.datePattern || bundle["dateFormat-" + formatLength],
+		timePattern = options.timePattern || bundle["timeFormat-" + formatLength],
+		pattern;
+	if(options.selector == 'date'){
+		pattern = datePattern;
+	}else if(options.selector == 'time'){
+		pattern = timePattern;
+	}else{
+		pattern = bundle["dateTimeFormat-"+formatLength].replace(/\{(\d+)\}/g,
+			function(match, key){ return [timePattern, datePattern][key]; });
+	}
+
+	var tokens = [],
+		re = _processPattern(pattern, lang.hitch(this, _buildDateTimeRE, tokens, bundle, options));
+	return {regexp: re, tokens: tokens, bundle: bundle};
+};
+
+dojo.date.locale.parse = function(/*String*/value, /*dojo.date.locale.__FormatOptions?*/options){
+	// summary:
+	//		Convert a properly formatted string to a primitive Date object,
+	//		using locale-specific settings.
+	//
+	// description:
+	//		Create a Date object from a string using a known localized pattern.
+	//		By default, this method parses looking for both date and time in the string.
+	//		Formatting patterns are chosen appropriate to the locale.  Different
+	//		formatting lengths may be chosen, with "full" used by default.
+	//		Custom patterns may be used or registered with translations using
+	//		the dojo.date.locale.addCustomFormats method.
+	//
+	//		Formatting patterns are implemented using [the syntax described at
+	//		unicode.org](http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns)
+	//		When two digit years are used, a century is chosen according to a sliding
+	//		window of 80 years before and 20 years after present year, for both `yy` and `yyyy` patterns.
+	//		year < 100CE requires strict mode.
+	//
+	// value:
+	//		A string representation of a date
+
+	// remove non-printing bidi control chars from input and pattern
+	var controlChars = /[\u200E\u200F\u202A\u202E]/g,
+		info = dojo.date.locale._parseInfo(options),
+		tokens = info.tokens, bundle = info.bundle,
+		re = new RegExp("^" + info.regexp.replace(controlChars, "") + "$",
+			info.strict ? "" : "i"),
+		match = re.exec(value && value.replace(controlChars, ""));
+
+	if(!match){ return null; } // null
+
+	var widthList = ['abbr', 'wide', 'narrow'],
+		result = [1970,0,1,0,0,0,0], // will get converted to a Date at the end
+		amPm = "",
+		valid = dojo.every(match, function(v, i){
+		if(!i){return true;}
+		var token=tokens[i-1];
+		var l=token.length;
+		switch(token.charAt(0)){
+			case 'y':
+				if(l != 2 && options.strict){
+					//interpret year literally, so '5' would be 5 A.D.
+					result[0] = v;
+				}else{
+					if(v<100){
+						v = Number(v);
+						//choose century to apply, according to a sliding window
+						//of 80 years before and 20 years after present year
+						var year = '' + new Date().getFullYear(),
+							century = year.substring(0, 2) * 100,
+							cutoff = Math.min(Number(year.substring(2, 4)) + 20, 99);
+						result[0] = (v < cutoff) ? century + v : century - 100 + v;
+					}else{
+						//we expected 2 digits and got more...
+						if(options.strict){
+							return false;
+						}
+						//interpret literally, so '150' would be 150 A.D.
+						//also tolerate '1950', if 'yyyy' input passed to 'yy' format
+						result[0] = v;
+					}
+				}
+				break;
+			case 'M':
+				if(l>2){
+					var months = bundle['months-format-' + widthList[l-3]].concat();
+					if(!options.strict){
+						//Tolerate abbreviating period in month part
+						//Case-insensitive comparison
+						v = v.replace(".","").toLowerCase();
+						months = dojo.map(months, function(s){ return s.replace(".","").toLowerCase(); } );
+					}
+					v = dojo.indexOf(months, v);
+					if(v == -1){
+//						console.log("dojo.date.locale.parse: Could not parse month name: '" + v + "'.");
+						return false;
+					}
+				}else{
+					v--;
+				}
+				result[1] = v;
+				break;
+			case 'E':
+			case 'e':
+				var days = bundle['days-format-' + widthList[l-3]].concat();
+				if(!options.strict){
+					//Case-insensitive comparison
+					v = v.toLowerCase();
+					days = dojo.map(days, function(d){return d.toLowerCase();});
+				}
+				v = dojo.indexOf(days, v);
+				if(v == -1){
+//					console.log("dojo.date.locale.parse: Could not parse weekday name: '" + v + "'.");
+					return false;
+				}
+
+				//TODO: not sure what to actually do with this input,
+				//in terms of setting something on the Date obj...?
+				//without more context, can't affect the actual date
+				//TODO: just validate?
+				break;
+			case 'D':
+				result[1] = 0;
+				// fallthrough...
+			case 'd':
+				result[2] = v;
+				break;
+			case 'a': //am/pm
+				var am = options.am || bundle['dayPeriods-format-wide-am'],
+					pm = options.pm || bundle['dayPeriods-format-wide-pm'];
+				if(!options.strict){
+					var period = /\./g;
+					v = v.replace(period,'').toLowerCase();
+					am = am.replace(period,'').toLowerCase();
+					pm = pm.replace(period,'').toLowerCase();
+				}
+				if(options.strict && v != am && v != pm){
+//					console.log("dojo.date.locale.parse: Could not parse am/pm part.");
+					return false;
+				}
+
+				// we might not have seen the hours field yet, so store the state and apply hour change later
+				amPm = (v == pm) ? 'p' : (v == am) ? 'a' : '';
+				break;
+			case 'K': //hour (1-24)
+				if(v == 24){ v = 0; }
+				// fallthrough...
+			case 'h': //hour (1-12)
+			case 'H': //hour (0-23)
+			case 'k': //hour (0-11)
+				//TODO: strict bounds checking, padding
+				if(v > 23){
+//					console.log("dojo.date.locale.parse: Illegal hours value");
+					return false;
+				}
+
+				//in the 12-hour case, adjusting for am/pm requires the 'a' part
+				//which could come before or after the hour, so we will adjust later
+				result[3] = v;
+				break;
+			case 'm': //minutes
+				result[4] = v;
+				break;
+			case 's': //seconds
+				result[5] = v;
+				break;
+			case 'S': //milliseconds
+				result[6] = v;
+//				break;
+//			case 'w':
+//TODO				var firstDay = 0;
+//			default:
+//TODO: throw?
+//				console.log("dojo.date.locale.parse: unsupported pattern char=" + token.charAt(0));
+		}
+		return true;
+	});
+
+	var hours = +result[3];
+	if(amPm === 'p' && hours < 12){
+		result[3] = hours + 12; //e.g., 3pm -> 15
+	}else if(amPm === 'a' && hours == 12){
+		result[3] = 0; //12am -> 0
+	}
+
+	//TODO: implement a getWeekday() method in order to test
+	//validity of input strings containing 'EEE' or 'EEEE'...
+
+	var dateObject = new Date(result[0], result[1], result[2], result[3], result[4], result[5], result[6]); // Date
+	if(options.strict){
+		dateObject.setFullYear(result[0]);
+	}
+
+	// Check for overflow.  The Date() constructor normalizes things like April 32nd...
+	//TODO: why isn't this done for times as well?
+	var allTokens = tokens.join(""),
+		dateToken = allTokens.indexOf('d') != -1,
+		monthToken = allTokens.indexOf('M') != -1;
+
+	if(!valid ||
+		(monthToken && dateObject.getMonth() > result[1]) ||
+		(dateToken && dateObject.getDate() > result[2])){
+		return null;
+	}
+
+	// Check for underflow, due to DST shifts.  See #9366
+	// This assumes a 1 hour dst shift correction at midnight
+	// We could compare the timezone offset after the shift and add the difference instead.
+	if((monthToken && dateObject.getMonth() < result[1]) ||
+		(dateToken && dateObject.getDate() < result[2])){
+		dateObject = date.add(dateObject, "hour", 1);
+	}
+
+	return dateObject; // Date
+};
+
+function _processPattern(pattern, applyPattern, applyLiteral, applyAll){
+	//summary: Process a pattern with literals in it
+
+	// Break up on single quotes, treat every other one as a literal, except '' which becomes '
+	var identity = function(x){return x;};
+	applyPattern = applyPattern || identity;
+	applyLiteral = applyLiteral || identity;
+	applyAll = applyAll || identity;
+
+	//split on single quotes (which escape literals in date format strings)
+	//but preserve escaped single quotes (e.g., o''clock)
+	var chunks = pattern.match(/(''|[^'])+/g),
+		literal = pattern.charAt(0) == "'";
+
+	dojo.forEach(chunks, function(chunk, i){
+		if(!chunk){
+			chunks[i]='';
+		}else{
+			chunks[i]=(literal ? applyLiteral : applyPattern)(chunk.replace(/''/g, "'"));
+			literal = !literal;
+		}
+	});
+	return applyAll(chunks.join(''));
+}
+
+function _buildDateTimeRE(tokens, bundle, options, pattern){
+	pattern = regexp.escapeString(pattern);
+	if(!options.strict){ pattern = pattern.replace(" a", " ?a"); } // kludge to tolerate no space before am/pm
+	return pattern.replace(/([a-z])\1*/ig, function(match){
+		// Build a simple regexp.  Avoid captures, which would ruin the tokens list
+		var s,
+			c = match.charAt(0),
+			l = match.length,
+			p2 = '', p3 = '';
+		if(options.strict){
+			if(l > 1){ p2 = '0' + '{'+(l-1)+'}'; }
+			if(l > 2){ p3 = '0' + '{'+(l-2)+'}'; }
+		}else{
+			p2 = '0?'; p3 = '0{0,2}';
+		}
+		switch(c){
+			case 'y':
+				s = '\\d{2,4}';
+				break;
+			case 'M':
+				s = (l>2) ? '\\S+?' : '1[0-2]|'+p2+'[1-9]';
+				break;
+			case 'D':
+				s = '[12][0-9][0-9]|3[0-5][0-9]|36[0-6]|'+p2+'[1-9][0-9]|'+p3+'[1-9]';
+				break;
+			case 'd':
+				s = '3[01]|[12]\\d|'+p2+'[1-9]';
+				break;
+			case 'w':
+				s = '[1-4][0-9]|5[0-3]|'+p2+'[1-9]';
+				break;
+			case 'E':
+				s = '\\S+';
+				break;
+			case 'h': //hour (1-12)
+				s = '1[0-2]|'+p2+'[1-9]';
+				break;
+			case 'k': //hour (0-11)
+				s = '1[01]|'+p2+'\\d';
+				break;
+			case 'H': //hour (0-23)
+				s = '1\\d|2[0-3]|'+p2+'\\d';
+				break;
+			case 'K': //hour (1-24)
+				s = '1\\d|2[0-4]|'+p2+'[1-9]';
+				break;
+			case 'm':
+			case 's':
+				s = '[0-5]\\d';
+				break;
+			case 'S':
+				s = '\\d{'+l+'}';
+				break;
+			case 'a':
+				var am = options.am || bundle['dayPeriods-format-wide-am'],
+					pm = options.pm || bundle['dayPeriods-format-wide-pm'];
+					s = am + '|' + pm;
+				if(!options.strict){
+					if(am != am.toLowerCase()){ s += '|' + am.toLowerCase(); }
+					if(pm != pm.toLowerCase()){ s += '|' + pm.toLowerCase(); }
+					if(s.indexOf('.') != -1){ s += '|' + s.replace(/\./g, ""); }
+				}
+				s = s.replace(/\./g, "\\.");
+				break;
+			default:
+			// case 'v':
+			// case 'z':
+			// case 'Z':
+				s = ".*";
+//				console.log("parse of date format, pattern=" + pattern);
+		}
+
+		if(tokens){ tokens.push(match); }
+
+		return "(" + s + ")"; // add capture
+	}).replace(/[\xa0 ]/g, "[\\s\\xa0]"); // normalize whitespace.  Need explicit handling of \xa0 for IE.
+}
+
+var _customFormats = [];
+dojo.date.locale.addCustomFormats = function(/*String*/packageName, /*String*/bundleName){
+	// summary:
+	//		Add a reference to a bundle containing localized custom formats to be
+	//		used by date/time formatting and parsing routines.
+	//
+	// description:
+	//		The user may add custom localized formats where the bundle has properties following the
+	//		same naming convention used by dojo.cldr: `dateFormat-xxxx` / `timeFormat-xxxx`
+	//		The pattern string should match the format used by the CLDR.
+	//		See dojo.date.locale.format() for details.
+	//		The resources must be loaded by dojo.requireLocalization() prior to use
+
+	_customFormats.push({pkg:packageName,name:bundleName});
+};
+
+dojo.date.locale._getGregorianBundle = function(/*String*/locale){
+	var gregorian = {};
+	dojo.forEach(_customFormats, function(desc){
+		var bundle = dojo.i18n.getLocalization(desc.pkg, desc.name, locale);
+		gregorian = lang.mixin(gregorian, bundle);
+	}, this);
+	return gregorian; /*Object*/
+};
+
+dojo.date.locale.addCustomFormats("dojo.cldr","gregorian");
+
+dojo.date.locale.getNames = function(/*String*/item, /*String*/type, /*String?*/context, /*String?*/locale){
+	// summary:
+	//		Used to get localized strings from dojo.cldr for day or month names.
+	//
+	// item:
+	//	'months' || 'days'
+	// type:
+	//	'wide' || 'abbr' || 'narrow' (e.g. "Monday", "Mon", or "M" respectively, in English)
+	// context:
+	//	'standAlone' || 'format' (default)
+	// locale:
+	//	override locale used to find the names
+
+	var label,
+		lookup = dojo.date.locale._getGregorianBundle(locale),
+		props = [item, context, type];
+	if(context == 'standAlone'){
+		var key = props.join('-');
+		label = lookup[key];
+		// Fall back to 'format' flavor of name
+		if(label[0] == 1){ label = undefined; } // kludge, in the absence of real aliasing support in dojo.cldr
+	}
+	props[1] = 'format';
+
+	// return by copy so changes won't be made accidentally to the in-memory model
+	return (label || lookup[props.join('-')]).concat(); /*Array*/
+};
+
+dojo.date.locale.isWeekend = function(/*Date?*/dateObject, /*String?*/locale){
+	// summary:
+	//	Determines if the date falls on a weekend, according to local custom.
+
+	var weekend = cldr.getWeekend(locale),
+		day = (dateObject || new Date()).getDay();
+	if(weekend.end < weekend.start){
+		weekend.end += 7;
+		if(day < weekend.start){ day += 7; }
+	}
+	return day >= weekend.start && day <= weekend.end; // Boolean
+};
+
+// These are used only by format and strftime.  Do they need to be public?  Which module should they go in?
+
+dojo.date.locale._getDayOfYear = function(/*Date*/dateObject){
+	// summary: gets the day of the year as represented by dateObject
+	return date.difference(new Date(dateObject.getFullYear(), 0, 1, dateObject.getHours()), dateObject) + 1; // Number
+};
+
+dojo.date.locale._getWeekOfYear = function(/*Date*/dateObject, /*Number*/firstDayOfWeek){
+	if(arguments.length == 1){ firstDayOfWeek = 0; } // Sunday
+
+	var firstDayOfYear = new Date(dateObject.getFullYear(), 0, 1).getDay(),
+		adj = (firstDayOfYear - firstDayOfWeek + 7) % 7,
+		week = Math.floor((dojo.date.locale._getDayOfYear(dateObject) + adj - 1) / 7);
+
+	// if year starts on the specified day, start counting weeks at 1
+	if(firstDayOfYear == firstDayOfWeek){ week++; }
+
+	return week; // Number
+};
+
+return dojo.date.locale;
+});
diff --git a/js/dojo-1.7.2/dojo/date/stamp.js b/js/dojo-1.7.2/dojo/date/stamp.js
new file mode 100644
index 0000000..05d8d57
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/date/stamp.js
@@ -0,0 +1,147 @@
+//>>built
+define("dojo/date/stamp", ["../_base/kernel", "../_base/lang", "../_base/array"], function(dojo, lang, array) {
+	// module:
+	//		dojo/date/stamp
+	// summary:
+	//		TODOC
+
+lang.getObject("date.stamp", true, dojo);
+
+// Methods to convert dates to or from a wire (string) format using well-known conventions
+
+dojo.date.stamp.fromISOString = function(/*String*/formattedString, /*Number?*/defaultTime){
+	//	summary:
+	//		Returns a Date object given a string formatted according to a subset of the ISO-8601 standard.
+	//
+	//	description:
+	//		Accepts a string formatted according to a profile of ISO8601 as defined by
+	//		[RFC3339](http://www.ietf.org/rfc/rfc3339.txt), except that partial input is allowed.
+	//		Can also process dates as specified [by the W3C](http://www.w3.org/TR/NOTE-datetime)
+	//		The following combinations are valid:
+	//
+	//			* dates only
+	//			|	* yyyy
+	//			|	* yyyy-MM
+	//			|	* yyyy-MM-dd
+	// 			* times only, with an optional time zone appended
+	//			|	* THH:mm
+	//			|	* THH:mm:ss
+	//			|	* THH:mm:ss.SSS
+	// 			* and "datetimes" which could be any combination of the above
+	//
+	//		timezones may be specified as Z (for UTC) or +/- followed by a time expression HH:mm
+	//		Assumes the local time zone if not specified.  Does not validate.  Improperly formatted
+	//		input may return null.  Arguments which are out of bounds will be handled
+	// 		by the Date constructor (e.g. January 32nd typically gets resolved to February 1st)
+	//		Only years between 100 and 9999 are supported.
+	//
+  	//	formattedString:
+	//		A string such as 2005-06-30T08:05:00-07:00 or 2005-06-30 or T08:05:00
+	//
+	//	defaultTime:
+	//		Used for defaults for fields omitted in the formattedString.
+	//		Uses 1970-01-01T00:00:00.0Z by default.
+
+	if(!dojo.date.stamp._isoRegExp){
+		dojo.date.stamp._isoRegExp =
+//TODO: could be more restrictive and check for 00-59, etc.
+			/^(?:(\d{4})(?:-(\d{2})(?:-(\d{2}))?)?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(.\d+)?)?((?:[+-](\d{2}):(\d{2}))|Z)?)?$/;
+	}
+
+	var match = dojo.date.stamp._isoRegExp.exec(formattedString),
+		result = null;
+
+	if(match){
+		match.shift();
+		if(match[1]){match[1]--;} // Javascript Date months are 0-based
+		if(match[6]){match[6] *= 1000;} // Javascript Date expects fractional seconds as milliseconds
+
+		if(defaultTime){
+			// mix in defaultTime.  Relatively expensive, so use || operators for the fast path of defaultTime === 0
+			defaultTime = new Date(defaultTime);
+			array.forEach(array.map(["FullYear", "Month", "Date", "Hours", "Minutes", "Seconds", "Milliseconds"], function(prop){
+				return defaultTime["get" + prop]();
+			}), function(value, index){
+				match[index] = match[index] || value;
+			});
+		}
+		result = new Date(match[0]||1970, match[1]||0, match[2]||1, match[3]||0, match[4]||0, match[5]||0, match[6]||0); //TODO: UTC defaults
+		if(match[0] < 100){
+			result.setFullYear(match[0] || 1970);
+		}
+
+		var offset = 0,
+			zoneSign = match[7] && match[7].charAt(0);
+		if(zoneSign != 'Z'){
+			offset = ((match[8] || 0) * 60) + (Number(match[9]) || 0);
+			if(zoneSign != '-'){ offset *= -1; }
+		}
+		if(zoneSign){
+			offset -= result.getTimezoneOffset();
+		}
+		if(offset){
+			result.setTime(result.getTime() + offset * 60000);
+		}
+	}
+
+	return result; // Date or null
+};
+
+/*=====
+	dojo.date.stamp.__Options = function(){
+		//	selector: String
+		//		"date" or "time" for partial formatting of the Date object.
+		//		Both date and time will be formatted by default.
+		//	zulu: Boolean
+		//		if true, UTC/GMT is used for a timezone
+		//	milliseconds: Boolean
+		//		if true, output milliseconds
+		this.selector = selector;
+		this.zulu = zulu;
+		this.milliseconds = milliseconds;
+	}
+=====*/
+
+dojo.date.stamp.toISOString = function(/*Date*/dateObject, /*dojo.date.stamp.__Options?*/options){
+	//	summary:
+	//		Format a Date object as a string according a subset of the ISO-8601 standard
+	//
+	//	description:
+	//		When options.selector is omitted, output follows [RFC3339](http://www.ietf.org/rfc/rfc3339.txt)
+	//		The local time zone is included as an offset from GMT, except when selector=='time' (time without a date)
+	//		Does not check bounds.  Only years between 100 and 9999 are supported.
+	//
+	//	dateObject:
+	//		A Date object
+
+	var _ = function(n){ return (n < 10) ? "0" + n : n; };
+	options = options || {};
+	var formattedDate = [],
+		getter = options.zulu ? "getUTC" : "get",
+		date = "";
+	if(options.selector != "time"){
+		var year = dateObject[getter+"FullYear"]();
+		date = ["0000".substr((year+"").length)+year, _(dateObject[getter+"Month"]()+1), _(dateObject[getter+"Date"]())].join('-');
+	}
+	formattedDate.push(date);
+	if(options.selector != "date"){
+		var time = [_(dateObject[getter+"Hours"]()), _(dateObject[getter+"Minutes"]()), _(dateObject[getter+"Seconds"]())].join(':');
+		var millis = dateObject[getter+"Milliseconds"]();
+		if(options.milliseconds){
+			time += "."+ (millis < 100 ? "0" : "") + _(millis);
+		}
+		if(options.zulu){
+			time += "Z";
+		}else if(options.selector != "time"){
+			var timezoneOffset = dateObject.getTimezoneOffset();
+			var absOffset = Math.abs(timezoneOffset);
+			time += (timezoneOffset > 0 ? "-" : "+") +
+				_(Math.floor(absOffset/60)) + ":" + _(absOffset%60);
+		}
+		formattedDate.push(time);
+	}
+	return formattedDate.join('T'); // String
+};
+
+return dojo.date.stamp;
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/AutoSource.js b/js/dojo-1.7.2/dojo/dnd/AutoSource.js
new file mode 100644
index 0000000..1184799
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/AutoSource.js
@@ -0,0 +1,14 @@
+//>>built
+define("dojo/dnd/AutoSource", [ "./Source" ], function(Source){
+	/*===== Source = dojo.dnd.Source =====*/
+	return dojo.declare("dojo.dnd.AutoSource", Source, {
+		// summary:
+		//		a source that syncs its DnD nodes by default
+
+		constructor: function(node, params){
+			// summary:
+			//		constructor of the AutoSource --- see the Source constructor for details
+			this.autoSync = true;
+		}
+	});
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/Avatar.js b/js/dojo-1.7.2/dojo/dnd/Avatar.js
new file mode 100644
index 0000000..6bbfe45
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/Avatar.js
@@ -0,0 +1,112 @@
+//>>built
+define("dojo/dnd/Avatar", ["../main", "./common"], function(dojo) {
+	// module:
+	//		dojo/dnd/Avatar
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.dnd.Avatar", null, {
+	// summary:
+	//		Object that represents transferred DnD items visually
+	// manager: Object
+	//		a DnD manager object
+
+	constructor: function(manager){
+		this.manager = manager;
+		this.construct();
+	},
+
+	// methods
+	construct: function(){
+		// summary:
+		//		constructor function;
+		//		it is separate so it can be (dynamically) overwritten in case of need
+		this.isA11y = dojo.hasClass(dojo.body(),"dijit_a11y");
+		var a = dojo.create("table", {
+				"class": "dojoDndAvatar",
+				style: {
+					position: "absolute",
+					zIndex:   "1999",
+					margin:   "0px"
+				}
+			}),
+			source = this.manager.source, node,
+			b = dojo.create("tbody", null, a),
+			tr = dojo.create("tr", null, b),
+			td = dojo.create("td", null, tr),
+			icon = this.isA11y ? dojo.create("span", {
+						id : "a11yIcon",
+						innerHTML : this.manager.copy ? '+' : "<"
+					}, td) : null,
+			span = dojo.create("span", {
+				innerHTML: source.generateText ? this._generateText() : ""
+			}, td),
+			k = Math.min(5, this.manager.nodes.length), i = 0;
+		// we have to set the opacity on IE only after the node is live
+		dojo.attr(tr, {
+			"class": "dojoDndAvatarHeader",
+			style: {opacity: 0.9}
+		});
+		for(; i < k; ++i){
+			if(source.creator){
+				// create an avatar representation of the node
+				node = source._normalizedCreator(source.getItem(this.manager.nodes[i].id).data, "avatar").node;
+			}else{
+				// or just clone the node and hope it works
+				node = this.manager.nodes[i].cloneNode(true);
+				if(node.tagName.toLowerCase() == "tr"){
+					// insert extra table nodes
+					var table = dojo.create("table"),
+						tbody = dojo.create("tbody", null, table);
+					tbody.appendChild(node);
+					node = table;
+				}
+			}
+			node.id = "";
+			tr = dojo.create("tr", null, b);
+			td = dojo.create("td", null, tr);
+			td.appendChild(node);
+			dojo.attr(tr, {
+				"class": "dojoDndAvatarItem",
+				style: {opacity: (9 - i) / 10}
+			});
+		}
+		this.node = a;
+	},
+	destroy: function(){
+		// summary:
+		//		destructor for the avatar; called to remove all references so it can be garbage-collected
+		dojo.destroy(this.node);
+		this.node = false;
+	},
+	update: function(){
+		// summary:
+		//		updates the avatar to reflect the current DnD state
+		dojo[(this.manager.canDropFlag ? "add" : "remove") + "Class"](this.node, "dojoDndAvatarCanDrop");
+		if (this.isA11y){
+			var icon = dojo.byId("a11yIcon");
+			var text = '+';   // assume canDrop && copy
+			if (this.manager.canDropFlag && !this.manager.copy) {
+				text = '< '; // canDrop && move
+			}else if (!this.manager.canDropFlag && !this.manager.copy) {
+				text = "o"; //!canDrop && move
+			}else if(!this.manager.canDropFlag){
+				text = 'x';  // !canDrop && copy
+			}
+			icon.innerHTML=text;
+		}
+		// replace text
+		dojo.query(("tr.dojoDndAvatarHeader td span" +(this.isA11y ? " span" : "")), this.node).forEach(
+			function(node){
+				node.innerHTML = this._generateText();
+			}, this);
+	},
+	_generateText: function(){
+		// summary: generates a proper text to reflect copying or moving of items
+		return this.manager.nodes.length.toString();
+	}
+});
+
+return dojo.dnd.Avatar;
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/Container.js b/js/dojo-1.7.2/dojo/dnd/Container.js
new file mode 100644
index 0000000..64548ff
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/Container.js
@@ -0,0 +1,433 @@
+//>>built
+define("dojo/dnd/Container", ["../main", "../Evented", "./common", "../parser"], function(dojo, Evented) {
+	// module:
+	//		dojo/dnd/Container
+	// summary:
+	//		TODOC
+
+
+/*
+	Container states:
+		""		- normal state
+		"Over"	- mouse over a container
+	Container item states:
+		""		- normal state
+		"Over"	- mouse over a container item
+*/
+
+/*=====
+dojo.declare("dojo.dnd.__ContainerArgs", [], {
+	creator: function(){
+		// summary:
+		//		a creator function, which takes a data item, and returns an object like that:
+		//		{node: newNode, data: usedData, type: arrayOfStrings}
+	},
+
+	// skipForm: Boolean
+	//		don't start the drag operation, if clicked on form elements
+	skipForm: false,
+
+	// dropParent: Node||String
+	//		node or node's id to use as the parent node for dropped items
+	//		(must be underneath the 'node' parameter in the DOM)
+	dropParent: null,
+
+	// _skipStartup: Boolean
+	//		skip startup(), which collects children, for deferred initialization
+	//		(this is used in the markup mode)
+	_skipStartup: false
+});
+
+dojo.dnd.Item = function(){
+	// summary:
+	//		Represents (one of) the source node(s) being dragged.
+	//		Contains (at least) the "type" and "data" attributes.
+	// type: String[]
+	//		Type(s) of this item, by default this is ["text"]
+	// data: Object
+	//		Logical representation of the object being dragged.
+	//		If the drag object's type is "text" then data is a String,
+	//		if it's another type then data could be a different Object,
+	//		perhaps a name/value hash.
+
+	this.type = type;
+	this.data = data;
+}
+=====*/
+
+dojo.declare("dojo.dnd.Container", Evented, {
+	// summary:
+	//		a Container object, which knows when mouse hovers over it,
+	//		and over which element it hovers
+
+	// object attributes (for markup)
+	skipForm: false,
+
+	/*=====
+	// current: DomNode
+	//		The DOM node the mouse is currently hovered over
+	current: null,
+
+	// map: Hash<String, dojo.dnd.Item>
+	//		Map from an item's id (which is also the DOMNode's id) to
+	//		the dojo.dnd.Item itself.
+	map: {},
+	=====*/
+
+	constructor: function(node, params){
+		// summary:
+		//		a constructor of the Container
+		// node: Node
+		//		node or node's id to build the container on
+		// params: dojo.dnd.__ContainerArgs
+		//		a dictionary of parameters
+		this.node = dojo.byId(node);
+		if(!params){ params = {}; }
+		this.creator = params.creator || null;
+		this.skipForm = params.skipForm;
+		this.parent = params.dropParent && dojo.byId(params.dropParent);
+
+		// class-specific variables
+		this.map = {};
+		this.current = null;
+
+		// states
+		this.containerState = "";
+		dojo.addClass(this.node, "dojoDndContainer");
+
+		// mark up children
+		if(!(params && params._skipStartup)){
+			this.startup();
+		}
+
+		// set up events
+		this.events = [
+			dojo.connect(this.node, "onmouseover", this, "onMouseOver"),
+			dojo.connect(this.node, "onmouseout",  this, "onMouseOut"),
+			// cancel text selection and text dragging
+			dojo.connect(this.node, "ondragstart",   this, "onSelectStart"),
+			dojo.connect(this.node, "onselectstart", this, "onSelectStart")
+		];
+	},
+
+	// object attributes (for markup)
+	creator: function(){
+		// summary:
+		//		creator function, dummy at the moment
+	},
+
+	// abstract access to the map
+	getItem: function(/*String*/ key){
+		// summary:
+		//		returns a data item by its key (id)
+		return this.map[key];	// dojo.dnd.Item
+	},
+	setItem: function(/*String*/ key, /*dojo.dnd.Item*/ data){
+		// summary:
+		//		associates a data item with its key (id)
+		this.map[key] = data;
+	},
+	delItem: function(/*String*/ key){
+		// summary:
+		//		removes a data item from the map by its key (id)
+		delete this.map[key];
+	},
+	forInItems: function(/*Function*/ f, /*Object?*/ o){
+		// summary:
+		//		iterates over a data map skipping members that
+		//		are present in the empty object (IE and/or 3rd-party libraries).
+		o = o || dojo.global;
+		var m = this.map, e = dojo.dnd._empty;
+		for(var i in m){
+			if(i in e){ continue; }
+			f.call(o, m[i], i, this);
+		}
+		return o;	// Object
+	},
+	clearItems: function(){
+		// summary:
+		//		removes all data items from the map
+		this.map = {};
+	},
+
+	// methods
+	getAllNodes: function(){
+		// summary:
+		//		returns a list (an array) of all valid child nodes
+		return dojo.query("> .dojoDndItem", this.parent);	// NodeList
+	},
+	sync: function(){
+		// summary:
+		//		sync up the node list with the data map
+		var map = {};
+		this.getAllNodes().forEach(function(node){
+			if(node.id){
+				var item = this.getItem(node.id);
+				if(item){
+					map[node.id] = item;
+					return;
+				}
+			}else{
+				node.id = dojo.dnd.getUniqueId();
+			}
+			var type = node.getAttribute("dndType"),
+				data = node.getAttribute("dndData");
+			map[node.id] = {
+				data: data || node.innerHTML,
+				type: type ? type.split(/\s*,\s*/) : ["text"]
+			};
+		}, this);
+		this.map = map;
+		return this;	// self
+	},
+	insertNodes: function(data, before, anchor){
+		// summary:
+		//		inserts an array of new nodes before/after an anchor node
+		// data: Array
+		//		a list of data items, which should be processed by the creator function
+		// before: Boolean
+		//		insert before the anchor, if true, and after the anchor otherwise
+		// anchor: Node
+		//		the anchor node to be used as a point of insertion
+		if(!this.parent.firstChild){
+			anchor = null;
+		}else if(before){
+			if(!anchor){
+				anchor = this.parent.firstChild;
+			}
+		}else{
+			if(anchor){
+				anchor = anchor.nextSibling;
+			}
+		}
+		if(anchor){
+			for(var i = 0; i < data.length; ++i){
+				var t = this._normalizedCreator(data[i]);
+				this.setItem(t.node.id, {data: t.data, type: t.type});
+				this.parent.insertBefore(t.node, anchor);
+			}
+		}else{
+			for(var i = 0; i < data.length; ++i){
+				var t = this._normalizedCreator(data[i]);
+				this.setItem(t.node.id, {data: t.data, type: t.type});
+				this.parent.appendChild(t.node);
+			}
+		}
+		return this;	// self
+	},
+	destroy: function(){
+		// summary:
+		//		prepares this object to be garbage-collected
+		dojo.forEach(this.events, dojo.disconnect);
+		this.clearItems();
+		this.node = this.parent = this.current = null;
+	},
+
+	// markup methods
+	markupFactory: function(params, node, ctor){
+		params._skipStartup = true;
+		return new ctor(node, params);
+	},
+	startup: function(){
+		// summary:
+		//		collects valid child items and populate the map
+
+		// set up the real parent node
+		if(!this.parent){
+			// use the standard algorithm, if not assigned
+			this.parent = this.node;
+			if(this.parent.tagName.toLowerCase() == "table"){
+				var c = this.parent.getElementsByTagName("tbody");
+				if(c && c.length){ this.parent = c[0]; }
+			}
+		}
+		this.defaultCreator = dojo.dnd._defaultCreator(this.parent);
+
+		// process specially marked children
+		this.sync();
+	},
+
+	// mouse events
+	onMouseOver: function(e){
+		// summary:
+		//		event processor for onmouseover
+		// e: Event
+		//		mouse event
+		var n = e.relatedTarget;
+		while(n){
+			if(n == this.node){ break; }
+			try{
+				n = n.parentNode;
+			}catch(x){
+				n = null;
+			}
+		}
+		if(!n){
+			this._changeState("Container", "Over");
+			this.onOverEvent();
+		}
+		n = this._getChildByEvent(e);
+		if(this.current == n){ return; }
+		if(this.current){ this._removeItemClass(this.current, "Over"); }
+		if(n){ this._addItemClass(n, "Over"); }
+		this.current = n;
+	},
+	onMouseOut: function(e){
+		// summary:
+		//		event processor for onmouseout
+		// e: Event
+		//		mouse event
+		for(var n = e.relatedTarget; n;){
+			if(n == this.node){ return; }
+			try{
+				n = n.parentNode;
+			}catch(x){
+				n = null;
+			}
+		}
+		if(this.current){
+			this._removeItemClass(this.current, "Over");
+			this.current = null;
+		}
+		this._changeState("Container", "");
+		this.onOutEvent();
+	},
+	onSelectStart: function(e){
+		// summary:
+		//		event processor for onselectevent and ondragevent
+		// e: Event
+		//		mouse event
+		if(!this.skipForm || !dojo.dnd.isFormElement(e)){
+			dojo.stopEvent(e);
+		}
+	},
+
+	// utilities
+	onOverEvent: function(){
+		// summary:
+		//		this function is called once, when mouse is over our container
+	},
+	onOutEvent: function(){
+		// summary:
+		//		this function is called once, when mouse is out of our container
+	},
+	_changeState: function(type, newState){
+		// summary:
+		//		changes a named state to new state value
+		// type: String
+		//		a name of the state to change
+		// newState: String
+		//		new state
+		var prefix = "dojoDnd" + type;
+		var state  = type.toLowerCase() + "State";
+		//dojo.replaceClass(this.node, prefix + newState, prefix + this[state]);
+		dojo.replaceClass(this.node, prefix + newState, prefix + this[state]);
+		this[state] = newState;
+	},
+	_addItemClass: function(node, type){
+		// summary:
+		//		adds a class with prefix "dojoDndItem"
+		// node: Node
+		//		a node
+		// type: String
+		//		a variable suffix for a class name
+		dojo.addClass(node, "dojoDndItem" + type);
+	},
+	_removeItemClass: function(node, type){
+		// summary:
+		//		removes a class with prefix "dojoDndItem"
+		// node: Node
+		//		a node
+		// type: String
+		//		a variable suffix for a class name
+		dojo.removeClass(node, "dojoDndItem" + type);
+	},
+	_getChildByEvent: function(e){
+		// summary:
+		//		gets a child, which is under the mouse at the moment, or null
+		// e: Event
+		//		a mouse event
+		var node = e.target;
+		if(node){
+			for(var parent = node.parentNode; parent; node = parent, parent = node.parentNode){
+				if(parent == this.parent && dojo.hasClass(node, "dojoDndItem")){ return node; }
+			}
+		}
+		return null;
+	},
+	_normalizedCreator: function(/*dojo.dnd.Item*/ item, /*String*/ hint){
+		// summary:
+		//		adds all necessary data to the output of the user-supplied creator function
+		var t = (this.creator || this.defaultCreator).call(this, item, hint);
+		if(!dojo.isArray(t.type)){ t.type = ["text"]; }
+		if(!t.node.id){ t.node.id = dojo.dnd.getUniqueId(); }
+		dojo.addClass(t.node, "dojoDndItem");
+		return t;
+	}
+});
+
+dojo.dnd._createNode = function(tag){
+	// summary:
+	//		returns a function, which creates an element of given tag
+	//		(SPAN by default) and sets its innerHTML to given text
+	// tag: String
+	//		a tag name or empty for SPAN
+	if(!tag){ return dojo.dnd._createSpan; }
+	return function(text){	// Function
+		return dojo.create(tag, {innerHTML: text});	// Node
+	};
+};
+
+dojo.dnd._createTrTd = function(text){
+	// summary:
+	//		creates a TR/TD structure with given text as an innerHTML of TD
+	// text: String
+	//		a text for TD
+	var tr = dojo.create("tr");
+	dojo.create("td", {innerHTML: text}, tr);
+	return tr;	// Node
+};
+
+dojo.dnd._createSpan = function(text){
+	// summary:
+	//		creates a SPAN element with given text as its innerHTML
+	// text: String
+	//		a text for SPAN
+	return dojo.create("span", {innerHTML: text});	// Node
+};
+
+// dojo.dnd._defaultCreatorNodes: Object
+//		a dictionary that maps container tag names to child tag names
+dojo.dnd._defaultCreatorNodes = {ul: "li", ol: "li", div: "div", p: "div"};
+
+dojo.dnd._defaultCreator = function(node){
+	// summary:
+	//		takes a parent node, and returns an appropriate creator function
+	// node: Node
+	//		a container node
+	var tag = node.tagName.toLowerCase();
+	var c = tag == "tbody" || tag == "thead" ? dojo.dnd._createTrTd :
+			dojo.dnd._createNode(dojo.dnd._defaultCreatorNodes[tag]);
+	return function(item, hint){	// Function
+		var isObj = item && dojo.isObject(item), data, type, n;
+		if(isObj && item.tagName && item.nodeType && item.getAttribute){
+			// process a DOM node
+			data = item.getAttribute("dndData") || item.innerHTML;
+			type = item.getAttribute("dndType");
+			type = type ? type.split(/\s*,\s*/) : ["text"];
+			n = item;	// this node is going to be moved rather than copied
+		}else{
+			// process a DnD item object or a string
+			data = (isObj && item.data) ? item.data : item;
+			type = (isObj && item.type) ? item.type : ["text"];
+			n = (hint == "avatar" ? dojo.dnd._createSpan : c)(String(data));
+		}
+		if(!n.id){
+			n.id = dojo.dnd.getUniqueId();
+		}
+		return {node: n, data: data, type: type};
+	};
+};
+
+return dojo.dnd.Container;
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/Manager.js b/js/dojo-1.7.2/dojo/dnd/Manager.js
new file mode 100644
index 0000000..0513943
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/Manager.js
@@ -0,0 +1,214 @@
+//>>built
+define("dojo/dnd/Manager", ["../main", "../Evented", "./common", "./autoscroll", "./Avatar"], function(dojo, Evented) {
+	// module:
+	//		dojo/dnd/Manager
+	// summary:
+	//		TODOC
+
+
+var Manager = dojo.declare("dojo.dnd.Manager", [Evented], {
+	// summary:
+	//		the manager of DnD operations (usually a singleton)
+	constructor: function(){
+		this.avatar  = null;
+		this.source = null;
+		this.nodes = [];
+		this.copy  = true;
+		this.target = null;
+		this.canDropFlag = false;
+		this.events = [];
+	},
+
+	// avatar's offset from the mouse
+	OFFSET_X: 16,
+	OFFSET_Y: 16,
+
+	// methods
+	overSource: function(source){
+		// summary:
+		//		called when a source detected a mouse-over condition
+		// source: Object
+		//		the reporter
+		if(this.avatar){
+			this.target = (source && source.targetState != "Disabled") ? source : null;
+			this.canDropFlag = Boolean(this.target);
+			this.avatar.update();
+		}
+		dojo.publish("/dnd/source/over", [source]);
+	},
+	outSource: function(source){
+		// summary:
+		//		called when a source detected a mouse-out condition
+		// source: Object
+		//		the reporter
+		if(this.avatar){
+			if(this.target == source){
+				this.target = null;
+				this.canDropFlag = false;
+				this.avatar.update();
+				dojo.publish("/dnd/source/over", [null]);
+			}
+		}else{
+			dojo.publish("/dnd/source/over", [null]);
+		}
+	},
+	startDrag: function(source, nodes, copy){
+		// summary:
+		//		called to initiate the DnD operation
+		// source: Object
+		//		the source which provides items
+		// nodes: Array
+		//		the list of transferred items
+		// copy: Boolean
+		//		copy items, if true, move items otherwise
+		this.source = source;
+		this.nodes  = nodes;
+		this.copy   = Boolean(copy); // normalizing to true boolean
+		this.avatar = this.makeAvatar();
+		dojo.body().appendChild(this.avatar.node);
+		dojo.publish("/dnd/start", [source, nodes, this.copy]);
+		this.events = [
+			dojo.connect(dojo.doc, "onmousemove", this, "onMouseMove"),
+			dojo.connect(dojo.doc, "onmouseup",   this, "onMouseUp"),
+			dojo.connect(dojo.doc, "onkeydown",   this, "onKeyDown"),
+			dojo.connect(dojo.doc, "onkeyup",     this, "onKeyUp"),
+			// cancel text selection and text dragging
+			dojo.connect(dojo.doc, "ondragstart",   dojo.stopEvent),
+			dojo.connect(dojo.body(), "onselectstart", dojo.stopEvent)
+		];
+		var c = "dojoDnd" + (copy ? "Copy" : "Move");
+		dojo.addClass(dojo.body(), c);
+	},
+	canDrop: function(flag){
+		// summary:
+		//		called to notify if the current target can accept items
+		var canDropFlag = Boolean(this.target && flag);
+		if(this.canDropFlag != canDropFlag){
+			this.canDropFlag = canDropFlag;
+			this.avatar.update();
+		}
+	},
+	stopDrag: function(){
+		// summary:
+		//		stop the DnD in progress
+		dojo.removeClass(dojo.body(), ["dojoDndCopy", "dojoDndMove"]);
+		dojo.forEach(this.events, dojo.disconnect);
+		this.events = [];
+		this.avatar.destroy();
+		this.avatar = null;
+		this.source = this.target = null;
+		this.nodes = [];
+	},
+	makeAvatar: function(){
+		// summary:
+		//		makes the avatar; it is separate to be overwritten dynamically, if needed
+		return new dojo.dnd.Avatar(this);
+	},
+	updateAvatar: function(){
+		// summary:
+		//		updates the avatar; it is separate to be overwritten dynamically, if needed
+		this.avatar.update();
+	},
+
+	// mouse event processors
+	onMouseMove: function(e){
+		// summary:
+		//		event processor for onmousemove
+		// e: Event
+		//		mouse event
+		var a = this.avatar;
+		if(a){
+			dojo.dnd.autoScrollNodes(e);
+			//dojo.dnd.autoScroll(e);
+			var s = a.node.style;
+			s.left = (e.pageX + this.OFFSET_X) + "px";
+			s.top  = (e.pageY + this.OFFSET_Y) + "px";
+			var copy = Boolean(this.source.copyState(dojo.isCopyKey(e)));
+			if(this.copy != copy){
+				this._setCopyStatus(copy);
+			}
+		}
+	},
+	onMouseUp: function(e){
+		// summary:
+		//		event processor for onmouseup
+		// e: Event
+		//		mouse event
+		if(this.avatar){
+			if(this.target && this.canDropFlag){
+				var copy = Boolean(this.source.copyState(dojo.isCopyKey(e))),
+				params = [this.source, this.nodes, copy, this.target, e];
+				dojo.publish("/dnd/drop/before", params);
+				dojo.publish("/dnd/drop", params);
+			}else{
+				dojo.publish("/dnd/cancel");
+			}
+			this.stopDrag();
+		}
+	},
+
+	// keyboard event processors
+	onKeyDown: function(e){
+		// summary:
+		//		event processor for onkeydown:
+		//		watching for CTRL for copy/move status, watching for ESCAPE to cancel the drag
+		// e: Event
+		//		keyboard event
+		if(this.avatar){
+			switch(e.keyCode){
+				case dojo.keys.CTRL:
+					var copy = Boolean(this.source.copyState(true));
+					if(this.copy != copy){
+						this._setCopyStatus(copy);
+					}
+					break;
+				case dojo.keys.ESCAPE:
+					dojo.publish("/dnd/cancel");
+					this.stopDrag();
+					break;
+			}
+		}
+	},
+	onKeyUp: function(e){
+		// summary:
+		//		event processor for onkeyup, watching for CTRL for copy/move status
+		// e: Event
+		//		keyboard event
+		if(this.avatar && e.keyCode == dojo.keys.CTRL){
+			var copy = Boolean(this.source.copyState(false));
+			if(this.copy != copy){
+				this._setCopyStatus(copy);
+			}
+		}
+	},
+
+	// utilities
+	_setCopyStatus: function(copy){
+		// summary:
+		//		changes the copy status
+		// copy: Boolean
+		//		the copy status
+		this.copy = copy;
+		this.source._markDndStatus(this.copy);
+		this.updateAvatar();
+		dojo.replaceClass(dojo.body(),
+			"dojoDnd" + (this.copy ? "Copy" : "Move"),
+			"dojoDnd" + (this.copy ? "Move" : "Copy"));
+	}
+});
+
+// dojo.dnd._manager:
+//		The manager singleton variable. Can be overwritten if needed.
+dojo.dnd._manager = null;
+
+Manager.manager = dojo.dnd.manager = function(){
+	// summary:
+	//		Returns the current DnD manager.  Creates one if it is not created yet.
+	if(!dojo.dnd._manager){
+		dojo.dnd._manager = new dojo.dnd.Manager();
+	}
+	return dojo.dnd._manager;	// Object
+};
+
+return Manager;
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/Moveable.js b/js/dojo-1.7.2/dojo/dnd/Moveable.js
new file mode 100644
index 0000000..8b97db5
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/Moveable.js
@@ -0,0 +1,174 @@
+//>>built
+define("dojo/dnd/Moveable", ["../main", "../Evented", "../touch", "./Mover"], function(dojo, Evented, touch) {
+	// module:
+	//		dojo/dnd/Moveable
+	// summary:
+	//		TODOC
+
+
+/*=====
+dojo.declare("dojo.dnd.__MoveableArgs", [], {
+	// handle: Node||String
+	//		A node (or node's id), which is used as a mouse handle.
+	//		If omitted, the node itself is used as a handle.
+	handle: null,
+
+	// delay: Number
+	//		delay move by this number of pixels
+	delay: 0,
+
+	// skip: Boolean
+	//		skip move of form elements
+	skip: false,
+
+	// mover: Object
+	//		a constructor of custom Mover
+	mover: dojo.dnd.Mover
+});
+=====*/
+
+dojo.declare("dojo.dnd.Moveable", [Evented], {
+	// object attributes (for markup)
+	handle: "",
+	delay: 0,
+	skip: false,
+
+	constructor: function(node, params){
+		// summary:
+		//		an object, which makes a node moveable
+		// node: Node
+		//		a node (or node's id) to be moved
+		// params: dojo.dnd.__MoveableArgs?
+		//		optional parameters
+		this.node = dojo.byId(node);
+		if(!params){ params = {}; }
+		this.handle = params.handle ? dojo.byId(params.handle) : null;
+		if(!this.handle){ this.handle = this.node; }
+		this.delay = params.delay > 0 ? params.delay : 0;
+		this.skip  = params.skip;
+		this.mover = params.mover ? params.mover : dojo.dnd.Mover;
+		this.events = [
+			dojo.connect(this.handle, touch.press, this, "onMouseDown"),
+			// cancel text selection and text dragging
+			dojo.connect(this.handle, "ondragstart",   this, "onSelectStart"),
+			dojo.connect(this.handle, "onselectstart", this, "onSelectStart")
+		];
+	},
+
+	// markup methods
+	markupFactory: function(params, node, ctor){
+		return new ctor(node, params);
+	},
+
+	// methods
+	destroy: function(){
+		// summary:
+		//		stops watching for possible move, deletes all references, so the object can be garbage-collected
+		dojo.forEach(this.events, dojo.disconnect);
+		this.events = this.node = this.handle = null;
+	},
+
+	// mouse event processors
+	onMouseDown: function(e){
+		// summary:
+		//		event processor for onmousedown/ontouchstart, creates a Mover for the node
+		// e: Event
+		//		mouse/touch event
+		if(this.skip && dojo.dnd.isFormElement(e)){ return; }
+		if(this.delay){
+			this.events.push(
+				dojo.connect(this.handle, touch.move, this, "onMouseMove"),
+				dojo.connect(this.handle, touch.release, this, "onMouseUp")
+			);
+			this._lastX = e.pageX;
+			this._lastY = e.pageY;
+		}else{
+			this.onDragDetected(e);
+		}
+		dojo.stopEvent(e);
+	},
+	onMouseMove: function(e){
+		// summary:
+		//		event processor for onmousemove/ontouchmove, used only for delayed drags
+		// e: Event
+		//		mouse/touch event
+		if(Math.abs(e.pageX - this._lastX) > this.delay || Math.abs(e.pageY - this._lastY) > this.delay){
+			this.onMouseUp(e);
+			this.onDragDetected(e);
+		}
+		dojo.stopEvent(e);
+	},
+	onMouseUp: function(e){
+		// summary:
+		//		event processor for onmouseup, used only for delayed drags
+		// e: Event
+		//		mouse event
+		for(var i = 0; i < 2; ++i){
+			dojo.disconnect(this.events.pop());
+		}
+		dojo.stopEvent(e);
+	},
+	onSelectStart: function(e){
+		// summary:
+		//		event processor for onselectevent and ondragevent
+		// e: Event
+		//		mouse event
+		if(!this.skip || !dojo.dnd.isFormElement(e)){
+			dojo.stopEvent(e);
+		}
+	},
+
+	// local events
+	onDragDetected: function(/* Event */ e){
+		// summary:
+		//		called when the drag is detected;
+		//		responsible for creation of the mover
+		new this.mover(this.node, e, this);
+	},
+	onMoveStart: function(/* dojo.dnd.Mover */ mover){
+		// summary:
+		//		called before every move operation
+		dojo.publish("/dnd/move/start", [mover]);
+		dojo.addClass(dojo.body(), "dojoMove");
+		dojo.addClass(this.node, "dojoMoveItem");
+	},
+	onMoveStop: function(/* dojo.dnd.Mover */ mover){
+		// summary:
+		//		called after every move operation
+		dojo.publish("/dnd/move/stop", [mover]);
+		dojo.removeClass(dojo.body(), "dojoMove");
+		dojo.removeClass(this.node, "dojoMoveItem");
+	},
+	onFirstMove: function(/* dojo.dnd.Mover */ mover, /* Event */ e){
+		// summary:
+		//		called during the very first move notification;
+		//		can be used to initialize coordinates, can be overwritten.
+
+		// default implementation does nothing
+	},
+	onMove: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop, /* Event */ e){
+		// summary:
+		//		called during every move notification;
+		//		should actually move the node; can be overwritten.
+		this.onMoving(mover, leftTop);
+		var s = mover.node.style;
+		s.left = leftTop.l + "px";
+		s.top  = leftTop.t + "px";
+		this.onMoved(mover, leftTop);
+	},
+	onMoving: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop){
+		// summary:
+		//		called before every incremental move; can be overwritten.
+
+		// default implementation does nothing
+	},
+	onMoved: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop){
+		// summary:
+		//		called after every incremental move; can be overwritten.
+
+		// default implementation does nothing
+	}
+});
+
+return dojo.dnd.Moveable;
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/Mover.js b/js/dojo-1.7.2/dojo/dnd/Mover.js
new file mode 100644
index 0000000..fb27b94
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/Mover.js
@@ -0,0 +1,120 @@
+//>>built
+define("dojo/dnd/Mover", ["../main", "../Evented", "../touch", "./common", "./autoscroll"], function(dojo, Evented, touch) {
+	// module:
+	//		dojo/dnd/Mover
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.dnd.Mover", [Evented], {
+	constructor: function(node, e, host){
+		// summary:
+		//		an object which makes a node follow the mouse, or touch-drag on touch devices.
+		//		Used as a default mover, and as a base class for custom movers.
+		// node: Node
+		//		a node (or node's id) to be moved
+		// e: Event
+		//		a mouse event, which started the move;
+		//		only pageX and pageY properties are used
+		// host: Object?
+		//		object which implements the functionality of the move,
+		//	 	and defines proper events (onMoveStart and onMoveStop)
+		this.node = dojo.byId(node);
+		this.marginBox = {l: e.pageX, t: e.pageY};
+		this.mouseButton = e.button;
+		var h = (this.host = host), d = node.ownerDocument;
+		this.events = [
+			// At the start of a drag, onFirstMove is called, and then the following two
+			// connects are disconnected
+			dojo.connect(d, touch.move, this, "onFirstMove"),
+
+			// These are called continually during the drag
+			dojo.connect(d, touch.move, this, "onMouseMove"),
+
+			// And these are called at the end of the drag
+			dojo.connect(d, touch.release,   this, "onMouseUp"),
+
+			// cancel text selection and text dragging
+			dojo.connect(d, "ondragstart",   dojo.stopEvent),
+			dojo.connect(d.body, "onselectstart", dojo.stopEvent)
+		];
+		// notify that the move has started
+		if(h && h.onMoveStart){
+			h.onMoveStart(this);
+		}
+	},
+	// mouse event processors
+	onMouseMove: function(e){
+		// summary:
+		//		event processor for onmousemove/ontouchmove
+		// e: Event
+		//		mouse/touch event
+		dojo.dnd.autoScroll(e);
+		var m = this.marginBox;
+		this.host.onMove(this, {l: m.l + e.pageX, t: m.t + e.pageY}, e);
+		dojo.stopEvent(e);
+	},
+	onMouseUp: function(e){
+		if(dojo.isWebKit && dojo.isMac && this.mouseButton == 2 ?
+				e.button == 0 : this.mouseButton == e.button){ // TODO Should condition be met for touch devices, too?
+			this.destroy();
+		}
+		dojo.stopEvent(e);
+	},
+	// utilities
+	onFirstMove: function(e){
+		// summary:
+		//		makes the node absolute; it is meant to be called only once.
+		// 		relative and absolutely positioned nodes are assumed to use pixel units
+		var s = this.node.style, l, t, h = this.host;
+		switch(s.position){
+			case "relative":
+			case "absolute":
+				// assume that left and top values are in pixels already
+				l = Math.round(parseFloat(s.left)) || 0;
+				t = Math.round(parseFloat(s.top)) || 0;
+				break;
+			default:
+				s.position = "absolute";	// enforcing the absolute mode
+				var m = dojo.marginBox(this.node);
+				// event.pageX/pageY (which we used to generate the initial
+				// margin box) includes padding and margin set on the body.
+				// However, setting the node's position to absolute and then
+				// doing dojo.marginBox on it *doesn't* take that additional
+				// space into account - so we need to subtract the combined
+				// padding and margin.  We use getComputedStyle and
+				// _getMarginBox/_getContentBox to avoid the extra lookup of
+				// the computed style.
+				var b = dojo.doc.body;
+				var bs = dojo.getComputedStyle(b);
+				var bm = dojo._getMarginBox(b, bs);
+				var bc = dojo._getContentBox(b, bs);
+				l = m.l - (bc.l - bm.l);
+				t = m.t - (bc.t - bm.t);
+				break;
+		}
+		this.marginBox.l = l - this.marginBox.l;
+		this.marginBox.t = t - this.marginBox.t;
+		if(h && h.onFirstMove){
+			h.onFirstMove(this, e);
+		}
+
+		// Disconnect onmousemove and ontouchmove events that call this function
+		dojo.disconnect(this.events.shift());
+	},
+	destroy: function(){
+		// summary:
+		//		stops the move, deletes all references, so the object can be garbage-collected
+		dojo.forEach(this.events, dojo.disconnect);
+		// undo global settings
+		var h = this.host;
+		if(h && h.onMoveStop){
+			h.onMoveStop(this);
+		}
+		// destroy objects
+		this.events = this.node = this.host = null;
+	}
+});
+
+return dojo.dnd.Mover;
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/Selector.js b/js/dojo-1.7.2/dojo/dnd/Selector.js
new file mode 100644
index 0000000..bb34d0a
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/Selector.js
@@ -0,0 +1,325 @@
+//>>built
+define("dojo/dnd/Selector", ["../main", "./common", "./Container"], function(dojo) {
+	// module:
+	//		dojo/dnd/Selector
+	// summary:
+	//		TODOC
+
+
+/*
+	Container item states:
+		""			- an item is not selected
+		"Selected"	- an item is selected
+		"Anchor"	- an item is selected, and is an anchor for a "shift" selection
+*/
+
+/*=====
+dojo.declare("dojo.dnd.__SelectorArgs", [dojo.dnd.__ContainerArgs], {
+	//	singular: Boolean
+	//		allows selection of only one element, if true
+	singular: false,
+
+	//	autoSync: Boolean
+	//		autosynchronizes the source with its list of DnD nodes,
+	autoSync: false
+});
+=====*/
+
+dojo.declare("dojo.dnd.Selector", dojo.dnd.Container, {
+	// summary:
+	//		a Selector object, which knows how to select its children
+
+	/*=====
+	// selection: Set<String>
+	//		The set of id's that are currently selected, such that this.selection[id] == 1
+	//		if the node w/that id is selected.  Can iterate over selected node's id's like:
+	//	|		for(var id in this.selection)
+	selection: {},
+	=====*/
+
+	constructor: function(node, params){
+		// summary:
+		//		constructor of the Selector
+		// node: Node||String
+		//		node or node's id to build the selector on
+		// params: dojo.dnd.__SelectorArgs?
+		//		a dictionary of parameters
+		if(!params){ params = {}; }
+		this.singular = params.singular;
+		this.autoSync = params.autoSync;
+		// class-specific variables
+		this.selection = {};
+		this.anchor = null;
+		this.simpleSelection = false;
+		// set up events
+		this.events.push(
+			dojo.connect(this.node, "onmousedown", this, "onMouseDown"),
+			dojo.connect(this.node, "onmouseup",   this, "onMouseUp"));
+	},
+
+	// object attributes (for markup)
+	singular: false,	// is singular property
+
+	// methods
+	getSelectedNodes: function(){
+		// summary:
+		//		returns a list (an array) of selected nodes
+		var t = new dojo.NodeList();
+		var e = dojo.dnd._empty;
+		for(var i in this.selection){
+			if(i in e){ continue; }
+			t.push(dojo.byId(i));
+		}
+		return t;	// NodeList
+	},
+	selectNone: function(){
+		// summary:
+		//		unselects all items
+		return this._removeSelection()._removeAnchor();	// self
+	},
+	selectAll: function(){
+		// summary:
+		//		selects all items
+		this.forInItems(function(data, id){
+			this._addItemClass(dojo.byId(id), "Selected");
+			this.selection[id] = 1;
+		}, this);
+		return this._removeAnchor();	// self
+	},
+	deleteSelectedNodes: function(){
+		// summary:
+		//		deletes all selected items
+		var e = dojo.dnd._empty;
+		for(var i in this.selection){
+			if(i in e){ continue; }
+			var n = dojo.byId(i);
+			this.delItem(i);
+			dojo.destroy(n);
+		}
+		this.anchor = null;
+		this.selection = {};
+		return this;	// self
+	},
+	forInSelectedItems: function(/*Function*/ f, /*Object?*/ o){
+		// summary:
+		//		iterates over selected items;
+		//		see `dojo.dnd.Container.forInItems()` for details
+		o = o || dojo.global;
+		var s = this.selection, e = dojo.dnd._empty;
+		for(var i in s){
+			if(i in e){ continue; }
+			f.call(o, this.getItem(i), i, this);
+		}
+	},
+	sync: function(){
+		// summary:
+		//		sync up the node list with the data map
+
+		dojo.dnd.Selector.superclass.sync.call(this);
+
+		// fix the anchor
+		if(this.anchor){
+			if(!this.getItem(this.anchor.id)){
+				this.anchor = null;
+			}
+		}
+
+		// fix the selection
+		var t = [], e = dojo.dnd._empty;
+		for(var i in this.selection){
+			if(i in e){ continue; }
+			if(!this.getItem(i)){
+				t.push(i);
+			}
+		}
+		dojo.forEach(t, function(i){
+			delete this.selection[i];
+		}, this);
+
+		return this;	// self
+	},
+	insertNodes: function(addSelected, data, before, anchor){
+		// summary:
+		//		inserts new data items (see `dojo.dnd.Container.insertNodes()` method for details)
+		// addSelected: Boolean
+		//		all new nodes will be added to selected items, if true, no selection change otherwise
+		// data: Array
+		//		a list of data items, which should be processed by the creator function
+		// before: Boolean
+		//		insert before the anchor, if true, and after the anchor otherwise
+		// anchor: Node
+		//		the anchor node to be used as a point of insertion
+		var oldCreator = this._normalizedCreator;
+		this._normalizedCreator = function(item, hint){
+			var t = oldCreator.call(this, item, hint);
+			if(addSelected){
+				if(!this.anchor){
+					this.anchor = t.node;
+					this._removeItemClass(t.node, "Selected");
+					this._addItemClass(this.anchor, "Anchor");
+				}else if(this.anchor != t.node){
+					this._removeItemClass(t.node, "Anchor");
+					this._addItemClass(t.node, "Selected");
+				}
+				this.selection[t.node.id] = 1;
+			}else{
+				this._removeItemClass(t.node, "Selected");
+				this._removeItemClass(t.node, "Anchor");
+			}
+			return t;
+		};
+		dojo.dnd.Selector.superclass.insertNodes.call(this, data, before, anchor);
+		this._normalizedCreator = oldCreator;
+		return this;	// self
+	},
+	destroy: function(){
+		// summary:
+		//		prepares the object to be garbage-collected
+		dojo.dnd.Selector.superclass.destroy.call(this);
+		this.selection = this.anchor = null;
+	},
+
+	// mouse events
+	onMouseDown: function(e){
+		// summary:
+		//		event processor for onmousedown
+		// e: Event
+		//		mouse event
+		if(this.autoSync){ this.sync(); }
+		if(!this.current){ return; }
+		if(!this.singular && !dojo.isCopyKey(e) && !e.shiftKey && (this.current.id in this.selection)){
+			this.simpleSelection = true;
+			if(e.button === dojo.mouseButtons.LEFT){
+				// accept the left button and stop the event
+				// for IE we don't stop event when multiple buttons are pressed
+				dojo.stopEvent(e);
+			}
+			return;
+		}
+		if(!this.singular && e.shiftKey){
+			if(!dojo.isCopyKey(e)){
+				this._removeSelection();
+			}
+			var c = this.getAllNodes();
+			if(c.length){
+				if(!this.anchor){
+					this.anchor = c[0];
+					this._addItemClass(this.anchor, "Anchor");
+				}
+				this.selection[this.anchor.id] = 1;
+				if(this.anchor != this.current){
+					var i = 0;
+					for(; i < c.length; ++i){
+						var node = c[i];
+						if(node == this.anchor || node == this.current){ break; }
+					}
+					for(++i; i < c.length; ++i){
+						var node = c[i];
+						if(node == this.anchor || node == this.current){ break; }
+						this._addItemClass(node, "Selected");
+						this.selection[node.id] = 1;
+					}
+					this._addItemClass(this.current, "Selected");
+					this.selection[this.current.id] = 1;
+				}
+			}
+		}else{
+			if(this.singular){
+				if(this.anchor == this.current){
+					if(dojo.isCopyKey(e)){
+						this.selectNone();
+					}
+				}else{
+					this.selectNone();
+					this.anchor = this.current;
+					this._addItemClass(this.anchor, "Anchor");
+					this.selection[this.current.id] = 1;
+				}
+			}else{
+				if(dojo.isCopyKey(e)){
+					if(this.anchor == this.current){
+						delete this.selection[this.anchor.id];
+						this._removeAnchor();
+					}else{
+						if(this.current.id in this.selection){
+							this._removeItemClass(this.current, "Selected");
+							delete this.selection[this.current.id];
+						}else{
+							if(this.anchor){
+								this._removeItemClass(this.anchor, "Anchor");
+								this._addItemClass(this.anchor, "Selected");
+							}
+							this.anchor = this.current;
+							this._addItemClass(this.current, "Anchor");
+							this.selection[this.current.id] = 1;
+						}
+					}
+				}else{
+					if(!(this.current.id in this.selection)){
+						this.selectNone();
+						this.anchor = this.current;
+						this._addItemClass(this.current, "Anchor");
+						this.selection[this.current.id] = 1;
+					}
+				}
+			}
+		}
+		dojo.stopEvent(e);
+	},
+	onMouseUp: function(e){
+		// summary:
+		//		event processor for onmouseup
+		// e: Event
+		//		mouse event
+		if(!this.simpleSelection){ return; }
+		this.simpleSelection = false;
+		this.selectNone();
+		if(this.current){
+			this.anchor = this.current;
+			this._addItemClass(this.anchor, "Anchor");
+			this.selection[this.current.id] = 1;
+		}
+	},
+	onMouseMove: function(e){
+		// summary:
+		//		event processor for onmousemove
+		// e: Event
+		//		mouse event
+		this.simpleSelection = false;
+	},
+
+	// utilities
+	onOverEvent: function(){
+		// summary:
+		//		this function is called once, when mouse is over our container
+		this.onmousemoveEvent = dojo.connect(this.node, "onmousemove", this, "onMouseMove");
+	},
+	onOutEvent: function(){
+		// summary:
+		//		this function is called once, when mouse is out of our container
+		dojo.disconnect(this.onmousemoveEvent);
+		delete this.onmousemoveEvent;
+	},
+	_removeSelection: function(){
+		// summary:
+		//		unselects all items
+		var e = dojo.dnd._empty;
+		for(var i in this.selection){
+			if(i in e){ continue; }
+			var node = dojo.byId(i);
+			if(node){ this._removeItemClass(node, "Selected"); }
+		}
+		this.selection = {};
+		return this;	// self
+	},
+	_removeAnchor: function(){
+		if(this.anchor){
+			this._removeItemClass(this.anchor, "Anchor");
+			this.anchor = null;
+		}
+		return this;	// self
+	}
+});
+
+return dojo.dnd.Selector;
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/Source.js b/js/dojo-1.7.2/dojo/dnd/Source.js
new file mode 100644
index 0000000..e96e571
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/Source.js
@@ -0,0 +1,514 @@
+//>>built
+define("dojo/dnd/Source", ["../main", "./Selector", "./Manager"], function(dojo, Selector, Manager) {
+	// module:
+	//		dojo/dnd/Source
+	// summary:
+	//		TODOC
+
+/*=====
+Selector = dojo.dnd.Selector;
+=====*/
+
+/*
+	Container property:
+		"Horizontal"- if this is the horizontal container
+	Source states:
+		""			- normal state
+		"Moved"		- this source is being moved
+		"Copied"	- this source is being copied
+	Target states:
+		""			- normal state
+		"Disabled"	- the target cannot accept an avatar
+	Target anchor state:
+		""			- item is not selected
+		"Before"	- insert point is before the anchor
+		"After"		- insert point is after the anchor
+*/
+
+/*=====
+dojo.dnd.__SourceArgs = function(){
+	//	summary:
+	//		a dict of parameters for DnD Source configuration. Note that any
+	//		property on Source elements may be configured, but this is the
+	//		short-list
+	//	isSource: Boolean?
+	//		can be used as a DnD source. Defaults to true.
+	//	accept: Array?
+	//		list of accepted types (text strings) for a target; defaults to
+	//		["text"]
+	//	autoSync: Boolean
+	//		if true refreshes the node list on every operation; false by default
+	//	copyOnly: Boolean?
+	//		copy items, if true, use a state of Ctrl key otherwise,
+	//		see selfCopy and selfAccept for more details
+	//	delay: Number
+	//		the move delay in pixels before detecting a drag; 0 by default
+	//	horizontal: Boolean?
+	//		a horizontal container, if true, vertical otherwise or when omitted
+	//	selfCopy: Boolean?
+	//		copy items by default when dropping on itself,
+	//		false by default, works only if copyOnly is true
+	//	selfAccept: Boolean?
+	//		accept its own items when copyOnly is true,
+	//		true by default, works only if copyOnly is true
+	//	withHandles: Boolean?
+	//		allows dragging only by handles, false by default
+	//  generateText: Boolean?
+	//		generate text node for drag and drop, true by default
+	this.isSource = isSource;
+	this.accept = accept;
+	this.autoSync = autoSync;
+	this.copyOnly = copyOnly;
+	this.delay = delay;
+	this.horizontal = horizontal;
+	this.selfCopy = selfCopy;
+	this.selfAccept = selfAccept;
+	this.withHandles = withHandles;
+	this.generateText = true;
+}
+=====*/
+
+// For back-compat, remove in 2.0.
+if(!dojo.isAsync){
+	dojo.ready(0, function(){
+		var requires = ["dojo/dnd/AutoSource", "dojo/dnd/Target"];
+		require(requires);	// use indirection so modules not rolled into a build
+	})
+}
+
+return dojo.declare("dojo.dnd.Source", Selector, {
+	// summary:
+	//		a Source object, which can be used as a DnD source, or a DnD target
+
+	// object attributes (for markup)
+	isSource: true,
+	horizontal: false,
+	copyOnly: false,
+	selfCopy: false,
+	selfAccept: true,
+	skipForm: false,
+	withHandles: false,
+	autoSync: false,
+	delay: 0, // pixels
+	accept: ["text"],
+	generateText: true,
+
+	constructor: function(/*DOMNode|String*/node, /*dojo.dnd.__SourceArgs?*/params){
+		// summary:
+		//		a constructor of the Source
+		// node:
+		//		node or node's id to build the source on
+		// params:
+		//		any property of this class may be configured via the params
+		//		object which is mixed-in to the `dojo.dnd.Source` instance
+		dojo.mixin(this, dojo.mixin({}, params));
+		var type = this.accept;
+		if(type.length){
+			this.accept = {};
+			for(var i = 0; i < type.length; ++i){
+				this.accept[type[i]] = 1;
+			}
+		}
+		// class-specific variables
+		this.isDragging = false;
+		this.mouseDown = false;
+		this.targetAnchor = null;
+		this.targetBox = null;
+		this.before = true;
+		this._lastX = 0;
+		this._lastY = 0;
+		// states
+		this.sourceState  = "";
+		if(this.isSource){
+			dojo.addClass(this.node, "dojoDndSource");
+		}
+		this.targetState  = "";
+		if(this.accept){
+			dojo.addClass(this.node, "dojoDndTarget");
+		}
+		if(this.horizontal){
+			dojo.addClass(this.node, "dojoDndHorizontal");
+		}
+		// set up events
+		this.topics = [
+			dojo.subscribe("/dnd/source/over", this, "onDndSourceOver"),
+			dojo.subscribe("/dnd/start",  this, "onDndStart"),
+			dojo.subscribe("/dnd/drop",   this, "onDndDrop"),
+			dojo.subscribe("/dnd/cancel", this, "onDndCancel")
+		];
+	},
+
+	// methods
+	checkAcceptance: function(source, nodes){
+		// summary:
+		//		checks if the target can accept nodes from this source
+		// source: Object
+		//		the source which provides items
+		// nodes: Array
+		//		the list of transferred items
+		if(this == source){
+			return !this.copyOnly || this.selfAccept;
+		}
+		for(var i = 0; i < nodes.length; ++i){
+			var type = source.getItem(nodes[i].id).type;
+			// type instanceof Array
+			var flag = false;
+			for(var j = 0; j < type.length; ++j){
+				if(type[j] in this.accept){
+					flag = true;
+					break;
+				}
+			}
+			if(!flag){
+				return false;	// Boolean
+			}
+		}
+		return true;	// Boolean
+	},
+	copyState: function(keyPressed, self){
+		// summary:
+		//		Returns true if we need to copy items, false to move.
+		//		It is separated to be overwritten dynamically, if needed.
+		// keyPressed: Boolean
+		//		the "copy" key was pressed
+		// self: Boolean?
+		//		optional flag that means that we are about to drop on itself
+
+		if(keyPressed){ return true; }
+		if(arguments.length < 2){
+			self = this == Manager.manager().target;
+		}
+		if(self){
+			if(this.copyOnly){
+				return this.selfCopy;
+			}
+		}else{
+			return this.copyOnly;
+		}
+		return false;	// Boolean
+	},
+	destroy: function(){
+		// summary:
+		//		prepares the object to be garbage-collected
+		dojo.dnd.Source.superclass.destroy.call(this);
+		dojo.forEach(this.topics, dojo.unsubscribe);
+		this.targetAnchor = null;
+	},
+
+	// mouse event processors
+	onMouseMove: function(e){
+		// summary:
+		//		event processor for onmousemove
+		// e: Event
+		//		mouse event
+		if(this.isDragging && this.targetState == "Disabled"){ return; }
+		dojo.dnd.Source.superclass.onMouseMove.call(this, e);
+		var m = Manager.manager();
+		if(!this.isDragging){
+			if(this.mouseDown && this.isSource &&
+					(Math.abs(e.pageX - this._lastX) > this.delay || Math.abs(e.pageY - this._lastY) > this.delay)){
+				var nodes = this.getSelectedNodes();
+				if(nodes.length){
+					m.startDrag(this, nodes, this.copyState(dojo.isCopyKey(e), true));
+				}
+			}
+		}
+		if(this.isDragging){
+			// calculate before/after
+			var before = false;
+			if(this.current){
+				if(!this.targetBox || this.targetAnchor != this.current){
+					this.targetBox = dojo.position(this.current, true);
+				}
+				if(this.horizontal){
+					before = (e.pageX - this.targetBox.x) < (this.targetBox.w / 2);
+				}else{
+					before = (e.pageY - this.targetBox.y) < (this.targetBox.h / 2);
+				}
+			}
+			if(this.current != this.targetAnchor || before != this.before){
+				this._markTargetAnchor(before);
+				m.canDrop(!this.current || m.source != this || !(this.current.id in this.selection));
+			}
+		}
+	},
+	onMouseDown: function(e){
+		// summary:
+		//		event processor for onmousedown
+		// e: Event
+		//		mouse event
+		if(!this.mouseDown && this._legalMouseDown(e) && (!this.skipForm || !dojo.dnd.isFormElement(e))){
+			this.mouseDown = true;
+			this._lastX = e.pageX;
+			this._lastY = e.pageY;
+			dojo.dnd.Source.superclass.onMouseDown.call(this, e);
+		}
+	},
+	onMouseUp: function(e){
+		// summary:
+		//		event processor for onmouseup
+		// e: Event
+		//		mouse event
+		if(this.mouseDown){
+			this.mouseDown = false;
+			dojo.dnd.Source.superclass.onMouseUp.call(this, e);
+		}
+	},
+
+	// topic event processors
+	onDndSourceOver: function(source){
+		// summary:
+		//		topic event processor for /dnd/source/over, called when detected a current source
+		// source: Object
+		//		the source which has the mouse over it
+		if(this != source){
+			this.mouseDown = false;
+			if(this.targetAnchor){
+				this._unmarkTargetAnchor();
+			}
+		}else if(this.isDragging){
+			var m = Manager.manager();
+			m.canDrop(this.targetState != "Disabled" && (!this.current || m.source != this || !(this.current.id in this.selection)));
+		}
+	},
+	onDndStart: function(source, nodes, copy){
+		// summary:
+		//		topic event processor for /dnd/start, called to initiate the DnD operation
+		// source: Object
+		//		the source which provides items
+		// nodes: Array
+		//		the list of transferred items
+		// copy: Boolean
+		//		copy items, if true, move items otherwise
+		if(this.autoSync){ this.sync(); }
+		if(this.isSource){
+			this._changeState("Source", this == source ? (copy ? "Copied" : "Moved") : "");
+		}
+		var accepted = this.accept && this.checkAcceptance(source, nodes);
+		this._changeState("Target", accepted ? "" : "Disabled");
+		if(this == source){
+			Manager.manager().overSource(this);
+		}
+		this.isDragging = true;
+	},
+	onDndDrop: function(source, nodes, copy, target){
+		// summary:
+		//		topic event processor for /dnd/drop, called to finish the DnD operation
+		// source: Object
+		//		the source which provides items
+		// nodes: Array
+		//		the list of transferred items
+		// copy: Boolean
+		//		copy items, if true, move items otherwise
+		// target: Object
+		//		the target which accepts items
+		if(this == target){
+			// this one is for us => move nodes!
+			this.onDrop(source, nodes, copy);
+		}
+		this.onDndCancel();
+	},
+	onDndCancel: function(){
+		// summary:
+		//		topic event processor for /dnd/cancel, called to cancel the DnD operation
+		if(this.targetAnchor){
+			this._unmarkTargetAnchor();
+			this.targetAnchor = null;
+		}
+		this.before = true;
+		this.isDragging = false;
+		this.mouseDown = false;
+		this._changeState("Source", "");
+		this._changeState("Target", "");
+	},
+
+	// local events
+	onDrop: function(source, nodes, copy){
+		// summary:
+		//		called only on the current target, when drop is performed
+		// source: Object
+		//		the source which provides items
+		// nodes: Array
+		//		the list of transferred items
+		// copy: Boolean
+		//		copy items, if true, move items otherwise
+
+		if(this != source){
+			this.onDropExternal(source, nodes, copy);
+		}else{
+			this.onDropInternal(nodes, copy);
+		}
+	},
+	onDropExternal: function(source, nodes, copy){
+		// summary:
+		//		called only on the current target, when drop is performed
+		//		from an external source
+		// source: Object
+		//		the source which provides items
+		// nodes: Array
+		//		the list of transferred items
+		// copy: Boolean
+		//		copy items, if true, move items otherwise
+
+		var oldCreator = this._normalizedCreator;
+		// transferring nodes from the source to the target
+		if(this.creator){
+			// use defined creator
+			this._normalizedCreator = function(node, hint){
+				return oldCreator.call(this, source.getItem(node.id).data, hint);
+			};
+		}else{
+			// we have no creator defined => move/clone nodes
+			if(copy){
+				// clone nodes
+				this._normalizedCreator = function(node, hint){
+					var t = source.getItem(node.id);
+					var n = node.cloneNode(true);
+					n.id = dojo.dnd.getUniqueId();
+					return {node: n, data: t.data, type: t.type};
+				};
+			}else{
+				// move nodes
+				this._normalizedCreator = function(node, hint){
+					var t = source.getItem(node.id);
+					source.delItem(node.id);
+					return {node: node, data: t.data, type: t.type};
+				};
+			}
+		}
+		this.selectNone();
+		if(!copy && !this.creator){
+			source.selectNone();
+		}
+		this.insertNodes(true, nodes, this.before, this.current);
+		if(!copy && this.creator){
+			source.deleteSelectedNodes();
+		}
+		this._normalizedCreator = oldCreator;
+	},
+	onDropInternal: function(nodes, copy){
+		// summary:
+		//		called only on the current target, when drop is performed
+		//		from the same target/source
+		// nodes: Array
+		//		the list of transferred items
+		// copy: Boolean
+		//		copy items, if true, move items otherwise
+
+		var oldCreator = this._normalizedCreator;
+		// transferring nodes within the single source
+		if(this.current && this.current.id in this.selection){
+			// do nothing
+			return;
+		}
+		if(copy){
+			if(this.creator){
+				// create new copies of data items
+				this._normalizedCreator = function(node, hint){
+					return oldCreator.call(this, this.getItem(node.id).data, hint);
+				};
+			}else{
+				// clone nodes
+				this._normalizedCreator = function(node, hint){
+					var t = this.getItem(node.id);
+					var n = node.cloneNode(true);
+					n.id = dojo.dnd.getUniqueId();
+					return {node: n, data: t.data, type: t.type};
+				};
+			}
+		}else{
+			// move nodes
+			if(!this.current){
+				// do nothing
+				return;
+			}
+			this._normalizedCreator = function(node, hint){
+				var t = this.getItem(node.id);
+				return {node: node, data: t.data, type: t.type};
+			};
+		}
+		this._removeSelection();
+		this.insertNodes(true, nodes, this.before, this.current);
+		this._normalizedCreator = oldCreator;
+	},
+	onDraggingOver: function(){
+		// summary:
+		//		called during the active DnD operation, when items
+		//		are dragged over this target, and it is not disabled
+	},
+	onDraggingOut: function(){
+		// summary:
+		//		called during the active DnD operation, when items
+		//		are dragged away from this target, and it is not disabled
+	},
+
+	// utilities
+	onOverEvent: function(){
+		// summary:
+		//		this function is called once, when mouse is over our container
+		dojo.dnd.Source.superclass.onOverEvent.call(this);
+		Manager.manager().overSource(this);
+		if(this.isDragging && this.targetState != "Disabled"){
+			this.onDraggingOver();
+		}
+	},
+	onOutEvent: function(){
+		// summary:
+		//		this function is called once, when mouse is out of our container
+		dojo.dnd.Source.superclass.onOutEvent.call(this);
+		Manager.manager().outSource(this);
+		if(this.isDragging && this.targetState != "Disabled"){
+			this.onDraggingOut();
+		}
+	},
+	_markTargetAnchor: function(before){
+		// summary:
+		//		assigns a class to the current target anchor based on "before" status
+		// before: Boolean
+		//		insert before, if true, after otherwise
+		if(this.current == this.targetAnchor && this.before == before){ return; }
+		if(this.targetAnchor){
+			this._removeItemClass(this.targetAnchor, this.before ? "Before" : "After");
+		}
+		this.targetAnchor = this.current;
+		this.targetBox = null;
+		this.before = before;
+		if(this.targetAnchor){
+			this._addItemClass(this.targetAnchor, this.before ? "Before" : "After");
+		}
+	},
+	_unmarkTargetAnchor: function(){
+		// summary:
+		//		removes a class of the current target anchor based on "before" status
+		if(!this.targetAnchor){ return; }
+		this._removeItemClass(this.targetAnchor, this.before ? "Before" : "After");
+		this.targetAnchor = null;
+		this.targetBox = null;
+		this.before = true;
+	},
+	_markDndStatus: function(copy){
+		// summary:
+		//		changes source's state based on "copy" status
+		this._changeState("Source", copy ? "Copied" : "Moved");
+	},
+	_legalMouseDown: function(e){
+		// summary:
+		//		checks if user clicked on "approved" items
+		// e: Event
+		//		mouse event
+
+		// accept only the left mouse button
+		if(!dojo.mouseButtons.isLeft(e)){ return false; }
+
+		if(!this.withHandles){ return true; }
+
+		// check for handles
+		for(var node = e.target; node && node !== this.node; node = node.parentNode){
+			if(dojo.hasClass(node, "dojoDndHandle")){ return true; }
+			if(dojo.hasClass(node, "dojoDndItem") || dojo.hasClass(node, "dojoDndIgnore")){ break; }
+		}
+		return false;	// Boolean
+	}
+});
+
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/Target.js b/js/dojo-1.7.2/dojo/dnd/Target.js
new file mode 100644
index 0000000..10bf029
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/Target.js
@@ -0,0 +1,14 @@
+//>>built
+define("dojo/dnd/Target", [ "./Source" ], function(Source){
+	/*===== Source = dojo.dnd.Source =====*/
+	return dojo.declare("dojo.dnd.Target", Source, {
+		// summary: a Target object, which can be used as a DnD target
+
+		constructor: function(node, params){
+			// summary:
+			//		a constructor of the Target --- see the `dojo.dnd.Source.constructor` for details
+			this.isSource = false;
+			dojo.removeClass(this.node, "dojoDndSource");
+		}
+	});
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/TimedMoveable.js b/js/dojo-1.7.2/dojo/dnd/TimedMoveable.js
new file mode 100644
index 0000000..9495a2d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/TimedMoveable.js
@@ -0,0 +1,70 @@
+//>>built
+define("dojo/dnd/TimedMoveable", ["../main", "./Moveable"], function(dojo) {
+	// module:
+	//		dojo/dnd/TimedMoveable
+	// summary:
+	//		TODOC
+
+	/*=====
+	dojo.declare("dojo.dnd.__TimedMoveableArgs", [dojo.dnd.__MoveableArgs], {
+		// timeout: Number
+		//		delay move by this number of ms,
+		//		accumulating position changes during the timeout
+		timeout: 0
+	});
+	=====*/
+
+	// precalculate long expressions
+	var oldOnMove = dojo.dnd.Moveable.prototype.onMove;
+
+	dojo.declare("dojo.dnd.TimedMoveable", dojo.dnd.Moveable, {
+		// summary:
+		//		A specialized version of Moveable to support an FPS throttling.
+		//		This class puts an upper restriction on FPS, which may reduce
+		//		the CPU load. The additional parameter "timeout" regulates
+		//		the delay before actually moving the moveable object.
+
+		// object attributes (for markup)
+		timeout: 40,	// in ms, 40ms corresponds to 25 fps
+
+		constructor: function(node, params){
+			// summary:
+			//		an object that makes a node moveable with a timer
+			// node: Node||String
+			//		a node (or node's id) to be moved
+			// params: dojo.dnd.__TimedMoveableArgs
+			//		object with additional parameters.
+
+			// sanitize parameters
+			if(!params){ params = {}; }
+			if(params.timeout && typeof params.timeout == "number" && params.timeout >= 0){
+				this.timeout = params.timeout;
+			}
+		},
+
+		onMoveStop: function(/* dojo.dnd.Mover */ mover){
+			if(mover._timer){
+				// stop timer
+				clearTimeout(mover._timer);
+				// reflect the last received position
+				oldOnMove.call(this, mover, mover._leftTop)
+			}
+			dojo.dnd.Moveable.prototype.onMoveStop.apply(this, arguments);
+		},
+		onMove: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop){
+			mover._leftTop = leftTop;
+			if(!mover._timer){
+				var _t = this;	// to avoid using dojo.hitch()
+				mover._timer = setTimeout(function(){
+					// we don't have any pending requests
+					mover._timer = null;
+					// reflect the last received position
+					oldOnMove.call(_t, mover, mover._leftTop);
+				}, this.timeout);
+			}
+		}
+	});
+
+	return dojo.dnd.TimedMoveable;
+	
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/autoscroll.js b/js/dojo-1.7.2/dojo/dnd/autoscroll.js
new file mode 100644
index 0000000..2c8b275
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/autoscroll.js
@@ -0,0 +1,119 @@
+//>>built
+define("dojo/dnd/autoscroll", ["../main", "../window"], function(dojo) {
+	// module:
+	//		dojo/dnd/autoscroll
+	// summary:
+	//		TODOC
+
+dojo.getObject("dnd", true, dojo);
+
+dojo.dnd.getViewport = dojo.window.getBox;
+
+dojo.dnd.V_TRIGGER_AUTOSCROLL = 32;
+dojo.dnd.H_TRIGGER_AUTOSCROLL = 32;
+
+dojo.dnd.V_AUTOSCROLL_VALUE = 16;
+dojo.dnd.H_AUTOSCROLL_VALUE = 16;
+
+dojo.dnd.autoScroll = function(e){
+	// summary:
+	//		a handler for onmousemove event, which scrolls the window, if
+	//		necesary
+	// e: Event
+	//		onmousemove event
+
+	// FIXME: needs more docs!
+	var v = dojo.window.getBox(), dx = 0, dy = 0;
+	if(e.clientX < dojo.dnd.H_TRIGGER_AUTOSCROLL){
+		dx = -dojo.dnd.H_AUTOSCROLL_VALUE;
+	}else if(e.clientX > v.w - dojo.dnd.H_TRIGGER_AUTOSCROLL){
+		dx = dojo.dnd.H_AUTOSCROLL_VALUE;
+	}
+	if(e.clientY < dojo.dnd.V_TRIGGER_AUTOSCROLL){
+		dy = -dojo.dnd.V_AUTOSCROLL_VALUE;
+	}else if(e.clientY > v.h - dojo.dnd.V_TRIGGER_AUTOSCROLL){
+		dy = dojo.dnd.V_AUTOSCROLL_VALUE;
+	}
+	window.scrollBy(dx, dy);
+};
+
+dojo.dnd._validNodes = {"div": 1, "p": 1, "td": 1};
+dojo.dnd._validOverflow = {"auto": 1, "scroll": 1};
+
+dojo.dnd.autoScrollNodes = function(e){
+	// summary:
+	//		a handler for onmousemove event, which scrolls the first avaialble
+	//		Dom element, it falls back to dojo.dnd.autoScroll()
+	// e: Event
+	//		onmousemove event
+
+	// FIXME: needs more docs!
+
+	var b, t, w, h, rx, ry, dx = 0, dy = 0, oldLeft, oldTop;
+
+	for(var n = e.target; n;){
+		if(n.nodeType == 1 && (n.tagName.toLowerCase() in dojo.dnd._validNodes)){
+			var s = dojo.getComputedStyle(n),
+				overflow = (s.overflow.toLowerCase() in dojo.dnd._validOverflow),
+				overflowX = (s.overflowX.toLowerCase() in dojo.dnd._validOverflow),
+				overflowY = (s.overflowY.toLowerCase() in dojo.dnd._validOverflow);
+			if(overflow || overflowX || overflowY){
+				b = dojo._getContentBox(n, s);
+				t = dojo.position(n, true);
+			}
+			// overflow-x
+			if(overflow || overflowX){
+				w = Math.min(dojo.dnd.H_TRIGGER_AUTOSCROLL, b.w / 2);
+				rx = e.pageX - t.x;
+				if(dojo.isWebKit || dojo.isOpera){
+					// FIXME: this code should not be here, it should be taken into account
+					// either by the event fixing code, or the dojo.position()
+					// FIXME: this code doesn't work on Opera 9.5 Beta
+					rx += dojo.body().scrollLeft;
+				}
+				dx = 0;
+				if(rx > 0 && rx < b.w){
+					if(rx < w){
+						dx = -w;
+					}else if(rx > b.w - w){
+						dx = w;
+					}
+					oldLeft = n.scrollLeft;
+					n.scrollLeft = n.scrollLeft + dx;
+				}
+			}
+			// overflow-y
+			if(overflow || overflowY){
+				//console.log(b.l, b.t, t.x, t.y, n.scrollLeft, n.scrollTop);
+				h = Math.min(dojo.dnd.V_TRIGGER_AUTOSCROLL, b.h / 2);
+				ry = e.pageY - t.y;
+				if(dojo.isWebKit || dojo.isOpera){
+					// FIXME: this code should not be here, it should be taken into account
+					// either by the event fixing code, or the dojo.position()
+					// FIXME: this code doesn't work on Opera 9.5 Beta
+					ry += dojo.body().scrollTop;
+				}
+				dy = 0;
+				if(ry > 0 && ry < b.h){
+					if(ry < h){
+						dy = -h;
+					}else if(ry > b.h - h){
+						dy = h;
+					}
+					oldTop = n.scrollTop;
+					n.scrollTop  = n.scrollTop  + dy;
+				}
+			}
+			if(dx || dy){ return; }
+		}
+		try{
+			n = n.parentNode;
+		}catch(x){
+			n = null;
+		}
+	}
+	dojo.dnd.autoScroll(e);
+};
+
+	return dojo.dnd;
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/common.js b/js/dojo-1.7.2/dojo/dnd/common.js
new file mode 100644
index 0000000..6de1291
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/common.js
@@ -0,0 +1,36 @@
+//>>built
+define("dojo/dnd/common", ["../main"], function(dojo) {
+	// module:
+	//		dojo/dnd/common
+	// summary:
+	//		TODOC
+
+dojo.getObject("dnd", true, dojo);
+
+dojo.dnd.getCopyKeyState = dojo.isCopyKey;
+
+dojo.dnd._uniqueId = 0;
+dojo.dnd.getUniqueId = function(){
+	// summary:
+	//		returns a unique string for use with any DOM element
+	var id;
+	do{
+		id = dojo._scopeName + "Unique" + (++dojo.dnd._uniqueId);
+	}while(dojo.byId(id));
+	return id;
+};
+
+dojo.dnd._empty = {};
+
+dojo.dnd.isFormElement = function(/*Event*/ e){
+	// summary:
+	//		returns true if user clicked on a form element
+	var t = e.target;
+	if(t.nodeType == 3 /*TEXT_NODE*/){
+		t = t.parentNode;
+	}
+	return " button textarea input select option ".indexOf(" " + t.tagName.toLowerCase() + " ") >= 0;	// Boolean
+};
+
+return dojo.dnd;
+});
diff --git a/js/dojo-1.7.2/dojo/dnd/move.js b/js/dojo-1.7.2/dojo/dnd/move.js
new file mode 100644
index 0000000..1faf24a
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dnd/move.js
@@ -0,0 +1,144 @@
+//>>built
+define("dojo/dnd/move", ["../main", "./Mover", "./Moveable"], function(dojo) {
+	// module:
+	//		dojo/dnd/move
+	// summary:
+	//		TODOC
+
+
+/*=====
+dojo.declare("dojo.dnd.move.__constrainedMoveableArgs", [dojo.dnd.__MoveableArgs], {
+	// constraints: Function
+	//		Calculates a constraint box.
+	//		It is called in a context of the moveable object.
+	constraints: function(){},
+
+	// within: Boolean
+	//		restrict move within boundaries.
+	within: false
+});
+=====*/
+
+dojo.declare("dojo.dnd.move.constrainedMoveable", dojo.dnd.Moveable, {
+	// object attributes (for markup)
+	constraints: function(){},
+	within: false,
+
+	constructor: function(node, params){
+		// summary:
+		//		an object that makes a node moveable
+		// node: Node
+		//		a node (or node's id) to be moved
+		// params: dojo.dnd.move.__constrainedMoveableArgs?
+		//		an optional object with additional parameters;
+		//		the rest is passed to the base class
+		if(!params){ params = {}; }
+		this.constraints = params.constraints;
+		this.within = params.within;
+	},
+	onFirstMove: function(/* dojo.dnd.Mover */ mover){
+		// summary:
+		//		called during the very first move notification;
+		//		can be used to initialize coordinates, can be overwritten.
+		var c = this.constraintBox = this.constraints.call(this, mover);
+		c.r = c.l + c.w;
+		c.b = c.t + c.h;
+		if(this.within){
+			var mb = dojo._getMarginSize(mover.node);
+			c.r -= mb.w;
+			c.b -= mb.h;
+		}
+	},
+	onMove: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop){
+		// summary:
+		//		called during every move notification;
+		//		should actually move the node; can be overwritten.
+		var c = this.constraintBox, s = mover.node.style;
+		this.onMoving(mover, leftTop);
+		leftTop.l = leftTop.l < c.l ? c.l : c.r < leftTop.l ? c.r : leftTop.l;
+		leftTop.t = leftTop.t < c.t ? c.t : c.b < leftTop.t ? c.b : leftTop.t;
+		s.left = leftTop.l + "px";
+		s.top  = leftTop.t + "px";
+		this.onMoved(mover, leftTop);
+	}
+});
+
+/*=====
+dojo.declare("dojo.dnd.move.__boxConstrainedMoveableArgs", [dojo.dnd.move.__constrainedMoveableArgs], {
+	// box: Object
+	//		a constraint box
+	box: {}
+});
+=====*/
+
+dojo.declare("dojo.dnd.move.boxConstrainedMoveable", dojo.dnd.move.constrainedMoveable, {
+	// box:
+	//		object attributes (for markup)
+	box: {},
+
+	constructor: function(node, params){
+		// summary:
+		//		an object, which makes a node moveable
+		// node: Node
+		//		a node (or node's id) to be moved
+		// params: dojo.dnd.move.__boxConstrainedMoveableArgs?
+		//		an optional object with parameters
+		var box = params && params.box;
+		this.constraints = function(){ return box; };
+	}
+});
+
+/*=====
+dojo.declare("dojo.dnd.move.__parentConstrainedMoveableArgs", [dojo.dnd.move.__constrainedMoveableArgs], {
+	// area: String
+	//		A parent's area to restrict the move.
+	//		Can be "margin", "border", "padding", or "content".
+	area: ""
+});
+=====*/
+
+dojo.declare("dojo.dnd.move.parentConstrainedMoveable", dojo.dnd.move.constrainedMoveable, {
+	// area:
+	//		object attributes (for markup)
+	area: "content",
+
+	constructor: function(node, params){
+		// summary:
+		//		an object, which makes a node moveable
+		// node: Node
+		//		a node (or node's id) to be moved
+		// params: dojo.dnd.move.__parentConstrainedMoveableArgs?
+		//		an optional object with parameters
+		var area = params && params.area;
+		this.constraints = function(){
+			var n = this.node.parentNode,
+				s = dojo.getComputedStyle(n),
+				mb = dojo._getMarginBox(n, s);
+			if(area == "margin"){
+				return mb;	// Object
+			}
+			var t = dojo._getMarginExtents(n, s);
+			mb.l += t.l, mb.t += t.t, mb.w -= t.w, mb.h -= t.h;
+			if(area == "border"){
+				return mb;	// Object
+			}
+			t = dojo._getBorderExtents(n, s);
+			mb.l += t.l, mb.t += t.t, mb.w -= t.w, mb.h -= t.h;
+			if(area == "padding"){
+				return mb;	// Object
+			}
+			t = dojo._getPadExtents(n, s);
+			mb.l += t.l, mb.t += t.t, mb.w -= t.w, mb.h -= t.h;
+			return mb;	// Object
+		};
+	}
+});
+
+// patching functions one level up for compatibility
+
+dojo.dnd.constrainedMover = dojo.dnd.move.constrainedMover;
+dojo.dnd.boxConstrainedMover = dojo.dnd.move.boxConstrainedMover;
+dojo.dnd.parentConstrainedMover = dojo.dnd.move.parentConstrainedMover;
+
+return dojo.dnd.move;
+});
diff --git a/js/dojo-1.7.2/dojo/dojo.js b/js/dojo-1.7.2/dojo/dojo.js
new file mode 100644
index 0000000..9f5f7d5
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dojo.js
@@ -0,0 +1,15 @@
+/*
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+/*
+	This is an optimized version of Dojo, built for deployment and not for
+	development. To get sources and documentation, please visit:
+
+		http://dojotoolkit.org
+*/
+
+//>>built
+(function(_1,_2){var _3=function(){},_4=function(it){for(var p in it){return 0;}return 1;},_5={}.toString,_6=function(it){return _5.call(it)=="[object Function]";},_7=function(it){return _5.call(it)=="[object String]";},_8=function(it){return _5.call(it)=="[object Array]";},_9=function(_a,_b){if(_a){for(var i=0;i<_a.length;){_b(_a[i++]);}}},_c=function(_d,_e){for(var p in _e){_d[p]=_e[p];}return _d;},_f=function(_10,_11){return _c(new Error(_10),{src:"dojoLoader",info:_11});},_12=1,uid=function(){return "_"+_12++;},req=function(_13,_14,_15){return _16(_13,_14,_15,0,req);},_17=this,doc=_17.document,_18=doc&&doc.createElement("DiV"),has=req.has=function(_19){return _6(_1a[_19])?(_1a[_19]=_1a[_19](_17,doc,_18)):_1a[_19];},_1a=has.cache=_2.hasCache;has.add=function(_1b,_1c,now,_1d){(_1a[_1b]===undefined||_1d)&&(_1a[_1b]=_1c);return now&&has(_1b);};false&&has.add("host-node",typeof process=="object"&&/node(\.exe)?$/.test(process.execPath));if(0){require("./_base/configNode.js").config(_2);_2.loaderPatch.nodeRequire=require;}false&&has.add("host-rhino",typeof load=="function"&&(typeof Packages=="function"||typeof Packages=="object"));if(0){for(var _1e=_1.baseUrl||".",arg,_1f=this.arguments,i=0;i<_1f.length;){arg=(_1f[i++]+"").split("=");if(arg[0]=="baseUrl"){_1e=arg[1];break;}}load(_1e+"/_base/configRhino.js");rhinoDojoConfig(_2,_1e,_1f);}for(var p in _1.has){has.add(p,_1.has[p],0,1);}var _20=1,_21=2,_22=3,_23=4,_24=5;if(0){_20="requested";_21="arrived";_22="not-a-module";_23="executing";_24="executed";}var _25=0,_26="sync",xd="xd",_27=[],_28=0,_29=_3,_2a=_3,_2b;if(1){req.isXdUrl=_3;req.initSyncLoader=function(_2c,_2d,_2e){if(!_28){_28=_2c;_29=_2d;_2a=_2e;}return {sync:_26,xd:xd,arrived:_21,nonmodule:_22,executing:_23,executed:_24,syncExecStack:_27,modules:_2f,execQ:_30,getModule:_31,injectModule:_32,setArrived:_33,signal:_34,finishExec:_35,execModule:_36,dojoRequirePlugin:_28,getLegacyMode:function(){return _25;},holdIdle:function(){_74++;},releaseIdle:function(){_37();}};};if(1){var _38=location.protocol,_39=location.host,_3a=!_39;req.isXdUrl=function(url){if(_3a||/^\./.test(url)){return false;}if(/^\/\//.test(url)){return true;}var _3b=url.match(/^([^\/\:]+\:)\/\/([^\/]+)/);return _3b&&(_3b[1]!=_38||_3b[2]!=_39);};true||has.add("dojo-xhr-factory",1);has.add("dojo-force-activex-xhr",1&&!doc.addEventListener&&window.location.protocol=="file:");has.add("native-xhr",typeof XMLHttpRequest!="undefined");if(has("native-xhr")&&!has("dojo-force-activex-xhr")){_2b=function(){return new XMLHttpRequest();};}else{for(var _3c=["Msxml2.XMLHTTP","Microsoft.XMLHTTP","Msxml2.XMLHTTP.4.0"],_3d,i=0;i<3;){try{_3d=_3c[i++];if(new ActiveXObject(_3d)){break;}}catch(e){}}_2b=function(){return new ActiveXObject(_3d);};}req.getXhr=_2b;has.add("dojo-gettext-api",1);req.getText=function(url,_3e,_3f){var xhr=_2b();xhr.open("GET",_40(url),false);xhr.send(null);if(xhr.status==200||(!location.host&&!xhr.status)){if(_3f){_3f(xhr.responseText,_3e);}}else{throw _f("xhrFailed",xhr.status);}return xhr.responseText;};}}else{req.async=1;}var _41=new Function("__text","return eval(__text);");req.eval=function(_42,_43){return _41(_42+"\r\n////@ sourceURL="+_43);};var _44={},_45="error",_34=req.signal=function(_46,_47){var _48=_44[_46];_9(_48&&_48.slice(0),function(_49){_49.apply(null,_8(_47)?_47:[_47]);});},on=req.on=function(_4a,_4b){var _4c=_44[_4a]||(_44[_4a]=[]);_4c.push(_4b);return {remove:function(){for(var i=0;i<_4c.length;i++){if(_4c[i]===_4b){_4c.splice(i,1);return;}}}};};var _4d=[],_4e={},_4f=[],_50={},_51={},_52=[],_2f={},_53="",_54={},_55={},_56={};if(1){var _57=function(_58){for(var p in _55){var _59=p.match(/^url\:(.+)/);if(_59){_54[_5a(_59[1],_58)]=_55[p];}else{if(p!="*noref"){_54[_5b(p,_58).mid]=_55[p];}}}_55={};},_5c=function(map,_5d,_5e){_5d.splice(0,_5d.length);var p,i,_5f,_60=0;for(p in map){_5d.push([p,map[p]]);if(map[p]==_5e){_60=p;}}_5d.sort(function(lhs,rhs){return rhs[0].length-lhs[0].length;});for(i=0;i<_5d.length;){_5f=_5d[i++];_5f[2]=new RegExp("^"+_5f[0].replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g,function(c){return "\\"+c;})+"(/|$)");_5f[3]=_5f[0].length+1;}return _60;},_61=function(_62,_63){var _64=_62.name;if(!_64){_64=_62;_62={name:_64};}_62=_c({main:"main",mapProg:[]},_62);_62.location=(_63||"")+(_62.location?_62.location:_64);_62.reverseName=_5c(_62.packageMap,_62.mapProg,_64);if(!_62.main.indexOf("./")){_62.main=_62.main.substring(2);}_c(_4e,_62.paths);_50[_64]=_62;_51[_64]=_64;},_65=function(_66,_67){for(var p in _66){if(p=="waitSeconds"){req.waitms=(_66[p]||0)*1000;}if(p=="cacheBust"){_53=_66[p]?(_7(_66[p])?_66[p]:(new Date()).getTime()+""):"";}if(p=="baseUrl"||p=="combo"){req[p]=_66[p];}if(1&&p=="async"){var _68=_66[p];req.legacyMode=_25=(_7(_68)&&/sync|legacyAsync/.test(_68)?_68:(!_68?"sync":false));req.async=!_25;}if(_66[p]!==_1a){req.rawConfig[p]=_66[p];p!="has"&&has.add("config-"+p,_66[p],0,_67);}}if(!req.baseUrl){req.baseUrl="./";}if(!/\/$/.test(req.baseUrl)){req.baseUrl+="/";}for(p in _66.has){has.add(p,_66.has[p],0,_67);}_9(_66.packages,_61);for(_1e in _66.packagePaths){_9(_66.packagePaths[_1e],function(_69){_61(_69,_1e+"/");});}_5c(_c(_4e,_66.paths),_4f);_9(_66.aliases,function(_6a){if(_7(_6a[0])){_6a[0]=new RegExp("^"+_6a[0].replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g,function(c){return "\\"+c;})+"$");}_4d.push(_6a);});_5c(_c(_51,_66.packageMap),_52);if(_66.cache){_57();_55=_66.cache;if(_66.cache["*noref"]){_57();}}_34("config",[_66,req.rawConfig]);};if(has("dojo-cdn")||1){for(var _6b,src,_6c,_6d=doc.getElementsByTagName("script"),i=0;i<_6d.length&&!_6c;i++){if((src=_6d[i].getAttribute("src"))&&(_6c=src.match(/(.*)\/?dojo\.js(\W|$)/i))){_1.baseUrl=_6b=_1.baseUrl||_2.baseUrl||_6c[1];src=(_6d[i].getAttribute("data-dojo-config")||_6d[i].getAttribute("djConfig"));if(src){_56=req.eval("({ "+src+" })","data-dojo-config");}if(0){var _6e=_6d[i].getAttribute("data-main");if(_6e){_56.deps=_56.deps||[_6e];}}}}}if(0){try{if(window.parent!=window&&window.parent.require){var doh=window.parent.require("doh");doh&&_c(_56,doh.testConfig);}}catch(e){}}req.rawConfig={};_65(_2,1);_65(_1,1);_65(_56,1);if(has("dojo-cdn")){_50.dojo.location=_6b;_50.dijit.location=_6b+"../dijit/";_50.dojox.location=_6b+"../dojox/";}}else{_4e=_2.paths;_4f=_2.pathsMapProg;_50=_2.packs;_4d=_2.aliases;_51=_2.packageMap;_52=_2.packageMapProg;_2f=_2.modules;_54=_2.cache;_53=_2.cacheBust;req.rawConfig=_2;}if(0){req.combo=req.combo||{add:_3};var _6f=0,_70=[],_71=null;}var _72=function(_73){_74++;_9(_73.deps,_32);if(0&&_6f&&!_71){_71=setTimeout(function(){_6f=0;_71=null;req.combo.done(function(_75,url){var _76=function(){_77(0,_75);_78();};_70.push(_75);_79=_75;req.injectUrl(url,_76,_75);_79=0;},req);},0);}_37();},_16=function(a1,a2,a3,_7a,_7b){var _7c,_7d;if(_7(a1)){_7c=_31(a1,_7a,true);if(_7c&&_7c.executed){return _7c.result;}throw _f("undefinedModule",a1);}if(!_8(a1)){_65(a1);a1=a2;a2=a3;}if(_8(a1)){if(!a1.length){a2&&a2();}else{_7d="require*"+uid();for(var mid,_7e=[],i=0;i<a1.length;){mid=a1[i++];if(mid in {exports:1,module:1}){throw _f("illegalModuleId",mid);}_7e.push(_31(mid,_7a));}_7c=_c(_7f("",_7d,0,""),{injected:_21,deps:_7e,def:a2||_3,require:_7a?_7a.require:req});_2f[_7c.mid]=_7c;_72(_7c);var _80=_74&&req.async;_74++;_36(_7c,_80);_37();if(!_7c.executed){_30.push(_7c);}_78();}}return _7b;},_81=function(_82){if(!_82){return req;}var _83=_82.require;if(!_83){_83=function(a1,a2,a3){return _16(a1,a2,a3,_82,_83);};_82.require=_c(_83,req);_83.module=_82;_83.toUrl=function(_84){return _5a(_84,_82);};_83.toAbsMid=function(mid){return _af(mid,_82);};if(0){_83.undef=function(mid){req.undef(mid,_82);};}}return _83;},_30=[],_85=[],_86={},_87=function(_88){_88.injected=_20;_86[_88.mid]=1;if(_88.url){_86[_88.url]=_88.pack||1;}},_33=function(_89){_89.injected=_21;delete _86[_89.mid];if(_89.url){delete _86[_89.url];}if(_4(_86)){_8a();1&&_25==xd&&(_25=_26);}},_8b=req.idle=function(){return !_85.length&&_4(_86)&&!_30.length&&!_74;},_8c=function(_8d,map){for(var i=0;i<map.length;i++){if(map[i][2].test(_8d)){return map[i];}}return 0;},_8e=function(_8f){var _90=[],_91,_92;_8f=_8f.replace(/\\/g,"/").split("/");while(_8f.length){_91=_8f.shift();if(_91==".."&&_90.length&&_92!=".."){_90.pop();_92=_90[_90.length-1];}else{if(_91!="."){_90.push(_92=_91);}}}return _90.join("/");},_7f=function(pid,mid,_93,url,_94){if(1){var xd=req.isXdUrl(url);return {pid:pid,mid:mid,pack:_93,url:url,executed:0,def:0,isXd:xd,isAmd:!!(xd||(_50[pid]&&_50[pid].isAmd)),cacheId:_94};}else{return {pid:pid,mid:mid,pack:_93,url:url,executed:0,def:0,cacheId:_94};}},_95=function(mid,_96,_97,_98,_99,_9a,_9b,_9c){var pid,_9d,_9e,_9f,_a0,_a1,url,_a2,_a3,_a4,_a5=0;_a4=mid;_a3=/^\./.test(mid);if(/(^\/)|(\:)|(\.js$)/.test(mid)||(_a3&&!_96)){return _7f(0,mid,0,mid);}else{mid=_8e(_a3?(_96.mid+"/../"+mid):mid);if(/^\./.test(mid)){throw _f("irrationalPath",mid);}_9f=_96&&_96.pack&&_96.pack.mapProg;_a0=(_9f&&_8c(mid,_9f))||_8c(mid,_9a);if(_a0){pid=_a0[1];mid=mid.substring(_a0[3]);_9d=_97[pid];if(!mid){mid=_9d.main;}_9e=mid;_a5=_9d.reverseName+"/"+mid;mid=pid+"/"+mid;}else{pid="";}var _a6=0,_a7=0;_9(_4d,function(_a8){var _a9=mid.match(_a8[0]);if(_a9&&_a9.length>_a6){_a7=_6(_a8[1])?mid.replace(_a8[0],_a8[1]):_a8[1];}});if(_a7){return _95(_a7,0,_97,_98,_99,_9a,_9b,_9c);}_a2=_98[mid];if(_a2){return _9c?_7f(_a2.pid,_a2.mid,_a2.pack,_a2.url,_a5):_98[mid];}}_a0=_8c(mid,_9b);if(_a0){url=_a0[1]+mid.substring(_a0[3]-1);}else{if(pid){url=_9d.location+"/"+_9e;}else{if(has("config-tlmSiblingOfDojo")){url="../"+mid;}else{url=mid;}}}if(!(/(^\/)|(\:)/.test(url))){url=_99+url;}url+=".js";return _7f(pid,mid,_9d,_8e(url),_a5);},_5b=function(mid,_aa){return _95(mid,_aa,_50,_2f,req.baseUrl,_52,_4f);},_ab=function(_ac,_ad,_ae){return _ac.normalize?_ac.normalize(_ad,function(mid){return _af(mid,_ae);}):_af(_ad,_ae);},_b0=0,_31=function(mid,_b1,_b2){var _b3,_b4,_b5,_b6;_b3=mid.match(/^(.+?)\!(.*)$/);if(_b3){_b4=_31(_b3[1],_b1,_b2);if(1&&_25==_26&&!_b4.executed){_32(_b4);if(_b4.injected===_21&&!_b4.executed){_74++;_36(_b4);_37();}if(_b4.executed){_b7(_b4);}else{_30.unshift(_b4);}}if(_b4.executed===_24&&!_b4.load){_b7(_b4);}if(_b4.load){_b5=_ab(_b4,_b3[2],_b1);mid=(_b4.mid+"!"+(_b4.dynamic?++_b0+"!":"")+_b5);}else{_b5=_b3[2];mid=_b4.mid+"!"+(++_b0)+"!waitingForPlugin";}_b6={plugin:_b4,mid:mid,req:_81(_b1),prid:_b5};}else{_b6=_5b(mid,_b1);}return _2f[_b6.mid]||(!_b2&&(_2f[_b6.mid]=_b6));},_af=req.toAbsMid=function(mid,_b8){return _5b(mid,_b8).mid;},_5a=req.toUrl=function(_b9,_ba){var _bb=_b9.match(/(.+)(\.[^\/\.]+?)$/),_bc=(_bb&&_bb[1])||_b9,ext=(_bb&&_bb[2])||"",_bd=_5b(_bc,_ba),url=_bd.url;url=typeof _bd.pid=="string"?url.substring(0,url.length-3):url;return _40(url+ext);},_be={injected:_21,executed:_24,def:_22,result:_22},_bf=function(mid){return _2f[mid]=_c({mid:mid},_be);},_c0=_bf("require"),_c1=_bf("exports"),_c2=_bf("module"),_c3=function(_c4,_c5){req.trace("loader-run-factory",[_c4.mid]);var _c6=_c4.def,_c7;1&&_27.unshift(_c4);if(has("config-dojo-loader-catches")){try{_c7=_6(_c6)?_c6.apply(null,_c5):_c6;}catch(e){_34(_45,_c4.result=_f("factoryThrew",[_c4,e]));}}else{_c7=_6(_c6)?_c6.apply(null,_c5):_c6;}_c4.result=_c7===undefined&&_c4.cjs?_c4.cjs.exports:_c7;1&&_27.shift(_c4);},_c8={},_c9=0,_b7=function(_ca){var _cb=_ca.result;_ca.dynamic=_cb.dynamic;_ca.normalize=_cb.normalize;_ca.load=_cb.load;return _ca;},_cc=function(_cd){var map={};_9(_cd.loadQ,function(_ce){var _cf=_ce.mid,_d0=_ab(_cd,_ce.prid,_ce.req.module),mid=_cd.dynamic?_ce.mid.replace(/waitingForPlugin$/,_d0):(_cd.mid+"!"+_d0),_d1=_c(_c({},_ce),{mid:mid,prid:_d0,injected:0});if(!_2f[mid]){_e2(_2f[mid]=_d1);}map[_ce.mid]=_2f[mid];_33(_ce);delete _2f[_ce.mid];});_cd.loadQ=0;var _d2=function(_d3){for(var _d4,_d5=_d3.deps||[],i=0;i<_d5.length;i++){_d4=map[_d5[i].mid];if(_d4){_d5[i]=_d4;}}};for(var p in _2f){_d2(_2f[p]);}_9(_30,_d2);},_35=function(_d6){req.trace("loader-finish-exec",[_d6.mid]);_d6.executed=_24;_d6.defOrder=_c9++;1&&_9(_d6.provides,function(cb){cb();});if(_d6.loadQ){_b7(_d6);_cc(_d6);}for(i=0;i<_30.length;){if(_30[i]===_d6){_30.splice(i,1);}else{i++;}}},_d7=[],_36=function(_d8,_d9){if(_d8.executed===_23){req.trace("loader-circular-dependency",[_d7.concat(mid).join("->")]);return (!_d8.def||_d9)?_c8:(_d8.cjs&&_d8.cjs.exports);}if(!_d8.executed){if(!_d8.def){return _c8;}var mid=_d8.mid,_da=_d8.deps||[],arg,_db,_dc=[],i=0;if(0){_d7.push(mid);req.trace("loader-exec-module",["exec",_d7.length,mid]);}_d8.executed=_23;while(i<_da.length){arg=_da[i++];_db=((arg===_c0)?_81(_d8):((arg===_c1)?_d8.cjs.exports:((arg===_c2)?_d8.cjs:_36(arg,_d9))));if(_db===_c8){_d8.executed=0;req.trace("loader-exec-module",["abort",mid]);0&&_d7.pop();return _c8;}_dc.push(_db);}_c3(_d8,_dc);_35(_d8);}0&&_d7.pop();return _d8.result;},_74=0,_78=function(){if(_74){return;}_74++;_29();for(var _dd,_de,i=0;i<_30.length;){_dd=_c9;_de=_30[i];_36(_de);if(_dd!=_c9){_29();i=0;}else{i++;}}_37();},_37=function(){_74--;if(_8b()){_34("idle",[]);}};if(0){req.undef=function(_df,_e0){var _e1=_31(_df,_e0);_33(_e1);delete _2f[_e1.mid];};}if(1){if(has("dojo-loader-eval-hint-url")===undefined){has.add("dojo-loader-eval-hint-url",1);}var _40=function(url){url+="";return url+(_53?((/\?/.test(url)?"&":"?")+_53):"");},_e2=function(_e3){var _e4=_e3.plugin;if(_e4.executed===_24&&!_e4.load){_b7(_e4);}var _e5=function(def){_e3.result=def;_33(_e3);_35(_e3);_78();};_87(_e3);if(_e4.load){_e4.load(_e3.prid,_e3.req,_e5);}else{if(_e4.loadQ){_e4.loadQ.push(_e3);}else{_30.unshift(_e4);_32(_e4);if(_e4.load){_e4.load(_e3.prid,_e3.req,_e5);}else{_e4.loadQ=[_e3];}}}},_e6=0,_79=0,_e7=0,_e8=function(_e9,_ea){_e7=1;if(has("config-dojo-loader-catches")){try{if(_e9===_e6){_e6.call(null);}else{req.eval(_e9,has("dojo-loader-eval-hint-url")?_ea.url:_ea.mid);}}catch(e){_34(_45,_f("evalModuleThrew",_ea));}}else{if(_e9===_e6){_e6.call(null);}else{req.eval(_e9,has("dojo-loader-eval-hint-url")?_ea.url:_ea.mid);}}_e7=0;},_32=function(_eb){var mid=_eb.mid,url=_eb.url;if(_eb.executed||_eb.injected||_86[mid]||(_eb.url&&((_eb.pack&&_86[_eb.url]===_eb.pack)||_86[_eb.url]==1))){return;}if(0){var _ec=0;if(_eb.plugin&&_eb.plugin.isCombo){req.combo.add(_eb.plugin.mid,_eb.prid,0,req);_ec=1;}else{if(!_eb.plugin){_ec=req.combo.add(0,_eb.mid,_eb.url,req);}}if(_ec){_87(_eb);_6f=1;return;}}if(_eb.plugin){_e2(_eb);return;}_87(_eb);var _ed=function(){_77(_eb);if(_eb.injected!==_21){_33(_eb);_c(_eb,_be);}if(1&&_25){!_27.length&&_78();}else{_78();}};_e6=_54[mid]||_54[_eb.cacheId];if(_e6){req.trace("loader-inject",["cache",_eb.mid,url]);_e8(_e6,_eb);_ed();return;}if(1&&_25){if(_eb.isXd){_25==_26&&(_25=xd);}else{if(_eb.isAmd&&_25!=_26){}else{var _ee=function(_ef){if(_25==_26){_27.unshift(_eb);_e8(_ef,_eb);_27.shift();_77(_eb);if(!_eb.cjs){_33(_eb);_35(_eb);}if(_eb.finish){var _f0=mid+"*finish",_f1=_eb.finish;delete _eb.finish;def(_f0,["dojo",("dojo/require!"+_f1.join(",")).replace(/\./g,"/")],function(_f2){_9(_f1,function(mid){_f2.require(mid);});});_30.unshift(_31(_f0));}_ed();}else{_ef=_2a(_eb,_ef);if(_ef){_e8(_ef,_eb);_ed();}else{_79=_eb;req.injectUrl(_40(url),_ed,_eb);_79=0;}}};req.trace("loader-inject",["xhr",_eb.mid,url,_25!=_26]);if(has("config-dojo-loader-catches")){try{req.getText(url,_25!=_26,_ee);}catch(e){_34(_45,_f("xhrInjectFailed",[_eb,e]));}}else{req.getText(url,_25!=_26,_ee);}return;}}}req.trace("loader-inject",["script",_eb.mid,url]);_79=_eb;req.injectUrl(_40(url),_ed,_eb);_79=0;},_f3=function(_f4,_f5,def){req.trace("loader-define-module",[_f4.mid,_f5]);if(0&&_f4.plugin&&_f4.plugin.isCombo){_f4.result=_6(def)?def():def;_33(_f4);_35(_f4);return _f4;}var mid=_f4.mid;if(_f4.injected===_21){_34(_45,_f("multipleDefine",_f4));return _f4;}_c(_f4,{deps:_f5,def:def,cjs:{id:_f4.mid,uri:_f4.url,exports:(_f4.result={}),setExports:function(_f6){_f4.cjs.exports=_f6;}}});for(var i=0;i<_f5.length;i++){_f5[i]=_31(_f5[i],_f4);}if(1&&_25&&!_86[mid]){_72(_f4);_30.push(_f4);_78();}_33(_f4);if(!_6(def)&&!_f5.length){_f4.result=def;_35(_f4);}return _f4;},_77=function(_f7,_f8){_57(_f7);var _f9=[],_fa,_fb;while(_85.length){_fb=_85.shift();_f8&&(_fb[0]=_f8.shift());_fa=_fb[0]&&_31(_fb[0])||_f7;_f9.push(_f3(_fa,_fb[1],_fb[2]));}_9(_f9,_72);};}var _fc=0,_8a=_3,_fd=_3;if(1){_8a=function(){_fc&&clearTimeout(_fc);_fc=0;},_fd=function(){_8a();req.waitms&&(_fc=setTimeout(function(){_8a();_34(_45,_f("timeout",_86));},req.waitms));};}if(1){has.add("ie-event-behavior",doc.attachEvent&&(typeof opera==="undefined"||opera.toString()!="[object Opera]"));}if(1&&(1||1)){var _fe=function(_ff,_100,_101,_102){if(!has("ie-event-behavior")){_ff.addEventListener(_100,_102,false);return function(){_ff.removeEventListener(_100,_102,false);};}else{_ff.attachEvent(_101,_102);return function(){_ff.detachEvent(_101,_102);};}},_103=_fe(window,"load","onload",function(){req.pageLoaded=1;doc.readyState!="complete"&&(doc.readyState="complete");_103();});if(1){var _104=doc.getElementsByTagName("script")[0],_105=_104.parentNode;req.injectUrl=function(url,_106,_107){_fd();var node=_107.node=doc.createElement("script"),_108=function(e){e=e||window.event;var node=e.target||e.srcElement;if(e.type==="load"||/complete|loaded/.test(node.readyState)){_109();_106&&_106();}},_109=_fe(node,"load","onreadystatechange",_108);node.type="text/javascript";node.charset="utf-8";node.src=url;_105.insertBefore(node,_104);return node;};}}if(1){req.log=function(){try{for(var i=0;i<arguments.length;i++){}}catch(e){}};}else{req.log=_3;}if(0){var _10a=req.trace=function(_10b,args){if(_10a.on&&_10a.group[_10b]){_34("trace",[_10b,args]);for(var arg,dump=[],text="trace:"+_10b+(args.length?(":"+args[0]):""),i=1;i<args.length;){arg=args[i++];if(_7(arg)){text+=", "+arg;}else{dump.push(arg);}}req.log(text);dump.length&&dump.push(".");req.log.apply(req,dump);}};_c(_10a,{on:1,group:{},set:function(_10c,_10d){if(_7(_10c)){_10a.group[_10c]=_10d;}else{_c(_10a.group,_10c);}}});_10a.set(_c(_c(_c({},_2.trace),_1.trace),_56.trace));on("config",function(_10e){_10e.trace&&_10a.set(_10e.trace);});}else{req.trace=_3;}var def=function(mid,_10f,_110){var _111=arguments.length,args=0,_112=["require","exports","module"];if(0){if(_111==1&&_6(mid)){_10f=[];mid.toString().replace(/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,"").replace(/require\(["']([\w\!\-_\.\/]+)["']\)/g,function(_113,dep){_10f.push(dep);});args=[0,_112.concat(_10f),mid];}}if(!args){args=_111==1?[0,_112,mid]:(_111==2?(_8(mid)?[0,mid,_10f]:(_6(_10f)?[mid,_112,_10f]:[mid,[],_10f])):[mid,_10f,_110]);}req.trace("loader-define",args.slice(0,2));var _114=args[0]&&_31(args[0]),_115;if(_114&&!_86[_114.mid]){_72(_f3(_114,args[1],args[2]));}else{if(!has("ie-event-behavior")||!1||_e7){_85.push(args);}else{_114=_114||_79;if(!_114){for(mid in _86){_115=_2f[mid];if(_115&&_115.node&&_115.node.readyState==="interactive"){_114=_115;break;}}if(0&&!_114){for(var i=0;i<_70.length;i++){_114=_70[i];if(_114.node&&_114.node.readyState==="interactive"){break;}_114=0;}}}if(0&&_8(_114)){_72(_f3(_31(_114.shift()),args[1],args[2]));if(!_114.length){_70.splice(i,1);}}else{if(_114){_57(_114);_72(_f3(_114,args[1],args[2]));}else{_34(_45,_f("ieDefineFailed",args[0]));}}_78();}}};def.amd={vendor:"dojotoolkit.org"};if(0){req.def=def;}_c(_c(req,_2.loaderPatch),_1.loaderPatch);on(_45,function(arg){try{console.error(arg);if(arg instanceof Error){for(var p in arg){}}}catch(e){}});_c(req,{uid:uid,cache:_54,packs:_50});if(0){_c(req,{paths:_4e,aliases:_4d,packageMap:_51,modules:_2f,legacyMode:_25,execQ:_30,defQ:_85,waiting:_86,pathsMapProg:_4f,packageMapProg:_52,listenerQueues:_44,computeMapProg:_5c,runMapProg:_8c,compactPath:_8e,getModuleInfo:_95});}if(_17.define){if(1){_34(_45,_f("defineAlreadyDefined",0));}}else{_17.define=def;_17.require=req;}if(0&&req.combo&&req.combo.plugins){var _116=req.combo.plugins,_117;for(_117 in _116){_c(_c(_31(_117),_116[_117]),{isCombo:1,executed:"executed",load:1});}}if(1){var _118=_2.deps||_1.deps||_56.deps,_119=_2.callback||_1.callback||_56.callback;req.boot=(_118||_119)?[_118||[],_119]:0;}if(!1){!req.async&&req(["dojo"]);req.boot&&req.apply(null,req.boot);}})(this.dojoConfig||this.djConfig||this.require||{},{async:0,hasCache:{"config-selectorEngine":"acme","config-tlmSiblingOfDojo":1,"dojo-built":1,"dojo-loader":1,dom:1,"host-browser":1},packages:[{location:"../dijit",name:"dijit"},{location:"../dojox",name:"dojox"},{location:".",name:"dojo"}]});require({cache:{"dojo/_base/fx":function(){define(["./kernel","./lang","../Evented","./Color","./connect","./sniff","../dom","../dom-style"],function(dojo,lang,_11a,_11b,_11c,has,dom,_11d){var _11e=lang.mixin;dojo._Line=function(_11f,end){this.start=_11f;this.end=end;};dojo._Line.prototype.getValue=function(n){return ((this.end-this.start)*n)+this.start;};dojo.Animation=function(args){_11e(this,args);if(lang.isArray(this.curve)){this.curve=new dojo._Line(this.curve[0],this.curve[1]);}};dojo.Animation.prototype=new _11a();dojo._Animation=dojo.Animation;lang.extend(dojo.Animation,{duration:350,repeat:0,rate:20,_percent:0,_startRepeatCount:0,_getStep:function(){var _120=this._percent,_121=this.easing;return _121?_121(_120):_120;},_fire:function(evt,args){var a=args||[];if(this[evt]){if(dojo.config.debugAtAllCosts){this[evt].apply(this,a);}else{try{this[evt].apply(this,a);}catch(e){console.error("exception in animation handler for:",evt);console.error(e);}}}return this;},play:function(_122,_123){var _124=this;if(_124._delayTimer){_124._clearTimer();}if(_123){_124._stopTimer();_124._active=_124._paused=false;_124._percent=0;}else{if(_124._active&&!_124._paused){return _124;}}_124._fire("beforeBegin",[_124.node]);var de=_122||_124.delay,_125=lang.hitch(_124,"_play",_123);if(de>0){_124._delayTimer=setTimeout(_125,de);return _124;}_125();return _124;},_play:function(_126){var _127=this;if(_127._delayTimer){_127._clearTimer();}_127._startTime=new Date().valueOf();if(_127._paused){_127._startTime-=_127.duration*_127._percent;}_127._active=true;_127._paused=false;var _128=_127.curve.getValue(_127._getStep());if(!_127._percent){if(!_127._startRepeatCount){_127._startRepeatCount=_127.repeat;}_127._fire("onBegin",[_128]);}_127._fire("onPlay",[_128]);_127._cycle();return _127;},pause:function(){var _129=this;if(_129._delayTimer){_129._clearTimer();}_129._stopTimer();if(!_129._active){return _129;}_129._paused=true;_129._fire("onPause",[_129.curve.getValue(_129._getStep())]);return _129;},gotoPercent:function(_12a,_12b){var _12c=this;_12c._stopTimer();_12c._active=_12c._paused=true;_12c._percent=_12a;if(_12b){_12c.play();}return _12c;},stop:function(_12d){var _12e=this;if(_12e._delayTimer){_12e._clearTimer();}if(!_12e._timer){return _12e;}_12e._stopTimer();if(_12d){_12e._percent=1;}_12e._fire("onStop",[_12e.curve.getValue(_12e._getStep())]);_12e._active=_12e._paused=false;return _12e;},status:function(){if(this._active){return this._paused?"paused":"playing";}return "stopped";},_cycle:function(){var _12f=this;if(_12f._active){var curr=new Date().valueOf();var step=(curr-_12f._startTime)/(_12f.duration);if(step>=1){step=1;}_12f._percent=step;if(_12f.easing){step=_12f.easing(step);}_12f._fire("onAnimate",[_12f.curve.getValue(step)]);if(_12f._percent<1){_12f._startTimer();}else{_12f._active=false;if(_12f.repeat>0){_12f.repeat--;_12f.play(null,true);}else{if(_12f.repeat==-1){_12f.play(null,true);}else{if(_12f._startRepeatCount){_12f.repeat=_12f._startRepeatCount;_12f._startRepeatCount=0;}}}_12f._percent=0;_12f._fire("onEnd",[_12f.node]);!_12f.repeat&&_12f._stopTimer();}}return _12f;},_clearTimer:function(){clearTimeout(this._delayTimer);delete this._delayTimer;}});var ctr=0,_130=null,_131={run:function(){}};lang.extend(dojo.Animation,{_startTimer:function(){if(!this._timer){this._timer=_11c.connect(_131,"run",this,"_cycle");ctr++;}if(!_130){_130=setInterval(lang.hitch(_131,"run"),this.rate);}},_stopTimer:function(){if(this._timer){_11c.disconnect(this._timer);this._timer=null;ctr--;}if(ctr<=0){clearInterval(_130);_130=null;ctr=0;}}});var _132=has("ie")?function(node){var ns=node.style;if(!ns.width.length&&_11d.get(node,"width")=="auto"){ns.width="auto";}}:function(){};dojo._fade=function(args){args.node=dom.byId(args.node);var _133=_11e({properties:{}},args),_134=(_133.properties.opacity={});_134.start=!("start" in _133)?function(){return +_11d.get(_133.node,"opacity")||0;}:_133.start;_134.end=_133.end;var anim=dojo.animateProperty(_133);_11c.connect(anim,"beforeBegin",lang.partial(_132,_133.node));return anim;};dojo.fadeIn=function(args){return dojo._fade(_11e({end:1},args));};dojo.fadeOut=function(args){return dojo._fade(_11e({end:0},args));};dojo._defaultEasing=function(n){return 0.5+((Math.sin((n+1.5)*Math.PI))/2);};var _135=function(_136){this._properties=_136;for(var p in _136){var prop=_136[p];if(prop.start instanceof _11b){prop.tempColor=new _11b();}}};_135.prototype.getValue=function(r){var ret={};for(var p in this._properties){var prop=this._properties[p],_137=prop.start;if(_137 instanceof _11b){ret[p]=_11b.blendColors(_137,prop.end,r,prop.tempColor).toCss();}else{if(!lang.isArray(_137)){ret[p]=((prop.end-_137)*r)+_137+(p!="opacity"?prop.units||"px":0);}}}return ret;};dojo.animateProperty=function(args){var n=args.node=dom.byId(args.node);if(!args.easing){args.easing=dojo._defaultEasing;}var anim=new dojo.Animation(args);_11c.connect(anim,"beforeBegin",anim,function(){var pm={};for(var p in this.properties){if(p=="width"||p=="height"){this.node.display="block";}var prop=this.properties[p];if(lang.isFunction(prop)){prop=prop(n);}prop=pm[p]=_11e({},(lang.isObject(prop)?prop:{end:prop}));if(lang.isFunction(prop.start)){prop.start=prop.start(n);}if(lang.isFunction(prop.end)){prop.end=prop.end(n);}var _138=(p.toLowerCase().indexOf("color")>=0);function _139(node,p){var v={height:node.offsetHeight,width:node.offsetWidth}[p];if(v!==undefined){return v;}v=_11d.get(node,p);return (p=="opacity")?+v:(_138?v:parseFloat(v));};if(!("end" in prop)){prop.end=_139(n,p);}else{if(!("start" in prop)){prop.start=_139(n,p);}}if(_138){prop.start=new _11b(prop.start);prop.end=new _11b(prop.end);}else{prop.start=(p=="opacity")?+prop.start:parseFloat(prop.start);}}this.curve=new _135(pm);});_11c.connect(anim,"onAnimate",lang.hitch(_11d,"set",anim.node));return anim;};dojo.anim=function(node,_13a,_13b,_13c,_13d,_13e){return dojo.animateProperty({node:node,duration:_13b||dojo.Animation.prototype.duration,properties:_13a,easing:_13c,onEnd:_13d}).play(_13e||0);};return {_Line:dojo._Line,Animation:dojo.Animation,_fade:dojo._fade,fadeIn:dojo.fadeIn,fadeOut:dojo.fadeOut,_defaultEasing:dojo._defaultEasing,animateProperty:dojo.animateProperty,anim:dojo.anim};});},"dojo/dom-form":function(){define("dojo/dom-form",["./_base/lang","./dom","./io-query","./json"],function(lang,dom,ioq,json){function _13f(obj,name,_140){if(_140===null){return;}var val=obj[name];if(typeof val=="string"){obj[name]=[val,_140];}else{if(lang.isArray(val)){val.push(_140);}else{obj[name]=_140;}}};var _141="file|submit|image|reset|button";var form={fieldToObject:function fieldToObject(_142){var ret=null;_142=dom.byId(_142);if(_142){var _143=_142.name,type=(_142.type||"").toLowerCase();if(_143&&type&&!_142.disabled){if(type=="radio"||type=="checkbox"){if(_142.checked){ret=_142.value;}}else{if(_142.multiple){ret=[];var _144=[_142.firstChild];while(_144.length){for(var node=_144.pop();node;node=node.nextSibling){if(node.nodeType==1&&node.tagName.toLowerCase()=="option"){if(node.selected){ret.push(node.value);}}else{if(node.nextSibling){_144.push(node.nextSibling);}if(node.firstChild){_144.push(node.firstChild);}break;}}}}else{ret=_142.value;}}}}return ret;},toObject:function formToObject(_145){var ret={},_146=dom.byId(_145).elements;for(var i=0,l=_146.length;i<l;++i){var item=_146[i],_147=item.name,type=(item.type||"").toLowerCase();if(_147&&type&&_141.indexOf(type)<0&&!item.disabled){_13f(ret,_147,form.fieldToObject(item));if(type=="image"){ret[_147+".x"]=ret[_147+".y"]=ret[_147].x=ret[_147].y=0;}}}return ret;},toQuery:function formToQuery(_148){return ioq.objectToQuery(form.toObject(_148));},toJson:function formToJson(_149,_14a){return json.stringify(form.toObject(_149),null,_14a?4:0);}};return form;});},"dojo/i18n":function(){define(["./_base/kernel","require","./has","./_base/array","./_base/config","./_base/lang","./_base/xhr"],function(dojo,_14b,has,_14c,_14d,lang,xhr){var _14e=dojo.i18n={},_14f=/(^.*(^|\/)nls)(\/|$)([^\/]*)\/?([^\/]*)/,_150=function(root,_151,_152,_153){for(var _154=[_152+_153],_155=_151.split("-"),_156="",i=0;i<_155.length;i++){_156+=(_156?"-":"")+_155[i];if(!root||root[_156]){_154.push(_152+_156+"/"+_153);}}return _154;},_157={},_158=dojo.getL10nName=function(_159,_15a,_15b){_15b=_15b?_15b.toLowerCase():dojo.locale;_159="dojo/i18n!"+_159.replace(/\./g,"/");_15a=_15a.replace(/\./g,"/");return (/root/i.test(_15b))?(_159+"/nls/"+_15a):(_159+"/nls/"+_15b+"/"+_15a);},_15c=function(_15d,_15e,_15f,_160,_161,load){_15d([_15e],function(root){var _162=_157[_15e+"/"]=lang.clone(root.root),_163=_150(!root._v1x&&root,_161,_15f,_160);_15d(_163,function(){for(var i=1;i<_163.length;i++){_157[_163[i]]=_162=lang.mixin(lang.clone(_162),arguments[i]);}var _164=_15e+"/"+_161;_157[_164]=_162;load&&load(lang.delegate(_162));});});},_165=function(id,_166){var _167=_14f.exec(id),_168=_167[1];return /^\./.test(_168)?_166(_168)+"/"+id.substring(_168.length):id;},_169=function(){},load=function(id,_16a,load){var _16b=_14f.exec(id),_16c=_16b[1]+"/",_16d=_16b[5]||_16b[4],_16e=_16c+_16d,_16f=(_16b[5]&&_16b[4]),_170=_16f||dojo.locale,_171=_16e+"/"+_170;if(_16f){_169(_171);if(_157[_171]){load(_157[_171]);}else{_15c(_16a,_16e,_16c,_16d,_170,load);}return;}var _172=_14d.extraLocale||[];_172=lang.isArray(_172)?_172:[_172];_172.push(_170);var _173=_172.length,_174;_14c.forEach(_172,function(_175){_15c(_16a,_16e,_16c,_16d,_175,function(_176){if(_175==_170){_174=_176;}if(!--_173){load(_174);}});});};if(has("dojo-unit-tests")){var _177=_14e.unitTests=[];}true||has.add("dojo-v1x-i18n-Api",1);if(1){var _178={},_179=new Function("bundle, __evalError","var __amdResult, define = function(x){__amdResult= x;};"+"return [(function(){"+"try{eval(arguments[0]);}catch(e){}"+"if(__amdResult)return 0;"+"try{return eval('('+arguments[0]+')');}"+"catch(e){__evalError.e = e; return __evalError;}"+"})(arguments[0]) , __amdResult];"),_17a=function(url,_17b,_17c){if(_17b===_178){console.error("failed to evaluate i18n bundle; url="+url,_178.e);return {};}return _17b?(/nls\/[^\/]+\/[^\/]+$/.test(url)?_17b:{root:_17b,_v1x:1}):_17c;},_17d=function(deps,_17e){var _17f=[];_14c.forEach(deps,function(mid){var url=_14b.toUrl(mid+".js");if(_157[url]){_17f.push(_157[url]);}else{try{var _180=_14b(mid);if(_180){_17f.push(_180);return;}}catch(e){}xhr.get({url:url,sync:true,load:function(text){var _181=_179(text,_178);_17f.push(_157[url]=_17a(url,_181[0],_181[1]));},error:function(){_17f.push(_157[url]={});}});}});_17e&&_17e.apply(null,_17f);},_182=_14e.normalizeLocale=function(_183){var _184=_183?_183.toLowerCase():dojo.locale;if(_184=="root"){_184="ROOT";}return _184;},_185=function(_186,func){var _187=_186.split("-");while(_187.length){if(func(_187.join("-"))){return true;}_187.pop();}return func("ROOT");};_169=function(_188){for(var _189=_188.split("/"),_18a=dojo.global[_189[0]],i=1;_18a&&i<_189.length;_18a=_18a[_189[i++]]){}if(_18a){_157[_188]=_18a;}};_14e.getLocalization=function(_18b,_18c,_18d){var _18e,_18f=_158(_18b,_18c,_18d).substring(10);load(_18f,(1&&!_14b.isXdUrl(_14b.toUrl(_18f+".js"))?_17d:_14b),function(_190){_18e=_190;});return _18e;};_14e._preloadLocalizations=function(_191,_192){function _193(_194){_194=_182(_194);_185(_194,function(loc){for(var i=0;i<_192.length;i++){if(_192[i]==loc){_17d([_191.replace(/\./g,"/")+"_"+loc]);return true;}}return false;});};_193();var _195=dojo.config.extraLocale||[];for(var i=0;i<_195.length;i++){_193(_195[i]);}};if(has("dojo-unit-tests")){_177.push(function(doh){doh.register("tests.i18n.unit",function(t){var _196;_196=_179("{prop:1}",_178);t.is({prop:1},_196[0]);t.is(undefined,_196[1]);_196=_179("({prop:1})",_178);t.is({prop:1},_196[0]);t.is(undefined,_196[1]);_196=_179("{'prop-x':1}",_178);t.is({"prop-x":1},_196[0]);t.is(undefined,_196[1]);_196=_179("({'prop-x':1})",_178);t.is({"prop-x":1},_196[0]);t.is(undefined,_196[1]);_196=_179("define({'prop-x':1})",_178);t.is(0,_196[0]);t.is({"prop-x":1},_196[1]);_196=_179("define({'prop-x':1});",_178);t.is(0,_196[0]);t.is({"prop-x":1},_196[1]);_196=_179("this is total nonsense and should throw an error",_178);t.is(_178,_196[0]);t.is(undefined,_196[1]);t.is({},_17a("some/url",_196[0],_196[1]));});});}}return lang.mixin(_14e,{dynamic:true,normalize:_165,load:load,cache:function(mid,_197){_157[mid]=_197;}});});},"dojo/_base/html":function(){define(["./kernel","../dom","../dom-style","../dom-attr","../dom-prop","../dom-class","../dom-construct","../dom-geometry"],function(dojo,dom,_198,attr,prop,cls,ctr,geom){dojo.byId=dom.byId;dojo.isDescendant=dom.isDescendant;dojo.setSelectable=dom.setSelectable;dojo.getAttr=attr.get;dojo.setAttr=attr.set;dojo.hasAttr=attr.has;dojo.removeAttr=attr.remove;dojo.getNodeProp=attr.getNodeProp;dojo.attr=function(node,name,_199){if(arguments.length==2){return attr[typeof name=="string"?"get":"set"](node,name);}return attr.set(node,name,_199);};dojo.hasClass=cls.contains;dojo.addClass=cls.add;dojo.removeClass=cls.remove;dojo.toggleClass=cls.toggle;dojo.replaceClass=cls.replace;dojo._toDom=dojo.toDom=ctr.toDom;dojo.place=ctr.place;dojo.create=ctr.create;dojo.empty=function(node){ctr.empty(node);};dojo._destroyElement=dojo.destroy=function(node){ctr.destroy(node);};dojo._getPadExtents=dojo.getPadExtents=geom.getPadExtents;dojo._getBorderExtents=dojo.getBorderExtents=geom.getBorderExtents;dojo._getPadBorderExtents=dojo.getPadBorderExtents=geom.getPadBorderExtents;dojo._getMarginExtents=dojo.getMarginExtents=geom.getMarginExtents;dojo._getMarginSize=dojo.getMarginSize=geom.getMarginSize;dojo._getMarginBox=dojo.getMarginBox=geom.getMarginBox;dojo.setMarginBox=geom.setMarginBox;dojo._getContentBox=dojo.getContentBox=geom.getContentBox;dojo.setContentSize=geom.setContentSize;dojo._isBodyLtr=dojo.isBodyLtr=geom.isBodyLtr;dojo._docScroll=dojo.docScroll=geom.docScroll;dojo._getIeDocumentElementOffset=dojo.getIeDocumentElementOffset=geom.getIeDocumentElementOffset;dojo._fixIeBiDiScrollLeft=dojo.fixIeBiDiScrollLeft=geom.fixIeBiDiScrollLeft;dojo.position=geom.position;dojo.marginBox=function marginBox(node,box){return box?geom.setMarginBox(node,box):geom.getMarginBox(node);};dojo.contentBox=function contentBox(node,box){return box?geom.setContentSize(node,box):geom.getContentBox(node);};dojo.coords=function(node,_19a){dojo.deprecated("dojo.coords()","Use dojo.position() or dojo.marginBox().");node=dom.byId(node);var s=_198.getComputedStyle(node),mb=geom.getMarginBox(node,s);var abs=geom.position(node,_19a);mb.x=abs.x;mb.y=abs.y;return mb;};dojo.getProp=prop.get;dojo.setProp=prop.set;dojo.prop=function(node,name,_19b){if(arguments.length==2){return prop[typeof name=="string"?"get":"set"](node,name);}return prop.set(node,name,_19b);};dojo.getStyle=_198.get;dojo.setStyle=_198.set;dojo.getComputedStyle=_198.getComputedStyle;dojo.__toPixelValue=dojo.toPixelValue=_198.toPixelValue;dojo.style=function(node,name,_19c){switch(arguments.length){case 1:return _198.get(node);case 2:return _198[typeof name=="string"?"get":"set"](node,name);}return _198.set(node,name,_19c);};return dojo;});},"dojo/_base/kernel":function(){define(["../has","./config","require","module"],function(has,_19d,_19e,_19f){var i,p,_1a0={},_1a1={},dojo={config:_19d,global:this,dijit:_1a0,dojox:_1a1};var _1a2={dojo:["dojo",dojo],dijit:["dijit",_1a0],dojox:["dojox",_1a1]},_1a3=(_19e.packs&&_19e.packs[_19f.id.match(/[^\/]+/)[0]].packageMap)||{},item;for(p in _1a3){if(_1a2[p]){_1a2[p][0]=_1a3[p];}else{_1a2[p]=[_1a3[p],{}];}}for(p in _1a2){item=_1a2[p];item[1]._scopeName=item[0];if(!_19d.noGlobals){this[item[0]]=item[1];}}dojo.scopeMap=_1a2;dojo.baseUrl=dojo.config.baseUrl=_19e.baseUrl;dojo.isAsync=!1||_19e.async;dojo.locale=_19d.locale;var rev="$Rev: 27913 $".match(/\d+/);dojo.version={major:1,minor:7,patch:2,flag:"",revision:rev?+rev[0]:NaN,toString:function(){var v=dojo.version;return v.major+"."+v.minor+"."+v.patch+v.flag+" ("+v.revision+")";}};true||has.add("extend-dojo",1);dojo.eval=function(_1a4){};(Function("d","d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);if(0){dojo.exit=function(_1a5){quit(_1a5);};}else{dojo.exit=function(){};}true||has.add("dojo-guarantee-console",1);if(1){typeof console!="undefined"||(console={});var cn=["assert","count","debug","dir","dirxml","error","group","groupEnd","info","profile","profileEnd","time","timeEnd","trace","warn","log"];var tn;i=0;while((tn=cn[i++])){if(!console[tn]){(function(){var tcn=tn+"";console[tcn]=("log" in console)?function(){var a=Array.apply({},arguments);a.unshift(tcn+":");console["log"](a.join(" "));}:function(){};console[tcn]._fake=true;})();}}}has.add("dojo-debug-messages",!!_19d.isDebug);if(has("dojo-debug-messages")){dojo.deprecated=function(_1a6,_1a7,_1a8){var _1a9="DEPRECATED: "+_1a6;if(_1a7){_1a9+=" "+_1a7;}if(_1a8){_1a9+=" -- will be removed in version: "+_1a8;}console.warn(_1a9);};dojo.experimental=function(_1aa,_1ab){var _1ac="EXPERIMENTAL: "+_1aa+" -- APIs subject to change without notice.";if(_1ab){_1ac+=" "+_1ab;}console.warn(_1ac);};}else{dojo.deprecated=dojo.experimental=function(){};}true||has.add("dojo-modulePaths",1);if(1){if(_19d.modulePaths){dojo.deprecated("dojo.modulePaths","use paths configuration");var _1ad={};for(p in _19d.modulePaths){_1ad[p.replace(/\./g,"/")]=_19d.modulePaths[p];}_19e({paths:_1ad});}}true||has.add("dojo-moduleUrl",1);if(1){dojo.moduleUrl=function(_1ae,url){dojo.deprecated("dojo.moduleUrl()","use require.toUrl","2.0");var _1af=null;if(_1ae){_1af=_19e.toUrl(_1ae.replace(/\./g,"/")+(url?("/"+url):"")+"/*.*").replace(/\/\*\.\*/,"")+(url?"":"/");}return _1af;};}dojo._hasResource={};return dojo;});},"dojo/io-query":function(){define(["./_base/lang"],function(lang){var _1b0={};function _1b1(map){var enc=encodeURIComponent,_1b2=[];for(var name in map){var _1b3=map[name];if(_1b3!=_1b0[name]){var _1b4=enc(name)+"=";if(lang.isArray(_1b3)){for(var i=0,l=_1b3.length;i<l;++i){_1b2.push(_1b4+enc(_1b3[i]));}}else{_1b2.push(_1b4+enc(_1b3));}}}return _1b2.join("&");};function _1b5(str){var dec=decodeURIComponent,qp=str.split("&"),ret={},name,val;for(var i=0,l=qp.length,item;i<l;++i){item=qp[i];if(item.length){var s=item.indexOf("=");if(s<0){name=dec(item);val="";}else{name=dec(item.slice(0,s));val=dec(item.slice(s+1));}if(typeof ret[name]=="string"){ret[name]=[ret[name]];}if(lang.isArray(ret[name])){ret[name].push(val);}else{ret[name]=val;}}}return ret;};return {objectToQuery:_1b1,queryToObject:_1b5};});},"dojo/_base/Deferred":function(){define("dojo/_base/Deferred",["./kernel","./lang"],function(dojo,lang){var _1b6=function(){};var _1b7=Object.freeze||function(){};dojo.Deferred=function(_1b8){var _1b9,_1ba,_1bb,head,_1bc;var _1bd=(this.promise={});function _1be(_1bf){if(_1ba){throw new Error("This deferred has already been resolved");}_1b9=_1bf;_1ba=true;_1c0();};function _1c0(){var _1c1;while(!_1c1&&_1bc){var _1c2=_1bc;_1bc=_1bc.next;if((_1c1=(_1c2.progress==_1b6))){_1ba=false;}var func=(_1bb?_1c2.error:_1c2.resolved);if(func){try{var _1c3=func(_1b9);if(_1c3&&typeof _1c3.then==="function"){_1c3.then(lang.hitch(_1c2.deferred,"resolve"),lang.hitch(_1c2.deferred,"reject"),lang.hitch(_1c2.deferred,"progress"));continue;}var _1c4=_1c1&&_1c3===undefined;if(_1c1&&!_1c4){_1bb=_1c3 instanceof Error;}_1c2.deferred[_1c4&&_1bb?"reject":"resolve"](_1c4?_1b9:_1c3);}catch(e){_1c2.deferred.reject(e);}}else{if(_1bb){_1c2.deferred.reject(_1b9);}else{_1c2.deferred.resolve(_1b9);}}}};this.resolve=this.callback=function(_1c5){this.fired=0;this.results=[_1c5,null];_1be(_1c5);};this.reject=this.errback=function(_1c6){_1bb=true;this.fired=1;_1be(_1c6);this.results=[null,_1c6];if(!_1c6||_1c6.log!==false){(dojo.config.deferredOnError||function(x){console.error(x);})(_1c6);}};this.progress=function(_1c7){var _1c8=_1bc;while(_1c8){var _1c9=_1c8.progress;_1c9&&_1c9(_1c7);_1c8=_1c8.next;}};this.addCallbacks=function(_1ca,_1cb){this.then(_1ca,_1cb,_1b6);return this;};_1bd.then=this.then=function(_1cc,_1cd,_1ce){var _1cf=_1ce==_1b6?this:new dojo.Deferred(_1bd.cancel);var _1d0={resolved:_1cc,error:_1cd,progress:_1ce,deferred:_1cf};if(_1bc){head=head.next=_1d0;}else{_1bc=head=_1d0;}if(_1ba){_1c0();}return _1cf.promise;};var _1d1=this;_1bd.cancel=this.cancel=function(){if(!_1ba){var _1d2=_1b8&&_1b8(_1d1);if(!_1ba){if(!(_1d2 instanceof Error)){_1d2=new Error(_1d2);}_1d2.log=false;_1d1.reject(_1d2);}}};_1b7(_1bd);};lang.extend(dojo.Deferred,{addCallback:function(_1d3){return this.addCallbacks(lang.hitch.apply(dojo,arguments));},addErrback:function(_1d4){return this.addCallbacks(null,lang.hitch.apply(dojo,arguments));},addBoth:function(_1d5){var _1d6=lang.hitch.apply(dojo,arguments);return this.addCallbacks(_1d6,_1d6);},fired:-1});dojo.Deferred.when=dojo.when=function(_1d7,_1d8,_1d9,_1da){if(_1d7&&typeof _1d7.then==="function"){return _1d7.then(_1d8,_1d9,_1da);}return _1d8?_1d8(_1d7):_1d7;};return dojo.Deferred;});},"dojo/NodeList-dom":function(){define(["./_base/kernel","./query","./_base/array","./_base/lang","./dom-class","./dom-construct","./dom-geometry","./dom-attr","./dom-style"],function(dojo,_1db,_1dc,lang,_1dd,_1de,_1df,_1e0,_1e1){var _1e2=function(a){return a.length==1&&(typeof a[0]=="string");};var _1e3=function(node){var p=node.parentNode;if(p){p.removeChild(node);}};var _1e4=_1db.NodeList,awc=_1e4._adaptWithCondition,aafe=_1e4._adaptAsForEach,aam=_1e4._adaptAsMap;function _1e5(_1e6){return function(node,name,_1e7){if(arguments.length==2){return _1e6[typeof name=="string"?"get":"set"](node,name);}return _1e6.set(node,name,_1e7);};};lang.extend(_1e4,{_normalize:function(_1e8,_1e9){var _1ea=_1e8.parse===true;if(typeof _1e8.template=="string"){var _1eb=_1e8.templateFunc||(dojo.string&&dojo.string.substitute);_1e8=_1eb?_1eb(_1e8.template,_1e8):_1e8;}var type=(typeof _1e8);if(type=="string"||type=="number"){_1e8=_1de.toDom(_1e8,(_1e9&&_1e9.ownerDocument));if(_1e8.nodeType==11){_1e8=lang._toArray(_1e8.childNodes);}else{_1e8=[_1e8];}}else{if(!lang.isArrayLike(_1e8)){_1e8=[_1e8];}else{if(!lang.isArray(_1e8)){_1e8=lang._toArray(_1e8);}}}if(_1ea){_1e8._runParse=true;}return _1e8;},_cloneNode:function(node){return node.cloneNode(true);},_place:function(ary,_1ec,_1ed,_1ee){if(_1ec.nodeType!=1&&_1ed=="only"){return;}var _1ef=_1ec,_1f0;var _1f1=ary.length;for(var i=_1f1-1;i>=0;i--){var node=(_1ee?this._cloneNode(ary[i]):ary[i]);if(ary._runParse&&dojo.parser&&dojo.parser.parse){if(!_1f0){_1f0=_1ef.ownerDocument.createElement("div");}_1f0.appendChild(node);dojo.parser.parse(_1f0);node=_1f0.firstChild;while(_1f0.firstChild){_1f0.removeChild(_1f0.firstChild);}}if(i==_1f1-1){_1de.place(node,_1ef,_1ed);}else{_1ef.parentNode.insertBefore(node,_1ef);}_1ef=node;}},attr:awc(_1e5(_1e0),_1e2),style:awc(_1e5(_1e1),_1e2),addClass:aafe(_1dd.add),removeClass:aafe(_1dd.remove),replaceClass:aafe(_1dd.replace),toggleClass:aafe(_1dd.toggle),empty:aafe(_1de.empty),removeAttr:aafe(_1e0.remove),position:aam(_1df.position),marginBox:aam(_1df.getMarginBox),place:function(_1f2,_1f3){var item=_1db(_1f2)[0];return this.forEach(function(node){_1de.place(node,item,_1f3);});},orphan:function(_1f4){return (_1f4?_1db._filterResult(this,_1f4):this).forEach(_1e3);},adopt:function(_1f5,_1f6){return _1db(_1f5).place(this[0],_1f6)._stash(this);},query:function(_1f7){if(!_1f7){return this;}var ret=new _1e4;this.map(function(node){_1db(_1f7,node).forEach(function(_1f8){if(_1f8!==undefined){ret.push(_1f8);}});});return ret._stash(this);},filter:function(_1f9){var a=arguments,_1fa=this,_1fb=0;if(typeof _1f9=="string"){_1fa=_1db._filterResult(this,a[0]);if(a.length==1){return _1fa._stash(this);}_1fb=1;}return this._wrap(_1dc.filter(_1fa,a[_1fb],a[_1fb+1]),this);},addContent:function(_1fc,_1fd){_1fc=this._normalize(_1fc,this[0]);for(var i=0,node;(node=this[i]);i++){this._place(_1fc,node,_1fd,i>0);}return this;}});return _1e4;});},"dojo/query":function(){define(["./_base/kernel","./has","./dom","./on","./_base/array","./_base/lang","./selector/_loader","./selector/_loader!default"],function(dojo,has,dom,on,_1fe,lang,_1ff,_200){"use strict";has.add("array-extensible",function(){return lang.delegate([],{length:1}).length==1&&!has("bug-for-in-skips-shadowed");});var ap=Array.prototype,aps=ap.slice,apc=ap.concat,_201=_1fe.forEach;var tnl=function(a,_202,_203){var _204=new (_203||this._NodeListCtor||nl)(a);return _202?_204._stash(_202):_204;};var _205=function(f,a,o){a=[0].concat(aps.call(a,0));o=o||dojo.global;return function(node){a[0]=node;return f.apply(o,a);};};var _206=function(f,o){return function(){this.forEach(_205(f,arguments,o));return this;};};var _207=function(f,o){return function(){return this.map(_205(f,arguments,o));};};var _208=function(f,o){return function(){return this.filter(_205(f,arguments,o));};};var _209=function(f,g,o){return function(){var a=arguments,body=_205(f,a,o);if(g.call(o||dojo.global,a)){return this.map(body);}this.forEach(body);return this;};};var _20a=function(_20b){var _20c=this instanceof nl&&has("array-extensible");if(typeof _20b=="number"){_20b=Array(_20b);}var _20d=(_20b&&"length" in _20b)?_20b:arguments;if(_20c||!_20d.sort){var _20e=_20c?this:[],l=_20e.length=_20d.length;for(var i=0;i<l;i++){_20e[i]=_20d[i];}if(_20c){return _20e;}_20d=_20e;}lang._mixin(_20d,nlp);_20d._NodeListCtor=function(_20f){return nl(_20f);};return _20d;};var nl=_20a,nlp=nl.prototype=has("array-extensible")?[]:{};nl._wrap=nlp._wrap=tnl;nl._adaptAsMap=_207;nl._adaptAsForEach=_206;nl._adaptAsFilter=_208;nl._adaptWithCondition=_209;_201(["slice","splice"],function(name){var f=ap[name];nlp[name]=function(){return this._wrap(f.apply(this,arguments),name=="slice"?this:null);};});_201(["indexOf","lastIndexOf","every","some"],function(name){var f=_1fe[name];nlp[name]=function(){return f.apply(dojo,[this].concat(aps.call(arguments,0)));};});lang.extend(_20a,{constructor:nl,_NodeListCtor:nl,toString:function(){return this.join(",");},_stash:function(_210){this._parent=_210;return this;},on:function(_211,_212){var _213=this.map(function(node){return on(node,_211,_212);});_213.remove=function(){for(var i=0;i<_213.length;i++){_213[i].remove();}};return _213;},end:function(){if(this._parent){return this._parent;}else{return new this._NodeListCtor(0);}},concat:function(item){var t=lang.isArray(this)?this:aps.call(this,0),m=_1fe.map(arguments,function(a){return a&&!lang.isArray(a)&&(typeof _20a!="undefined"&&a.constructor===_20a||a.constructor===this._NodeListCtor)?aps.call(a,0):a;});return this._wrap(apc.apply(t,m),this);},map:function(func,obj){return this._wrap(_1fe.map(this,func,obj),this);},forEach:function(_214,_215){_201(this,_214,_215);return this;},filter:function(_216){var a=arguments,_217=this,_218=0;if(typeof _216=="string"){_217=_219._filterResult(this,a[0]);if(a.length==1){return _217._stash(this);}_218=1;}return this._wrap(_1fe.filter(_217,a[_218],a[_218+1]),this);},instantiate:function(_21a,_21b){var c=lang.isFunction(_21a)?_21a:lang.getObject(_21a);_21b=_21b||{};return this.forEach(function(node){new c(_21b,node);});},at:function(){var t=new this._NodeListCtor(0);_201(arguments,function(i){if(i<0){i=this.length+i;}if(this[i]){t.push(this[i]);}},this);return t._stash(this);}});function _21c(_21d,_21e){var _21f=function(_220,root){if(typeof root=="string"){root=dom.byId(root);if(!root){return new _21e([]);}}var _221=typeof _220=="string"?_21d(_220,root):_220.orphan?_220:[_220];if(_221.orphan){return _221;}return new _21e(_221);};_21f.matches=_21d.match||function(node,_222,root){return _21f.filter([node],_222,root).length>0;};_21f.filter=_21d.filter||function(_223,_224,root){return _21f(_224,root).filter(function(node){return _1fe.indexOf(_223,node)>-1;});};if(typeof _21d!="function"){var _225=_21d.search;_21d=function(_226,root){return _225(root||document,_226);};}return _21f;};var _219=_21c(_200,_20a);dojo.query=_21c(_200,function(_227){return _20a(_227);});_219.load=function(id,_228,_229,_22a){_1ff.load(id,_228,function(_22b){_229(_21c(_22b,_20a));});};dojo._filterQueryResult=_219._filterResult=function(_22c,_22d,root){return new _20a(_219.filter(_22c,_22d,root));};dojo.NodeList=_219.NodeList=_20a;return _219;});},"dojo/has":function(){define(["require"],function(_22e){var has=_22e.has||function(){};if(!1){var _22f=typeof window!="undefined"&&typeof location!="undefined"&&typeof document!="undefined"&&window.location==location&&window.document==document,_230=this,doc=_22f&&document,_231=doc&&doc.createElement("DiV"),_232={};has=function(name){return typeof _232[name]=="function"?(_232[name]=_232[name](_230,doc,_231)):_232[name];};has.cache=_232;has.add=function(name,test,now,_233){(typeof _232[name]=="undefined"||_233)&&(_232[name]=test);return now&&has(name);};true||has.add("host-browser",_22f);true||has.add("dom",_22f);true||has.add("dojo-dom-ready-api",1);true||has.add("dojo-sniff",1);}if(1){var _234=navigator.userAgent;has.add("dom-addeventlistener",!!document.addEventListener);has.add("touch","ontouchstart" in document);has.add("device-width",screen.availWidth||innerWidth);has.add("agent-ios",!!_234.match(/iPhone|iP[ao]d/));has.add("agent-android",_234.indexOf("android")>1);}has.clearElement=function(_235){_235.innerHTML="";return _235;};has.normalize=function(id,_236){var _237=id.match(/[\?:]|[^:\?]*/g),i=0,get=function(skip){var term=_237[i++];if(term==":"){return 0;}else{if(_237[i++]=="?"){if(!skip&&has(term)){return get();}else{get(true);return get(skip);}}return term||0;}};id=get();return id&&_236(id);};has.load=function(id,_238,_239){if(id){_238([id],_239);}else{_239();}};return has;});},"dojo/_base/loader":function(){define(["./kernel","../has","require","module","./json","./lang","./array"],function(dojo,has,_23a,_23b,json,lang,_23c){if(!1){console.error("cannot load the Dojo v1.x loader with a foreign loader");return 0;}var _23d=function(id){return {src:_23b.id,id:id};},_23e=function(name){return name.replace(/\./g,"/");},_23f=/\/\/>>built/,_240=[],_241=[],_242=function(mid,_243,_244){_240.push(_244);_23c.forEach(mid.split(","),function(mid){var _245=_246(mid,_243.module);_241.push(_245);_247(_245);});_248();},_249,_24a=function(m){if(_249[m.mid]||/loadInit\!/.test(m.mid)){return true;}_249[m.mid]=1;if(m.injected!==_24b&&!m.executed){return false;}for(var deps=m.deps||[],i=0;i<deps.length;i++){if(!_24a(deps[i])){return false;}}return true;},_248=function(){_249={};_241=_23c.filter(_241,function(_24c){return !_24a(_24c);});if(!_241.length){_24e.holdIdle();var _24d=_240;_240=[];_23c.forEach(_24d,function(cb){cb(1);});_24e.releaseIdle();}},_24f=function(mid,_250,_251){_250([mid],function(_252){_250(_252.names,function(){for(var _253="",args=[],i=0;i<arguments.length;i++){_253+="var "+_252.names[i]+"= arguments["+i+"]; ";args.push(arguments[i]);}eval(_253);var _254=_250.module,deps=[],hold={},_255=[],p,_256={provide:function(_257){_257=_23e(_257);var _258=_246(_257,_254);if(_258!==_254){_27d(_258);}},require:function(_259,_25a){_259=_23e(_259);_25a&&(_246(_259,_254).result=_277);_255.push(_259);},requireLocalization:function(_25b,_25c,_25d){deps.length||(deps=["dojo/i18n"]);_25d=(_25d||dojo.locale).toLowerCase();_25b=_23e(_25b)+"/nls/"+(/root/i.test(_25d)?"":_25d+"/")+_23e(_25c);if(_246(_25b,_254).isXd){deps.push("dojo/i18n!"+_25b);}},loadInit:function(f){f();}};try{for(p in _256){hold[p]=dojo[p];dojo[p]=_256[p];}_252.def.apply(null,args);}catch(e){_27e("error",[_23d("failedDojoLoadInit"),e]);}finally{for(p in _256){dojo[p]=hold[p];}}_255.length&&deps.push("dojo/require!"+_255.join(","));_240.push(_251);_23c.forEach(_255,function(mid){var _25e=_246(mid,_250.module);_241.push(_25e);_247(_25e);});_248();});});},_25f=function(text,_260,_261){var _262=/\(|\)/g,_263=1,_264;_262.lastIndex=_260;while((_264=_262.exec(text))){if(_264[0]==")"){_263-=1;}else{_263+=1;}if(_263==0){break;}}if(_263!=0){throw "unmatched paren around character "+_262.lastIndex+" in: "+text;}return [dojo.trim(text.substring(_261,_262.lastIndex))+";\n",_262.lastIndex];},_265=/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,_266=/(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg,_267=/(^|\s)(require|define)\s*\(/m,_268=function(text,_269){var _26a,_26b,_26c,_26d,_26e=[],_26f=[],_270=[];_269=_269||text.replace(_265,function(_271){_266.lastIndex=_267.lastIndex=0;return (_266.test(_271)||_267.test(_271))?"":_271;});while((_26a=_266.exec(_269))){_26b=_266.lastIndex;_26c=_26b-_26a[0].length;_26d=_25f(_269,_26b,_26c);if(_26a[2]=="loadInit"){_26e.push(_26d[0]);}else{_26f.push(_26d[0]);}_266.lastIndex=_26d[1];}_270=_26e.concat(_26f);if(_270.length||!_267.test(_269)){return [text.replace(/(^|\s)dojo\.loadInit\s*\(/g,"\n0 && dojo.loadInit("),_270.join(""),_270];}else{return 0;}},_272=function(_273,text){var _274,id,_275=[],_276=[];if(_23f.test(text)||!(_274=_268(text))){return 0;}id=_273.mid+"-*loadInit";for(var p in _246("dojo",_273).result.scopeMap){_275.push(p);_276.push("\""+p+"\"");}return "// xdomain rewrite of "+_273.path+"\n"+"define('"+id+"',{\n"+"\tnames:"+dojo.toJson(_275)+",\n"+"\tdef:function("+_275.join(",")+"){"+_274[1]+"}"+"});\n\n"+"define("+dojo.toJson(_275.concat(["dojo/loadInit!"+id]))+", function("+_275.join(",")+"){\n"+_274[0]+"});";},_24e=_23a.initSyncLoader(_242,_248,_272),sync=_24e.sync,xd=_24e.xd,_24b=_24e.arrived,_277=_24e.nonmodule,_278=_24e.executing,_279=_24e.executed,_27a=_24e.syncExecStack,_27b=_24e.modules,_27c=_24e.execQ,_246=_24e.getModule,_247=_24e.injectModule,_27d=_24e.setArrived,_27e=_24e.signal,_27f=_24e.finishExec,_280=_24e.execModule,_281=_24e.getLegacyMode;dojo.provide=function(mid){var _282=_27a[0],_283=lang.mixin(_246(_23e(mid),_23a.module),{executed:_278,result:lang.getObject(mid,true)});_27d(_283);if(_282){(_282.provides||(_282.provides=[])).push(function(){_283.result=lang.getObject(mid);delete _283.provides;_283.executed!==_279&&_27f(_283);});}return _283.result;};has.add("config-publishRequireResult",1,0,0);dojo.require=function(_284,_285){function _286(mid,_287){var _288=_246(_23e(mid),_23a.module);if(_27a.length&&_27a[0].finish){_27a[0].finish.push(mid);return undefined;}if(_288.executed){return _288.result;}_287&&(_288.result=_277);var _289=_281();_247(_288);_289=_281();if(_288.executed!==_279&&_288.injected===_24b){_24e.holdIdle();_280(_288);_24e.releaseIdle();}if(_288.executed){return _288.result;}if(_289==sync){if(_288.cjs){_27c.unshift(_288);}else{_27a.length&&(_27a[0].finish=[mid]);}}else{_27c.push(_288);}return undefined;};var _28a=_286(_284,_285);if(has("config-publishRequireResult")&&!lang.exists(_284)&&_28a!==undefined){lang.setObject(_284,_28a);}return _28a;};dojo.loadInit=function(f){f();};dojo.registerModulePath=function(_28b,_28c){var _28d={};_28d[_28b.replace(/\./g,"/")]=_28c;_23a({paths:_28d});};dojo.platformRequire=function(_28e){var _28f=(_28e.common||[]).concat(_28e[dojo._name]||_28e["default"]||[]),temp;while(_28f.length){if(lang.isArray(temp=_28f.shift())){dojo.require.apply(dojo,temp);}else{dojo.require(temp);}}};dojo.requireIf=dojo.requireAfterIf=function(_290,_291,_292){if(_290){dojo.require(_291,_292);}};dojo.requireLocalization=function(_293,_294,_295){_23a(["../i18n"],function(i18n){i18n.getLocalization(_293,_294,_295);});};return {extractLegacyApiApplications:_268,require:_24e.dojoRequirePlugin,loadInit:_24f};});},"dojo/json":function(){define(["./has"],function(has){"use strict";var _296=typeof JSON!="undefined";has.add("json-parse",_296);has.add("json-stringify",_296&&JSON.stringify({a:0},function(k,v){return v||1;})=="{\"a\":1}");if(has("json-stringify")){return JSON;}else{var _297=function(str){return ("\""+str.replace(/(["\\])/g,"\\$1")+"\"").replace(/[\f]/g,"\\f").replace(/[\b]/g,"\\b").replace(/[\n]/g,"\\n").replace(/[\t]/g,"\\t").replace(/[\r]/g,"\\r");};return {parse:has("json-parse")?JSON.parse:function(str,_298){if(_298&&!/^([\s\[\{]*(?:"(?:\\.|[^"])+"|-?\d[\d\.]*(?:[Ee][+-]?\d+)?|null|true|false|)[\s\]\}]*(?:,|:|$))+$/.test(str)){throw new SyntaxError("Invalid characters in JSON");}return eval("("+str+")");},stringify:function(_299,_29a,_29b){var _29c;if(typeof _29a=="string"){_29b=_29a;_29a=null;}function _29d(it,_29e,key){if(_29a){it=_29a(key,it);}var val,_29f=typeof it;if(_29f=="number"){return isFinite(it)?it+"":"null";}if(_29f=="boolean"){return it+"";}if(it===null){return "null";}if(typeof it=="string"){return _297(it);}if(_29f=="function"||_29f=="undefined"){return _29c;}if(typeof it.toJSON=="function"){return _29d(it.toJSON(key),_29e,key);}if(it instanceof Date){return "\"{FullYear}-{Month+}-{Date}T{Hours}:{Minutes}:{Seconds}Z\"".replace(/\{(\w+)(\+)?\}/g,function(t,prop,plus){var num=it["getUTC"+prop]()+(plus?1:0);return num<10?"0"+num:num;});}if(it.valueOf()!==it){return _29d(it.valueOf(),_29e,key);}var _2a0=_29b?(_29e+_29b):"";var sep=_29b?" ":"";var _2a1=_29b?"\n":"";if(it instanceof Array){var itl=it.length,res=[];for(key=0;key<itl;key++){var obj=it[key];val=_29d(obj,_2a0,key);if(typeof val!="string"){val="null";}res.push(_2a1+_2a0+val);}return "["+res.join(",")+_2a1+_29e+"]";}var _2a2=[];for(key in it){var _2a3;if(typeof key=="number"){_2a3="\""+key+"\"";}else{if(typeof key=="string"){_2a3=_297(key);}else{continue;}}val=_29d(it[key],_2a0,key);if(typeof val!="string"){continue;}_2a2.push(_2a1+_2a0+_2a3+":"+sep+val);}return "{"+_2a2.join(",")+_2a1+_29e+"}";};return _29d(_299,"","");}};}});},"dojo/_base/declare":function(){define(["./kernel","../has","./lang"],function(dojo,has,lang){var mix=lang.mixin,op=Object.prototype,opts=op.toString,xtor=new Function,_2a4=0,_2a5="constructor";function err(msg,cls){throw new Error("declare"+(cls?" "+cls:"")+": "+msg);};function _2a6(_2a7,_2a8){var _2a9=[],_2aa=[{cls:0,refs:[]}],_2ab={},_2ac=1,l=_2a7.length,i=0,j,lin,base,top,_2ad,rec,name,refs;for(;i<l;++i){base=_2a7[i];if(!base){err("mixin #"+i+" is unknown. Did you use dojo.require to pull it in?",_2a8);}else{if(opts.call(base)!="[object Function]"){err("mixin #"+i+" is not a callable constructor.",_2a8);}}lin=base._meta?base._meta.bases:[base];top=0;for(j=lin.length-1;j>=0;--j){_2ad=lin[j].prototype;if(!_2ad.hasOwnProperty("declaredClass")){_2ad.declaredClass="uniqName_"+(_2a4++);}name=_2ad.declaredClass;if(!_2ab.hasOwnProperty(name)){_2ab[name]={count:0,refs:[],cls:lin[j]};++_2ac;}rec=_2ab[name];if(top&&top!==rec){rec.refs.push(top);++top.count;}top=rec;}++top.count;_2aa[0].refs.push(top);}while(_2aa.length){top=_2aa.pop();_2a9.push(top.cls);--_2ac;while(refs=top.refs,refs.length==1){top=refs[0];if(!top||--top.count){top=0;break;}_2a9.push(top.cls);--_2ac;}if(top){for(i=0,l=refs.length;i<l;++i){top=refs[i];if(!--top.count){_2aa.push(top);}}}}if(_2ac){err("can't build consistent linearization",_2a8);}base=_2a7[0];_2a9[0]=base?base._meta&&base===_2a9[_2a9.length-base._meta.bases.length]?base._meta.bases.length:1:0;return _2a9;};function _2ae(args,a,f){var name,_2af,_2b0,_2b1,meta,base,_2b2,opf,pos,_2b3=this._inherited=this._inherited||{};if(typeof args=="string"){name=args;args=a;a=f;}f=0;_2b1=args.callee;name=name||_2b1.nom;if(!name){err("can't deduce a name to call inherited()",this.declaredClass);}meta=this.constructor._meta;_2b0=meta.bases;pos=_2b3.p;if(name!=_2a5){if(_2b3.c!==_2b1){pos=0;base=_2b0[0];meta=base._meta;if(meta.hidden[name]!==_2b1){_2af=meta.chains;if(_2af&&typeof _2af[name]=="string"){err("calling chained method with inherited: "+name,this.declaredClass);}do{meta=base._meta;_2b2=base.prototype;if(meta&&(_2b2[name]===_2b1&&_2b2.hasOwnProperty(name)||meta.hidden[name]===_2b1)){break;}}while(base=_2b0[++pos]);pos=base?pos:-1;}}base=_2b0[++pos];if(base){_2b2=base.prototype;if(base._meta&&_2b2.hasOwnProperty(name)){f=_2b2[name];}else{opf=op[name];do{_2b2=base.prototype;f=_2b2[name];if(f&&(base._meta?_2b2.hasOwnProperty(name):f!==opf)){break;}}while(base=_2b0[++pos]);}}f=base&&f||op[name];}else{if(_2b3.c!==_2b1){pos=0;meta=_2b0[0]._meta;if(meta&&meta.ctor!==_2b1){_2af=meta.chains;if(!_2af||_2af.constructor!=="manual"){err("calling chained constructor with inherited",this.declaredClass);}while(base=_2b0[++pos]){meta=base._meta;if(meta&&meta.ctor===_2b1){break;}}pos=base?pos:-1;}}while(base=_2b0[++pos]){meta=base._meta;f=meta?meta.ctor:base;if(f){break;}}f=base&&f;}_2b3.c=f;_2b3.p=pos;if(f){return a===true?f:f.apply(this,a||args);}};function _2b4(name,args){if(typeof name=="string"){return this.__inherited(name,args,true);}return this.__inherited(name,true);};function _2b5(args,a1,a2){var f=this.getInherited(args,a1);if(f){return f.apply(this,a2||a1||args);}};var _2b6=dojo.config.isDebug?_2b5:_2ae;function _2b7(cls){var _2b8=this.constructor._meta.bases;for(var i=0,l=_2b8.length;i<l;++i){if(_2b8[i]===cls){return true;}}return this instanceof cls;};function _2b9(_2ba,_2bb){for(var name in _2bb){if(name!=_2a5&&_2bb.hasOwnProperty(name)){_2ba[name]=_2bb[name];}}if(has("bug-for-in-skips-shadowed")){for(var _2bc=lang._extraNames,i=_2bc.length;i;){name=_2bc[--i];if(name!=_2a5&&_2bb.hasOwnProperty(name)){_2ba[name]=_2bb[name];}}}};function _2bd(_2be,_2bf){var name,t;for(name in _2bf){t=_2bf[name];if((t!==op[name]||!(name in op))&&name!=_2a5){if(opts.call(t)=="[object Function]"){t.nom=name;}_2be[name]=t;}}if(has("bug-for-in-skips-shadowed")){for(var _2c0=lang._extraNames,i=_2c0.length;i;){name=_2c0[--i];t=_2bf[name];if((t!==op[name]||!(name in op))&&name!=_2a5){if(opts.call(t)=="[object Function]"){t.nom=name;}_2be[name]=t;}}}return _2be;};function _2c1(_2c2){_2c3.safeMixin(this.prototype,_2c2);return this;};function _2c4(_2c5,_2c6){return function(){var a=arguments,args=a,a0=a[0],f,i,m,l=_2c5.length,_2c7;if(!(this instanceof a.callee)){return _2c8(a);}if(_2c6&&(a0&&a0.preamble||this.preamble)){_2c7=new Array(_2c5.length);_2c7[0]=a;for(i=0;;){a0=a[0];if(a0){f=a0.preamble;if(f){a=f.apply(this,a)||a;}}f=_2c5[i].prototype;f=f.hasOwnProperty("preamble")&&f.preamble;if(f){a=f.apply(this,a)||a;}if(++i==l){break;}_2c7[i]=a;}}for(i=l-1;i>=0;--i){f=_2c5[i];m=f._meta;f=m?m.ctor:f;if(f){f.apply(this,_2c7?_2c7[i]:a);}}f=this.postscript;if(f){f.apply(this,args);}};};function _2c9(ctor,_2ca){return function(){var a=arguments,t=a,a0=a[0],f;if(!(this instanceof a.callee)){return _2c8(a);}if(_2ca){if(a0){f=a0.preamble;if(f){t=f.apply(this,t)||t;}}f=this.preamble;if(f){f.apply(this,t);}}if(ctor){ctor.apply(this,a);}f=this.postscript;if(f){f.apply(this,a);}};};function _2cb(_2cc){return function(){var a=arguments,i=0,f,m;if(!(this instanceof a.callee)){return _2c8(a);}for(;f=_2cc[i];++i){m=f._meta;f=m?m.ctor:f;if(f){f.apply(this,a);break;}}f=this.postscript;if(f){f.apply(this,a);}};};function _2cd(name,_2ce,_2cf){return function(){var b,m,f,i=0,step=1;if(_2cf){i=_2ce.length-1;step=-1;}for(;b=_2ce[i];i+=step){m=b._meta;f=(m?m.hidden:b.prototype)[name];if(f){f.apply(this,arguments);}}};};function _2d0(ctor){xtor.prototype=ctor.prototype;var t=new xtor;xtor.prototype=null;return t;};function _2c8(args){var ctor=args.callee,t=_2d0(ctor);ctor.apply(t,args);return t;};function _2c3(_2d1,_2d2,_2d3){if(typeof _2d1!="string"){_2d3=_2d2;_2d2=_2d1;_2d1="";}_2d3=_2d3||{};var _2d4,i,t,ctor,name,_2d5,_2d6,_2d7=1,_2d8=_2d2;if(opts.call(_2d2)=="[object Array]"){_2d5=_2a6(_2d2,_2d1);t=_2d5[0];_2d7=_2d5.length-t;_2d2=_2d5[_2d7];}else{_2d5=[0];if(_2d2){if(opts.call(_2d2)=="[object Function]"){t=_2d2._meta;_2d5=_2d5.concat(t?t.bases:_2d2);}else{err("base class is not a callable constructor.",_2d1);}}else{if(_2d2!==null){err("unknown base class. Did you use dojo.require to pull it in?",_2d1);}}}if(_2d2){for(i=_2d7-1;;--i){_2d4=_2d0(_2d2);if(!i){break;}t=_2d5[i];(t._meta?_2b9:mix)(_2d4,t.prototype);ctor=new Function;ctor.superclass=_2d2;ctor.prototype=_2d4;_2d2=_2d4.constructor=ctor;}}else{_2d4={};}_2c3.safeMixin(_2d4,_2d3);t=_2d3.constructor;if(t!==op.constructor){t.nom=_2a5;_2d4.constructor=t;}for(i=_2d7-1;i;--i){t=_2d5[i]._meta;if(t&&t.chains){_2d6=mix(_2d6||{},t.chains);}}if(_2d4["-chains-"]){_2d6=mix(_2d6||{},_2d4["-chains-"]);}t=!_2d6||!_2d6.hasOwnProperty(_2a5);_2d5[0]=ctor=(_2d6&&_2d6.constructor==="manual")?_2cb(_2d5):(_2d5.length==1?_2c9(_2d3.constructor,t):_2c4(_2d5,t));ctor._meta={bases:_2d5,hidden:_2d3,chains:_2d6,parents:_2d8,ctor:_2d3.constructor};ctor.superclass=_2d2&&_2d2.prototype;ctor.extend=_2c1;ctor.prototype=_2d4;_2d4.constructor=ctor;_2d4.getInherited=_2b4;_2d4.isInstanceOf=_2b7;_2d4.inherited=_2b6;_2d4.__inherited=_2ae;if(_2d1){_2d4.declaredClass=_2d1;lang.setObject(_2d1,ctor);}if(_2d6){for(name in _2d6){if(_2d4[name]&&typeof _2d6[name]=="string"&&name!=_2a5){t=_2d4[name]=_2cd(name,_2d5,_2d6[name]==="after");t.nom=name;}}}return ctor;};dojo.safeMixin=_2c3.safeMixin=_2bd;dojo.declare=_2c3;return _2c3;});},"dojo/dom":function(){define(["./_base/sniff","./_base/lang","./_base/window"],function(has,lang,win){try{document.execCommand("BackgroundImageCache",false,true);}catch(e){}var dom={};if(has("ie")){dom.byId=function(id,doc){if(typeof id!="string"){return id;}var _2d9=doc||win.doc,te=id&&_2d9.getElementById(id);if(te&&(te.attributes.id.value==id||te.id==id)){return te;}else{var eles=_2d9.all[id];if(!eles||eles.nodeName){eles=[eles];}var i=0;while((te=eles[i++])){if((te.attributes&&te.attributes.id&&te.attributes.id.value==id)||te.id==id){return te;}}}};}else{dom.byId=function(id,doc){return ((typeof id=="string")?(doc||win.doc).getElementById(id):id)||null;};}dom.isDescendant=function(node,_2da){try{node=dom.byId(node);_2da=dom.byId(_2da);while(node){if(node==_2da){return true;}node=node.parentNode;}}catch(e){}return false;};dom.setSelectable=function(node,_2db){node=dom.byId(node);if(has("mozilla")){node.style.MozUserSelect=_2db?"":"none";}else{if(has("khtml")||has("webkit")){node.style.KhtmlUserSelect=_2db?"auto":"none";}else{if(has("ie")){var v=(node.unselectable=_2db?"":"on"),cs=node.getElementsByTagName("*"),i=0,l=cs.length;for(;i<l;++i){cs.item(i).unselectable=v;}}}}};return dom;});},"dojo/_base/browser":function(){if(require.has){require.has.add("config-selectorEngine","acme");}define("dojo/_base/browser",["../ready","./kernel","./connect","./unload","./window","./event","./html","./NodeList","../query","./xhr","./fx"],function(dojo){return dojo;});},"dojo/selector/acme":function(){define(["../_base/kernel","../has","../dom","../_base/sniff","../_base/array","../_base/lang","../_base/window"],function(dojo,has,dom){var trim=dojo.trim;var each=dojo.forEach;var _2dc=function(){return dojo.doc;};var _2dd=((dojo.isWebKit||dojo.isMozilla)&&((_2dc().compatMode)=="BackCompat"));var _2de=">~+";var _2df=false;var _2e0=function(){return true;};var _2e1=function(_2e2){if(_2de.indexOf(_2e2.slice(-1))>=0){_2e2+=" * ";}else{_2e2+=" ";}var ts=function(s,e){return trim(_2e2.slice(s,e));};var _2e3=[];var _2e4=-1,_2e5=-1,_2e6=-1,_2e7=-1,_2e8=-1,inId=-1,_2e9=-1,lc="",cc="",_2ea;var x=0,ql=_2e2.length,_2eb=null,_2ec=null;var _2ed=function(){if(_2e9>=0){var tv=(_2e9==x)?null:ts(_2e9,x);_2eb[(_2de.indexOf(tv)<0)?"tag":"oper"]=tv;_2e9=-1;}};var _2ee=function(){if(inId>=0){_2eb.id=ts(inId,x).replace(/\\/g,"");inId=-1;}};var _2ef=function(){if(_2e8>=0){_2eb.classes.push(ts(_2e8+1,x).replace(/\\/g,""));_2e8=-1;}};var _2f0=function(){_2ee();_2ed();_2ef();};var _2f1=function(){_2f0();if(_2e7>=0){_2eb.pseudos.push({name:ts(_2e7+1,x)});}_2eb.loops=(_2eb.pseudos.length||_2eb.attrs.length||_2eb.classes.length);_2eb.oquery=_2eb.query=ts(_2ea,x);_2eb.otag=_2eb.tag=(_2eb["oper"])?null:(_2eb.tag||"*");if(_2eb.tag){_2eb.tag=_2eb.tag.toUpperCase();}if(_2e3.length&&(_2e3[_2e3.length-1].oper)){_2eb.infixOper=_2e3.pop();_2eb.query=_2eb.infixOper.query+" "+_2eb.query;}_2e3.push(_2eb);_2eb=null;};for(;lc=cc,cc=_2e2.charAt(x),x<ql;x++){if(lc=="\\"){continue;}if(!_2eb){_2ea=x;_2eb={query:null,pseudos:[],attrs:[],classes:[],tag:null,oper:null,id:null,getTag:function(){return (_2df)?this.otag:this.tag;}};_2e9=x;}if(_2e4>=0){if(cc=="]"){if(!_2ec.attr){_2ec.attr=ts(_2e4+1,x);}else{_2ec.matchFor=ts((_2e6||_2e4+1),x);}var cmf=_2ec.matchFor;if(cmf){if((cmf.charAt(0)=="\"")||(cmf.charAt(0)=="'")){_2ec.matchFor=cmf.slice(1,-1);}}_2eb.attrs.push(_2ec);_2ec=null;_2e4=_2e6=-1;}else{if(cc=="="){var _2f2=("|~^$*".indexOf(lc)>=0)?lc:"";_2ec.type=_2f2+cc;_2ec.attr=ts(_2e4+1,x-_2f2.length);_2e6=x+1;}}}else{if(_2e5>=0){if(cc==")"){if(_2e7>=0){_2ec.value=ts(_2e5+1,x);}_2e7=_2e5=-1;}}else{if(cc=="#"){_2f0();inId=x+1;}else{if(cc=="."){_2f0();_2e8=x;}else{if(cc==":"){_2f0();_2e7=x;}else{if(cc=="["){_2f0();_2e4=x;_2ec={};}else{if(cc=="("){if(_2e7>=0){_2ec={name:ts(_2e7+1,x),value:null};_2eb.pseudos.push(_2ec);}_2e5=x;}else{if((cc==" ")&&(lc!=cc)){_2f1();}}}}}}}}}return _2e3;};var _2f3=function(_2f4,_2f5){if(!_2f4){return _2f5;}if(!_2f5){return _2f4;}return function(){return _2f4.apply(window,arguments)&&_2f5.apply(window,arguments);};};var _2f6=function(i,arr){var r=arr||[];if(i){r.push(i);}return r;};var _2f7=function(n){return (1==n.nodeType);};var _2f8="";var _2f9=function(elem,attr){if(!elem){return _2f8;}if(attr=="class"){return elem.className||_2f8;}if(attr=="for"){return elem.htmlFor||_2f8;}if(attr=="style"){return elem.style.cssText||_2f8;}return (_2df?elem.getAttribute(attr):elem.getAttribute(attr,2))||_2f8;};var _2fa={"*=":function(attr,_2fb){return function(elem){return (_2f9(elem,attr).indexOf(_2fb)>=0);};},"^=":function(attr,_2fc){return function(elem){return (_2f9(elem,attr).indexOf(_2fc)==0);};},"$=":function(attr,_2fd){return function(elem){var ea=" "+_2f9(elem,attr);return (ea.lastIndexOf(_2fd)==(ea.length-_2fd.length));};},"~=":function(attr,_2fe){var tval=" "+_2fe+" ";return function(elem){var ea=" "+_2f9(elem,attr)+" ";return (ea.indexOf(tval)>=0);};},"|=":function(attr,_2ff){var _300=_2ff+"-";return function(elem){var ea=_2f9(elem,attr);return ((ea==_2ff)||(ea.indexOf(_300)==0));};},"=":function(attr,_301){return function(elem){return (_2f9(elem,attr)==_301);};}};var _302=(typeof _2dc().firstChild.nextElementSibling=="undefined");var _303=!_302?"nextElementSibling":"nextSibling";var _304=!_302?"previousElementSibling":"previousSibling";var _305=(_302?_2f7:_2e0);var _306=function(node){while(node=node[_304]){if(_305(node)){return false;}}return true;};var _307=function(node){while(node=node[_303]){if(_305(node)){return false;}}return true;};var _308=function(node){var root=node.parentNode;var i=0,tret=root.children||root.childNodes,ci=(node["_i"]||-1),cl=(root["_l"]||-1);if(!tret){return -1;}var l=tret.length;if(cl==l&&ci>=0&&cl>=0){return ci;}root["_l"]=l;ci=-1;for(var te=root["firstElementChild"]||root["firstChild"];te;te=te[_303]){if(_305(te)){te["_i"]=++i;if(node===te){ci=i;}}}return ci;};var _309=function(elem){return !((_308(elem))%2);};var _30a=function(elem){return ((_308(elem))%2);};var _30b={"checked":function(name,_30c){return function(elem){return !!("checked" in elem?elem.checked:elem.selected);};},"first-child":function(){return _306;},"last-child":function(){return _307;},"only-child":function(name,_30d){return function(node){return _306(node)&&_307(node);};},"empty":function(name,_30e){return function(elem){var cn=elem.childNodes;var cnl=elem.childNodes.length;for(var x=cnl-1;x>=0;x--){var nt=cn[x].nodeType;if((nt===1)||(nt==3)){return false;}}return true;};},"contains":function(name,_30f){var cz=_30f.charAt(0);if(cz=="\""||cz=="'"){_30f=_30f.slice(1,-1);}return function(elem){return (elem.innerHTML.indexOf(_30f)>=0);};},"not":function(name,_310){var p=_2e1(_310)[0];var _311={el:1};if(p.tag!="*"){_311.tag=1;}if(!p.classes.length){_311.classes=1;}var ntf=_312(p,_311);return function(elem){return (!ntf(elem));};},"nth-child":function(name,_313){var pi=parseInt;if(_313=="odd"){return _30a;}else{if(_313=="even"){return _309;}}if(_313.indexOf("n")!=-1){var _314=_313.split("n",2);var pred=_314[0]?((_314[0]=="-")?-1:pi(_314[0])):1;var idx=_314[1]?pi(_314[1]):0;var lb=0,ub=-1;if(pred>0){if(idx<0){idx=(idx%pred)&&(pred+(idx%pred));}else{if(idx>0){if(idx>=pred){lb=idx-idx%pred;}idx=idx%pred;}}}else{if(pred<0){pred*=-1;if(idx>0){ub=idx;idx=idx%pred;}}}if(pred>0){return function(elem){var i=_308(elem);return (i>=lb)&&(ub<0||i<=ub)&&((i%pred)==idx);};}else{_313=idx;}}var _315=pi(_313);return function(elem){return (_308(elem)==_315);};}};var _316=(dojo.isIE&&(dojo.isIE<9||dojo.isQuirks))?function(cond){var clc=cond.toLowerCase();if(clc=="class"){cond="className";}return function(elem){return (_2df?elem.getAttribute(cond):elem[cond]||elem[clc]);};}:function(cond){return function(elem){return (elem&&elem.getAttribute&&elem.hasAttribute(cond));};};var _312=function(_317,_318){if(!_317){return _2e0;}_318=_318||{};var ff=null;if(!("el" in _318)){ff=_2f3(ff,_2f7);}if(!("tag" in _318)){if(_317.tag!="*"){ff=_2f3(ff,function(elem){return (elem&&(elem.tagName==_317.getTag()));});}}if(!("classes" in _318)){each(_317.classes,function(_319,idx,arr){var re=new RegExp("(?:^|\\s)"+_319+"(?:\\s|$)");ff=_2f3(ff,function(elem){return re.test(elem.className);});ff.count=idx;});}if(!("pseudos" in _318)){each(_317.pseudos,function(_31a){var pn=_31a.name;if(_30b[pn]){ff=_2f3(ff,_30b[pn](pn,_31a.value));}});}if(!("attrs" in _318)){each(_317.attrs,function(attr){var _31b;var a=attr.attr;if(attr.type&&_2fa[attr.type]){_31b=_2fa[attr.type](a,attr.matchFor);}else{if(a.length){_31b=_316(a);}}if(_31b){ff=_2f3(ff,_31b);}});}if(!("id" in _318)){if(_317.id){ff=_2f3(ff,function(elem){return (!!elem&&(elem.id==_317.id));});}}if(!ff){if(!("default" in _318)){ff=_2e0;}}return ff;};var _31c=function(_31d){return function(node,ret,bag){while(node=node[_303]){if(_302&&(!_2f7(node))){continue;}if((!bag||_31e(node,bag))&&_31d(node)){ret.push(node);}break;}return ret;};};var _31f=function(_320){return function(root,ret,bag){var te=root[_303];while(te){if(_305(te)){if(bag&&!_31e(te,bag)){break;}if(_320(te)){ret.push(te);}}te=te[_303];}return ret;};};var _321=function(_322){_322=_322||_2e0;return function(root,ret,bag){var te,x=0,tret=root.children||root.childNodes;while(te=tret[x++]){if(_305(te)&&(!bag||_31e(te,bag))&&(_322(te,x))){ret.push(te);}}return ret;};};var _323=function(node,root){var pn=node.parentNode;while(pn){if(pn==root){break;}pn=pn.parentNode;}return !!pn;};var _324={};var _325=function(_326){var _327=_324[_326.query];if(_327){return _327;}var io=_326.infixOper;var oper=(io?io.oper:"");var _328=_312(_326,{el:1});var qt=_326.tag;var _329=("*"==qt);var ecs=_2dc()["getElementsByClassName"];if(!oper){if(_326.id){_328=(!_326.loops&&_329)?_2e0:_312(_326,{el:1,id:1});_327=function(root,arr){var te=dom.byId(_326.id,(root.ownerDocument||root));if(!te||!_328(te)){return;}if(9==root.nodeType){return _2f6(te,arr);}else{if(_323(te,root)){return _2f6(te,arr);}}};}else{if(ecs&&/\{\s*\[native code\]\s*\}/.test(String(ecs))&&_326.classes.length&&!_2dd){_328=_312(_326,{el:1,classes:1,id:1});var _32a=_326.classes.join(" ");_327=function(root,arr,bag){var ret=_2f6(0,arr),te,x=0;var tret=root.getElementsByClassName(_32a);while((te=tret[x++])){if(_328(te,root)&&_31e(te,bag)){ret.push(te);}}return ret;};}else{if(!_329&&!_326.loops){_327=function(root,arr,bag){var ret=_2f6(0,arr),te,x=0;var tret=root.getElementsByTagName(_326.getTag());while((te=tret[x++])){if(_31e(te,bag)){ret.push(te);}}return ret;};}else{_328=_312(_326,{el:1,tag:1,id:1});_327=function(root,arr,bag){var ret=_2f6(0,arr),te,x=0;var tret=root.getElementsByTagName(_326.getTag());while((te=tret[x++])){if(_328(te,root)&&_31e(te,bag)){ret.push(te);}}return ret;};}}}}else{var _32b={el:1};if(_329){_32b.tag=1;}_328=_312(_326,_32b);if("+"==oper){_327=_31c(_328);}else{if("~"==oper){_327=_31f(_328);}else{if(">"==oper){_327=_321(_328);}}}}return _324[_326.query]=_327;};var _32c=function(root,_32d){var _32e=_2f6(root),qp,x,te,qpl=_32d.length,bag,ret;for(var i=0;i<qpl;i++){ret=[];qp=_32d[i];x=_32e.length-1;if(x>0){bag={};ret.nozip=true;}var gef=_325(qp);for(var j=0;(te=_32e[j]);j++){gef(te,ret,bag);}if(!ret.length){break;}_32e=ret;}return ret;};var _32f={},_330={};var _331=function(_332){var _333=_2e1(trim(_332));if(_333.length==1){var tef=_325(_333[0]);return function(root){var r=tef(root,[]);if(r){r.nozip=true;}return r;};}return function(root){return _32c(root,_333);};};var nua=navigator.userAgent;var wk="WebKit/";var _334=(dojo.isWebKit&&(nua.indexOf(wk)>0)&&(parseFloat(nua.split(wk)[1])>528));var _335=dojo.isIE?"commentStrip":"nozip";var qsa="querySelectorAll";var _336=(!!_2dc()[qsa]&&(!dojo.isSafari||(dojo.isSafari>3.1)||_334));var _337=/n\+\d|([^ ])?([>~+])([^ =])?/g;var _338=function(_339,pre,ch,post){return ch?(pre?pre+" ":"")+ch+(post?" "+post:""):_339;};var _33a=function(_33b,_33c){_33b=_33b.replace(_337,_338);if(_336){var _33d=_330[_33b];if(_33d&&!_33c){return _33d;}}var _33e=_32f[_33b];if(_33e){return _33e;}var qcz=_33b.charAt(0);var _33f=(-1==_33b.indexOf(" "));if((_33b.indexOf("#")>=0)&&(_33f)){_33c=true;}var _340=(_336&&(!_33c)&&(_2de.indexOf(qcz)==-1)&&(!dojo.isIE||(_33b.indexOf(":")==-1))&&(!(_2dd&&(_33b.indexOf(".")>=0)))&&(_33b.indexOf(":contains")==-1)&&(_33b.indexOf(":checked")==-1)&&(_33b.indexOf("|=")==-1));if(_340){var tq=(_2de.indexOf(_33b.charAt(_33b.length-1))>=0)?(_33b+" *"):_33b;return _330[_33b]=function(root){try{if(!((9==root.nodeType)||_33f)){throw "";}var r=root[qsa](tq);r[_335]=true;return r;}catch(e){return _33a(_33b,true)(root);}};}else{var _341=_33b.split(/\s*,\s*/);return _32f[_33b]=((_341.length<2)?_331(_33b):function(root){var _342=0,ret=[],tp;while((tp=_341[_342++])){ret=ret.concat(_331(tp)(root));}return ret;});}};var _343=0;var _344=dojo.isIE?function(node){if(_2df){return (node.getAttribute("_uid")||node.setAttribute("_uid",++_343)||_343);}else{return node.uniqueID;}}:function(node){return (node._uid||(node._uid=++_343));};var _31e=function(node,bag){if(!bag){return 1;}var id=_344(node);if(!bag[id]){return bag[id]=1;}return 0;};var _345="_zipIdx";var _346=function(arr){if(arr&&arr.nozip){return arr;}var ret=[];if(!arr||!arr.length){return ret;}if(arr[0]){ret.push(arr[0]);}if(arr.length<2){return ret;}_343++;if(dojo.isIE&&_2df){var _347=_343+"";arr[0].setAttribute(_345,_347);for(var x=1,te;te=arr[x];x++){if(arr[x].getAttribute(_345)!=_347){ret.push(te);}te.setAttribute(_345,_347);}}else{if(dojo.isIE&&arr.commentStrip){try{for(var x=1,te;te=arr[x];x++){if(_2f7(te)){ret.push(te);}}}catch(e){}}else{if(arr[0]){arr[0][_345]=_343;}for(var x=1,te;te=arr[x];x++){if(arr[x][_345]!=_343){ret.push(te);}te[_345]=_343;}}}return ret;};var _348=function(_349,root){root=root||_2dc();var od=root.ownerDocument||root.documentElement;_2df=(root.contentType&&root.contentType=="application/xml")||(dojo.isOpera&&(root.doctype||od.toString()=="[object XMLDocument]"))||(!!od)&&(dojo.isIE?od.xml:(root.xmlVersion||od.xmlVersion));var r=_33a(_349)(root);if(r&&r.nozip){return r;}return _346(r);};_348.filter=function(_34a,_34b,root){var _34c=[],_34d=_2e1(_34b),_34e=(_34d.length==1&&!/[^\w#\.]/.test(_34b))?_312(_34d[0]):function(node){return dojo.query(_34b,root).indexOf(node)!=-1;};for(var x=0,te;te=_34a[x];x++){if(_34e(te)){_34c.push(te);}}return _34c;};return _348;});},"dojo/dom-style":function(){define(["./_base/sniff","./dom"],function(has,dom){var _34f,_350={};if(has("webkit")){_34f=function(node){var s;if(node.nodeType==1){var dv=node.ownerDocument.defaultView;s=dv.getComputedStyle(node,null);if(!s&&node.style){node.style.display="";s=dv.getComputedStyle(node,null);}}return s||{};};}else{if(has("ie")&&(has("ie")<9||has("quirks"))){_34f=function(node){return node.nodeType==1?node.currentStyle:{};};}else{_34f=function(node){return node.nodeType==1?node.ownerDocument.defaultView.getComputedStyle(node,null):{};};}}_350.getComputedStyle=_34f;var _351;if(!has("ie")){_351=function(_352,_353){return parseFloat(_353)||0;};}else{_351=function(_354,_355){if(!_355){return 0;}if(_355=="medium"){return 4;}if(_355.slice&&_355.slice(-2)=="px"){return parseFloat(_355);}var s=_354.style,rs=_354.runtimeStyle,cs=_354.currentStyle,_356=s.left,_357=rs.left;rs.left=cs.left;try{s.left=_355;_355=s.pixelLeft;}catch(e){_355=0;}s.left=_356;rs.left=_357;return _355;};}_350.toPixelValue=_351;var astr="DXImageTransform.Microsoft.Alpha";var af=function(n,f){try{return n.filters.item(astr);}catch(e){return f?{}:null;}};var _358=has("ie")<9||(has("ie")&&has("quirks"))?function(node){try{return af(node).Opacity/100;}catch(e){return 1;}}:function(node){return _34f(node).opacity;};var _359=has("ie")<9||(has("ie")&&has("quirks"))?function(node,_35a){var ov=_35a*100,_35b=_35a==1;node.style.zoom=_35b?"":1;if(!af(node)){if(_35b){return _35a;}node.style.filter+=" progid:"+astr+"(Opacity="+ov+")";}else{af(node,1).Opacity=ov;}af(node,1).Enabled=!_35b;if(node.tagName.toLowerCase()=="tr"){for(var td=node.firstChild;td;td=td.nextSibling){if(td.tagName.toLowerCase()=="td"){_359(td,_35a);}}}return _35a;}:function(node,_35c){return node.style.opacity=_35c;};var _35d={left:true,top:true};var _35e=/margin|padding|width|height|max|min|offset/;function _35f(node,type,_360){type=type.toLowerCase();if(has("ie")){if(_360=="auto"){if(type=="height"){return node.offsetHeight;}if(type=="width"){return node.offsetWidth;}}if(type=="fontweight"){switch(_360){case 700:return "bold";case 400:default:return "normal";}}}if(!(type in _35d)){_35d[type]=_35e.test(type);}return _35d[type]?_351(node,_360):_360;};var _361=has("ie")?"styleFloat":"cssFloat",_362={"cssFloat":_361,"styleFloat":_361,"float":_361};_350.get=function getStyle(node,name){var n=dom.byId(node),l=arguments.length,op=(name=="opacity");if(l==2&&op){return _358(n);}name=_362[name]||name;var s=_350.getComputedStyle(n);return (l==1)?s:_35f(n,name,s[name]||n.style[name]);};_350.set=function setStyle(node,name,_363){var n=dom.byId(node),l=arguments.length,op=(name=="opacity");name=_362[name]||name;if(l==3){return op?_359(n,_363):n.style[name]=_363;}for(var x in name){_350.set(node,x,name[x]);}return _350.getComputedStyle(n);};return _350;});},"dojo/dom-geometry":function(){define(["./_base/sniff","./_base/window","./dom","./dom-style"],function(has,win,dom,_364){var geom={};geom.boxModel="content-box";if(has("ie")){geom.boxModel=document.compatMode=="BackCompat"?"border-box":"content-box";}geom.getPadExtents=function getPadExtents(node,_365){node=dom.byId(node);var s=_365||_364.getComputedStyle(node),px=_364.toPixelValue,l=px(node,s.paddingLeft),t=px(node,s.paddingTop),r=px(node,s.paddingRight),b=px(node,s.paddingBottom);return {l:l,t:t,r:r,b:b,w:l+r,h:t+b};};var none="none";geom.getBorderExtents=function getBorderExtents(node,_366){node=dom.byId(node);var px=_364.toPixelValue,s=_366||_364.getComputedStyle(node),l=s.borderLeftStyle!=none?px(node,s.borderLeftWidth):0,t=s.borderTopStyle!=none?px(node,s.borderTopWidth):0,r=s.borderRightStyle!=none?px(node,s.borderRightWidth):0,b=s.borderBottomStyle!=none?px(node,s.borderBottomWidth):0;return {l:l,t:t,r:r,b:b,w:l+r,h:t+b};};geom.getPadBorderExtents=function getPadBorderExtents(node,_367){node=dom.byId(node);var s=_367||_364.getComputedStyle(node),p=geom.getPadExtents(node,s),b=geom.getBorderExtents(node,s);return {l:p.l+b.l,t:p.t+b.t,r:p.r+b.r,b:p.b+b.b,w:p.w+b.w,h:p.h+b.h};};geom.getMarginExtents=function getMarginExtents(node,_368){node=dom.byId(node);var s=_368||_364.getComputedStyle(node),px=_364.toPixelValue,l=px(node,s.marginLeft),t=px(node,s.marginTop),r=px(node,s.marginRight),b=px(node,s.marginBottom);if(has("webkit")&&(s.position!="absolute")){r=l;}return {l:l,t:t,r:r,b:b,w:l+r,h:t+b};};geom.getMarginBox=function getMarginBox(node,_369){node=dom.byId(node);var s=_369||_364.getComputedStyle(node),me=geom.getMarginExtents(node,s),l=node.offsetLeft-me.l,t=node.offsetTop-me.t,p=node.parentNode,px=_364.toPixelValue,pcs;if(has("mozilla")){var sl=parseFloat(s.left),st=parseFloat(s.top);if(!isNaN(sl)&&!isNaN(st)){l=sl,t=st;}else{if(p&&p.style){pcs=_364.getComputedStyle(p);if(pcs.overflow!="visible"){l+=pcs.borderLeftStyle!=none?px(node,pcs.borderLeftWidth):0;t+=pcs.borderTopStyle!=none?px(node,pcs.borderTopWidth):0;}}}}else{if(has("opera")||(has("ie")==8&&!has("quirks"))){if(p){pcs=_364.getComputedStyle(p);l-=pcs.borderLeftStyle!=none?px(node,pcs.borderLeftWidth):0;t-=pcs.borderTopStyle!=none?px(node,pcs.borderTopWidth):0;}}}return {l:l,t:t,w:node.offsetWidth+me.w,h:node.offsetHeight+me.h};};geom.getContentBox=function getContentBox(node,_36a){node=dom.byId(node);var s=_36a||_364.getComputedStyle(node),w=node.clientWidth,h,pe=geom.getPadExtents(node,s),be=geom.getBorderExtents(node,s);if(!w){w=node.offsetWidth;h=node.offsetHeight;}else{h=node.clientHeight;be.w=be.h=0;}if(has("opera")){pe.l+=be.l;pe.t+=be.t;}return {l:pe.l,t:pe.t,w:w-pe.w-be.w,h:h-pe.h-be.h};};function _36b(node,l,t,w,h,u){u=u||"px";var s=node.style;if(!isNaN(l)){s.left=l+u;}if(!isNaN(t)){s.top=t+u;}if(w>=0){s.width=w+u;}if(h>=0){s.height=h+u;}};function _36c(node){return node.tagName.toLowerCase()=="button"||node.tagName.toLowerCase()=="input"&&(node.getAttribute("type")||"").toLowerCase()=="button";};function _36d(node){return geom.boxModel=="border-box"||node.tagName.toLowerCase()=="table"||_36c(node);};geom.setContentSize=function setContentSize(node,box,_36e){node=dom.byId(node);var w=box.w,h=box.h;if(_36d(node)){var pb=geom.getPadBorderExtents(node,_36e);if(w>=0){w+=pb.w;}if(h>=0){h+=pb.h;}}_36b(node,NaN,NaN,w,h);};var _36f={l:0,t:0,w:0,h:0};geom.setMarginBox=function setMarginBox(node,box,_370){node=dom.byId(node);var s=_370||_364.getComputedStyle(node),w=box.w,h=box.h,pb=_36d(node)?_36f:geom.getPadBorderExtents(node,s),mb=geom.getMarginExtents(node,s);if(has("webkit")){if(_36c(node)){var ns=node.style;if(w>=0&&!ns.width){ns.width="4px";}if(h>=0&&!ns.height){ns.height="4px";}}}if(w>=0){w=Math.max(w-pb.w-mb.w,0);}if(h>=0){h=Math.max(h-pb.h-mb.h,0);}_36b(node,box.l,box.t,w,h);};geom.isBodyLtr=function isBodyLtr(){return (win.body().dir||win.doc.documentElement.dir||"ltr").toLowerCase()=="ltr";};geom.docScroll=function docScroll(){var node=win.doc.parentWindow||win.doc.defaultView;return "pageXOffset" in node?{x:node.pageXOffset,y:node.pageYOffset}:(node=has("quirks")?win.body():win.doc.documentElement,{x:geom.fixIeBiDiScrollLeft(node.scrollLeft||0),y:node.scrollTop||0});};geom.getIeDocumentElementOffset=function getIeDocumentElementOffset(){var de=win.doc.documentElement;if(has("ie")<8){var r=de.getBoundingClientRect(),l=r.left,t=r.top;if(has("ie")<7){l+=de.clientLeft;t+=de.clientTop;}return {x:l<0?0:l,y:t<0?0:t};}else{return {x:0,y:0};}};geom.fixIeBiDiScrollLeft=function fixIeBiDiScrollLeft(_371){var ie=has("ie");if(ie&&!geom.isBodyLtr()){var qk=has("quirks"),de=qk?win.body():win.doc.documentElement;if(ie==6&&!qk&&win.global.frameElement&&de.scrollHeight>de.clientHeight){_371+=de.clientLeft;}return (ie<8||qk)?(_371+de.clientWidth-de.scrollWidth):-_371;}return _371;};geom.position=function(node,_372){node=dom.byId(node);var db=win.body(),dh=db.parentNode,ret=node.getBoundingClientRect();ret={x:ret.left,y:ret.top,w:ret.right-ret.left,h:ret.bottom-ret.top};if(has("ie")){var _373=geom.getIeDocumentElementOffset();ret.x-=_373.x+(has("quirks")?db.clientLeft+db.offsetLeft:0);ret.y-=_373.y+(has("quirks")?db.clientTop+db.offsetTop:0);}else{if(has("ff")==3){var cs=_364.getComputedStyle(dh),px=_364.toPixelValue;ret.x-=px(dh,cs.marginLeft)+px(dh,cs.borderLeftWidth);ret.y-=px(dh,cs.marginTop)+px(dh,cs.borderTopWidth);}}if(_372){var _374=geom.docScroll();ret.x+=_374.x;ret.y+=_374.y;}return ret;};geom.getMarginSize=function getMarginSize(node,_375){node=dom.byId(node);var me=geom.getMarginExtents(node,_375||_364.getComputedStyle(node));var size=node.getBoundingClientRect();return {w:(size.right-size.left)+me.w,h:(size.bottom-size.top)+me.h};};geom.normalizeEvent=function(_376){if(!("layerX" in _376)){_376.layerX=_376.offsetX;_376.layerY=_376.offsetY;}if(!has("dom-addeventlistener")){var se=_376.target;var doc=(se&&se.ownerDocument)||document;var _377=has("quirks")?doc.body:doc.documentElement;var _378=geom.getIeDocumentElementOffset();_376.pageX=_376.clientX+geom.fixIeBiDiScrollLeft(_377.scrollLeft||0)-_378.x;_376.pageY=_376.clientY+(_377.scrollTop||0)-_378.y;}};return geom;});},"dojo/dom-prop":function(){define("dojo/dom-prop",["exports","./_base/kernel","./_base/sniff","./_base/lang","./dom","./dom-style","./dom-construct","./_base/connect"],function(_379,dojo,has,lang,dom,_37a,ctr,conn){var _37b={},_37c=0,_37d=dojo._scopeName+"attrid";var _37e={col:1,colgroup:1,table:1,tbody:1,tfoot:1,thead:1,tr:1,title:1};_379.names={"class":"className","for":"htmlFor",tabindex:"tabIndex",readonly:"readOnly",colspan:"colSpan",frameborder:"frameBorder",rowspan:"rowSpan",valuetype:"valueType"};_379.get=function getProp(node,name){node=dom.byId(node);var lc=name.toLowerCase(),_37f=_379.names[lc]||name;return node[_37f];};_379.set=function setProp(node,name,_380){node=dom.byId(node);var l=arguments.length;if(l==2&&typeof name!="string"){for(var x in name){_379.set(node,x,name[x]);}return node;}var lc=name.toLowerCase(),_381=_379.names[lc]||name;if(_381=="style"&&typeof _380!="string"){_37a.style(node,_380);return node;}if(_381=="innerHTML"){if(has("ie")&&node.tagName.toLowerCase() in _37e){ctr.empty(node);node.appendChild(ctr.toDom(_380,node.ownerDocument));}else{node[_381]=_380;}return node;}if(lang.isFunction(_380)){var _382=node[_37d];if(!_382){_382=_37c++;node[_37d]=_382;}if(!_37b[_382]){_37b[_382]={};}var h=_37b[_382][_381];if(h){conn.disconnect(h);}else{try{delete node[_381];}catch(e){}}if(_380){_37b[_382][_381]=conn.connect(node,_381,_380);}else{node[_381]=null;}return node;}node[_381]=_380;return node;};});},"dojo/dom-attr":function(){define(["exports","./_base/sniff","./_base/lang","./dom","./dom-style","./dom-prop"],function(_383,has,lang,dom,_384,prop){var _385={innerHTML:1,className:1,htmlFor:has("ie"),value:1},_386={classname:"class",htmlfor:"for",tabindex:"tabIndex",readonly:"readOnly"};function _387(node,name){var attr=node.getAttributeNode&&node.getAttributeNode(name);return attr&&attr.specified;};_383.has=function hasAttr(node,name){var lc=name.toLowerCase();return _385[prop.names[lc]||name]||_387(dom.byId(node),_386[lc]||name);};_383.get=function getAttr(node,name){node=dom.byId(node);var lc=name.toLowerCase(),_388=prop.names[lc]||name,_389=_385[_388];value=node[_388];if(_389&&typeof value!="undefined"){return value;}if(_388!="href"&&(typeof value=="boolean"||lang.isFunction(value))){return value;}var _38a=_386[lc]||name;return _387(node,_38a)?node.getAttribute(_38a):null;};_383.set=function setAttr(node,name,_38b){node=dom.byId(node);if(arguments.length==2){for(var x in name){_383.set(node,x,name[x]);}return node;}var lc=name.toLowerCase(),_38c=prop.names[lc]||name,_38d=_385[_38c];if(_38c=="style"&&typeof _38b!="string"){_384.set(node,_38b);return node;}if(_38d||typeof _38b=="boolean"||lang.isFunction(_38b)){return prop.set(node,name,_38b);}node.setAttribute(_386[lc]||name,_38b);return node;};_383.remove=function removeAttr(node,name){dom.byId(node).removeAttribute(_386[name.toLowerCase()]||name);};_383.getNodeProp=function getNodeProp(node,name){node=dom.byId(node);var lc=name.toLowerCase(),_38e=prop.names[lc]||name;if((_38e in node)&&_38e!="href"){return node[_38e];}var _38f=_386[lc]||name;return _387(node,_38f)?node.getAttribute(_38f):null;};});},"dojo/dom-construct":function(){define("dojo/dom-construct",["exports","./_base/kernel","./_base/sniff","./_base/window","./dom","./dom-attr","./on"],function(_390,dojo,has,win,dom,attr,on){var _391={option:["select"],tbody:["table"],thead:["table"],tfoot:["table"],tr:["table","tbody"],td:["table","tbody","tr"],th:["table","thead","tr"],legend:["fieldset"],caption:["table"],colgroup:["table"],col:["table","colgroup"],li:["ul"]},_392=/<\s*([\w\:]+)/,_393={},_394=0,_395="__"+dojo._scopeName+"ToDomId";for(var _396 in _391){if(_391.hasOwnProperty(_396)){var tw=_391[_396];tw.pre=_396=="option"?"<select multiple=\"multiple\">":"<"+tw.join("><")+">";tw.post="</"+tw.reverse().join("></")+">";}}function _397(node,ref){var _398=ref.parentNode;if(_398){_398.insertBefore(node,ref);}};function _399(node,ref){var _39a=ref.parentNode;if(_39a){if(_39a.lastChild==ref){_39a.appendChild(node);}else{_39a.insertBefore(node,ref.nextSibling);}}};var _39b=null,_39c;on(window,"unload",function(){_39b=null;});_390.toDom=function toDom(frag,doc){doc=doc||win.doc;var _39d=doc[_395];if(!_39d){doc[_395]=_39d=++_394+"";_393[_39d]=doc.createElement("div");}frag+="";var _39e=frag.match(_392),tag=_39e?_39e[1].toLowerCase():"",_39f=_393[_39d],wrap,i,fc,df;if(_39e&&_391[tag]){wrap=_391[tag];_39f.innerHTML=wrap.pre+frag+wrap.post;for(i=wrap.length;i;--i){_39f=_39f.firstChild;}}else{_39f.innerHTML=frag;}if(_39f.childNodes.length==1){return _39f.removeChild(_39f.firstChild);}df=doc.createDocumentFragment();while(fc=_39f.firstChild){df.appendChild(fc);}return df;};_390.place=function place(node,_3a0,_3a1){_3a0=dom.byId(_3a0);if(typeof node=="string"){node=/^\s*</.test(node)?_390.toDom(node,_3a0.ownerDocument):dom.byId(node);}if(typeof _3a1=="number"){var cn=_3a0.childNodes;if(!cn.length||cn.length<=_3a1){_3a0.appendChild(node);}else{_397(node,cn[_3a1<0?0:_3a1]);}}else{switch(_3a1){case "before":_397(node,_3a0);break;case "after":_399(node,_3a0);break;case "replace":_3a0.parentNode.replaceChild(node,_3a0);break;case "only":_390.empty(_3a0);_3a0.appendChild(node);break;case "first":if(_3a0.firstChild){_397(node,_3a0.firstChild);break;}default:_3a0.appendChild(node);}}return node;};_390.create=function create(tag,_3a2,_3a3,pos){var doc=win.doc;if(_3a3){_3a3=dom.byId(_3a3);doc=_3a3.ownerDocument;}if(typeof tag=="string"){tag=doc.createElement(tag);}if(_3a2){attr.set(tag,_3a2);}if(_3a3){_390.place(tag,_3a3,pos);}return tag;};_390.empty=has("ie")?function(node){node=dom.byId(node);for(var c;c=node.lastChild;){_390.destroy(c);}}:function(node){dom.byId(node).innerHTML="";};_390.destroy=function destroy(node){node=dom.byId(node);try{var doc=node.ownerDocument;if(!_39b||_39c!=doc){_39b=doc.createElement("div");_39c=doc;}_39b.appendChild(node.parentNode?node.parentNode.removeChild(node):node);_39b.innerHTML="";}catch(e){}};});},"dojo/text":function(){define(["./_base/kernel","require","./has","./_base/xhr"],function(dojo,_3a4,has,xhr){var _3a5;if(1){_3a5=function(url,sync,load){xhr("GET",{url:url,sync:!!sync,load:load});};}else{if(_3a4.getText){_3a5=_3a4.getText;}else{console.error("dojo/text plugin failed to load because loader does not support getText");}}var _3a6={},_3a7=function(text){if(text){text=text.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,"");var _3a8=text.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);if(_3a8){text=_3a8[1];}}else{text="";}return text;},_3a9={},_3aa={},_3ab={dynamic:true,normalize:function(id,_3ac){var _3ad=id.split("!"),url=_3ad[0];return (/^\./.test(url)?_3ac(url):url)+(_3ad[1]?"!"+_3ad[1]:"");},load:function(id,_3ae,load){var _3af=id.split("!"),_3b0=_3af.length>1,_3b1=_3af[0],url=_3ae.toUrl(_3af[0]),text=_3a9,_3b2=function(text){load(_3b0?_3a7(text):text);};if(_3b1 in _3a6){text=_3a6[_3b1];}else{if(url in _3ae.cache){text=_3ae.cache[url];}else{if(url in _3a6){text=_3a6[url];}}}if(text===_3a9){if(_3aa[url]){_3aa[url].push(_3b2);}else{var _3b3=_3aa[url]=[_3b2];_3a5(url,!_3ae.async,function(text){_3a6[_3b1]=_3a6[url]=text;for(var i=0;i<_3b3.length;){_3b3[i++](text);}delete _3aa[url];});}}else{_3b2(text);}}};dojo.cache=function(_3b4,url,_3b5){var key;if(typeof _3b4=="string"){if(/\//.test(_3b4)){key=_3b4;_3b5=url;}else{key=_3a4.toUrl(_3b4.replace(/\./g,"/")+(url?("/"+url):""));}}else{key=_3b4+"";_3b5=url;}var val=(_3b5!=undefined&&typeof _3b5!="string")?_3b5.value:_3b5,_3b6=_3b5&&_3b5.sanitize;if(typeof val=="string"){_3a6[key]=val;return _3b6?_3a7(val):val;}else{if(val===null){delete _3a6[key];return null;}else{if(!(key in _3a6)){_3a5(key,true,function(text){_3a6[key]=text;});}return _3b6?_3a7(_3a6[key]):_3a6[key];}}};return _3ab;});},"dojo/keys":function(){define("dojo/keys",["./_base/kernel","./_base/sniff"],function(dojo,has){return dojo.keys={BACKSPACE:8,TAB:9,CLEAR:12,ENTER:13,SHIFT:16,CTRL:17,ALT:18,META:has("safari")?91:224,PAUSE:19,CAPS_LOCK:20,ESCAPE:27,SPACE:32,PAGE_UP:33,PAGE_DOWN:34,END:35,HOME:36,LEFT_ARROW:37,UP_ARROW:38,RIGHT_ARROW:39,DOWN_ARROW:40,INSERT:45,DELETE:46,HELP:47,LEFT_WINDOW:91,RIGHT_WINDOW:92,SELECT:93,NUMPAD_0:96,NUMPAD_1:97,NUMPAD_2:98,NUMPAD_3:99,NUMPAD_4:100,NUMPAD_5:101,NUMPAD_6:102,NUMPAD_7:103,NUMPAD_8:104,NUMPAD_9:105,NUMPAD_MULTIPLY:106,NUMPAD_PLUS:107,NUMPAD_ENTER:108,NUMPAD_MINUS:109,NUMPAD_PERIOD:110,NUMPAD_DIVIDE:111,F1:112,F2:113,F3:114,F4:115,F5:116,F6:117,F7:118,F8:119,F9:120,F10:121,F11:122,F12:123,F13:124,F14:125,F15:126,NUM_LOCK:144,SCROLL_LOCK:145,UP_DPAD:175,DOWN_DPAD:176,LEFT_DPAD:177,RIGHT_DPAD:178,copyKey:has("mac")&&!has("air")?(has("safari")?91:224):17};});},"dojo/domReady":function(){define(["./has"],function(has){var _3b7=this,doc=document,_3b8={"loaded":1,"complete":1},_3b9=typeof doc.readyState!="string",_3ba=!!_3b8[doc.readyState];if(_3b9){doc.readyState="loading";}if(!_3ba){var _3bb=[],_3bc=[],_3bd=function(evt){evt=evt||_3b7.event;if(_3ba||(evt.type=="readystatechange"&&!_3b8[doc.readyState])){return;}_3ba=1;if(_3b9){doc.readyState="complete";}while(_3bb.length){(_3bb.shift())();}},on=function(node,_3be){node.addEventListener(_3be,_3bd,false);_3bb.push(function(){node.removeEventListener(_3be,_3bd,false);});};if(!has("dom-addeventlistener")){on=function(node,_3bf){_3bf="on"+_3bf;node.attachEvent(_3bf,_3bd);_3bb.push(function(){node.detachEvent(_3bf,_3bd);});};var div=doc.createElement("div");try{if(div.doScroll&&_3b7.frameElement===null){_3bc.push(function(){try{div.doScroll("left");return 1;}catch(e){}});}}catch(e){}}on(doc,"DOMContentLoaded");on(_3b7,"load");if("onreadystatechange" in doc){on(doc,"readystatechange");}else{if(!_3b9){_3bc.push(function(){return _3b8[doc.readyState];});}}if(_3bc.length){var _3c0=function(){if(_3ba){return;}var i=_3bc.length;while(i--){if(_3bc[i]()){_3bd("poller");return;}}setTimeout(_3c0,30);};_3c0();}}function _3c1(_3c2){if(_3ba){_3c2(1);}else{_3bb.push(_3c2);}};_3c1.load=function(id,req,load){_3c1(load);};return _3c1;});},"dojo/_base/lang":function(){define(["./kernel","../has","./sniff"],function(dojo,has){has.add("bug-for-in-skips-shadowed",function(){for(var i in {toString:1}){return 0;}return 1;});var _3c3=has("bug-for-in-skips-shadowed")?"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split("."):[],_3c4=_3c3.length,_3c5=function(dest,_3c6,_3c7){var name,s,i,_3c8={};for(name in _3c6){s=_3c6[name];if(!(name in dest)||(dest[name]!==s&&(!(name in _3c8)||_3c8[name]!==s))){dest[name]=_3c7?_3c7(s):s;}}if(has("bug-for-in-skips-shadowed")){if(_3c6){for(i=0;i<_3c4;++i){name=_3c3[i];s=_3c6[name];if(!(name in dest)||(dest[name]!==s&&(!(name in _3c8)||_3c8[name]!==s))){dest[name]=_3c7?_3c7(s):s;}}}}return dest;},_3c9=function(dest,_3ca){if(!dest){dest={};}for(var i=1,l=arguments.length;i<l;i++){lang._mixin(dest,arguments[i]);}return dest;},_3cb=function(_3cc,_3cd,_3ce){var p,i=0,_3cf=dojo.global;if(!_3ce){if(!_3cc.length){return _3cf;}else{p=_3cc[i++];try{_3ce=dojo.scopeMap[p]&&dojo.scopeMap[p][1];}catch(e){}_3ce=_3ce||(p in _3cf?_3cf[p]:(_3cd?_3cf[p]={}:undefined));}}while(_3ce&&(p=_3cc[i++])){_3ce=(p in _3ce?_3ce[p]:(_3cd?_3ce[p]={}:undefined));}return _3ce;},_3d0=function(name,_3d1,_3d2){var _3d3=name.split("."),p=_3d3.pop(),obj=_3cb(_3d3,true,_3d2);return obj&&p?(obj[p]=_3d1):undefined;},_3d4=function(name,_3d5,_3d6){return _3cb(name.split("."),_3d5,_3d6);},_3d7=function(name,obj){return lang.getObject(name,false,obj)!==undefined;},opts=Object.prototype.toString,_3d8=function(it){return (typeof it=="string"||it instanceof String);},_3d9=function(it){return it&&(it instanceof Array||typeof it=="array");},_3da=function(it){return opts.call(it)==="[object Function]";},_3db=function(it){return it!==undefined&&(it===null||typeof it=="object"||lang.isArray(it)||lang.isFunction(it));},_3dc=function(it){return it&&it!==undefined&&!lang.isString(it)&&!lang.isFunction(it)&&!(it.tagName&&it.tagName.toLowerCase()=="form")&&(lang.isArray(it)||isFinite(it.length));},_3dd=function(it){return it&&!lang.isFunction(it)&&/\{\s*\[native code\]\s*\}/.test(String(it));},_3de=function(_3df,_3e0){for(var i=1,l=arguments.length;i<l;i++){lang._mixin(_3df.prototype,arguments[i]);}return _3df;},_3e1=function(_3e2,_3e3){var pre=_3e4(arguments,2);var _3e5=lang.isString(_3e3);return function(){var args=_3e4(arguments);var f=_3e5?(_3e2||dojo.global)[_3e3]:_3e3;return f&&f.apply(_3e2||this,pre.concat(args));};},_3e6=function(_3e7,_3e8){if(arguments.length>2){return lang._hitchArgs.apply(dojo,arguments);}if(!_3e8){_3e8=_3e7;_3e7=null;}if(lang.isString(_3e8)){_3e7=_3e7||dojo.global;if(!_3e7[_3e8]){throw (["dojo.hitch: scope[\"",_3e8,"\"] is null (scope=\"",_3e7,"\")"].join(""));}return function(){return _3e7[_3e8].apply(_3e7,arguments||[]);};}return !_3e7?_3e8:function(){return _3e8.apply(_3e7,arguments||[]);};},_3e9=(function(){function TMP(){};return function(obj,_3ea){TMP.prototype=obj;var tmp=new TMP();TMP.prototype=null;if(_3ea){lang._mixin(tmp,_3ea);}return tmp;};})(),_3eb=function(obj,_3ec,_3ed){return (_3ed||[]).concat(Array.prototype.slice.call(obj,_3ec||0));},_3e4=has("ie")?(function(){function slow(obj,_3ee,_3ef){var arr=_3ef||[];for(var x=_3ee||0;x<obj.length;x++){arr.push(obj[x]);}return arr;};return function(obj){return ((obj.item)?slow:_3eb).apply(this,arguments);};})():_3eb,_3f0=function(_3f1){var arr=[null];return lang.hitch.apply(dojo,arr.concat(lang._toArray(arguments)));},_3f2=function(src){if(!src||typeof src!="object"||lang.isFunction(src)){return src;}if(src.nodeType&&"cloneNode" in src){return src.cloneNode(true);}if(src instanceof Date){return new Date(src.getTime());}if(src instanceof RegExp){return new RegExp(src);}var r,i,l;if(lang.isArray(src)){r=[];for(i=0,l=src.length;i<l;++i){if(i in src){r.push(_3f2(src[i]));}}}else{r=src.constructor?new src.constructor():{};}return lang._mixin(r,src,_3f2);},trim=String.prototype.trim?function(str){return str.trim();}:function(str){return str.replace(/^\s\s*/,"").replace(/\s\s*$/,"");},_3f3=/\{([^\}]+)\}/g,_3f4=function(tmpl,map,_3f5){return tmpl.replace(_3f5||_3f3,lang.isFunction(map)?map:function(_3f6,k){return _3d4(k,false,map);});},lang={_extraNames:_3c3,_mixin:_3c5,mixin:_3c9,setObject:_3d0,getObject:_3d4,exists:_3d7,isString:_3d8,isArray:_3d9,isFunction:_3da,isObject:_3db,isArrayLike:_3dc,isAlien:_3dd,extend:_3de,_hitchArgs:_3e1,hitch:_3e6,delegate:_3e9,_toArray:_3e4,partial:_3f0,clone:_3f2,trim:trim,replace:_3f4};1&&_3c9(dojo,lang);return lang;});},"dojo/Evented":function(){define(["./aspect","./on"],function(_3f7,on){"use strict";var _3f8=_3f7.after;function _3f9(){};_3f9.prototype={on:function(type,_3fa){return on.parse(this,type,_3fa,function(_3fb,type){return _3f8(_3fb,"on"+type,_3fa,true);});},emit:function(type,_3fc){var args=[this];args.push.apply(args,arguments);return on.emit.apply(on,args);}};return _3f9;});},"dojo/mouse":function(){define(["./_base/kernel","./on","./has","./dom","./_base/window"],function(dojo,on,has,dom,win){has.add("dom-quirks",win.doc&&win.doc.compatMode=="BackCompat");has.add("events-mouseenter",win.doc&&"onmouseenter" in win.doc.createElement("div"));var _3fd;if(has("dom-quirks")||!has("dom-addeventlistener")){_3fd={LEFT:1,MIDDLE:4,RIGHT:2,isButton:function(e,_3fe){return e.button&_3fe;},isLeft:function(e){return e.button&1;},isMiddle:function(e){return e.button&4;},isRight:function(e){return e.button&2;}};}else{_3fd={LEFT:0,MIDDLE:1,RIGHT:2,isButton:function(e,_3ff){return e.button==_3ff;},isLeft:function(e){return e.button==0;},isMiddle:function(e){return e.button==1;},isRight:function(e){return e.button==2;}};}dojo.mouseButtons=_3fd;function _400(type,_401){var _402=function(node,_403){return on(node,type,function(evt){if(!dom.isDescendant(evt.relatedTarget,_401?evt.target:node)){return _403.call(this,evt);}});};if(!_401){_402.bubble=_400(type,true);}return _402;};return {enter:_400("mouseover"),leave:_400("mouseout"),isLeft:_3fd.isLeft,isMiddle:_3fd.isMiddle,isRight:_3fd.isRight};});},"dojo/topic":function(){define(["./Evented"],function(_404){var hub=new _404;return {publish:function(_405,_406){return hub.emit.apply(hub,arguments);},subscribe:function(_407,_408){return hub.on.apply(hub,arguments);}};});},"dojo/_base/xhr":function(){define(["./kernel","./sniff","require","../io-query","../dom","../dom-form","./Deferred","./json","./lang","./array","../on"],function(dojo,has,_409,ioq,dom,_40a,_40b,json,lang,_40c,on){has.add("native-xhr",function(){return typeof XMLHttpRequest!=="undefined";});if(1){dojo._xhrObj=_409.getXhr;}else{if(has("native-xhr")){dojo._xhrObj=function(){try{return new XMLHttpRequest();}catch(e){throw new Error("XMLHTTP not available: "+e);}};}else{for(var _40d=["Msxml2.XMLHTTP","Microsoft.XMLHTTP","Msxml2.XMLHTTP.4.0"],_40e,i=0;i<3;){try{_40e=_40d[i++];if(new ActiveXObject(_40e)){break;}}catch(e){}}dojo._xhrObj=function(){return new ActiveXObject(_40e);};}}var cfg=dojo.config;dojo.objectToQuery=ioq.objectToQuery;dojo.queryToObject=ioq.queryToObject;dojo.fieldToObject=_40a.fieldToObject;dojo.formToObject=_40a.toObject;dojo.formToQuery=_40a.toQuery;dojo.formToJson=_40a.toJson;dojo._blockAsync=false;var _40f=dojo._contentHandlers=dojo.contentHandlers={"text":function(xhr){return xhr.responseText;},"json":function(xhr){return json.fromJson(xhr.responseText||null);},"json-comment-filtered":function(xhr){if(!dojo.config.useCommentedJson){console.warn("Consider using the standard mimetype:application/json."+" json-commenting can introduce security issues. To"+" decrease the chances of hijacking, use the standard the 'json' handler and"+" prefix your json with: {}&&\n"+"Use djConfig.useCommentedJson=true to turn off this message.");}var _410=xhr.responseText;var _411=_410.indexOf("/*");var _412=_410.lastIndexOf("*/");if(_411==-1||_412==-1){throw new Error("JSON was not comment filtered");}return json.fromJson(_410.substring(_411+2,_412));},"javascript":function(xhr){return dojo.eval(xhr.responseText);},"xml":function(xhr){var _413=xhr.responseXML;if(has("ie")){if((!_413||!_413.documentElement)){var ms=function(n){return "MSXML"+n+".DOMDocument";};var dp=["Microsoft.XMLDOM",ms(6),ms(4),ms(3),ms(2)];_40c.some(dp,function(p){try{var dom=new ActiveXObject(p);dom.async=false;dom.loadXML(xhr.responseText);_413=dom;}catch(e){return false;}return true;});}}return _413;},"json-comment-optional":function(xhr){if(xhr.responseText&&/^[^{\[]*\/\*/.test(xhr.responseText)){return _40f["json-comment-filtered"](xhr);}else{return _40f["json"](xhr);}}};dojo._ioSetArgs=function(args,_414,_415,_416){var _417={args:args,url:args.url};var _418=null;if(args.form){var form=dom.byId(args.form);var _419=form.getAttributeNode("action");_417.url=_417.url||(_419?_419.value:null);_418=_40a.toObject(form);}var _41a=[{}];if(_418){_41a.push(_418);}if(args.content){_41a.push(args.content);}if(args.preventCache){_41a.push({"dojo.preventCache":new Date().valueOf()});}_417.query=ioq.objectToQuery(lang.mixin.apply(null,_41a));_417.handleAs=args.handleAs||"text";var d=new _40b(_414);d.addCallbacks(_415,function(_41b){return _416(_41b,d);});var ld=args.load;if(ld&&lang.isFunction(ld)){d.addCallback(function(_41c){return ld.call(args,_41c,_417);});}var err=args.error;if(err&&lang.isFunction(err)){d.addErrback(function(_41d){return err.call(args,_41d,_417);});}var _41e=args.handle;if(_41e&&lang.isFunction(_41e)){d.addBoth(function(_41f){return _41e.call(args,_41f,_417);});}if(cfg.ioPublish&&dojo.publish&&_417.args.ioPublish!==false){d.addCallbacks(function(res){dojo.publish("/dojo/io/load",[d,res]);return res;},function(res){dojo.publish("/dojo/io/error",[d,res]);return res;});d.addBoth(function(res){dojo.publish("/dojo/io/done",[d,res]);return res;});}d.ioArgs=_417;return d;};var _420=function(dfd){dfd.canceled=true;var xhr=dfd.ioArgs.xhr;var _421=typeof xhr.abort;if(_421=="function"||_421=="object"||_421=="unknown"){xhr.abort();}var err=dfd.ioArgs.error;if(!err){err=new Error("xhr cancelled");err.dojoType="cancel";}return err;};var _422=function(dfd){var ret=_40f[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);return ret===undefined?null:ret;};var _423=function(_424,dfd){if(!dfd.ioArgs.args.failOk){console.error(_424);}return _424;};var _425=null;var _426=[];var _427=0;var _428=function(dfd){if(_427<=0){_427=0;if(cfg.ioPublish&&dojo.publish&&(!dfd||dfd&&dfd.ioArgs.args.ioPublish!==false)){dojo.publish("/dojo/io/stop");}}};var _429=function(){var now=(new Date()).getTime();if(!dojo._blockAsync){for(var i=0,tif;i<_426.length&&(tif=_426[i]);i++){var dfd=tif.dfd;var func=function(){if(!dfd||dfd.canceled||!tif.validCheck(dfd)){_426.splice(i--,1);_427-=1;}else{if(tif.ioCheck(dfd)){_426.splice(i--,1);tif.resHandle(dfd);_427-=1;}else{if(dfd.startTime){if(dfd.startTime+(dfd.ioArgs.args.timeout||0)<now){_426.splice(i--,1);var err=new Error("timeout exceeded");err.dojoType="timeout";dfd.errback(err);dfd.cancel();_427-=1;}}}}};if(dojo.config.debugAtAllCosts){func.call(this);}else{func.call(this);}}}_428(dfd);if(!_426.length){clearInterval(_425);_425=null;}};dojo._ioCancelAll=function(){try{_40c.forEach(_426,function(i){try{i.dfd.cancel();}catch(e){}});}catch(e){}};if(has("ie")){on(window,"unload",dojo._ioCancelAll);}dojo._ioNotifyStart=function(dfd){if(cfg.ioPublish&&dojo.publish&&dfd.ioArgs.args.ioPublish!==false){if(!_427){dojo.publish("/dojo/io/start");}_427+=1;dojo.publish("/dojo/io/send",[dfd]);}};dojo._ioWatch=function(dfd,_42a,_42b,_42c){var args=dfd.ioArgs.args;if(args.timeout){dfd.startTime=(new Date()).getTime();}_426.push({dfd:dfd,validCheck:_42a,ioCheck:_42b,resHandle:_42c});if(!_425){_425=setInterval(_429,50);}if(args.sync){_429();}};var _42d="application/x-www-form-urlencoded";var _42e=function(dfd){return dfd.ioArgs.xhr.readyState;};var _42f=function(dfd){return 4==dfd.ioArgs.xhr.readyState;};var _430=function(dfd){var xhr=dfd.ioArgs.xhr;if(dojo._isDocumentOk(xhr)){dfd.callback(dfd);}else{var err=new Error("Unable to load "+dfd.ioArgs.url+" status:"+xhr.status);err.status=xhr.status;err.responseText=xhr.responseText;err.xhr=xhr;dfd.errback(err);}};dojo._ioAddQueryToUrl=function(_431){if(_431.query.length){_431.url+=(_431.url.indexOf("?")==-1?"?":"&")+_431.query;_431.query=null;}};dojo.xhr=function(_432,args,_433){var dfd=dojo._ioSetArgs(args,_420,_422,_423);var _434=dfd.ioArgs;var xhr=_434.xhr=dojo._xhrObj(_434.args);if(!xhr){dfd.cancel();return dfd;}if("postData" in args){_434.query=args.postData;}else{if("putData" in args){_434.query=args.putData;}else{if("rawBody" in args){_434.query=args.rawBody;}else{if((arguments.length>2&&!_433)||"POST|PUT".indexOf(_432.toUpperCase())==-1){dojo._ioAddQueryToUrl(_434);}}}}xhr.open(_432,_434.url,args.sync!==true,args.user||undefined,args.password||undefined);if(args.headers){for(var hdr in args.headers){if(hdr.toLowerCase()==="content-type"&&!args.contentType){args.contentType=args.headers[hdr];}else{if(args.headers[hdr]){xhr.setRequestHeader(hdr,args.headers[hdr]);}}}}if(args.contentType!==false){xhr.setRequestHeader("Content-Type",args.contentType||_42d);}if(!args.headers||!("X-Requested-With" in args.headers)){xhr.setRequestHeader("X-Requested-With","XMLHttpRequest");}dojo._ioNotifyStart(dfd);if(dojo.config.debugAtAllCosts){xhr.send(_434.query);}else{try{xhr.send(_434.query);}catch(e){_434.error=e;dfd.cancel();}}dojo._ioWatch(dfd,_42e,_42f,_430);xhr=null;return dfd;};dojo.xhrGet=function(args){return dojo.xhr("GET",args);};dojo.rawXhrPost=dojo.xhrPost=function(args){return dojo.xhr("POST",args,true);};dojo.rawXhrPut=dojo.xhrPut=function(args){return dojo.xhr("PUT",args,true);};dojo.xhrDelete=function(args){return dojo.xhr("DELETE",args);};dojo._isDocumentOk=function(http){var stat=http.status||0;stat=(stat>=200&&stat<300)||stat==304||stat==1223||!stat;return stat;};dojo._getText=function(url){var _435;dojo.xhrGet({url:url,sync:true,load:function(text){_435=text;}});return _435;};lang.mixin(dojo.xhr,{_xhrObj:dojo._xhrObj,fieldToObject:_40a.fieldToObject,formToObject:_40a.toObject,objectToQuery:ioq.objectToQuery,formToQuery:_40a.toQuery,formToJson:_40a.toJson,queryToObject:ioq.queryToObject,contentHandlers:_40f,_ioSetArgs:dojo._ioSetArgs,_ioCancelAll:dojo._ioCancelAll,_ioNotifyStart:dojo._ioNotifyStart,_ioWatch:dojo._ioWatch,_ioAddQueryToUrl:dojo._ioAddQueryToUrl,_isDocumentOk:dojo._isDocumentOk,_getText:dojo._getText,get:dojo.xhrGet,post:dojo.xhrPost,put:dojo.xhrPut,del:dojo.xhrDelete});return dojo.xhr;});},"dojo/_base/unload":function(){define(["./kernel","./connect"],function(dojo,_436){var win=window;dojo.addOnWindowUnload=function(obj,_437){if(!dojo.windowUnloaded){_436.connect(win,"unload",(dojo.windowUnloaded=function(){}));}_436.connect(win,"unload",obj,_437);};dojo.addOnUnload=function(obj,_438){_436.connect(win,"beforeunload",obj,_438);};return {addOnWindowUnload:dojo.addOnWindowUnload,addOnUnload:dojo.addOnUnload};});},"dojo/loadInit":function(){define(["./_base/loader"],function(_439){return {dynamic:0,normalize:function(id){return id;},load:_439.loadInit};});},"dojo/_base/NodeList":function(){define(["./kernel","../query","./array","./html","../NodeList-dom"],function(dojo,_43a,_43b){var _43c=_43a.NodeList;var nlp=_43c.prototype;nlp.connect=_43c._adaptAsForEach(function(){return dojo.connect.apply(this,arguments);});nlp.coords=_43c._adaptAsMap(dojo.coords);_43c.events=["blur","focus","change","click","error","keydown","keypress","keyup","load","mousedown","mouseenter","mouseleave","mousemove","mouseout","mouseover","mouseup","submit"];_43b.forEach(_43c.events,function(evt){var _43d="on"+evt;nlp[_43d]=function(a,b){return this.connect(_43d,a,b);};});dojo.NodeList=_43c;return dojo.NodeList;});},"dojo/_base/Color":function(){define(["./kernel","./lang","./array","./config"],function(dojo,lang,_43e,_43f){var _440=dojo.Color=function(_441){if(_441){this.setColor(_441);}};_440.named={"black":[0,0,0],"silver":[192,192,192],"gray":[128,128,128],"white":[255,255,255],"maroon":[128,0,0],"red":[255,0,0],"purple":[128,0,128],"fuchsia":[255,0,255],"green":[0,128,0],"lime":[0,255,0],"olive":[128,128,0],"yellow":[255,255,0],"navy":[0,0,128],"blue":[0,0,255],"teal":[0,128,128],"aqua":[0,255,255],"transparent":_43f.transparentColor||[0,0,0,0]};lang.extend(_440,{r:255,g:255,b:255,a:1,_set:function(r,g,b,a){var t=this;t.r=r;t.g=g;t.b=b;t.a=a;},setColor:function(_442){if(lang.isString(_442)){_440.fromString(_442,this);}else{if(lang.isArray(_442)){_440.fromArray(_442,this);}else{this._set(_442.r,_442.g,_442.b,_442.a);if(!(_442 instanceof _440)){this.sanitize();}}}return this;},sanitize:function(){return this;},toRgb:function(){var t=this;return [t.r,t.g,t.b];},toRgba:function(){var t=this;return [t.r,t.g,t.b,t.a];},toHex:function(){var arr=_43e.map(["r","g","b"],function(x){var s=this[x].toString(16);return s.length<2?"0"+s:s;},this);return "#"+arr.join("");},toCss:function(_443){var t=this,rgb=t.r+", "+t.g+", "+t.b;return (_443?"rgba("+rgb+", "+t.a:"rgb("+rgb)+")";},toString:function(){return this.toCss(true);}});_440.blendColors=dojo.blendColors=function(_444,end,_445,obj){var t=obj||new _440();_43e.forEach(["r","g","b","a"],function(x){t[x]=_444[x]+(end[x]-_444[x])*_445;if(x!="a"){t[x]=Math.round(t[x]);}});return t.sanitize();};_440.fromRgb=dojo.colorFromRgb=function(_446,obj){var m=_446.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);return m&&_440.fromArray(m[1].split(/\s*,\s*/),obj);};_440.fromHex=dojo.colorFromHex=function(_447,obj){var t=obj||new _440(),bits=(_447.length==4)?4:8,mask=(1<<bits)-1;_447=Number("0x"+_447.substr(1));if(isNaN(_447)){return null;}_43e.forEach(["b","g","r"],function(x){var c=_447&mask;_447>>=bits;t[x]=bits==4?17*c:c;});t.a=1;return t;};_440.fromArray=dojo.colorFromArray=function(a,obj){var t=obj||new _440();t._set(Number(a[0]),Number(a[1]),Number(a[2]),Number(a[3]));if(isNaN(t.a)){t.a=1;}return t.sanitize();};_440.fromString=dojo.colorFromString=function(str,obj){var a=_440.named[str];return a&&_440.fromArray(a,obj)||_440.fromRgb(str,obj)||_440.fromHex(str,obj);};return _440;});},"dojo/selector/_loader":function(){define(["../has","require"],function(has,_448){"use strict";var _449=document.createElement("div");has.add("dom-qsa2.1",!!_449.querySelectorAll);has.add("dom-qsa3",function(){try{_449.innerHTML="<p class='TEST'></p>";return _449.querySelectorAll(".TEST:empty").length==1;}catch(e){}});var _44a;var acme="./acme",lite="./lite";return {load:function(id,_44b,_44c,_44d){var req=_448;id=id=="default"?has("config-selectorEngine")||"css3":id;id=id=="css2"||id=="lite"?lite:id=="css2.1"?has("dom-qsa2.1")?lite:acme:id=="css3"?has("dom-qsa3")?lite:acme:id=="acme"?acme:(req=_44b)&&id;if(id.charAt(id.length-1)=="?"){id=id.substring(0,id.length-1);var _44e=true;}if(_44e&&(has("dom-compliant-qsa")||_44a)){return _44c(_44a);}req([id],function(_44f){if(id!="./lite"){_44a=_44f;}_44c(_44f);});}};});},"dojo/on":function(){define(["./has!dom-addeventlistener?:./aspect","./_base/kernel","./has"],function(_450,dojo,has){"use strict";if(1){var _451=window.ScriptEngineMajorVersion;has.add("jscript",_451&&(_451()+ScriptEngineMinorVersion()/10));has.add("event-orientationchange",has("touch")&&!has("android"));}var on=function(_452,type,_453,_454){if(_452.on){return _452.on(type,_453);}return on.parse(_452,type,_453,_455,_454,this);};on.pausable=function(_456,type,_457,_458){var _459;var _45a=on(_456,type,function(){if(!_459){return _457.apply(this,arguments);}},_458);_45a.pause=function(){_459=true;};_45a.resume=function(){_459=false;};return _45a;};on.once=function(_45b,type,_45c,_45d){var _45e=on(_45b,type,function(){_45e.remove();return _45c.apply(this,arguments);});return _45e;};on.parse=function(_45f,type,_460,_461,_462,_463){if(type.call){return type.call(_463,_45f,_460);}if(type.indexOf(",")>-1){var _464=type.split(/\s*,\s*/);var _465=[];var i=0;var _466;while(_466=_464[i++]){_465.push(_461(_45f,_466,_460,_462,_463));}_465.remove=function(){for(var i=0;i<_465.length;i++){_465[i].remove();}};return _465;}return _461(_45f,type,_460,_462,_463);};var _467=/^touch/;function _455(_468,type,_469,_46a,_46b){var _46c=type.match(/(.*):(.*)/);if(_46c){type=_46c[2];_46c=_46c[1];return on.selector(_46c,type).call(_46b,_468,_469);}if(has("touch")){if(_467.test(type)){_469=_46d(_469);}if(!has("event-orientationchange")&&(type=="orientationchange")){type="resize";_468=window;_469=_46d(_469);}}if(_468.addEventListener){var _46e=type in _46f;_468.addEventListener(_46e?_46f[type]:type,_469,_46e);return {remove:function(){_468.removeEventListener(type,_469,_46e);}};}type="on"+type;if(_470&&_468.attachEvent){return _470(_468,type,_469);}throw new Error("Target must be an event emitter");};on.selector=function(_471,_472,_473){return function(_474,_475){var _476=this;var _477=_472.bubble;if(_477){_472=_477;}else{if(_473!==false){_473=true;}}return on(_474,_472,function(_478){var _479=_478.target;_476=_476&&_476.matches?_476:dojo.query;while(!_476.matches(_479,_471,_474)){if(_479==_474||!_473||!(_479=_479.parentNode)){return;}}return _475.call(_479,_478);});};};function _47a(){this.cancelable=false;};function _47b(){this.bubbles=false;};var _47c=[].slice,_47d=on.emit=function(_47e,type,_47f){var args=_47c.call(arguments,2);var _480="on"+type;if("parentNode" in _47e){var _481=args[0]={};for(var i in _47f){_481[i]=_47f[i];}_481.preventDefault=_47a;_481.stopPropagation=_47b;_481.target=_47e;_481.type=type;_47f=_481;}do{_47e[_480]&&_47e[_480].apply(_47e,args);}while(_47f&&_47f.bubbles&&(_47e=_47e.parentNode));return _47f&&_47f.cancelable&&_47f;};var _46f={};if(has("dom-addeventlistener")){_46f={focusin:"focus",focusout:"blur"};if(has("opera")){_46f.keydown="keypress";}on.emit=function(_482,type,_483){if(_482.dispatchEvent&&document.createEvent){var _484=document.createEvent("HTMLEvents");_484.initEvent(type,!!_483.bubbles,!!_483.cancelable);for(var i in _483){var _485=_483[i];if(!(i in _484)){_484[i]=_483[i];}}return _482.dispatchEvent(_484)&&_484;}return _47d.apply(on,arguments);};}else{on._fixEvent=function(evt,_486){if(!evt){var w=_486&&(_486.ownerDocument||_486.document||_486).parentWindow||window;evt=w.event;}if(!evt){return (evt);}if(!evt.target){evt.target=evt.srcElement;evt.currentTarget=(_486||evt.srcElement);if(evt.type=="mouseover"){evt.relatedTarget=evt.fromElement;}if(evt.type=="mouseout"){evt.relatedTarget=evt.toElement;}if(!evt.stopPropagation){evt.stopPropagation=_487;evt.preventDefault=_488;}switch(evt.type){case "keypress":var c=("charCode" in evt?evt.charCode:evt.keyCode);if(c==10){c=0;evt.keyCode=13;}else{if(c==13||c==27){c=0;}else{if(c==3){c=99;}}}evt.charCode=c;_489(evt);break;}}return evt;};var _48a=function(_48b){this.handle=_48b;};_48a.prototype.remove=function(){delete _dojoIEListeners_[this.handle];};var _48c=function(_48d){return function(evt){evt=on._fixEvent(evt,this);return _48d.call(this,evt);};};var _470=function(_48e,type,_48f){_48f=_48c(_48f);if(((_48e.ownerDocument?_48e.ownerDocument.parentWindow:_48e.parentWindow||_48e.window||window)!=top||has("jscript")<5.8)&&!has("config-_allow_leaks")){if(typeof _dojoIEListeners_=="undefined"){_dojoIEListeners_=[];}var _490=_48e[type];if(!_490||!_490.listeners){var _491=_490;_48e[type]=_490=Function("event","var callee = arguments.callee; for(var i = 0; i<callee.listeners.length; i++){var listener = _dojoIEListeners_[callee.listeners[i]]; if(listener){listener.call(this,event);}}");_490.listeners=[];_490.global=this;if(_491){_490.listeners.push(_dojoIEListeners_.push(_491)-1);}}var _492;_490.listeners.push(_492=(_490.global._dojoIEListeners_.push(_48f)-1));return new _48a(_492);}return _450.after(_48e,type,_48f,true);};var _489=function(evt){evt.keyChar=evt.charCode?String.fromCharCode(evt.charCode):"";evt.charOrCode=evt.keyChar||evt.keyCode;};var _487=function(){this.cancelBubble=true;};var _488=on._preventDefault=function(){this.bubbledKeyCode=this.keyCode;if(this.ctrlKey){try{this.keyCode=0;}catch(e){}}this.returnValue=false;};}if(has("touch")){var _493=function(){};var _494=window.orientation;var _46d=function(_495){return function(_496){var _497=_496.corrected;if(!_497){var type=_496.type;try{delete _496.type;}catch(e){}if(_496.type){_493.prototype=_496;var _497=new _493;_497.preventDefault=function(){_496.preventDefault();};_497.stopPropagation=function(){_496.stopPropagation();};}else{_497=_496;_497.type=type;}_496.corrected=_497;if(type=="resize"){if(_494==window.orientation){return null;}_494=window.orientation;_497.type="orientationchange";return _495.call(this,_497);}if(!("rotation" in _497)){_497.rotation=0;_497.scale=1;}var _498=_497.changedTouches[0];for(var i in _498){delete _497[i];_497[i]=_498[i];}}return _495.call(this,_497);};};}return on;});},"dojo/_base/sniff":function(){define(["./kernel","../has"],function(dojo,has){if(!1){return has;}dojo.isBrowser=true,dojo._name="browser";var _499=has.add,n=navigator,dua=n.userAgent,dav=n.appVersion,tv=parseFloat(dav),_49a,_49b,_49c,_49d,_49e,_49f,_4a0,_4a1,_4a2,isIE,isFF,_4a3,_4a4,_4a5,_4a6;if(dua.indexOf("AdobeAIR")>=0){_49b=1;}_49c=(dav.indexOf("Konqueror")>=0)?tv:0;_49d=parseFloat(dua.split("WebKit/")[1])||undefined;_49e=parseFloat(dua.split("Chrome/")[1])||undefined;_49f=dav.indexOf("Macintosh")>=0;_4a4=/iPhone|iPod|iPad/.test(dua);_4a5=parseFloat(dua.split("Android ")[1])||undefined;_4a6=typeof opera!="undefined"&&opera.wiiremote;var _4a7=Math.max(dav.indexOf("WebKit"),dav.indexOf("Safari"),0);if(_4a7&&!_49e){_4a0=parseFloat(dav.split("Version/")[1]);if(!_4a0||parseFloat(dav.substr(_4a7+7))<=419.3){_4a0=2;}}if(!has("dojo-webkit")){if(dua.indexOf("Opera")>=0){_49a=tv;if(_49a>=9.8){_49a=parseFloat(dua.split("Version/")[1])||tv;}}if(dua.indexOf("Gecko")>=0&&!_49c&&!_49d){_4a1=_4a2=tv;}if(_4a2){isFF=parseFloat(dua.split("Firefox/")[1]||dua.split("Minefield/")[1])||undefined;}if(document.all&&!_49a){isIE=parseFloat(dav.split("MSIE ")[1])||undefined;var mode=document.documentMode;if(mode&&mode!=5&&Math.floor(isIE)!=mode){isIE=mode;}}}_4a3=document.compatMode=="BackCompat";_499("opera",dojo.isOpera=_49a);_499("air",dojo.isAIR=_49b);_499("khtml",dojo.isKhtml=_49c);_499("webkit",dojo.isWebKit=_49d);_499("chrome",dojo.isChrome=_49e);_499("mac",dojo.isMac=_49f);_499("safari",dojo.isSafari=_4a0);_499("mozilla",dojo.isMozilla=dojo.isMoz=_4a1);_499("ie",dojo.isIE=isIE);_499("ff",dojo.isFF=isFF);_499("quirks",dojo.isQuirks=_4a3);_499("ios",dojo.isIos=_4a4);_499("android",dojo.isAndroid=_4a5);dojo.locale=dojo.locale||(isIE?n.userLanguage:n.language).toLowerCase();return has;});},"dojo/_base/array":function(){define("dojo/_base/array",["./kernel","../has","./lang"],function(dojo,has,lang){var _4a8={},u,_4a9;function _4aa(){_4a8={};};function _4ab(fn){return _4a8[fn]=new Function("item","index","array",fn);};function _4ac(some){var _4ad=!some;return function(a,fn,o){var i=0,l=a&&a.length||0,_4ae;if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4a8[fn]||_4ab(fn);}if(o){for(;i<l;++i){_4ae=!fn.call(o,a[i],i,a);if(some^_4ae){return !_4ae;}}}else{for(;i<l;++i){_4ae=!fn(a[i],i,a);if(some^_4ae){return !_4ae;}}}return _4ad;};};function _4af(up){var _4b0=1,_4b1=0,_4b2=0;if(!up){_4b0=_4b1=_4b2=-1;}return function(a,x,from,last){if(last&&_4b0>0){return _4a9.lastIndexOf(a,x,from);}var l=a&&a.length||0,end=up?l+_4b2:_4b1,i;if(from===u){i=up?_4b1:l+_4b2;}else{if(from<0){i=l+from;if(i<0){i=_4b1;}}else{i=from>=l?l+_4b2:from;}}if(l&&typeof a=="string"){a=a.split("");}for(;i!=end;i+=_4b0){if(a[i]==x){return i;}}return -1;};};function _4b3(a,fn,o){var i=0,l=a&&a.length||0;if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4a8[fn]||_4ab(fn);}if(o){for(;i<l;++i){fn.call(o,a[i],i,a);}}else{for(;i<l;++i){fn(a[i],i,a);}}};function map(a,fn,o,Ctr){var i=0,l=a&&a.length||0,out=new (Ctr||Array)(l);if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4a8[fn]||_4ab(fn);}if(o){for(;i<l;++i){out[i]=fn.call(o,a[i],i,a);}}else{for(;i<l;++i){out[i]=fn(a[i],i,a);}}return out;};function _4b4(a,fn,o){var i=0,l=a&&a.length||0,out=[],_4b5;if(l&&typeof a=="string"){a=a.split("");}if(typeof fn=="string"){fn=_4a8[fn]||_4ab(fn);}if(o){for(;i<l;++i){_4b5=a[i];if(fn.call(o,_4b5,i,a)){out.push(_4b5);}}}else{for(;i<l;++i){_4b5=a[i];if(fn(_4b5,i,a)){out.push(_4b5);}}}return out;};_4a9={every:_4ac(false),some:_4ac(true),indexOf:_4af(true),lastIndexOf:_4af(false),forEach:_4b3,map:map,filter:_4b4,clearCache:_4aa};1&&lang.mixin(dojo,_4a9);return _4a9;});},"dojo/_base/json":function(){define(["./kernel","../json"],function(dojo,json){dojo.fromJson=function(js){return eval("("+js+")");};dojo._escapeString=json.stringify;dojo.toJsonIndentStr="\t";dojo.toJson=function(it,_4b6){return json.stringify(it,function(key,_4b7){if(_4b7){var tf=_4b7.__json__||_4b7.json;if(typeof tf=="function"){return tf.call(_4b7);}}return _4b7;},_4b6&&dojo.toJsonIndentStr);};return dojo;});},"dojo/_base/window":function(){define(["./kernel","../has","./sniff"],function(dojo,has){dojo.doc=this["document"]||null;dojo.body=function(){return dojo.doc.body||dojo.doc.getElementsByTagName("body")[0];};dojo.setContext=function(_4b8,_4b9){dojo.global=ret.global=_4b8;dojo.doc=ret.doc=_4b9;};dojo.withGlobal=function(_4ba,_4bb,_4bc,_4bd){var _4be=dojo.global;try{dojo.global=ret.global=_4ba;return dojo.withDoc.call(null,_4ba.document,_4bb,_4bc,_4bd);}finally{dojo.global=ret.global=_4be;}};dojo.withDoc=function(_4bf,_4c0,_4c1,_4c2){var _4c3=dojo.doc,oldQ=dojo.isQuirks,_4c4=dojo.isIE,isIE,mode,pwin;try{dojo.doc=ret.doc=_4bf;dojo.isQuirks=has.add("quirks",dojo.doc.compatMode=="BackCompat",true,true);if(has("ie")){if((pwin=_4bf.parentWindow)&&pwin.navigator){isIE=parseFloat(pwin.navigator.appVersion.split("MSIE ")[1])||undefined;mode=_4bf.documentMode;if(mode&&mode!=5&&Math.floor(isIE)!=mode){isIE=mode;}dojo.isIE=has.add("ie",isIE,true,true);}}if(_4c1&&typeof _4c0=="string"){_4c0=_4c1[_4c0];}return _4c0.apply(_4c1,_4c2||[]);}finally{dojo.doc=ret.doc=_4c3;dojo.isQuirks=has.add("quirks",oldQ,true,true);dojo.isIE=has.add("ie",_4c4,true,true);}};var ret={global:dojo.global,doc:dojo.doc,body:dojo.body,setContext:dojo.setContext,withGlobal:dojo.withGlobal,withDoc:dojo.withDoc};return ret;});},"dojo/dom-class":function(){define(["./_base/lang","./_base/array","./dom"],function(lang,_4c5,dom){var _4c6="className";var cls,_4c7=/\s+/,a1=[""];function _4c8(s){if(typeof s=="string"||s instanceof String){if(s&&!_4c7.test(s)){a1[0]=s;return a1;}var a=s.split(_4c7);if(a.length&&!a[0]){a.shift();}if(a.length&&!a[a.length-1]){a.pop();}return a;}if(!s){return [];}return _4c5.filter(s,function(x){return x;});};var _4c9={};cls={contains:function containsClass(node,_4ca){return ((" "+dom.byId(node)[_4c6]+" ").indexOf(" "+_4ca+" ")>=0);},add:function addClass(node,_4cb){node=dom.byId(node);_4cb=_4c8(_4cb);var cls=node[_4c6],_4cc;cls=cls?" "+cls+" ":" ";_4cc=cls.length;for(var i=0,len=_4cb.length,c;i<len;++i){c=_4cb[i];if(c&&cls.indexOf(" "+c+" ")<0){cls+=c+" ";}}if(_4cc<cls.length){node[_4c6]=cls.substr(1,cls.length-2);}},remove:function removeClass(node,_4cd){node=dom.byId(node);var cls;if(_4cd!==undefined){_4cd=_4c8(_4cd);cls=" "+node[_4c6]+" ";for(var i=0,len=_4cd.length;i<len;++i){cls=cls.replace(" "+_4cd[i]+" "," ");}cls=lang.trim(cls);}else{cls="";}if(node[_4c6]!=cls){node[_4c6]=cls;}},replace:function replaceClass(node,_4ce,_4cf){node=dom.byId(node);_4c9[_4c6]=node[_4c6];cls.remove(_4c9,_4cf);cls.add(_4c9,_4ce);if(node[_4c6]!==_4c9[_4c6]){node[_4c6]=_4c9[_4c6];}},toggle:function toggleClass(node,_4d0,_4d1){node=dom.byId(node);if(_4d1===undefined){_4d0=_4c8(_4d0);for(var i=0,len=_4d0.length,c;i<len;++i){c=_4d0[i];cls[cls.contains(node,c)?"remove":"add"](node,c);}}else{cls[_4d1?"add":"remove"](node,_4d0);}return _4d1;}};return cls;});},"dojo/_base/config":function(){define(["../has","require"],function(has,_4d2){var _4d3={};if(1){var src=_4d2.rawConfig,p;for(p in src){_4d3[p]=src[p];}}else{var _4d4=function(_4d5,_4d6,_4d7){for(p in _4d5){p!="has"&&has.add(_4d6+p,_4d5[p],0,_4d7);}};_4d3=1?_4d2.rawConfig:this.dojoConfig||this.djConfig||{};_4d4(_4d3,"config",1);_4d4(_4d3.has,"",1);}return _4d3;});},"dojo/_base/event":function(){define(["./kernel","../on","../has","../dom-geometry"],function(dojo,on,has,dom){if(on._fixEvent){var _4d8=on._fixEvent;on._fixEvent=function(evt,se){evt=_4d8(evt,se);if(evt){dom.normalizeEvent(evt);}return evt;};}dojo.fixEvent=function(evt,_4d9){if(on._fixEvent){return on._fixEvent(evt,_4d9);}return evt;};dojo.stopEvent=function(evt){if(has("dom-addeventlistener")||(evt&&evt.preventDefault)){evt.preventDefault();evt.stopPropagation();}else{evt=evt||window.event;evt.cancelBubble=true;on._preventDefault.call(evt);}};return {fix:dojo.fixEvent,stop:dojo.stopEvent};});},"dojo/main":function(){define(["./_base/kernel","./has","require","./_base/sniff","./_base/lang","./_base/array","./ready","./_base/declare","./_base/connect","./_base/Deferred","./_base/json","./_base/Color","./has!dojo-firebug?./_firebug/firebug","./_base/browser","./_base/loader"],function(dojo,has,_4da,_4db,lang,_4dc,_4dd){if(dojo.config.isDebug){_4da(["./_firebug/firebug"]);}true||has.add("dojo-config-require",1);if(1){var deps=dojo.config.require;if(deps){deps=_4dc.map(lang.isArray(deps)?deps:[deps],function(item){return item.replace(/\./g,"/");});if(dojo.isAsync){_4da(deps);}else{_4dd(1,function(){_4da(deps);});}}}return dojo;});},"dojo/ready":function(){define(["./_base/kernel","./has","require","./domReady","./_base/lang"],function(dojo,has,_4de,_4df,lang){var _4e0=0,_4e1,_4e2=[],_4e3=0,_4e4=function(){_4e0=1;dojo._postLoad=dojo.config.afterOnLoad=true;if(_4e2.length){_4e1(_4e5);}},_4e5=function(){if(_4e0&&!_4e3&&_4e2.length){_4e3=1;var f=_4e2.shift();try{f();}finally{_4e3=0;}_4e3=0;if(_4e2.length){_4e1(_4e5);}}};if(1){_4de.on("idle",_4e5);_4e1=function(){if(_4de.idle()){_4e5();}};}else{_4e1=function(){_4de.ready(_4e5);};}var _4e6=dojo.ready=dojo.addOnLoad=function(_4e7,_4e8,_4e9){var _4ea=lang._toArray(arguments);if(typeof _4e7!="number"){_4e9=_4e8;_4e8=_4e7;_4e7=1000;}else{_4ea.shift();}_4e9=_4e9?lang.hitch.apply(dojo,_4ea):function(){_4e8();};_4e9.priority=_4e7;for(var i=0;i<_4e2.length&&_4e7>=_4e2[i].priority;i++){}_4e2.splice(i,0,_4e9);_4e1();};true||has.add("dojo-config-addOnLoad",1);if(1){var dca=dojo.config.addOnLoad;if(dca){_4e6[(lang.isArray(dca)?"apply":"call")](dojo,dca);}}if(1&&dojo.config.parseOnLoad&&!dojo.isAsync){_4e6(99,function(){if(!dojo.parser){dojo.deprecated("Add explicit require(['dojo/parser']);","","2.0");_4de(["dojo/parser"]);}});}if(1){_4df(_4e4);}else{_4e4();}return _4e6;});},"dojo/aspect":function(){define([],function(){"use strict";var _4eb=0;function _4ec(_4ed,type,_4ee,_4ef){var _4f0=_4ed[type];var _4f1=type=="around";var _4f2;if(_4f1){var _4f3=_4ee(function(){return _4f0.advice(this,arguments);});_4f2={remove:function(){_4f2.cancelled=true;},advice:function(_4f4,args){return _4f2.cancelled?_4f0.advice(_4f4,args):_4f3.apply(_4f4,args);}};}else{_4f2={remove:function(){var _4f5=_4f2.previous;var next=_4f2.next;if(!next&&!_4f5){delete _4ed[type];}else{if(_4f5){_4f5.next=next;}else{_4ed[type]=next;}if(next){next.previous=_4f5;}}},id:_4eb++,advice:_4ee,receiveArguments:_4ef};}if(_4f0&&!_4f1){if(type=="after"){var next=_4f0;while(next){_4f0=next;next=next.next;}_4f0.next=_4f2;_4f2.previous=_4f0;}else{if(type=="before"){_4ed[type]=_4f2;_4f2.next=_4f0;_4f0.previous=_4f2;}}}else{_4ed[type]=_4f2;}return _4f2;};function _4f6(type){return function(_4f7,_4f8,_4f9,_4fa){var _4fb=_4f7[_4f8],_4fc;if(!_4fb||_4fb.target!=_4f7){_4f7[_4f8]=_4fc=function(){var _4fd=_4eb;var args=arguments;var _4fe=_4fc.before;while(_4fe){args=_4fe.advice.apply(this,args)||args;_4fe=_4fe.next;}if(_4fc.around){var _4ff=_4fc.around.advice(this,args);}var _500=_4fc.after;while(_500&&_500.id<_4fd){_4ff=_500.receiveArguments?_500.advice.apply(this,args)||_4ff:_500.advice.call(this,_4ff);_500=_500.next;}return _4ff;};if(_4fb){_4fc.around={advice:function(_501,args){return _4fb.apply(_501,args);}};}_4fc.target=_4f7;}var _502=_4ec((_4fc||_4fb),type,_4f9,_4fa);_4f9=null;return _502;};};return {before:_4f6("before"),around:_4f6("around"),after:_4f6("after")};});},"dojo/_base/connect":function(){define(["./kernel","../on","../topic","../aspect","./event","../mouse","./sniff","./lang","../keys"],function(_503,on,hub,_504,_505,_506,has,lang){has.add("events-keypress-typed",function(){var _507={charCode:0};try{_507=document.createEvent("KeyboardEvent");(_507.initKeyboardEvent||_507.initKeyEvent).call(_507,"keypress",true,true,null,false,false,false,false,9,3);}catch(e){}return _507.charCode==0&&!has("opera");});function _508(obj,_509,_50a,_50b,_50c){_50b=lang.hitch(_50a,_50b);if(!obj||!(obj.addEventListener||obj.attachEvent)){return _504.after(obj||_503.global,_509,_50b,true);}if(typeof _509=="string"&&_509.substring(0,2)=="on"){_509=_509.substring(2);}if(!obj){obj=_503.global;}if(!_50c){switch(_509){case "keypress":_509=_50d;break;case "mouseenter":_509=_506.enter;break;case "mouseleave":_509=_506.leave;break;}}return on(obj,_509,_50b,_50c);};var _50e={106:42,111:47,186:59,187:43,188:44,189:45,190:46,191:47,192:96,219:91,220:92,221:93,222:39,229:113};var _50f=has("mac")?"metaKey":"ctrlKey";var _510=function(evt,_511){var faux=lang.mixin({},evt,_511);_512(faux);faux.preventDefault=function(){evt.preventDefault();};faux.stopPropagation=function(){evt.stopPropagation();};return faux;};function _512(evt){evt.keyChar=evt.charCode?String.fromCharCode(evt.charCode):"";evt.charOrCode=evt.keyChar||evt.keyCode;};var _50d;if(has("events-keypress-typed")){var _513=function(e,code){try{return (e.keyCode=code);}catch(e){return 0;}};_50d=function(_514,_515){var _516=on(_514,"keydown",function(evt){var k=evt.keyCode;var _517=(k!=13||(has("ie")>=9&&!has("quirks")))&&k!=32&&(k!=27||!has("ie"))&&(k<48||k>90)&&(k<96||k>111)&&(k<186||k>192)&&(k<219||k>222)&&k!=229;if(_517||evt.ctrlKey){var c=_517?0:k;if(evt.ctrlKey){if(k==3||k==13){return _515.call(evt.currentTarget,evt);}else{if(c>95&&c<106){c-=48;}else{if((!evt.shiftKey)&&(c>=65&&c<=90)){c+=32;}else{c=_50e[c]||c;}}}}var faux=_510(evt,{type:"keypress",faux:true,charCode:c});_515.call(evt.currentTarget,faux);if(has("ie")){_513(evt,faux.keyCode);}}});var _518=on(_514,"keypress",function(evt){var c=evt.charCode;c=c>=32?c:0;evt=_510(evt,{charCode:c,faux:true});return _515.call(this,evt);});return {remove:function(){_516.remove();_518.remove();}};};}else{if(has("opera")){_50d=function(_519,_51a){return on(_519,"keypress",function(evt){var c=evt.which;if(c==3){c=99;}c=c<32&&!evt.shiftKey?0:c;if(evt.ctrlKey&&!evt.shiftKey&&c>=65&&c<=90){c+=32;}return _51a.call(this,_510(evt,{charCode:c}));});};}else{_50d=function(_51b,_51c){return on(_51b,"keypress",function(evt){_512(evt);return _51c.call(this,evt);});};}}var _51d={_keypress:_50d,connect:function(obj,_51e,_51f,_520,_521){var a=arguments,args=[],i=0;args.push(typeof a[0]=="string"?null:a[i++],a[i++]);var a1=a[i+1];args.push(typeof a1=="string"||typeof a1=="function"?a[i++]:null,a[i++]);for(var l=a.length;i<l;i++){args.push(a[i]);}return _508.apply(this,args);},disconnect:function(_522){if(_522){_522.remove();}},subscribe:function(_523,_524,_525){return hub.subscribe(_523,lang.hitch(_524,_525));},publish:function(_526,args){return hub.publish.apply(hub,[_526].concat(args));},connectPublisher:function(_527,obj,_528){var pf=function(){_51d.publish(_527,arguments);};return _528?_51d.connect(obj,_528,pf):_51d.connect(obj,pf);},isCopyKey:function(e){return e[_50f];}};_51d.unsubscribe=_51d.disconnect;1&&lang.mixin(_503,_51d);return _51d;});}}});(function(){var _529=this.require;_529({cache:{}});!_529.async&&_529(["dojo"]);_529.boot&&_529.apply(null,_529.boot);})();
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/dojo.js.uncompressed.js b/js/dojo-1.7.2/dojo/dojo.js.uncompressed.js
new file mode 100644
index 0000000..a63fb64
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dojo.js.uncompressed.js
@@ -0,0 +1,16131 @@
+/*
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+/*
+	This is an optimized version of Dojo, built for deployment and not for
+	development. To get sources and documentation, please visit:
+
+		http://dojotoolkit.org
+*/
+
+(function(
+	userConfig,
+	defaultConfig
+){
+	// summary:
+	//		This is the "source loader" and is the entry point for Dojo during development. You may also load Dojo with
+	//		any AMD-compliant loader via the package main module dojo/main.
+	// description:
+	//		This is the "source loader" for Dojo. It provides an AMD-compliant loader that can be configured
+	//		to operate in either synchronous or asynchronous modes. After the loader is defined, dojo is loaded
+	//		IAW the package main module dojo/main. In the event you wish to use a foreign loader, you may load dojo as a package
+	//		via the package main module dojo/main and this loader is not required; see dojo/package.json for details.
+	//
+	//		In order to keep compatibility with the v1.x line, this loader includes additional machinery that enables
+	//		the dojo.provide, dojo.require et al API. This machinery is loaded by default, but may be dynamically removed
+	//		via the has.js API and statically removed via the build system.
+	//
+	//		This loader includes sniffing machinery to determine the environment; the following environments are supported:
+	//
+	//			* browser
+	//			* node.js
+	//			* rhino
+	//
+	//		This is the so-called "source loader". As such, it includes many optional features that may be discadred by
+	//		building a customized verion with the build system.
+
+	// Design and Implementation Notes
+	//
+	// This is a dojo-specific adaption of bdLoad, donated to the dojo foundation by Altoviso LLC.
+	//
+	// This function defines an AMD-compliant (http://wiki.commonjs.org/wiki/Modules/AsynchronousDefinition)
+	// loader that can be configured to operate in either synchronous or asynchronous modes.
+	//
+	// Since this machinery implements a loader, it does not have the luxury of using a load system and/or
+	// leveraging a utility library. This results in an unpleasantly long file; here is a road map of the contents:
+	//
+	//	 1. Small library for use implementing the loader.
+	//	 2. Define the has.js API; this is used throughout the loader to bracket features.
+	//	 3. Define the node.js and rhino sniffs and sniff.
+	//	 4. Define the loader's data.
+	//	 5. Define the configuration machinery.
+	//	 6. Define the script element sniffing machinery and sniff for configuration data.
+	//	 7. Configure the loader IAW the provided user, default, and sniffing data.
+	//	 8. Define the global require function.
+	//	 9. Define the module resolution machinery.
+	//	10. Define the module and plugin module definition machinery
+	//	11. Define the script injection machinery.
+	//	12. Define the window load detection.
+	//	13. Define the logging API.
+	//	14. Define the tracing API.
+	//	16. Define the AMD define function.
+	//	17. Define the dojo v1.x provide/require machinery--so called "legacy" modes.
+	//	18. Publish global variables.
+	//
+	// Language and Acronyms and Idioms
+	//
+	// moduleId: a CJS module identifier, (used for public APIs)
+	// mid: moduleId (used internally)
+	// packageId: a package identifier (used for public APIs)
+	// pid: packageId (used internally); the implied system or default package has pid===""
+	// pack: package is used internally to reference a package object (since javascript has reserved words including "package")
+	// prid: plugin resource identifier
+	// The integer constant 1 is used in place of true and 0 in place of false.
+
+	// define a minimal library to help build the loader
+	var	noop = function(){
+		},
+
+		isEmpty = function(it){
+			for(var p in it){
+				return 0;
+			}
+			return 1;
+		},
+
+		toString = {}.toString,
+
+		isFunction = function(it){
+			return toString.call(it) == "[object Function]";
+		},
+
+		isString = function(it){
+			return toString.call(it) == "[object String]";
+		},
+
+		isArray = function(it){
+			return toString.call(it) == "[object Array]";
+		},
+
+		forEach = function(vector, callback){
+			if(vector){
+				for(var i = 0; i < vector.length;){
+					callback(vector[i++]);
+				}
+			}
+		},
+
+		mix = function(dest, src){
+			for(var p in src){
+				dest[p] = src[p];
+			}
+			return dest;
+		},
+
+		makeError = function(error, info){
+			return mix(new Error(error), {src:"dojoLoader", info:info});
+		},
+
+		uidSeed = 1,
+
+		uid = function(){
+			// Returns a unique indentifier (within the lifetime of the document) of the form /_d+/.
+			return "_" + uidSeed++;
+		},
+
+		// FIXME: how to doc window.require() api
+
+		// this will be the global require function; define it immediately so we can start hanging things off of it
+		req = function(
+			config,       //(object, optional) hash of configuration properties
+			dependencies, //(array of commonjs.moduleId, optional) list of modules to be loaded before applying callback
+			callback      //(function, optional) lamda expression to apply to module values implied by dependencies
+		){
+			return contextRequire(config, dependencies, callback, 0, req);
+		},
+
+		// the loader uses the has.js API to control feature inclusion/exclusion; define then use throughout
+		global = this,
+
+		doc = global.document,
+
+		element = doc && doc.createElement("DiV"),
+
+		has = req.has = function(name){
+			return isFunction(hasCache[name]) ? (hasCache[name] = hasCache[name](global, doc, element)) : hasCache[name];
+		},
+
+		hasCache = has.cache = defaultConfig.hasCache;
+
+	has.add = function(name, test, now, force){
+		(hasCache[name]===undefined || force) && (hasCache[name] = test);
+		return now && has(name);
+	};
+
+	false && has.add("host-node", typeof process == "object" && /node(\.exe)?$/.test(process.execPath));
+	if(0){
+		// fixup the default config for node.js environment
+		require("./_base/configNode.js").config(defaultConfig);
+		// remember node's require (with respect to baseUrl==dojo's root)
+		defaultConfig.loaderPatch.nodeRequire = require;
+	}
+
+	false && has.add("host-rhino", typeof load == "function" && (typeof Packages == "function" || typeof Packages == "object"));
+	if(0){
+		// owing to rhino's lame feature that hides the source of the script, give the user a way to specify the baseUrl...
+		for(var baseUrl = userConfig.baseUrl || ".", arg, rhinoArgs = this.arguments, i = 0; i < rhinoArgs.length;){
+			arg = (rhinoArgs[i++] + "").split("=");
+			if(arg[0] == "baseUrl"){
+				baseUrl = arg[1];
+				break;
+			}
+		}
+		load(baseUrl + "/_base/configRhino.js");
+		rhinoDojoConfig(defaultConfig, baseUrl, rhinoArgs);
+	}
+
+	// userConfig has tests override defaultConfig has tests; do this after the environment detection because
+	// the environment detection usually sets some has feature values in the hasCache.
+	for(var p in userConfig.has){
+		has.add(p, userConfig.has[p], 0, 1);
+	}
+
+	//
+	// define the loader data
+	//
+
+	// the loader will use these like symbols if the loader has the traceApi; otherwise
+	// define magic numbers so that modules can be provided as part of defaultConfig
+	var	requested = 1,
+		arrived = 2,
+		nonmodule = 3,
+		executing = 4,
+		executed = 5;
+
+	if(0){
+		// these make debugging nice; but using strings for symbols is a gross rookie error; don't do it for production code
+		requested = "requested";
+		arrived = "arrived";
+		nonmodule = "not-a-module";
+		executing = "executing";
+		executed = "executed";
+	}
+
+	var legacyMode = 0,
+		sync = "sync",
+		xd = "xd",
+		syncExecStack = [],
+		dojoRequirePlugin = 0,
+		checkDojoRequirePlugin = noop,
+		transformToAmd = noop,
+		getXhr;
+	if(1){
+		req.isXdUrl = noop;
+
+		req.initSyncLoader = function(dojoRequirePlugin_, checkDojoRequirePlugin_, transformToAmd_){
+			if(!dojoRequirePlugin){
+				dojoRequirePlugin = dojoRequirePlugin_;
+				checkDojoRequirePlugin = checkDojoRequirePlugin_;
+				transformToAmd = transformToAmd_;
+			}
+			return {
+				sync:sync,
+				xd:xd,
+				arrived:arrived,
+				nonmodule:nonmodule,
+				executing:executing,
+				executed:executed,
+				syncExecStack:syncExecStack,
+				modules:modules,
+				execQ:execQ,
+				getModule:getModule,
+				injectModule:injectModule,
+				setArrived:setArrived,
+				signal:signal,
+				finishExec:finishExec,
+				execModule:execModule,
+				dojoRequirePlugin:dojoRequirePlugin,
+				getLegacyMode:function(){return legacyMode;},
+				holdIdle:function(){checkCompleteGuard++;},
+				releaseIdle:function(){checkIdle();}
+			};
+		};
+
+		if(1){
+			// in legacy sync mode, the loader needs a minimal XHR library to load dojo/_base/loader and dojo/_base/xhr
+
+			var locationProtocol = location.protocol,
+				locationHost = location.host,
+				fileProtocol = !locationHost;
+			req.isXdUrl = function(url){
+				if(fileProtocol || /^\./.test(url)){
+					// begins with a dot is always relative to page URL; therefore not xdomain
+					return false;
+				}
+				if(/^\/\//.test(url)){
+					// for v1.6- backcompat, url starting with // indicates xdomain
+					return true;
+				}
+				// get protocol and host
+				var match = url.match(/^([^\/\:]+\:)\/\/([^\/]+)/);
+				return match && (match[1] != locationProtocol || match[2] != locationHost);
+			};
+
+			// note: to get the file:// protocol to work in FF, you must set security.fileuri.strict_origin_policy to false in about:config
+			true || has.add("dojo-xhr-factory", 1);
+			has.add("dojo-force-activex-xhr", 1 && !doc.addEventListener && window.location.protocol == "file:");
+			has.add("native-xhr", typeof XMLHttpRequest != "undefined");
+			if(has("native-xhr") && !has("dojo-force-activex-xhr")){
+				getXhr = function(){
+					return new XMLHttpRequest();
+				};
+			}else{
+				// if in the browser an old IE; find an xhr
+				for(var XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'], progid, i = 0; i < 3;){
+					try{
+						progid = XMLHTTP_PROGIDS[i++];
+						if(new ActiveXObject(progid)){
+							// this progid works; therefore, use it from now on
+							break;
+						}
+					}catch(e){
+						// squelch; we're just trying to find a good ActiveX progid
+						// if they all fail, then progid ends up as the last attempt and that will signal the error
+						// the first time the client actually tries to exec an xhr
+					}
+				}
+				getXhr = function(){
+					return new ActiveXObject(progid);
+				};
+			}
+			req.getXhr = getXhr;
+
+			has.add("dojo-gettext-api", 1);
+			req.getText = function(url, async, onLoad){
+				var xhr = getXhr();
+				xhr.open('GET', fixupUrl(url), false);
+				xhr.send(null);
+				if(xhr.status == 200 || (!location.host && !xhr.status)){
+					if(onLoad){
+						onLoad(xhr.responseText, async);
+					}
+				}else{
+					throw makeError("xhrFailed", xhr.status);
+				}
+				return xhr.responseText;
+			};
+		}
+	}else{
+		req.async = 1;
+	}
+
+	//
+	// loader eval
+	//
+	var eval_ =
+		// use the function constructor so our eval is scoped close to (but not in) in the global space with minimal pollution
+		new Function("__text", 'return eval(__text);');
+
+	req.eval =
+		function(text, hint){
+			return eval_(text + "\r\n////@ sourceURL=" + hint);
+		};
+
+	//
+	// loader micro events API
+	//
+	var listenerQueues = {},
+		error = "error",
+		signal = req.signal = function(type, args){
+			var queue = listenerQueues[type];
+			// notice we run a copy of the queue; this allows listeners to add/remove
+			// other listeners without affecting this particular signal
+			forEach(queue && queue.slice(0), function(listener){
+				listener.apply(null, isArray(args) ? args : [args]);
+			});
+		},
+		on = req.on = function(type, listener){
+			// notice a queue is not created until a client actually connects
+			var queue = listenerQueues[type] || (listenerQueues[type] = []);
+			queue.push(listener);
+			return {
+				remove:function(){
+					for(var i = 0; i<queue.length; i++){
+						if(queue[i]===listener){
+							queue.splice(i, 1);
+							return;
+						}
+					}
+				}
+			};
+		};
+
+	// configuration machinery; with an optimized/built defaultConfig, all configuration machinery can be discarded
+	// lexical variables hold key loader data structures to help with minification; these may be completely,
+	// one-time initialized by defaultConfig for optimized/built versions
+	var
+		aliases
+			// a vector of pairs of [regexs or string, replacement] => (alias, actual)
+			= [],
+
+		paths
+			// CommonJS paths
+			= {},
+
+		pathsMapProg
+			// list of (from-path, to-path, regex, length) derived from paths;
+			// a "program" to apply paths; see computeMapProg
+			= [],
+
+		packs
+			// a map from packageId to package configuration object; see fixupPackageInfo
+			= {},
+
+		packageMap
+			// map from package name to local-installed package name
+			= {},
+
+		packageMapProg
+			// list of (from-package, to-package, regex, length) derived from packageMap;
+			// a "program" to apply paths; see computeMapProg
+			= [],
+
+		modules
+			// A hash:(mid) --> (module-object) the module namespace
+			//
+			// pid: the package identifier to which the module belongs (e.g., "dojo"); "" indicates the system or default package
+			// mid: the fully-resolved (i.e., mappings have been applied) module identifier without the package identifier (e.g., "dojo/io/script")
+			// url: the URL from which the module was retrieved
+			// pack: the package object of the package to which the module belongs
+			// executed: 0 => not executed; executing => in the process of tranversing deps and running factory; executed => factory has been executed
+			// deps: the dependency vector for this module (vector of modules objects)
+			// def: the factory for this module
+			// result: the result of the running the factory for this module
+			// injected: (requested | arrived | nonmodule) the status of the module; nonmodule means the resource did not call define
+			// load: plugin load function; applicable only for plugins
+			//
+			// Modules go through several phases in creation:
+			//
+			// 1. Requested: some other module's definition or a require application contained the requested module in
+			//    its dependency vector or executing code explicitly demands a module via req.require.
+			//
+			// 2. Injected: a script element has been appended to the insert-point element demanding the resource implied by the URL
+			//
+			// 3. Loaded: the resource injected in [2] has been evalated.
+			//
+			// 4. Defined: the resource contained a define statement that advised the loader about the module. Notice that some
+			//    resources may just contain a bundle of code and never formally define a module via define
+			//
+			// 5. Evaluated: the module was defined via define and the loader has evaluated the factory and computed a result.
+			= {},
+
+		cacheBust
+			// query string to append to module URLs to bust browser cache
+			= "",
+
+		cache
+			// hash:(mid)-->(function)
+			//
+			// Gives the contents of a cached resource; function should cause the same actions as if the given mid was downloaded
+			// and evaluated by the host environment
+			 = {},
+
+		pendingCacheInsert
+			// hash:(mid)-->(function)
+			//
+			// Gives a set of cache modules pending entry into cache. When cached modules are published to the loader, they are
+			// entered into pendingCacheInsert; modules are then pressed into cache upon (1) AMD define or (2) upon receiving another
+			// independent set of cached modules. (1) is the usual case, and this case allows normalizing mids given in the pending
+			// cache for the local configuration, possibly relocating modules.
+			 = {},
+
+		dojoSniffConfig
+			// map of configuration variables
+			// give the data-dojo-config as sniffed from the document (if any)
+			= {};
+
+	if(1){
+		var consumePendingCacheInsert = function(referenceModule){
+				for(var p in pendingCacheInsert){
+					var match = p.match(/^url\:(.+)/);
+					if(match){
+						cache[toUrl(match[1], referenceModule)] =  pendingCacheInsert[p];
+					}else if(p!="*noref"){
+						cache[getModuleInfo(p, referenceModule).mid] = pendingCacheInsert[p];
+					}
+				}
+				pendingCacheInsert = {};
+			},
+
+			computeMapProg = function(map, dest, packName){
+				// This routine takes a map target-prefix(string)-->replacement(string) into a vector
+				// of quads (target-prefix, replacement, regex-for-target-prefix, length-of-target-prefix)
+				//
+				// The loader contains processes that map one string prefix to another. These
+				// are encountered when applying the requirejs paths configuration and when mapping
+				// package names. We can make the mapping and any replacement easier and faster by
+				// replacing the map with a vector of quads and then using this structure in the simple machine runMapProg.
+				dest.splice(0, dest.length);
+				var p, i, item, reverseName = 0;
+				for(p in map){
+					dest.push([p, map[p]]);
+					if(map[p]==packName){
+						reverseName = p;
+					}
+				}
+				dest.sort(function(lhs, rhs){
+					return rhs[0].length - lhs[0].length;
+				});
+				for(i = 0; i < dest.length;){
+					item = dest[i++];
+					item[2] = new RegExp("^" + item[0].replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, function(c){ return "\\" + c; }) + "(\/|$)");
+					item[3] = item[0].length + 1;
+				}
+				return reverseName;
+			},
+
+			fixupPackageInfo = function(packageInfo, baseUrl){
+				// calculate the precise (name, baseUrl, main, mappings) for a package
+				var name = packageInfo.name;
+				if(!name){
+					// packageInfo must be a string that gives the name
+					name = packageInfo;
+					packageInfo = {name:name};
+				}
+				packageInfo = mix({main:"main", mapProg:[]}, packageInfo);
+				packageInfo.location = (baseUrl || "") + (packageInfo.location ? packageInfo.location : name);
+				packageInfo.reverseName = computeMapProg(packageInfo.packageMap, packageInfo.mapProg, name);
+
+				if(!packageInfo.main.indexOf("./")){
+					packageInfo.main = packageInfo.main.substring(2);
+				}
+
+				// allow paths to be specified in the package info
+				// TODO: this is not supported; remove
+				mix(paths, packageInfo.paths);
+
+				// now that we've got a fully-resolved package object, push it into the configuration
+				packs[name] = packageInfo;
+				packageMap[name] = name;
+			},
+
+			config = function(config, booting){
+				for(var p in config){
+					if(p=="waitSeconds"){
+						req.waitms = (config[p] || 0) * 1000;
+					}
+					if(p=="cacheBust"){
+						cacheBust = config[p] ? (isString(config[p]) ? config[p] : (new Date()).getTime() + "") : "";
+					}
+					if(p=="baseUrl" || p=="combo"){
+						req[p] = config[p];
+					}
+					if(1 && p=="async"){
+						// falsy or "sync" => legacy sync loader
+						// "xd" => sync but loading xdomain tree and therefore loading asynchronously (not configurable, set automatically by the loader)
+						// "legacyAsync" => permanently in "xd" by choice
+						// "debugAtAllCosts" => trying to load everything via script injection (not implemented)
+						// otherwise, must be truthy => AMD
+						// legacyMode: sync | legacyAsync | xd | false
+						var mode = config[p];
+						req.legacyMode = legacyMode = (isString(mode) && /sync|legacyAsync/.test(mode) ? mode : (!mode ? "sync" : false));
+						req.async = !legacyMode;
+					}
+					if(config[p]!==hasCache){
+						// accumulate raw config info for client apps which can use this to pass their own config
+						req.rawConfig[p] = config[p];
+						p!="has" && has.add("config-"+p, config[p], 0, booting);
+					}
+				}
+
+				// make sure baseUrl exists
+				if(!req.baseUrl){
+					req.baseUrl = "./";
+				}
+				// make sure baseUrl ends with a slash
+				if(!/\/$/.test(req.baseUrl)){
+					req.baseUrl += "/";
+				}
+
+				// now do the special work for has, packages, packagePaths, paths, aliases, and cache
+
+				for(p in config.has){
+					has.add(p, config.has[p], 0, booting);
+				}
+
+				// for each package found in any packages config item, augment the packs map owned by the loader
+				forEach(config.packages, fixupPackageInfo);
+
+				// for each packagePath found in any packagePaths config item, augment the packs map owned by the loader
+				for(baseUrl in config.packagePaths){
+					forEach(config.packagePaths[baseUrl], function(packageInfo){
+						fixupPackageInfo(packageInfo, baseUrl + "/");
+					});
+				}
+
+				// push in any paths and recompute the internal pathmap
+				// warning: this cann't be done until the package config is processed since packages may include path info
+				computeMapProg(mix(paths, config.paths), pathsMapProg);
+
+				// aliases
+				forEach(config.aliases, function(pair){
+					if(isString(pair[0])){
+						pair[0] = new RegExp("^" + pair[0].replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, function(c){return "\\" + c;}) + "$");
+					}
+					aliases.push(pair);
+				});
+
+				// mix any packageMap config item and recompute the internal packageMapProg
+				computeMapProg(mix(packageMap, config.packageMap), packageMapProg);
+
+				// push in any new cache values
+				if(config.cache){
+					consumePendingCacheInsert();
+					pendingCacheInsert = config.cache;
+					if(config.cache["*noref"]){
+						consumePendingCacheInsert();
+					}
+				}
+
+				signal("config", [config, req.rawConfig]);
+			};
+
+		//
+		// execute the various sniffs
+		//
+
+		if(has("dojo-cdn") || 1){
+			for(var dojoDir, src, match, scripts = doc.getElementsByTagName("script"), i = 0; i < scripts.length && !match; i++){
+				if((src = scripts[i].getAttribute("src")) && (match = src.match(/(.*)\/?dojo\.js(\W|$)/i))){
+					// if baseUrl wasn't explicitly set, set it here to the dojo directory; this is the 1.6- behavior
+					userConfig.baseUrl = dojoDir = userConfig.baseUrl || defaultConfig.baseUrl || match[1];
+
+					// see if there's a dojo configuration stuffed into the node
+					src = (scripts[i].getAttribute("data-dojo-config") || scripts[i].getAttribute("djConfig"));
+					if(src){
+						dojoSniffConfig = req.eval("({ " + src + " })", "data-dojo-config");
+					}
+					if(0){
+						var dataMain = scripts[i].getAttribute("data-main");
+						if(dataMain){
+							dojoSniffConfig.deps = dojoSniffConfig.deps || [dataMain];
+						}
+					}
+				}
+			}
+		}
+
+		if(0){
+			// pass down doh.testConfig from parent as if it were a data-dojo-config
+			try{
+				if(window.parent != window && window.parent.require){
+					var doh = window.parent.require("doh");
+					doh && mix(dojoSniffConfig, doh.testConfig);
+				}
+			}catch(e){}
+		}
+
+		// configure the loader; let the user override defaults
+		req.rawConfig = {};
+		config(defaultConfig, 1);
+		config(userConfig, 1);
+		config(dojoSniffConfig, 1);
+
+		if(has("dojo-cdn")){
+			packs.dojo.location = dojoDir;
+			packs.dijit.location = dojoDir + "../dijit/";
+			packs.dojox.location = dojoDir + "../dojox/";
+		}
+
+	}else{
+		// no config API, assume defaultConfig has everything the loader needs...for the entire lifetime of the application
+		paths = defaultConfig.paths;
+		pathsMapProg = defaultConfig.pathsMapProg;
+		packs = defaultConfig.packs;
+		aliases = defaultConfig.aliases;
+		packageMap = defaultConfig.packageMap;
+		packageMapProg = defaultConfig.packageMapProg;
+		modules = defaultConfig.modules;
+		cache = defaultConfig.cache;
+		cacheBust = defaultConfig.cacheBust;
+
+		// remember the default config for other processes (e.g., dojo/config)
+		req.rawConfig = defaultConfig;
+	}
+
+
+	if(0){
+		req.combo = req.combo || {add:noop};
+		var	comboPending = 0,
+			combosPending = [],
+			comboPendingTimer = null;
+	}
+
+
+	// build the loader machinery iaw configuration, including has feature tests
+	var	injectDependencies = function(module){
+			// checkComplete!=0 holds the idle signal; we're not idle if we're injecting dependencies
+			checkCompleteGuard++;
+			forEach(module.deps, injectModule);
+			if(0 && comboPending && !comboPendingTimer){
+				comboPendingTimer = setTimeout(function() {
+					comboPending = 0;
+					comboPendingTimer = null;
+					req.combo.done(function(mids, url) {
+						var onLoadCallback= function(){
+							// defQ is a vector of module definitions 1-to-1, onto mids
+							runDefQ(0, mids);
+							checkComplete();
+						};
+						combosPending.push(mids);
+						injectingModule = mids;
+						req.injectUrl(url, onLoadCallback, mids);
+						injectingModule = 0;
+					}, req);
+				}, 0);
+			}
+			checkIdle();
+		},
+
+		contextRequire = function(a1, a2, a3, referenceModule, contextRequire){
+			var module, syntheticMid;
+			if(isString(a1)){
+				// signature is (moduleId)
+				module = getModule(a1, referenceModule, true);
+				if(module && module.executed){
+					return module.result;
+				}
+				throw makeError("undefinedModule", a1);
+			}
+			if(!isArray(a1)){
+				// a1 is a configuration
+				config(a1);
+
+				// juggle args; (a2, a3) may be (dependencies, callback)
+				a1 = a2;
+				a2 = a3;
+			}
+			if(isArray(a1)){
+				// signature is (requestList [,callback])
+				if(!a1.length){
+					a2 && a2();
+				}else{
+					syntheticMid = "require*" + uid();
+
+					// resolve the request list with respect to the reference module
+					for(var mid, deps = [], i = 0; i < a1.length;){
+						mid = a1[i++];
+						if(mid in {exports:1, module:1}){
+							throw makeError("illegalModuleId", mid);
+						}
+						deps.push(getModule(mid, referenceModule));
+					}
+
+					// construct a synthetic module to control execution of the requestList, and, optionally, callback
+					module = mix(makeModuleInfo("", syntheticMid, 0, ""), {
+						injected: arrived,
+						deps: deps,
+						def: a2 || noop,
+						require: referenceModule ? referenceModule.require : req
+					});
+					modules[module.mid] = module;
+
+					// checkComplete!=0 holds the idle signal; we're not idle if we're injecting dependencies
+					injectDependencies(module);
+
+					// try to immediately execute
+					// if already traversing a factory tree, then strict causes circular dependency to abort the execution; maybe
+					// it's possible to execute this require later after the current traversal completes and avoid the circular dependency.
+					// ...but *always* insist on immediate in synch mode
+					var strict = checkCompleteGuard && req.async;
+					checkCompleteGuard++;
+					execModule(module, strict);
+					checkIdle();
+					if(!module.executed){
+						// some deps weren't on board or circular dependency detected and strict; therefore, push into the execQ
+						execQ.push(module);
+					}
+					checkComplete();
+				}
+			}
+			return contextRequire;
+		},
+
+		createRequire = function(module){
+			if(!module){
+				return req;
+			}
+			var result = module.require;
+			if(!result){
+				result = function(a1, a2, a3){
+					return contextRequire(a1, a2, a3, module, result);
+				};
+				module.require = mix(result, req);
+				result.module = module;
+				result.toUrl = function(name){
+					return toUrl(name, module);
+				};
+				result.toAbsMid = function(mid){
+					return toAbsMid(mid, module);
+				};
+				if(0){
+					result.undef = function(mid){
+						req.undef(mid, module);
+					};
+				}
+			}
+			return result;
+		},
+
+		execQ =
+			// The list of modules that need to be evaluated.
+			[],
+
+		defQ =
+			// The queue of define arguments sent to loader.
+			[],
+
+		waiting =
+			// The set of modules upon which the loader is waiting for definition to arrive
+			{},
+
+		setRequested = function(module){
+			module.injected = requested;
+			waiting[module.mid] = 1;
+			if(module.url){
+				waiting[module.url] = module.pack || 1;
+			}
+		},
+
+		setArrived = function(module){
+			module.injected = arrived;
+			delete waiting[module.mid];
+			if(module.url){
+				delete waiting[module.url];
+			}
+			if(isEmpty(waiting)){
+				clearTimer();
+				1 && legacyMode==xd && (legacyMode = sync);
+			}
+		},
+
+		execComplete = req.idle =
+			// says the loader has completed (or not) its work
+			function(){
+				return !defQ.length && isEmpty(waiting) && !execQ.length && !checkCompleteGuard;
+			},
+
+		runMapProg = function(targetMid, map){
+			// search for targetMid in map; return the map item if found; falsy otherwise
+			for(var i = 0; i < map.length; i++){
+				if(map[i][2].test(targetMid)){
+					return map[i];
+				}
+			}
+			return 0;
+		},
+
+		compactPath = function(path){
+			var result = [],
+				segment, lastSegment;
+			path = path.replace(/\\/g, '/').split('/');
+			while(path.length){
+				segment = path.shift();
+				if(segment==".." && result.length && lastSegment!=".."){
+					result.pop();
+					lastSegment = result[result.length - 1];
+				}else if(segment!="."){
+					result.push(lastSegment= segment);
+				} // else ignore "."
+			}
+			return result.join("/");
+		},
+
+		makeModuleInfo = function(pid, mid, pack, url, cacheId){
+			if(1){
+				var xd= req.isXdUrl(url);
+				return {pid:pid, mid:mid, pack:pack, url:url, executed:0, def:0, isXd:xd, isAmd:!!(xd || (packs[pid] && packs[pid].isAmd)), cacheId:cacheId};
+			}else{
+				return {pid:pid, mid:mid, pack:pack, url:url, executed:0, def:0, cacheId:cacheId};
+			}
+		},
+
+		getModuleInfo_ = function(mid, referenceModule, packs, modules, baseUrl, packageMapProg, pathsMapProg, alwaysCreate){
+			// arguments are passed instead of using lexical variables so that this function my be used independent of the loader (e.g., the builder)
+			// alwaysCreate is useful in this case so that getModuleInfo never returns references to real modules owned by the loader
+			var pid, pack, midInPackage, mapProg, mapItem, path, url, result, isRelative, requestedMid, cacheId=0;
+			requestedMid = mid;
+			isRelative = /^\./.test(mid);
+			if(/(^\/)|(\:)|(\.js$)/.test(mid) || (isRelative && !referenceModule)){
+				// absolute path or protocol of .js filetype, or relative path but no reference module and therefore relative to page
+				// whatever it is, it's not a module but just a URL of some sort
+				return makeModuleInfo(0, mid, 0, mid);
+			}else{
+				// relative module ids are relative to the referenceModule; get rid of any dots
+				mid = compactPath(isRelative ? (referenceModule.mid + "/../" + mid) : mid);
+				if(/^\./.test(mid)){
+					throw makeError("irrationalPath", mid);
+				}
+				// find the package indicated by the mid, if any
+				mapProg = referenceModule && referenceModule.pack && referenceModule.pack.mapProg;
+				mapItem = (mapProg && runMapProg(mid, mapProg)) || runMapProg(mid, packageMapProg);
+				if(mapItem){
+					// mid specified a module that's a member of a package; figure out the package id and module id
+					// notice we expect pack.main to be valid with no pre or post slash
+					pid = mapItem[1];
+					mid = mid.substring(mapItem[3]);
+					pack = packs[pid];
+					if(!mid){
+						mid= pack.main;
+					}
+					midInPackage = mid;
+					cacheId = pack.reverseName + "/" + mid;
+					mid = pid + "/" + mid;
+				}else{
+					pid = "";
+				}
+
+				// search aliases
+				var candidateLength = 0,
+					candidate = 0;
+				forEach(aliases, function(pair){
+					var match = mid.match(pair[0]);
+					if(match && match.length>candidateLength){
+						candidate = isFunction(pair[1]) ? mid.replace(pair[0], pair[1]) : pair[1];
+					}
+				});
+				if(candidate){
+					return getModuleInfo_(candidate, 0, packs, modules, baseUrl, packageMapProg, pathsMapProg, alwaysCreate);
+				}
+
+				result = modules[mid];
+				if(result){
+					return alwaysCreate ? makeModuleInfo(result.pid, result.mid, result.pack, result.url, cacheId) : modules[mid];
+				}
+			}
+			// get here iff the sought-after module does not yet exist; therefore, we need to compute the URL given the
+			// fully resolved (i.e., all relative indicators and package mapping resolved) module id
+
+			mapItem = runMapProg(mid, pathsMapProg);
+			if(mapItem){
+				url = mapItem[1] + mid.substring(mapItem[3] - 1);
+			}else if(pid){
+				url = pack.location + "/" + midInPackage;
+			}else if(has("config-tlmSiblingOfDojo")){
+				url = "../" + mid;
+			}else{
+				url = mid;
+			}
+			// if result is not absolute, add baseUrl
+			if(!(/(^\/)|(\:)/.test(url))){
+				url = baseUrl + url;
+			}
+			url += ".js";
+			return makeModuleInfo(pid, mid, pack, compactPath(url), cacheId);
+		},
+
+		getModuleInfo = function(mid, referenceModule){
+			return getModuleInfo_(mid, referenceModule, packs, modules, req.baseUrl, packageMapProg, pathsMapProg);
+		},
+
+		resolvePluginResourceId = function(plugin, prid, referenceModule){
+			return plugin.normalize ? plugin.normalize(prid, function(mid){return toAbsMid(mid, referenceModule);}) : toAbsMid(prid, referenceModule);
+		},
+
+		dynamicPluginUidGenerator = 0,
+
+		getModule = function(mid, referenceModule, immediate){
+			// compute and optionally construct (if necessary) the module implied by the mid with respect to referenceModule
+			var match, plugin, prid, result;
+			match = mid.match(/^(.+?)\!(.*)$/);
+			if(match){
+				// name was <plugin-module>!<plugin-resource-id>
+				plugin = getModule(match[1], referenceModule, immediate);
+
+				if(1 && legacyMode == sync && !plugin.executed){
+					injectModule(plugin);
+					if(plugin.injected===arrived && !plugin.executed){
+						checkCompleteGuard++;
+						execModule(plugin);
+						checkIdle();
+					}
+					if(plugin.executed){
+						promoteModuleToPlugin(plugin);
+					}else{
+						// we are in xdomain mode for some reason
+						execQ.unshift(plugin);
+					}
+				}
+
+
+
+				if(plugin.executed === executed && !plugin.load){
+					// executed the module not knowing it was a plugin
+					promoteModuleToPlugin(plugin);
+				}
+
+				// if the plugin has not been loaded, then can't resolve the prid and  must assume this plugin is dynamic until we find out otherwise
+				if(plugin.load){
+					prid = resolvePluginResourceId(plugin, match[2], referenceModule);
+					mid = (plugin.mid + "!" + (plugin.dynamic ? ++dynamicPluginUidGenerator + "!" : "") + prid);
+				}else{
+					prid = match[2];
+					mid = plugin.mid + "!" + (++dynamicPluginUidGenerator) + "!waitingForPlugin";
+				}
+				result = {plugin:plugin, mid:mid, req:createRequire(referenceModule), prid:prid};
+			}else{
+				result = getModuleInfo(mid, referenceModule);
+			}
+			return modules[result.mid] || (!immediate && (modules[result.mid] = result));
+		},
+
+		toAbsMid = req.toAbsMid = function(mid, referenceModule){
+			return getModuleInfo(mid, referenceModule).mid;
+		},
+
+		toUrl = req.toUrl = function(name, referenceModule){
+			// name must include a filetype; fault tolerate to allow no filetype (but things like "path/to/version2.13" will assume filetype of ".13")
+			var	match = name.match(/(.+)(\.[^\/\.]+?)$/),
+				root = (match && match[1]) || name,
+				ext = (match && match[2]) || "",
+				moduleInfo = getModuleInfo(root, referenceModule),
+				url= moduleInfo.url;
+			// recall, getModuleInfo always returns a url with a ".js" suffix iff pid; therefore, we've got to trim it
+			url= typeof moduleInfo.pid == "string" ? url.substring(0, url.length - 3) : url;
+			return fixupUrl(url + ext);
+		},
+
+		nonModuleProps = {
+			injected: arrived,
+			executed: executed,
+			def: nonmodule,
+			result: nonmodule
+		},
+
+		makeCjs = function(mid){
+			return modules[mid] = mix({mid:mid}, nonModuleProps);
+		},
+
+		cjsRequireModule = makeCjs("require"),
+		cjsExportsModule = makeCjs("exports"),
+		cjsModuleModule = makeCjs("module"),
+
+		runFactory = function(module, args){
+			req.trace("loader-run-factory", [module.mid]);
+			var factory = module.def,
+				result;
+			1 && syncExecStack.unshift(module);
+			if(has("config-dojo-loader-catches")){
+				try{
+					result= isFunction(factory) ? factory.apply(null, args) : factory;
+				}catch(e){
+					signal(error, module.result = makeError("factoryThrew", [module, e]));
+				}
+			}else{
+				result= isFunction(factory) ? factory.apply(null, args) : factory;
+			}
+			module.result = result===undefined && module.cjs ? module.cjs.exports : result;
+			1 && syncExecStack.shift(module);
+		},
+
+		abortExec = {},
+
+		defOrder = 0,
+
+		promoteModuleToPlugin = function(pluginModule){
+			var plugin = pluginModule.result;
+			pluginModule.dynamic = plugin.dynamic;
+			pluginModule.normalize = plugin.normalize;
+			pluginModule.load = plugin.load;
+			return pluginModule;
+		},
+
+		resolvePluginLoadQ = function(plugin){
+			// plugins is a newly executed module that has a loadQ waiting to run
+
+			// step 1: traverse the loadQ and fixup the mid and prid; remember the map from original mid to new mid
+			// recall the original mid was created before the plugin was on board and therefore it was impossible to
+			// compute the final mid; accordingly, prid may or may not change, but the mid will definitely change
+			var map = {};
+			forEach(plugin.loadQ, function(pseudoPluginResource){
+				// manufacture and insert the real module in modules
+				var pseudoMid = pseudoPluginResource.mid,
+					prid = resolvePluginResourceId(plugin, pseudoPluginResource.prid, pseudoPluginResource.req.module),
+					mid = plugin.dynamic ? pseudoPluginResource.mid.replace(/waitingForPlugin$/, prid) : (plugin.mid + "!" + prid),
+					pluginResource = mix(mix({}, pseudoPluginResource), {mid:mid, prid:prid, injected:0});
+				if(!modules[mid]){
+					// create a new (the real) plugin resource and inject it normally now that the plugin is on board
+					injectPlugin(modules[mid] = pluginResource);
+				} // else this was a duplicate request for the same (plugin, rid) for a nondynamic plugin
+
+				// pluginResource is really just a placeholder with the wrong mid (because we couldn't calculate it until the plugin was on board)
+				// mark is as arrived and delete it from modules; the real module was requested above
+				map[pseudoPluginResource.mid] = modules[mid];
+				setArrived(pseudoPluginResource);
+				delete modules[pseudoPluginResource.mid];
+			});
+			plugin.loadQ = 0;
+
+			// step2: replace all references to any placeholder modules with real modules
+			var substituteModules = function(module){
+				for(var replacement, deps = module.deps || [], i = 0; i<deps.length; i++){
+					replacement = map[deps[i].mid];
+					if(replacement){
+						deps[i] = replacement;
+					}
+				}
+			};
+			for(var p in modules){
+				substituteModules(modules[p]);
+			}
+			forEach(execQ, substituteModules);
+		},
+
+		finishExec = function(module){
+			req.trace("loader-finish-exec", [module.mid]);
+			module.executed = executed;
+			module.defOrder = defOrder++;
+			1 && forEach(module.provides, function(cb){ cb(); });
+			if(module.loadQ){
+				// the module was a plugin
+				promoteModuleToPlugin(module);
+				resolvePluginLoadQ(module);
+			}
+			// remove all occurences of this module from the execQ
+			for(i = 0; i < execQ.length;){
+				if(execQ[i] === module){
+					execQ.splice(i, 1);
+				}else{
+					i++;
+				}
+			}
+		},
+
+		circleTrace = [],
+
+		execModule = function(module, strict){
+			// run the dependency vector, then run the factory for module
+			if(module.executed === executing){
+				req.trace("loader-circular-dependency", [circleTrace.concat(mid).join("->")]);
+				return (!module.def || strict) ? abortExec :  (module.cjs && module.cjs.exports);
+			}
+			// at this point the module is either not executed or fully executed
+
+
+			if(!module.executed){
+				if(!module.def){
+					return abortExec;
+				}
+				var mid = module.mid,
+					deps = module.deps || [],
+					arg, argResult,
+					args = [],
+					i = 0;
+
+				if(0){
+					circleTrace.push(mid);
+					req.trace("loader-exec-module", ["exec", circleTrace.length, mid]);
+				}
+
+				// for circular dependencies, assume the first module encountered was executed OK
+				// modules that circularly depend on a module that has not run its factory will get
+				// the premade cjs.exports===module.result. They can take a reference to this object and/or
+				// add properties to it. When the module finally runs its factory, the factory can
+				// read/write/replace this object. Notice that so long as the object isn't replaced, any
+				// reference taken earlier while walking the deps list is still valid.
+				module.executed = executing;
+				while(i < deps.length){
+					arg = deps[i++];
+					argResult = ((arg === cjsRequireModule) ? createRequire(module) :
+									((arg === cjsExportsModule) ? module.cjs.exports :
+										((arg === cjsModuleModule) ? module.cjs :
+											execModule(arg, strict))));
+					if(argResult === abortExec){
+						module.executed = 0;
+						req.trace("loader-exec-module", ["abort", mid]);
+						0 && circleTrace.pop();
+						return abortExec;
+					}
+					args.push(argResult);
+				}
+				runFactory(module, args);
+				finishExec(module);
+			}
+			// at this point the module is guaranteed fully executed
+
+			0 && circleTrace.pop();
+			return module.result;
+		},
+
+
+		checkCompleteGuard =  0,
+
+		checkComplete = function(){
+			// keep going through the execQ as long as at least one factory is executed
+			// plugins, recursion, cached modules all make for many execution path possibilities
+			if(checkCompleteGuard){
+				return;
+			}
+			checkCompleteGuard++;
+			checkDojoRequirePlugin();
+			for(var currentDefOrder, module, i = 0; i < execQ.length;){
+				currentDefOrder = defOrder;
+				module = execQ[i];
+				execModule(module);
+				if(currentDefOrder!=defOrder){
+					// defOrder was bumped one or more times indicating something was executed (note, this indicates
+					// the execQ was modified, maybe a lot (for example a later module causes an earlier module to execute)
+					checkDojoRequirePlugin();
+					i = 0;
+				}else{
+					// nothing happened; check the next module in the exec queue
+					i++;
+				}
+			}
+			checkIdle();
+		},
+
+		checkIdle = function(){
+			checkCompleteGuard--;
+			if(execComplete()){
+				signal("idle", []);
+			}
+		};
+
+
+	if(0){
+		req.undef = function(moduleId, referenceModule){
+			// In order to reload a module, it must be undefined (this routine) and then re-requested.
+			// This is useful for testing frameworks (at least).
+			var module = getModule(moduleId, referenceModule);
+			setArrived(module);
+			delete modules[module.mid];
+		};
+	}
+
+	if(1){
+		if(has("dojo-loader-eval-hint-url")===undefined){
+			has.add("dojo-loader-eval-hint-url", 1);
+		}
+
+		var fixupUrl= function(url){
+				url += ""; // make sure url is a Javascript string (some paths may be a Java string)
+				return url + (cacheBust ? ((/\?/.test(url) ? "&" : "?") + cacheBust) : "");
+			},
+
+			injectPlugin = function(
+				module
+			){
+				// injects the plugin module given by module; may have to inject the plugin itself
+				var plugin = module.plugin;
+
+				if(plugin.executed === executed && !plugin.load){
+					// executed the module not knowing it was a plugin
+					promoteModuleToPlugin(plugin);
+				}
+
+				var onLoad = function(def){
+						module.result = def;
+						setArrived(module);
+						finishExec(module);
+						checkComplete();
+					};
+
+				setRequested(module);
+				if(plugin.load){
+					plugin.load(module.prid, module.req, onLoad);
+				}else if(plugin.loadQ){
+					plugin.loadQ.push(module);
+				}else{
+					// the unshift instead of push is important: we don't want plugins to execute as
+					// dependencies of some other module because this may cause circles when the plugin
+					// loadQ is run; also, generally, we want plugins to run early since they may load
+					// several other modules and therefore can potentially unblock many modules
+					execQ.unshift(plugin);
+					injectModule(plugin);
+
+					// maybe the module was cached and is now defined...
+					if(plugin.load){
+						plugin.load(module.prid, module.req, onLoad);
+					}else{
+						// nope; queue up the plugin resource to be loaded after the plugin module is loaded
+						plugin.loadQ = [module];
+					}
+				}
+			},
+
+			// for IE, injecting a module may result in a recursive execution if the module is in the cache
+
+			cached = 0,
+
+			injectingModule = 0,
+
+			injectingCachedModule = 0,
+
+			evalModuleText = function(text, module){
+				// see def() for the injectingCachedModule bracket; it simply causes a short, safe curcuit
+				injectingCachedModule = 1;
+				if(has("config-dojo-loader-catches")){
+					try{
+						if(text===cached){
+							cached.call(null);
+						}else{
+							req.eval(text, has("dojo-loader-eval-hint-url") ? module.url : module.mid);
+						}
+					}catch(e){
+						signal(error, makeError("evalModuleThrew", module));
+					}
+				}else{
+					if(text===cached){
+						cached.call(null);
+					}else{
+						req.eval(text, has("dojo-loader-eval-hint-url") ? module.url : module.mid);
+					}
+				}
+				injectingCachedModule = 0;
+			},
+
+			injectModule = function(module){
+				// Inject the module. In the browser environment, this means appending a script element into
+				// the document; in other environments, it means loading a file.
+				//
+				// If in synchronous mode, then get the module synchronously if it's not xdomainLoading.
+
+				var mid = module.mid,
+					url = module.url;
+				if(module.executed || module.injected || waiting[mid] || (module.url && ((module.pack && waiting[module.url]===module.pack) || waiting[module.url]==1))){
+					return;
+				}
+
+				if(0){
+					var viaCombo = 0;
+					if(module.plugin && module.plugin.isCombo){
+						// a combo plugin; therefore, must be handled by combo service
+						// the prid should have already been converted to a URL (if required by the plugin) during
+						// the normalze process; in any event, there is no way for the loader to know how to
+						// to the conversion; therefore the third argument is zero
+						req.combo.add(module.plugin.mid, module.prid, 0, req);
+						viaCombo = 1;
+					}else if(!module.plugin){
+						viaCombo = req.combo.add(0, module.mid, module.url, req);
+					}
+					if(viaCombo){
+						setRequested(module);
+						comboPending= 1;
+						return;
+					}
+				}
+
+				if(module.plugin){
+					injectPlugin(module);
+					return;
+				} // else a normal module (not a plugin)
+
+				setRequested(module);
+
+				var onLoadCallback = function(){
+					runDefQ(module);
+					if(module.injected !== arrived){
+						// the script that contained the module arrived and has been executed yet
+						// nothing was added to the defQ (so it wasn't an AMD module) and the module
+						// wasn't marked as arrived by dojo.provide (so it wasn't a v1.6- module);
+						// therefore, it must not have been a module; adjust state accordingly
+						setArrived(module);
+						mix(module, nonModuleProps);
+					}
+
+					if(1 && legacyMode){
+						// must call checkComplete even in for sync loader because we may be in xdomainLoading mode;
+						// but, if xd loading, then don't call checkComplete until out of the current sync traversal
+						// in order to preserve order of execution of the dojo.required modules
+						!syncExecStack.length && checkComplete();
+					}else{
+						checkComplete();
+					}
+				};
+				cached = cache[mid] || cache[module.cacheId];
+				if(cached){
+					req.trace("loader-inject", ["cache", module.mid, url]);
+					evalModuleText(cached, module);
+					onLoadCallback();
+					return;
+				}
+				if(1 && legacyMode){
+					if(module.isXd){
+						// switch to async mode temporarily; if current legacyMode!=sync, then is must be one of {legacyAsync, xd, false}
+						legacyMode==sync && (legacyMode = xd);
+						// fall through and load via script injection
+					}else if(module.isAmd && legacyMode!=sync){
+						// fall through and load via script injection
+					}else{
+						// mode may be sync, xd/legacyAsync, or async; module may be AMD or legacy; but module is always located on the same domain
+						var xhrCallback = function(text){
+							if(legacyMode==sync){
+								// the top of syncExecStack gives the current synchronously executing module; the loader needs
+								// to know this if it has to switch to async loading in the middle of evaluating a legacy module
+								// this happens when a modules dojo.require's a module that must be loaded async because it's xdomain
+								// (using unshift/shift because there is no back() methods for Javascript arrays)
+								syncExecStack.unshift(module);
+								evalModuleText(text, module);
+								syncExecStack.shift();
+
+								// maybe the module was an AMD module
+								runDefQ(module);
+
+								// legacy modules never get to defineModule() => cjs and injected never set; also evaluation implies executing
+								if(!module.cjs){
+									setArrived(module);
+									finishExec(module);
+								}
+
+								if(module.finish){
+									// while synchronously evaluating this module, dojo.require was applied referencing a module
+									// that had to be loaded async; therefore, the loader stopped answering all dojo.require
+									// requests so they could be answered completely in the correct sequence; module.finish gives
+									// the list of dojo.requires that must be re-applied once all target modules are available;
+									// make a synthetic module to execute the dojo.require's in the correct order
+
+									// compute a guarnateed-unique mid for the synthetic finish module; remember the finish vector; remove it from the reference module
+									// TODO: can we just leave the module.finish...what's it hurting?
+									var finishMid = mid + "*finish",
+										finish = module.finish;
+									delete module.finish;
+
+									def(finishMid, ["dojo", ("dojo/require!" + finish.join(",")).replace(/\./g, "/")], function(dojo){
+										forEach(finish, function(mid){ dojo.require(mid); });
+									});
+									// unshift, not push, which causes the current traversal to be reattempted from the top
+									execQ.unshift(getModule(finishMid));
+								}
+								onLoadCallback();
+							}else{
+								text = transformToAmd(module, text);
+								if(text){
+									evalModuleText(text, module);
+									onLoadCallback();
+								}else{
+									// if transformToAmd returned falsy, then the module was already AMD and it can be script-injected
+									// do so to improve debugability(even though it means another download...which probably won't happen with a good browser cache)
+									injectingModule = module;
+									req.injectUrl(fixupUrl(url), onLoadCallback, module);
+									injectingModule = 0;
+								}
+							}
+						};
+
+						req.trace("loader-inject", ["xhr", module.mid, url, legacyMode!=sync]);
+						if(has("config-dojo-loader-catches")){
+							try{
+								req.getText(url, legacyMode!=sync, xhrCallback);
+							}catch(e){
+								signal(error, makeError("xhrInjectFailed", [module, e]));
+							}
+						}else{
+							req.getText(url, legacyMode!=sync, xhrCallback);
+						}
+						return;
+					}
+				} // else async mode or fell through in xdomain loading mode; either way, load by script injection
+				req.trace("loader-inject", ["script", module.mid, url]);
+				injectingModule = module;
+				req.injectUrl(fixupUrl(url), onLoadCallback, module);
+				injectingModule = 0;
+			},
+
+			defineModule = function(module, deps, def){
+				req.trace("loader-define-module", [module.mid, deps]);
+
+				if(0 && module.plugin && module.plugin.isCombo){
+					// the module is a plugin resource loaded by the combo service
+					// note: check for module.plugin should be enough since normal plugin resources should
+					// not follow this path; module.plugin.isCombo is future-proofing belt and suspenders
+					module.result = isFunction(def) ? def() : def;
+					setArrived(module);
+					finishExec(module);
+					return module;
+				};
+
+				var mid = module.mid;
+				if(module.injected === arrived){
+					signal(error, makeError("multipleDefine", module));
+					return module;
+				}
+				mix(module, {
+					deps: deps,
+					def: def,
+					cjs: {
+						id: module.mid,
+						uri: module.url,
+						exports: (module.result = {}),
+						setExports: function(exports){
+							module.cjs.exports = exports;
+						}
+					}
+				});
+
+				// resolve deps with respect to this module
+				for(var i = 0; i < deps.length; i++){
+					deps[i] = getModule(deps[i], module);
+				}
+
+				if(1 && legacyMode && !waiting[mid]){
+					// the module showed up without being asked for; it was probably in a <script> element
+					injectDependencies(module);
+					execQ.push(module);
+					checkComplete();
+				}
+				setArrived(module);
+
+				if(!isFunction(def) && !deps.length){
+					module.result = def;
+					finishExec(module);
+				}
+
+				return module;
+			},
+
+			runDefQ = function(referenceModule, mids){
+				// defQ is an array of [id, dependencies, factory]
+				// mids (if any) is a vector of mids given by a combo service
+				consumePendingCacheInsert(referenceModule);
+				var definedModules = [],
+					module, args;
+				while(defQ.length){
+					args = defQ.shift();
+					mids && (args[0]= mids.shift());
+					// explicit define indicates possible multiple modules in a single file; delay injecting dependencies until defQ fully
+					// processed since modules earlier in the queue depend on already-arrived modules that are later in the queue
+					// TODO: what if no args[0] and no referenceModule
+					module = args[0] && getModule(args[0]) || referenceModule;
+					definedModules.push(defineModule(module, args[1], args[2]));
+				}
+				forEach(definedModules, injectDependencies);
+			};
+	}
+
+	var timerId = 0,
+		clearTimer = noop,
+		startTimer = noop;
+	if(1){
+		// Timer machinery that monitors how long the loader is waiting and signals an error when the timer runs out.
+		clearTimer = function(){
+			timerId && clearTimeout(timerId);
+			timerId = 0;
+		},
+
+		startTimer = function(){
+			clearTimer();
+			req.waitms && (timerId = setTimeout(function(){
+					clearTimer();
+					signal(error, makeError("timeout", waiting));
+			}, req.waitms));
+		};
+	}
+
+	if(1){
+		has.add("ie-event-behavior", doc.attachEvent && (typeof opera === "undefined" || opera.toString() != "[object Opera]"));
+	}
+
+	if(1 && (1 || 1)){
+		var domOn = function(node, eventName, ieEventName, handler){
+				// Add an event listener to a DOM node using the API appropriate for the current browser;
+				// return a function that will disconnect the listener.
+				if(!has("ie-event-behavior")){
+					node.addEventListener(eventName, handler, false);
+					return function(){
+						node.removeEventListener(eventName, handler, false);
+					};
+				}else{
+					node.attachEvent(ieEventName, handler);
+					return function(){
+						node.detachEvent(ieEventName, handler);
+					};
+				}
+			},
+			windowOnLoadListener = domOn(window, "load", "onload", function(){
+				req.pageLoaded = 1;
+				doc.readyState!="complete" && (doc.readyState = "complete");
+				windowOnLoadListener();
+			});
+
+		if(1){
+			// if the loader is on the page, there must be at least one script element
+			// getting its parent and then doing insertBefore solves the "Operation Aborted"
+			// error in IE from appending to a node that isn't properly closed; see
+			// dojo/tests/_base/loader/requirejs/simple-badbase.html for an example
+			var sibling = doc.getElementsByTagName("script")[0],
+				insertPoint= sibling.parentNode;
+			req.injectUrl = function(url, callback, owner){
+				// insert a script element to the insert-point element with src=url;
+				// apply callback upon detecting the script has loaded.
+
+				startTimer();
+				var node = owner.node = doc.createElement("script"),
+					onLoad = function(e){
+						e = e || window.event;
+						var node = e.target || e.srcElement;
+						if(e.type === "load" || /complete|loaded/.test(node.readyState)){
+							disconnector();
+							callback && callback();
+						}
+					},
+					disconnector = domOn(node, "load", "onreadystatechange", onLoad);
+				node.type = "text/javascript";
+				node.charset = "utf-8";
+				node.src = url;
+				insertPoint.insertBefore(node, sibling);
+				return node;
+			};
+		}
+	}
+
+	if(1){
+		req.log = function(){
+			try{
+				for(var i = 0; i < arguments.length; i++){
+					console.log(arguments[i]);
+				}
+			}catch(e){}
+		};
+	}else{
+		req.log = noop;
+	}
+
+	if(0){
+		var trace = req.trace = function(
+			group,	// the trace group to which this application belongs
+			args	// the contents of the trace
+		){
+			///
+			// Tracing interface by group.
+			//
+			// Sends the contents of args to the console iff (req.trace.on && req.trace[group])
+
+			if(trace.on && trace.group[group]){
+				signal("trace", [group, args]);
+				for(var arg, dump = [], text= "trace:" + group + (args.length ? (":" + args[0]) : ""), i= 1; i<args.length;){
+					arg = args[i++];
+					if(isString(arg)){
+						text += ", " + arg;
+					}else{
+						dump.push(arg);
+					}
+				}
+				req.log(text);
+				dump.length && dump.push(".");
+				req.log.apply(req, dump);
+			}
+		};
+		mix(trace, {
+			on:1,
+			group:{},
+			set:function(group, value){
+				if(isString(group)){
+					trace.group[group]= value;
+				}else{
+					mix(trace.group, group);
+				}
+			}
+		});
+		trace.set(mix(mix(mix({}, defaultConfig.trace), userConfig.trace), dojoSniffConfig.trace));
+		on("config", function(config){
+			config.trace && trace.set(config.trace);
+		});
+	}else{
+		req.trace = noop;
+	}
+
+	var def = function(
+		mid,		  //(commonjs.moduleId, optional) list of modules to be loaded before running factory
+		dependencies, //(array of commonjs.moduleId, optional)
+		factory		  //(any)
+	){
+		///
+		// Advises the loader of a module factory. //Implements http://wiki.commonjs.org/wiki/Modules/AsynchronousDefinition.
+		///
+		//note
+		// CommonJS factory scan courtesy of http://requirejs.org
+
+		var arity = arguments.length,
+			args = 0,
+			defaultDeps = ["require", "exports", "module"];
+
+		if(0){
+			if(arity == 1 && isFunction(mid)){
+				dependencies = [];
+				mid.toString()
+					.replace(/(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg, "")
+					.replace(/require\(["']([\w\!\-_\.\/]+)["']\)/g, function (match, dep){
+					dependencies.push(dep);
+				});
+				args = [0, defaultDeps.concat(dependencies), mid];
+			}
+		}
+		if(!args){
+			args = arity == 1 ? [0, defaultDeps, mid] :
+				(arity == 2 ? (isArray(mid) ? [0, mid, dependencies] : (isFunction(dependencies) ? [mid, defaultDeps, dependencies] : [mid, [], dependencies])) :
+					[mid, dependencies, factory]);
+		}
+		req.trace("loader-define", args.slice(0, 2));
+		var targetModule = args[0] && getModule(args[0]),
+			module;
+		if(targetModule && !waiting[targetModule.mid]){
+			// given a mid that hasn't been requested; therefore, defined through means other than injecting
+			// consequent to a require() or define() application; examples include defining modules on-the-fly
+			// due to some code path or including a module in a script element. In any case,
+			// there is no callback waiting to finish processing and nothing to trigger the defQ and the
+			// dependencies are never requested; therefore, do it here.
+			injectDependencies(defineModule(targetModule, args[1], args[2]));
+		}else if(!has("ie-event-behavior") || !1 || injectingCachedModule){
+			// not IE path: anonymous module and therefore must have been injected; therefore, onLoad will fire immediately
+			// after script finishes being evaluated and the defQ can be run from that callback to detect the module id
+			defQ.push(args);
+		}else{
+			// IE path: possibly anonymous module and therefore injected; therefore, cannot depend on 1-to-1,
+			// in-order exec of onLoad with script eval (since it's IE) and must manually detect here
+			targetModule = targetModule || injectingModule;
+			if(!targetModule){
+				for(mid in waiting){
+					module = modules[mid];
+					if(module && module.node && module.node.readyState === 'interactive'){
+						targetModule = module;
+						break;
+					}
+				}
+				if(0 && !targetModule){
+					for(var i = 0; i<combosPending.length; i++){
+						targetModule = combosPending[i];
+						if(targetModule.node && targetModule.node.readyState === 'interactive'){
+							break;
+						}
+						targetModule= 0;
+					}
+				}
+			}
+			if(0 && isArray(targetModule)){
+				injectDependencies(defineModule(getModule(targetModule.shift()), args[1], args[2]));
+				if(!targetModule.length){
+					combosPending.splice(i, 1);
+				}
+			}else if(targetModule){
+				consumePendingCacheInsert(targetModule);
+				injectDependencies(defineModule(targetModule, args[1], args[2]));
+			}else{
+				signal(error, makeError("ieDefineFailed", args[0]));
+			}
+			checkComplete();
+		}
+	};
+	def.amd = {
+		vendor:"dojotoolkit.org"
+	};
+
+	if(0){
+		req.def = def;
+	}
+
+	// allow config to override default implemention of named functions; this is useful for
+	// non-browser environments, e.g., overriding injectUrl, getText, log, etc. in node.js, Rhino, etc.
+	// also useful for testing and monkey patching loader
+	mix(mix(req, defaultConfig.loaderPatch), userConfig.loaderPatch);
+
+	// now that req is fully initialized and won't change, we can hook it up to the error signal
+	on(error, function(arg){
+		try{
+			console.error(arg);
+			if(arg instanceof Error){
+				for(var p in arg){
+					console.log(p + ":", arg[p]);
+				}
+				console.log(".");
+			}
+		}catch(e){}
+	});
+
+	// always publish these
+	mix(req, {
+		uid:uid,
+		cache:cache,
+		packs:packs
+	});
+
+
+	if(0){
+		mix(req, {
+			// these may be interesting to look at when debugging
+			paths:paths,
+			aliases:aliases,
+			packageMap:packageMap,
+			modules:modules,
+			legacyMode:legacyMode,
+			execQ:execQ,
+			defQ:defQ,
+			waiting:waiting,
+
+			// these are used for testing
+			// TODO: move testing infrastructure to a different has feature
+			pathsMapProg:pathsMapProg,
+			packageMapProg:packageMapProg,
+			listenerQueues:listenerQueues,
+
+			// these are used by the builder (at least)
+			computeMapProg:computeMapProg,
+			runMapProg:runMapProg,
+			compactPath:compactPath,
+			getModuleInfo:getModuleInfo_
+		});
+	}
+
+	// the loader can be defined exactly once; look for global define which is the symbol AMD loaders are
+	// *required* to define (as opposed to require, which is optional)
+	if(global.define){
+		if(1){
+			signal(error, makeError("defineAlreadyDefined", 0));
+		}
+	}else{
+		global.define = def;
+		global.require = req;
+	}
+
+	if(0 && req.combo && req.combo.plugins){
+		var plugins = req.combo.plugins,
+			pluginName;
+		for(pluginName in plugins){
+			mix(mix(getModule(pluginName), plugins[pluginName]), {isCombo:1, executed:"executed", load:1});
+		}
+	}
+
+	if(1){
+		var bootDeps = defaultConfig.deps || userConfig.deps || dojoSniffConfig.deps,
+			bootCallback = defaultConfig.callback || userConfig.callback || dojoSniffConfig.callback;
+		req.boot = (bootDeps || bootCallback) ? [bootDeps || [], bootCallback] : 0;
+	}
+	if(!1){
+		!req.async && req(["dojo"]);
+		req.boot && req.apply(null, req.boot);
+	}
+})
+(this.dojoConfig || this.djConfig || this.require || {}, {
+		async:0,
+		hasCache:{
+				'config-selectorEngine':"acme",
+				'config-tlmSiblingOfDojo':1,
+				'dojo-built':1,
+				'dojo-loader':1,
+				dom:1,
+				'host-browser':1
+		},
+		packages:[
+				{
+					 location:"../dijit",
+					 name:"dijit"
+				},
+				{
+					 location:"../dojox",
+					 name:"dojox"
+				},
+				{
+					 location:".",
+					 name:"dojo"
+				}
+		]
+});require({cache:{
+'dojo/_base/fx':function(){
+define(["./kernel", "./lang", "../Evented", "./Color", "./connect", "./sniff", "../dom", "../dom-style"], function(dojo, lang, Evented, Color, connect, has, dom, style){
+	// module:
+	//		dojo/_base/fx
+	// summary:
+	//		This module defines the base dojo.fx implementation.
+	// notes:
+	//		Animation loosely package based on Dan Pupius' work, contributed under CLA; see
+	//		http://pupius.co.uk/js/Toolkit.Drawing.js
+
+	var _mixin = lang.mixin;
+
+	dojo._Line = function(/*int*/ start, /*int*/ end){
+		//	summary:
+		//		dojo._Line is the object used to generate values from a start value
+		//		to an end value
+		//	start: int
+		//		Beginning value for range
+		//	end: int
+		//		Ending value for range
+		this.start = start;
+		this.end = end;
+	};
+
+	dojo._Line.prototype.getValue = function(/*float*/ n){
+		//	summary: Returns the point on the line
+		//	n: a floating point number greater than 0 and less than 1
+		return ((this.end - this.start) * n) + this.start; // Decimal
+	};
+
+	dojo.Animation = function(args){
+		//	summary:
+		//		A generic animation class that fires callbacks into its handlers
+		//		object at various states.
+		//	description:
+		//		A generic animation class that fires callbacks into its handlers
+		//		object at various states. Nearly all dojo animation functions
+		//		return an instance of this method, usually without calling the
+		//		.play() method beforehand. Therefore, you will likely need to
+		//		call .play() on instances of `dojo.Animation` when one is
+		//		returned.
+		// args: Object
+		//		The 'magic argument', mixing all the properties into this
+		//		animation instance.
+
+		_mixin(this, args);
+		if(lang.isArray(this.curve)){
+			this.curve = new dojo._Line(this.curve[0], this.curve[1]);
+		}
+
+	};
+	dojo.Animation.prototype = new Evented();
+	// Alias to drop come 2.0:
+	dojo._Animation = dojo.Animation;
+
+	lang.extend(dojo.Animation, {
+		// duration: Integer
+		//		The time in milliseonds the animation will take to run
+		duration: 350,
+
+	/*=====
+		// curve: dojo._Line|Array
+		//		A two element array of start and end values, or a `dojo._Line` instance to be
+		//		used in the Animation.
+		curve: null,
+
+		// easing: Function?
+		//		A Function to adjust the acceleration (or deceleration) of the progress
+		//		across a dojo._Line
+		easing: null,
+	=====*/
+
+		// repeat: Integer?
+		//		The number of times to loop the animation
+		repeat: 0,
+
+		// rate: Integer?
+		//		the time in milliseconds to wait before advancing to next frame
+		//		(used as a fps timer: 1000/rate = fps)
+		rate: 20 /* 50 fps */,
+
+	/*=====
+		// delay: Integer?
+		//		The time in milliseconds to wait before starting animation after it
+		//		has been .play()'ed
+		delay: null,
+
+		// beforeBegin: Event?
+		//		Synthetic event fired before a dojo.Animation begins playing (synchronous)
+		beforeBegin: null,
+
+		// onBegin: Event?
+		//		Synthetic event fired as a dojo.Animation begins playing (useful?)
+		onBegin: null,
+
+		// onAnimate: Event?
+		//		Synthetic event fired at each interval of a `dojo.Animation`
+		onAnimate: null,
+
+		// onEnd: Event?
+		//		Synthetic event fired after the final frame of a `dojo.Animation`
+		onEnd: null,
+
+		// onPlay: Event?
+		//		Synthetic event fired any time a `dojo.Animation` is play()'ed
+		onPlay: null,
+
+		// onPause: Event?
+		//		Synthetic event fired when a `dojo.Animation` is paused
+		onPause: null,
+
+		// onStop: Event
+		//		Synthetic event fires when a `dojo.Animation` is stopped
+		onStop: null,
+
+	=====*/
+
+		_percent: 0,
+		_startRepeatCount: 0,
+
+		_getStep: function(){
+			var _p = this._percent,
+				_e = this.easing
+			;
+			return _e ? _e(_p) : _p;
+		},
+		_fire: function(/*Event*/ evt, /*Array?*/ args){
+			//	summary:
+			//		Convenience function.  Fire event "evt" and pass it the
+			//		arguments specified in "args".
+			//	description:
+			//		Convenience function.  Fire event "evt" and pass it the
+			//		arguments specified in "args".
+			//		Fires the callback in the scope of the `dojo.Animation`
+			//		instance.
+			//	evt:
+			//		The event to fire.
+			//	args:
+			//		The arguments to pass to the event.
+			var a = args||[];
+			if(this[evt]){
+				if(dojo.config.debugAtAllCosts){
+					this[evt].apply(this, a);
+				}else{
+					try{
+						this[evt].apply(this, a);
+					}catch(e){
+						// squelch and log because we shouldn't allow exceptions in
+						// synthetic event handlers to cause the internal timer to run
+						// amuck, potentially pegging the CPU. I'm not a fan of this
+						// squelch, but hopefully logging will make it clear what's
+						// going on
+						console.error("exception in animation handler for:", evt);
+						console.error(e);
+					}
+				}
+			}
+			return this; // dojo.Animation
+		},
+
+		play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
+			// summary:
+			//		Start the animation.
+			// delay:
+			//		How many milliseconds to delay before starting.
+			// gotoStart:
+			//		If true, starts the animation from the beginning; otherwise,
+			//		starts it from its current position.
+			// returns: dojo.Animation
+			//		The instance to allow chaining.
+
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			if(gotoStart){
+				_t._stopTimer();
+				_t._active = _t._paused = false;
+				_t._percent = 0;
+			}else if(_t._active && !_t._paused){
+				return _t;
+			}
+
+			_t._fire("beforeBegin", [_t.node]);
+
+			var de = delay || _t.delay,
+				_p = lang.hitch(_t, "_play", gotoStart);
+
+			if(de > 0){
+				_t._delayTimer = setTimeout(_p, de);
+				return _t;
+			}
+			_p();
+			return _t;	// dojo.Animation
+		},
+
+		_play: function(gotoStart){
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			_t._startTime = new Date().valueOf();
+			if(_t._paused){
+				_t._startTime -= _t.duration * _t._percent;
+			}
+
+			_t._active = true;
+			_t._paused = false;
+			var value = _t.curve.getValue(_t._getStep());
+			if(!_t._percent){
+				if(!_t._startRepeatCount){
+					_t._startRepeatCount = _t.repeat;
+				}
+				_t._fire("onBegin", [value]);
+			}
+
+			_t._fire("onPlay", [value]);
+
+			_t._cycle();
+			return _t; // dojo.Animation
+		},
+
+		pause: function(){
+			// summary: Pauses a running animation.
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			_t._stopTimer();
+			if(!_t._active){ return _t; /*dojo.Animation*/ }
+			_t._paused = true;
+			_t._fire("onPause", [_t.curve.getValue(_t._getStep())]);
+			return _t; // dojo.Animation
+		},
+
+		gotoPercent: function(/*Decimal*/ percent, /*Boolean?*/ andPlay){
+			//	summary:
+			//		Sets the progress of the animation.
+			//	percent:
+			//		A percentage in decimal notation (between and including 0.0 and 1.0).
+			//	andPlay:
+			//		If true, play the animation after setting the progress.
+			var _t = this;
+			_t._stopTimer();
+			_t._active = _t._paused = true;
+			_t._percent = percent;
+			if(andPlay){ _t.play(); }
+			return _t; // dojo.Animation
+		},
+
+		stop: function(/*boolean?*/ gotoEnd){
+			// summary: Stops a running animation.
+			// gotoEnd: If true, the animation will end.
+			var _t = this;
+			if(_t._delayTimer){ _t._clearTimer(); }
+			if(!_t._timer){ return _t; /* dojo.Animation */ }
+			_t._stopTimer();
+			if(gotoEnd){
+				_t._percent = 1;
+			}
+			_t._fire("onStop", [_t.curve.getValue(_t._getStep())]);
+			_t._active = _t._paused = false;
+			return _t; // dojo.Animation
+		},
+
+		status: function(){
+			// summary:
+			//		Returns a string token representation of the status of
+			//		the animation, one of: "paused", "playing", "stopped"
+			if(this._active){
+				return this._paused ? "paused" : "playing"; // String
+			}
+			return "stopped"; // String
+		},
+
+		_cycle: function(){
+			var _t = this;
+			if(_t._active){
+				var curr = new Date().valueOf();
+				var step = (curr - _t._startTime) / (_t.duration);
+
+				if(step >= 1){
+					step = 1;
+				}
+				_t._percent = step;
+
+				// Perform easing
+				if(_t.easing){
+					step = _t.easing(step);
+				}
+
+				_t._fire("onAnimate", [_t.curve.getValue(step)]);
+
+				if(_t._percent < 1){
+					_t._startTimer();
+				}else{
+					_t._active = false;
+
+					if(_t.repeat > 0){
+						_t.repeat--;
+						_t.play(null, true);
+					}else if(_t.repeat == -1){
+						_t.play(null, true);
+					}else{
+						if(_t._startRepeatCount){
+							_t.repeat = _t._startRepeatCount;
+							_t._startRepeatCount = 0;
+						}
+					}
+					_t._percent = 0;
+					_t._fire("onEnd", [_t.node]);
+					!_t.repeat && _t._stopTimer();
+				}
+			}
+			return _t; // dojo.Animation
+		},
+
+		_clearTimer: function(){
+			// summary: Clear the play delay timer
+			clearTimeout(this._delayTimer);
+			delete this._delayTimer;
+		}
+
+	});
+
+	// the local timer, stubbed into all Animation instances
+	var ctr = 0,
+		timer = null,
+		runner = {
+			run: function(){}
+		};
+
+	lang.extend(dojo.Animation, {
+
+		_startTimer: function(){
+			if(!this._timer){
+				this._timer = connect.connect(runner, "run", this, "_cycle");
+				ctr++;
+			}
+			if(!timer){
+				timer = setInterval(lang.hitch(runner, "run"), this.rate);
+			}
+		},
+
+		_stopTimer: function(){
+			if(this._timer){
+				connect.disconnect(this._timer);
+				this._timer = null;
+				ctr--;
+			}
+			if(ctr <= 0){
+				clearInterval(timer);
+				timer = null;
+				ctr = 0;
+			}
+		}
+
+	});
+
+	var _makeFadeable =
+				has("ie") ? function(node){
+			// only set the zoom if the "tickle" value would be the same as the
+			// default
+			var ns = node.style;
+			// don't set the width to auto if it didn't already cascade that way.
+			// We don't want to f anyones designs
+			if(!ns.width.length && style.get(node, "width") == "auto"){
+				ns.width = "auto";
+			}
+		} :
+				function(){};
+
+	dojo._fade = function(/*Object*/ args){
+		//	summary:
+		//		Returns an animation that will fade the node defined by
+		//		args.node from the start to end values passed (args.start
+		//		args.end) (end is mandatory, start is optional)
+
+		args.node = dom.byId(args.node);
+		var fArgs = _mixin({ properties: {} }, args),
+			props = (fArgs.properties.opacity = {});
+
+		props.start = !("start" in fArgs) ?
+			function(){
+				return +style.get(fArgs.node, "opacity")||0;
+			} : fArgs.start;
+		props.end = fArgs.end;
+
+		var anim = dojo.animateProperty(fArgs);
+		connect.connect(anim, "beforeBegin", lang.partial(_makeFadeable, fArgs.node));
+
+		return anim; // dojo.Animation
+	};
+
+	/*=====
+	dojo.__FadeArgs = function(node, duration, easing){
+		//	node: DOMNode|String
+		//		The node referenced in the animation
+		//	duration: Integer?
+		//		Duration of the animation in milliseconds.
+		//	easing: Function?
+		//		An easing function.
+		this.node = node;
+		this.duration = duration;
+		this.easing = easing;
+	}
+	=====*/
+
+	dojo.fadeIn = function(/*dojo.__FadeArgs*/ args){
+		// summary:
+		//		Returns an animation that will fade node defined in 'args' from
+		//		its current opacity to fully opaque.
+		return dojo._fade(_mixin({ end: 1 }, args)); // dojo.Animation
+	};
+
+	dojo.fadeOut = function(/*dojo.__FadeArgs*/ args){
+		// summary:
+		//		Returns an animation that will fade node defined in 'args'
+		//		from its current opacity to fully transparent.
+		return dojo._fade(_mixin({ end: 0 }, args)); // dojo.Animation
+	};
+
+	dojo._defaultEasing = function(/*Decimal?*/ n){
+		// summary: The default easing function for dojo.Animation(s)
+		return 0.5 + ((Math.sin((n + 1.5) * Math.PI)) / 2);	// Decimal
+	};
+
+	var PropLine = function(properties){
+		// PropLine is an internal class which is used to model the values of
+		// an a group of CSS properties across an animation lifecycle. In
+		// particular, the "getValue" function handles getting interpolated
+		// values between start and end for a particular CSS value.
+		this._properties = properties;
+		for(var p in properties){
+			var prop = properties[p];
+			if(prop.start instanceof Color){
+				// create a reusable temp color object to keep intermediate results
+				prop.tempColor = new Color();
+			}
+		}
+	};
+
+	PropLine.prototype.getValue = function(r){
+		var ret = {};
+		for(var p in this._properties){
+			var prop = this._properties[p],
+				start = prop.start;
+			if(start instanceof Color){
+				ret[p] = Color.blendColors(start, prop.end, r, prop.tempColor).toCss();
+			}else if(!lang.isArray(start)){
+				ret[p] = ((prop.end - start) * r) + start + (p != "opacity" ? prop.units || "px" : 0);
+			}
+		}
+		return ret;
+	};
+
+	/*=====
+	dojo.declare("dojo.__AnimArgs", [dojo.__FadeArgs], {
+		// Properties: Object?
+		//	A hash map of style properties to Objects describing the transition,
+		//	such as the properties of dojo._Line with an additional 'units' property
+		properties: {}
+
+		//TODOC: add event callbacks
+	});
+	=====*/
+
+	dojo.animateProperty = function(/*dojo.__AnimArgs*/ args){
+		// summary:
+		//		Returns an animation that will transition the properties of
+		//		node defined in `args` depending how they are defined in
+		//		`args.properties`
+		//
+		// description:
+		//		`dojo.animateProperty` is the foundation of most `dojo.fx`
+		//		animations. It takes an object of "properties" corresponding to
+		//		style properties, and animates them in parallel over a set
+		//		duration.
+		//
+		// example:
+		//		A simple animation that changes the width of the specified node.
+		//	|	dojo.animateProperty({
+		//	|		node: "nodeId",
+		//	|		properties: { width: 400 },
+		//	|	}).play();
+		//		Dojo figures out the start value for the width and converts the
+		//		integer specified for the width to the more expressive but
+		//		verbose form `{ width: { end: '400', units: 'px' } }` which you
+		//		can also specify directly. Defaults to 'px' if ommitted.
+		//
+		// example:
+		//		Animate width, height, and padding over 2 seconds... the
+		//		pedantic way:
+		//	|	dojo.animateProperty({ node: node, duration:2000,
+		//	|		properties: {
+		//	|			width: { start: '200', end: '400', units:"px" },
+		//	|			height: { start:'200', end: '400', units:"px" },
+		//	|			paddingTop: { start:'5', end:'50', units:"px" }
+		//	|		}
+		//	|	}).play();
+		//		Note 'paddingTop' is used over 'padding-top'. Multi-name CSS properties
+		//		are written using "mixed case", as the hyphen is illegal as an object key.
+		//
+		// example:
+		//		Plug in a different easing function and register a callback for
+		//		when the animation ends. Easing functions accept values between
+		//		zero and one and return a value on that basis. In this case, an
+		//		exponential-in curve.
+		//	|	dojo.animateProperty({
+		//	|		node: "nodeId",
+		//	|		// dojo figures out the start value
+		//	|		properties: { width: { end: 400 } },
+		//	|		easing: function(n){
+		//	|			return (n==0) ? 0 : Math.pow(2, 10 * (n - 1));
+		//	|		},
+		//	|		onEnd: function(node){
+		//	|			// called when the animation finishes. The animation
+		//	|			// target is passed to this function
+		//	|		}
+		//	|	}).play(500); // delay playing half a second
+		//
+		// example:
+		//		Like all `dojo.Animation`s, animateProperty returns a handle to the
+		//		Animation instance, which fires the events common to Dojo FX. Use `dojo.connect`
+		//		to access these events outside of the Animation definiton:
+		//	|	var anim = dojo.animateProperty({
+		//	|		node:"someId",
+		//	|		properties:{
+		//	|			width:400, height:500
+		//	|		}
+		//	|	});
+		//	|	dojo.connect(anim,"onEnd", function(){
+		//	|		console.log("animation ended");
+		//	|	});
+		//	|	// play the animation now:
+		//	|	anim.play();
+		//
+		// example:
+		//		Each property can be a function whose return value is substituted along.
+		//		Additionally, each measurement (eg: start, end) can be a function. The node
+		//		reference is passed direcly to callbacks.
+		//	|	dojo.animateProperty({
+		//	|		node:"mine",
+		//	|		properties:{
+		//	|			height:function(node){
+		//	|				// shrink this node by 50%
+		//	|				return dojo.position(node).h / 2
+		//	|			},
+		//	|			width:{
+		//	|				start:function(node){ return 100; },
+		//	|				end:function(node){ return 200; }
+		//	|			}
+		//	|		}
+		//	|	}).play();
+		//
+
+		var n = args.node = dom.byId(args.node);
+		if(!args.easing){ args.easing = dojo._defaultEasing; }
+
+		var anim = new dojo.Animation(args);
+		connect.connect(anim, "beforeBegin", anim, function(){
+			var pm = {};
+			for(var p in this.properties){
+				// Make shallow copy of properties into pm because we overwrite
+				// some values below. In particular if start/end are functions
+				// we don't want to overwrite them or the functions won't be
+				// called if the animation is reused.
+				if(p == "width" || p == "height"){
+					this.node.display = "block";
+				}
+				var prop = this.properties[p];
+				if(lang.isFunction(prop)){
+					prop = prop(n);
+				}
+				prop = pm[p] = _mixin({}, (lang.isObject(prop) ? prop: { end: prop }));
+
+				if(lang.isFunction(prop.start)){
+					prop.start = prop.start(n);
+				}
+				if(lang.isFunction(prop.end)){
+					prop.end = prop.end(n);
+				}
+				var isColor = (p.toLowerCase().indexOf("color") >= 0);
+				function getStyle(node, p){
+					// dojo.style(node, "height") can return "auto" or "" on IE; this is more reliable:
+					var v = { height: node.offsetHeight, width: node.offsetWidth }[p];
+					if(v !== undefined){ return v; }
+					v = style.get(node, p);
+					return (p == "opacity") ? +v : (isColor ? v : parseFloat(v));
+				}
+				if(!("end" in prop)){
+					prop.end = getStyle(n, p);
+				}else if(!("start" in prop)){
+					prop.start = getStyle(n, p);
+				}
+
+				if(isColor){
+					prop.start = new Color(prop.start);
+					prop.end = new Color(prop.end);
+				}else{
+					prop.start = (p == "opacity") ? +prop.start : parseFloat(prop.start);
+				}
+			}
+			this.curve = new PropLine(pm);
+		});
+		connect.connect(anim, "onAnimate", lang.hitch(style, "set", anim.node));
+		return anim; // dojo.Animation
+	};
+
+	dojo.anim = function(	/*DOMNode|String*/	node,
+							/*Object*/			properties,
+							/*Integer?*/		duration,
+							/*Function?*/		easing,
+							/*Function?*/		onEnd,
+							/*Integer?*/		delay){
+		//	summary:
+		//		A simpler interface to `dojo.animateProperty()`, also returns
+		//		an instance of `dojo.Animation` but begins the animation
+		//		immediately, unlike nearly every other Dojo animation API.
+		//	description:
+		//		`dojo.anim` is a simpler (but somewhat less powerful) version
+		//		of `dojo.animateProperty`.  It uses defaults for many basic properties
+		//		and allows for positional parameters to be used in place of the
+		//		packed "property bag" which is used for other Dojo animation
+		//		methods.
+		//
+		//		The `dojo.Animation` object returned from `dojo.anim` will be
+		//		already playing when it is returned from this function, so
+		//		calling play() on it again is (usually) a no-op.
+		//	node:
+		//		a DOM node or the id of a node to animate CSS properties on
+		//	duration:
+		//		The number of milliseconds over which the animation
+		//		should run. Defaults to the global animation default duration
+		//		(350ms).
+		//	easing:
+		//		An easing function over which to calculate acceleration
+		//		and deceleration of the animation through its duration.
+		//		A default easing algorithm is provided, but you may
+		//		plug in any you wish. A large selection of easing algorithms
+		//		are available in `dojo.fx.easing`.
+		//	onEnd:
+		//		A function to be called when the animation finishes
+		//		running.
+		//	delay:
+		//		The number of milliseconds to delay beginning the
+		//		animation by. The default is 0.
+		//	example:
+		//		Fade out a node
+		//	|	dojo.anim("id", { opacity: 0 });
+		//	example:
+		//		Fade out a node over a full second
+		//	|	dojo.anim("id", { opacity: 0 }, 1000);
+		return dojo.animateProperty({ // dojo.Animation
+			node: node,
+			duration: duration || dojo.Animation.prototype.duration,
+			properties: properties,
+			easing: easing,
+			onEnd: onEnd
+		}).play(delay || 0);
+	};
+
+	return {
+		_Line: dojo._Line,
+		Animation: dojo.Animation,
+		_fade: dojo._fade,
+		fadeIn: dojo.fadeIn,
+		fadeOut: dojo.fadeOut,
+		_defaultEasing: dojo._defaultEasing,
+		animateProperty: dojo.animateProperty,
+		anim: dojo.anim
+	};
+});
+
+},
+'dojo/dom-form':function(){
+define("dojo/dom-form", ["./_base/lang", "./dom", "./io-query", "./json"], function(lang, dom, ioq, json){
+	// module:
+	//		dojo/dom-form
+	// summary:
+	//		This module defines form-processing functions.
+
+	/*=====
+	dojo.fieldToObject = function(inputNode){
+		// summary:
+		//		Serialize a form field to a JavaScript object.
+		// description:
+		//		Returns the value encoded in a form field as
+		//		as a string or an array of strings. Disabled form elements
+		//		and unchecked radio and checkboxes are skipped.	Multi-select
+		//		elements are returned as an array of string values.
+		// inputNode: DOMNode|String
+		// returns: Object
+	};
+	=====*/
+
+	/*=====
+    dojo.formToObject = function(formNode){
+        // summary:
+        //		Serialize a form node to a JavaScript object.
+        // description:
+        //		Returns the values encoded in an HTML form as
+        //		string properties in an object which it then returns. Disabled form
+        //		elements, buttons, and other non-value form elements are skipped.
+        //		Multi-select elements are returned as an array of string values.
+		// formNode: DOMNode|String
+		// returns: Object
+        //
+        // example:
+        //		This form:
+        //		|	<form id="test_form">
+        //		|		<input type="text" name="blah" value="blah">
+        //		|		<input type="text" name="no_value" value="blah" disabled>
+        //		|		<input type="button" name="no_value2" value="blah">
+        //		|		<select type="select" multiple name="multi" size="5">
+        //		|			<option value="blah">blah</option>
+        //		|			<option value="thud" selected>thud</option>
+        //		|			<option value="thonk" selected>thonk</option>
+        //		|		</select>
+        //		|	</form>
+        //
+        //		yields this object structure as the result of a call to
+        //		formToObject():
+        //
+        //		|	{
+        //		|		blah: "blah",
+        //		|		multi: [
+        //		|			"thud",
+        //		|			"thonk"
+        //		|		]
+        //		|	};
+    };
+	=====*/
+
+	/*=====
+    dojo.formToQuery = function(formNode){
+        // summary:
+        //		Returns a URL-encoded string representing the form passed as either a
+        //		node or string ID identifying the form to serialize
+		// formNode: DOMNode|String
+		// returns: String
+    };
+	=====*/
+
+	/*=====
+    dojo.formToJson = function(formNode, prettyPrint){
+        // summary:
+        //		Create a serialized JSON string from a form node or string
+        //		ID identifying the form to serialize
+		// formNode: DOMNode|String
+		// prettyPrint: Boolean?
+		// returns: String
+    };
+	=====*/
+
+    function setValue(/*Object*/obj, /*String*/name, /*String*/value){
+        // summary:
+        //		For the named property in object, set the value. If a value
+        //		already exists and it is a string, convert the value to be an
+        //		array of values.
+
+        // Skip it if there is no value
+        if(value === null){
+            return;
+        }
+
+        var val = obj[name];
+        if(typeof val == "string"){ // inline'd type check
+            obj[name] = [val, value];
+        }else if(lang.isArray(val)){
+            val.push(value);
+        }else{
+            obj[name] = value;
+        }
+    }
+
+	var exclude = "file|submit|image|reset|button";
+
+	var form = {
+		fieldToObject: function fieldToObject(/*DOMNode|String*/ inputNode){
+			var ret = null;
+			inputNode = dom.byId(inputNode);
+			if(inputNode){
+				var _in = inputNode.name, type = (inputNode.type || "").toLowerCase();
+				if(_in && type && !inputNode.disabled){
+					if(type == "radio" || type == "checkbox"){
+						if(inputNode.checked){
+							ret = inputNode.value;
+						}
+					}else if(inputNode.multiple){
+						ret = [];
+						var nodes = [inputNode.firstChild];
+						while(nodes.length){
+							for(var node = nodes.pop(); node; node = node.nextSibling){
+								if(node.nodeType == 1 && node.tagName.toLowerCase() == "option"){
+									if(node.selected){
+										ret.push(node.value);
+									}
+								}else{
+									if(node.nextSibling){
+										nodes.push(node.nextSibling);
+									}
+									if(node.firstChild){
+										nodes.push(node.firstChild);
+									}
+									break;
+								}
+							}
+						}
+					}else{
+						ret = inputNode.value;
+					}
+				}
+			}
+			return ret; // Object
+		},
+
+		toObject: function formToObject(/*DOMNode|String*/ formNode){
+			var ret = {}, elems = dom.byId(formNode).elements;
+			for(var i = 0, l = elems.length; i < l; ++i){
+				var item = elems[i], _in = item.name, type = (item.type || "").toLowerCase();
+				if(_in && type && exclude.indexOf(type) < 0 && !item.disabled){
+					setValue(ret, _in, form.fieldToObject(item));
+					if(type == "image"){
+						ret[_in + ".x"] = ret[_in + ".y"] = ret[_in].x = ret[_in].y = 0;
+					}
+				}
+			}
+			return ret; // Object
+		},
+
+		toQuery: function formToQuery(/*DOMNode|String*/ formNode){
+			return ioq.objectToQuery(form.toObject(formNode)); // String
+		},
+
+		toJson: function formToJson(/*DOMNode|String*/ formNode, /*Boolean?*/prettyPrint){
+			return json.stringify(form.toObject(formNode), null, prettyPrint ? 4 : 0); // String
+		}
+	};
+
+    return form;
+});
+
+},
+'dojo/i18n':function(){
+define(["./_base/kernel", "require", "./has", "./_base/array", "./_base/config", "./_base/lang", "./_base/xhr"],
+	function(dojo, require, has, array, config, lang, xhr) {
+	// module:
+	//		dojo/i18n
+	// summary:
+	//		This module implements the !dojo/i18n plugin and the v1.6- i18n API
+	// description:
+	//		We choose to include our own plugin to leverage functionality already contained in dojo
+	//		and thereby reduce the size of the plugin compared to various loader implementations. Also, this
+	//		allows foreign AMD loaders to be used without their plugins.
+	var
+		thisModule= dojo.i18n=
+			// the dojo.i18n module
+			{},
+
+		nlsRe=
+			// regexp for reconstructing the master bundle name from parts of the regexp match
+			// nlsRe.exec("foo/bar/baz/nls/en-ca/foo") gives:
+			// ["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
+			// nlsRe.exec("foo/bar/baz/nls/foo") gives:
+			// ["foo/bar/baz/nls/foo", "foo/bar/baz/nls/", "/", "/", "foo", ""]
+			// so, if match[5] is blank, it means this is the top bundle definition.
+			// courtesy of http://requirejs.org
+			/(^.*(^|\/)nls)(\/|$)([^\/]*)\/?([^\/]*)/,
+
+		getAvailableLocales= function(
+			root,
+			locale,
+			bundlePath,
+			bundleName
+		){
+			// return a vector of module ids containing all available locales with respect to the target locale
+			// For example, assuming:
+			//	 * the root bundle indicates specific bundles for "fr" and "fr-ca",
+			//	 * bundlePath is "myPackage/nls"
+			//	 * bundleName is "myBundle"
+			// Then a locale argument of "fr-ca" would return
+			//	 ["myPackage/nls/myBundle", "myPackage/nls/fr/myBundle", "myPackage/nls/fr-ca/myBundle"]
+			// Notice that bundles are returned least-specific to most-specific, starting with the root.
+			//
+			// If root===false indicates we're working with a pre-AMD i18n bundle that doesn't tell about the available locales;
+			// therefore, assume everything is available and get 404 errors that indicate a particular localization is not available
+			//
+
+			for(var result= [bundlePath + bundleName], localeParts= locale.split("-"), current= "", i= 0; i<localeParts.length; i++){
+				current+= (current ? "-" : "") + localeParts[i];
+				if(!root || root[current]){
+					result.push(bundlePath + current + "/" + bundleName);
+				}
+			}
+			return result;
+		},
+
+		cache= {},
+
+		getL10nName= dojo.getL10nName = function(moduleName, bundleName, locale){
+			locale = locale ? locale.toLowerCase() : dojo.locale;
+			moduleName = "dojo/i18n!" + moduleName.replace(/\./g, "/");
+			bundleName = bundleName.replace(/\./g, "/");
+			return (/root/i.test(locale)) ?
+				(moduleName + "/nls/" + bundleName) :
+				(moduleName + "/nls/" + locale + "/" + bundleName);
+		},
+
+		doLoad = function(require, bundlePathAndName, bundlePath, bundleName, locale, load){
+			// get the root bundle which instructs which other bundles are required to construct the localized bundle
+			require([bundlePathAndName], function(root){
+				var
+					current= cache[bundlePathAndName + "/"]= lang.clone(root.root),
+					availableLocales= getAvailableLocales(!root._v1x && root, locale, bundlePath, bundleName);
+				require(availableLocales, function(){
+					for (var i= 1; i<availableLocales.length; i++){
+						cache[availableLocales[i]]= current= lang.mixin(lang.clone(current), arguments[i]);
+					}
+					// target may not have been resolve (e.g., maybe only "fr" exists when "fr-ca" was requested)
+					var target= bundlePathAndName + "/" + locale;
+					cache[target]= current;
+					load && load(lang.delegate(current));
+				});
+			});
+		},
+
+		normalize = function(id, toAbsMid){
+			// note: id may be relative
+			var match= nlsRe.exec(id),
+				bundlePath= match[1];
+			return /^\./.test(bundlePath) ? toAbsMid(bundlePath) + "/" +  id.substring(bundlePath.length) : id;
+		},
+
+		checkForLegacyModules = function(){},
+
+		load = function(id, require, load){
+			// note: id is always absolute
+			var
+				match= nlsRe.exec(id),
+				bundlePath= match[1] + "/",
+				bundleName= match[5] || match[4],
+				bundlePathAndName= bundlePath + bundleName,
+				localeSpecified = (match[5] && match[4]),
+				targetLocale=  localeSpecified || dojo.locale,
+				target= bundlePathAndName + "/" + targetLocale;
+
+			if(localeSpecified){
+				checkForLegacyModules(target);
+				if(cache[target]){
+					// a request for a specific local that has already been loaded; just return it
+					load(cache[target]);
+				}else{
+					// a request for a specific local that has not been loaded; load and return just that locale
+					doLoad(require, bundlePathAndName, bundlePath, bundleName, targetLocale, load);
+				}
+				return;
+			}// else a non-locale-specific request; therefore always load dojo.locale + config.extraLocale
+
+			// notice the subtle algorithm that loads targetLocal last, which is the only doLoad application that passes a value for the load callback
+			// this makes the sync loader follow a clean code path that loads extras first and then proceeds with tracing the current deps graph
+			var extra = config.extraLocale || [];
+			extra = lang.isArray(extra) ? extra : [extra];
+			extra.push(targetLocale);
+			var remaining = extra.length,
+				targetBundle;
+			array.forEach(extra, function(locale){
+				doLoad(require, bundlePathAndName, bundlePath, bundleName, locale, function(bundle){
+					if(locale == targetLocale){
+						targetBundle = bundle;
+					}
+					if(!--remaining){
+						load(targetBundle);
+					}
+				});
+			});
+		};
+
+	if(has("dojo-unit-tests")){
+		var unitTests = thisModule.unitTests = [];
+	}
+
+	true || has.add("dojo-v1x-i18n-Api",
+		// if true, define the v1.x i18n functions
+		1
+	);
+
+	if(1){
+		var
+			__evalError = {},
+
+			evalBundle=
+				// use the function ctor to keep the minifiers away and come close to global scope
+				// if bundle is an AMD bundle, then __amdResult will be defined; otherwise it's a pre-amd bundle and the bundle value is returned by eval
+				new Function("bundle, __evalError",
+					"var __amdResult, define = function(x){__amdResult= x;};" +
+					"return [(function(){" +
+								"try{eval(arguments[0]);}catch(e){}" +
+								"if(__amdResult)return 0;" +
+								"try{return eval('('+arguments[0]+')');}" +
+								"catch(e){__evalError.e = e; return __evalError;}" +
+							"})(arguments[0]) , __amdResult];"
+				),
+
+			fixup= function(url, preAmdResult, amdResult){
+				// nls/<locale>/<bundle-name> indicates not the root.
+				if(preAmdResult===__evalError){
+					console.error("failed to evaluate i18n bundle; url=" + url, __evalError.e);
+					return {};
+				}
+				return preAmdResult ? (/nls\/[^\/]+\/[^\/]+$/.test(url) ? preAmdResult : {root:preAmdResult, _v1x:1}) : amdResult;
+			},
+
+			syncRequire= function(deps, callback){
+				var results= [];
+				array.forEach(deps, function(mid){
+					var url= require.toUrl(mid + ".js");
+					if(cache[url]){
+						results.push(cache[url]);
+					}else{
+
+						try {
+							var bundle= require(mid);
+							if(bundle){
+								results.push(bundle);
+								return;
+							}
+						}catch(e){}
+
+						xhr.get({
+							url:url,
+							sync:true,
+							load:function(text){
+								var result = evalBundle(text, __evalError);
+								results.push(cache[url]= fixup(url, result[0], result[1]));
+							},
+							error:function(){
+								results.push(cache[url]= {});
+							}
+						});
+					}
+				});
+				callback && callback.apply(null, results);
+			},
+
+			normalizeLocale = thisModule.normalizeLocale= function(locale){
+				var result = locale ? locale.toLowerCase() : dojo.locale;
+				if(result == "root"){
+					result = "ROOT";
+				}
+				return result;
+			},
+
+			forEachLocale = function(locale, func){
+				// this function is equivalent to v1.6 dojo.i18n._searchLocalePath with down===true
+				var parts = locale.split("-");
+				while(parts.length){
+					if(func(parts.join("-"))){
+						return true;
+					}
+					parts.pop();
+				}
+				return func("ROOT");
+			};
+
+		checkForLegacyModules = function(target){
+			// legacy code may have already loaded [e.g] the raw bundle x/y/z at x.y.z; when true, push into the cache
+			for(var names = target.split("/"), object = dojo.global[names[0]], i = 1; object && i<names.length; object = object[names[i++]]){}
+			if(object){
+				cache[target] = object;
+			}
+		};
+
+		thisModule.getLocalization= function(moduleName, bundleName, locale){
+			var result,
+				l10nName= getL10nName(moduleName, bundleName, locale).substring(10);
+			load(l10nName, (1 && !require.isXdUrl(require.toUrl(l10nName + ".js")) ? syncRequire : require), function(result_){ result= result_; });
+			return result;
+		};
+
+		thisModule._preloadLocalizations = function(/*String*/bundlePrefix, /*Array*/localesGenerated){
+			//	summary:
+			//		Load built, flattened resource bundles, if available for all
+			//		locales used in the page. Only called by built layer files.
+			//
+			//  note: this function a direct copy of v1.6 function of same name
+
+			function preload(locale){
+				locale = normalizeLocale(locale);
+				forEachLocale(locale, function(loc){
+					for(var i=0; i<localesGenerated.length;i++){
+						if(localesGenerated[i] == loc){
+							syncRequire([bundlePrefix.replace(/\./g, "/")+"_"+loc]);
+							return true; // Boolean
+						}
+					}
+					return false; // Boolean
+				});
+			}
+			preload();
+			var extra = dojo.config.extraLocale||[];
+			for(var i=0; i<extra.length; i++){
+				preload(extra[i]);
+			}
+		};
+
+		if(has("dojo-unit-tests")){
+			unitTests.push(function(doh){
+				doh.register("tests.i18n.unit", function(t){
+					var check;
+
+					check = evalBundle("{prop:1}", __evalError);
+					t.is({prop:1}, check[0]); t.is(undefined, check[1]);
+
+					check = evalBundle("({prop:1})", __evalError);
+					t.is({prop:1}, check[0]); t.is(undefined, check[1]);
+
+					check = evalBundle("{'prop-x':1}", __evalError);
+					t.is({'prop-x':1}, check[0]); t.is(undefined, check[1]);
+
+					check = evalBundle("({'prop-x':1})", __evalError);
+					t.is({'prop-x':1}, check[0]); t.is(undefined, check[1]);
+
+					check = evalBundle("define({'prop-x':1})", __evalError);
+					t.is(0, check[0]); t.is({'prop-x':1}, check[1]);
+
+					check = evalBundle("define({'prop-x':1});", __evalError);
+					t.is(0, check[0]); t.is({'prop-x':1}, check[1]);
+
+					check = evalBundle("this is total nonsense and should throw an error", __evalError);
+					t.is(__evalError, check[0]); t.is(undefined, check[1]);
+					t.is({}, fixup("some/url", check[0], check[1]));
+				});
+			});
+		}
+	}
+
+	return lang.mixin(thisModule, {
+		dynamic:true,
+		normalize:normalize,
+		load:load,
+		cache:function(mid, value){
+			cache[mid] = value;
+		}
+	});
+});
+
+},
+'dojo/_base/html':function(){
+define(["./kernel", "../dom", "../dom-style", "../dom-attr", "../dom-prop", "../dom-class", "../dom-construct", "../dom-geometry"], function(dojo, dom, style, attr, prop, cls, ctr, geom){
+	// module:
+	//		dojo/dom
+	// summary:
+	//		This module is a stub for the core dojo DOM API.
+
+	// mix-in dom
+	dojo.byId = dom.byId;
+	dojo.isDescendant = dom.isDescendant;
+	dojo.setSelectable = dom.setSelectable;
+
+	// mix-in dom-attr
+	dojo.getAttr = attr.get;
+	dojo.setAttr = attr.set;
+	dojo.hasAttr = attr.has;
+	dojo.removeAttr = attr.remove;
+	dojo.getNodeProp = attr.getNodeProp;
+
+	dojo.attr = function(node, name, value){
+		// summary:
+		//		Gets or sets an attribute on an HTML element.
+		// description:
+		//		Handles normalized getting and setting of attributes on DOM
+		//		Nodes. If 2 arguments are passed, and a the second argument is a
+		//		string, acts as a getter.
+		//
+		//		If a third argument is passed, or if the second argument is a
+		//		map of attributes, acts as a setter.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to get or set the attribute on
+		// name: String|Object
+		//		the name of the attribute to get or set.
+		// value: String?
+		//		The value to set for the attribute
+		// returns:
+		//		when used as a getter, the value of the requested attribute
+		//		or null if that attribute does not have a specified or
+		//		default value;
+		//
+		//		when used as a setter, the DOM node
+		//
+		// example:
+		//	|	// get the current value of the "foo" attribute on a node
+		//	|	dojo.attr(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.attr("nodeId", "foo");
+		//
+		// example:
+		//	|	// use attr() to set the tab index
+		//	|	dojo.attr("nodeId", "tabIndex", 3);
+		//	|
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.attr("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.attr("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.attr("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.style("someNode", obj);
+
+		if(arguments.length == 2){
+			return attr[typeof name == "string" ? "get" : "set"](node, name);
+		}
+		return attr.set(node, name, value);
+	};
+
+	// mix-in dom-class
+	dojo.hasClass = cls.contains;
+	dojo.addClass = cls.add;
+	dojo.removeClass = cls.remove;
+	dojo.toggleClass = cls.toggle;
+	dojo.replaceClass = cls.replace;
+
+	// mix-in dom-construct
+	dojo._toDom = dojo.toDom = ctr.toDom;
+	dojo.place = ctr.place;
+	dojo.create = ctr.create;
+	dojo.empty = function(node){ ctr.empty(node); };
+	dojo._destroyElement = dojo.destroy = function(node){ ctr.destroy(node); };
+
+	// mix-in dom-geometry
+	dojo._getPadExtents = dojo.getPadExtents = geom.getPadExtents;
+	dojo._getBorderExtents = dojo.getBorderExtents = geom.getBorderExtents;
+	dojo._getPadBorderExtents = dojo.getPadBorderExtents = geom.getPadBorderExtents;
+	dojo._getMarginExtents = dojo.getMarginExtents = geom.getMarginExtents;
+	dojo._getMarginSize = dojo.getMarginSize = geom.getMarginSize;
+	dojo._getMarginBox = dojo.getMarginBox = geom.getMarginBox;
+	dojo.setMarginBox = geom.setMarginBox;
+	dojo._getContentBox = dojo.getContentBox = geom.getContentBox;
+	dojo.setContentSize = geom.setContentSize;
+	dojo._isBodyLtr = dojo.isBodyLtr = geom.isBodyLtr;
+	dojo._docScroll = dojo.docScroll = geom.docScroll;
+	dojo._getIeDocumentElementOffset = dojo.getIeDocumentElementOffset = geom.getIeDocumentElementOffset;
+	dojo._fixIeBiDiScrollLeft = dojo.fixIeBiDiScrollLeft = geom.fixIeBiDiScrollLeft;
+	dojo.position = geom.position;
+
+	dojo.marginBox = function marginBox(/*DomNode|String*/node, /*Object?*/box){
+		// summary:
+		//		Getter/setter for the margin-box of node.
+		// description:
+		//		Getter/setter for the margin-box of node.
+		//		Returns an object in the expected format of box (regardless
+		//		if box is passed). The object might look like:
+		//			`{ l: 50, t: 200, w: 300: h: 150 }`
+		//		for a node offset from its parent 50px to the left, 200px from
+		//		the top with a margin width of 300px and a margin-height of
+		//		150px.
+		// node:
+		//		id or reference to DOM Node to get/set box for
+		// box:
+		//		If passed, denotes that dojo.marginBox() should
+		//		update/set the margin box for node. Box is an object in the
+		//		above format. All properties are optional if passed.
+		// example:
+		//		Retrieve the margin box of a passed node
+		//	|	var box = dojo.marginBox("someNodeId");
+		//	|	console.dir(box);
+		//
+		// example:
+		//		Set a node's margin box to the size of another node
+		//	|	var box = dojo.marginBox("someNodeId");
+		//	|	dojo.marginBox("someOtherNode", box);
+		return box ? geom.setMarginBox(node, box) : geom.getMarginBox(node); // Object
+	};
+
+	dojo.contentBox = function contentBox(/*DomNode|String*/node, /*Object?*/box){
+		// summary:
+		//		Getter/setter for the content-box of node.
+		// description:
+		//		Returns an object in the expected format of box (regardless if box is passed).
+		//		The object might look like:
+		//			`{ l: 50, t: 200, w: 300: h: 150 }`
+		//		for a node offset from its parent 50px to the left, 200px from
+		//		the top with a content width of 300px and a content-height of
+		//		150px. Note that the content box may have a much larger border
+		//		or margin box, depending on the box model currently in use and
+		//		CSS values set/inherited for node.
+		//		While the getter will return top and left values, the
+		//		setter only accepts setting the width and height.
+		// node:
+		//		id or reference to DOM Node to get/set box for
+		// box:
+		//		If passed, denotes that dojo.contentBox() should
+		//		update/set the content box for node. Box is an object in the
+		//		above format, but only w (width) and h (height) are supported.
+		//		All properties are optional if passed.
+		return box ? geom.setContentSize(node, box) : geom.getContentBox(node); // Object
+	};
+
+	dojo.coords = function(/*DomNode|String*/node, /*Boolean?*/includeScroll){
+		// summary:
+		//		Deprecated: Use position() for border-box x/y/w/h
+		//		or marginBox() for margin-box w/h/l/t.
+		//		Returns an object representing a node's size and position.
+		//
+		// description:
+		//		Returns an object that measures margin-box (w)idth/(h)eight
+		//		and absolute position x/y of the border-box. Also returned
+		//		is computed (l)eft and (t)op values in pixels from the
+		//		node's offsetParent as returned from marginBox().
+		//		Return value will be in the form:
+		//|			{ l: 50, t: 200, w: 300: h: 150, x: 100, y: 300 }
+		//		Does not act as a setter. If includeScroll is passed, the x and
+		//		y params are affected as one would expect in dojo.position().
+		dojo.deprecated("dojo.coords()", "Use dojo.position() or dojo.marginBox().");
+		node = dom.byId(node);
+		var s = style.getComputedStyle(node), mb = geom.getMarginBox(node, s);
+		var abs = geom.position(node, includeScroll);
+		mb.x = abs.x;
+		mb.y = abs.y;
+		return mb;	// Object
+	};
+
+	// mix-in dom-prop
+	dojo.getProp = prop.get;
+	dojo.setProp = prop.set;
+
+	dojo.prop = function(/*DomNode|String*/node, /*String|Object*/name, /*String?*/value){
+		// summary:
+		//		Gets or sets a property on an HTML element.
+		// description:
+		//		Handles normalized getting and setting of properties on DOM
+		//		Nodes. If 2 arguments are passed, and a the second argument is a
+		//		string, acts as a getter.
+		//
+		//		If a third argument is passed, or if the second argument is a
+		//		map of attributes, acts as a setter.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node:
+		//		id or reference to the element to get or set the property on
+		// name:
+		//		the name of the property to get or set.
+		// value:
+		//		The value to set for the property
+		// returns:
+		//		when used as a getter, the value of the requested property
+		//		or null if that attribute does not have a specified or
+		//		default value;
+		//
+		//		when used as a setter, the DOM node
+		//
+		// example:
+		//	|	// get the current value of the "foo" property on a node
+		//	|	dojo.prop(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.prop("nodeId", "foo");
+		//
+		// example:
+		//	|	// use prop() to set the tab index
+		//	|	dojo.prop("nodeId", "tabIndex", 3);
+		//	|
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.prop("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.prop("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.prop("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.style("someNode", obj);
+
+		if(arguments.length == 2){
+			return prop[typeof name == "string" ? "get" : "set"](node, name);
+		}
+		// setter
+		return prop.set(node, name, value);
+	};
+
+	// mix-in dom-style
+	dojo.getStyle = style.get;
+	dojo.setStyle = style.set;
+	dojo.getComputedStyle = style.getComputedStyle;
+	dojo.__toPixelValue = dojo.toPixelValue = style.toPixelValue;
+
+	dojo.style = function(node, name, value){
+		// summary:
+		//		Accesses styles on a node. If 2 arguments are
+		//		passed, acts as a getter. If 3 arguments are passed, acts
+		//		as a setter.
+		// description:
+		//		Getting the style value uses the computed style for the node, so the value
+		//		will be a calculated value, not just the immediate node.style value.
+		//		Also when getting values, use specific style names,
+		//		like "borderBottomWidth" instead of "border" since compound values like
+		//		"border" are not necessarily reflected as expected.
+		//		If you want to get node dimensions, use `dojo.marginBox()`,
+		//		`dojo.contentBox()` or `dojo.position()`.
+		// node: DOMNode|String
+		//		id or reference to node to get/set style for
+		// name: String?|Object?
+		//		the style property to set in DOM-accessor format
+		//		("borderWidth", not "border-width") or an object with key/value
+		//		pairs suitable for setting each property.
+		// value: String?
+		//		If passed, sets value on the node for style, handling
+		//		cross-browser concerns.  When setting a pixel value,
+		//		be sure to include "px" in the value. For instance, top: "200px".
+		//		Otherwise, in some cases, some browsers will not apply the style.
+		// returns:
+		//		when used as a getter, return the computed style of the node if passing in an ID or node,
+		//		or return the normalized, computed value for the property when passing in a node and a style property
+		// example:
+		//		Passing only an ID or node returns the computed style object of
+		//		the node:
+		//	|	dojo.style("thinger");
+		// example:
+		//		Passing a node and a style property returns the current
+		//		normalized, computed value for that property:
+		//	|	dojo.style("thinger", "opacity"); // 1 by default
+		//
+		// example:
+		//		Passing a node, a style property, and a value changes the
+		//		current display of the node and returns the new computed value
+		//	|	dojo.style("thinger", "opacity", 0.5); // == 0.5
+		//
+		// example:
+		//		Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
+		//	|	dojo.style("thinger", {
+		//	|		"opacity": 0.5,
+		//	|		"border": "3px solid black",
+		//	|		"height": "300px"
+		//	|	});
+		//
+		// example:
+		//		When the CSS style property is hyphenated, the JavaScript property is camelCased.
+		//		font-size becomes fontSize, and so on.
+		//	|	dojo.style("thinger",{
+		//	|		fontSize:"14pt",
+		//	|		letterSpacing:"1.2em"
+		//	|	});
+		//
+		// example:
+		//		dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
+		//		dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()`
+		//	|	dojo.query(".someClassName").style("visibility","hidden");
+		//	|	// or
+		//	|	dojo.query("#baz > div").style({
+		//	|		opacity:0.75,
+		//	|		fontSize:"13pt"
+		//	|	});
+
+		switch(arguments.length){
+			case 1:
+				return style.get(node);
+			case 2:
+				return style[typeof name == "string" ? "get" : "set"](node, name);
+		}
+		// setter
+		return style.set(node, name, value);
+	};
+
+	return dojo;
+});
+
+},
+'dojo/_base/kernel':function(){
+define(["../has", "./config", "require", "module"], function(has, config, require, module){
+	// module:
+	//		dojo/_base/kernel
+	// summary:
+	//		This module is the foundational module of the dojo boot sequence; it defines the dojo object.
+	var
+		// loop variables for this module
+		i, p,
+
+		// create dojo, dijit, and dojox
+		// FIXME: in 2.0 remove dijit, dojox being created by dojo
+		dijit = {},
+		dojox = {},
+		dojo = {
+			// notice dojo takes ownership of the value of the config module
+			config:config,
+			global:this,
+			dijit:dijit,
+			dojox:dojox
+		};
+
+
+	// Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide
+	// a _scopeName property for the dojo, dijit, and dojox root object so those packages can create
+	// unique names in the global space.
+	//
+	// Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox,
+	// where global when in fact they are either global under different names or not global at all. In v1.6-, the
+	// config variable "scopeMap" was used to map names as used within a module to global names. This has been
+	// subsumed by the dojo packageMap configuration variable which relocates packages to different names. See
+	// http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details.
+	//
+	// The following computations contort the packageMap for this dojo instance into a scopeMap.
+	var scopeMap =
+			// a map from a name used in a legacy module to the (global variable name, object addressed by that name)
+			// always map dojo, dijit, and dojox
+			{
+				dojo:["dojo", dojo],
+				dijit:["dijit", dijit],
+				dojox:["dojox", dojox]
+			},
+
+		packageMap =
+			// the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config
+			(require.packs && require.packs[module.id.match(/[^\/]+/)[0]].packageMap) || {},
+
+		item;
+
+	// process all mapped top-level names for this instance of dojo
+	for(p in packageMap){
+		if(scopeMap[p]){
+			// mapped dojo, dijit, or dojox
+			scopeMap[p][0] = packageMap[p];
+		}else{
+			// some other top-level name
+			scopeMap[p] = [packageMap[p], {}];
+		}
+	}
+
+	// publish those names to _scopeName and, optionally, the global namespace
+	for(p in scopeMap){
+		item = scopeMap[p];
+		item[1]._scopeName = item[0];
+		if(!config.noGlobals){
+			this[item[0]] = item[1];
+		}
+	}
+	dojo.scopeMap = scopeMap;
+
+	// FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated
+	dojo.baseUrl = dojo.config.baseUrl = require.baseUrl;
+	dojo.isAsync = !1 || require.async;
+	dojo.locale = config.locale;
+
+	/*=====
+		dojo.version = function(){
+			// summary:
+			//		Version number of the Dojo Toolkit
+			// major: Integer
+			//		Major version. If total version is "1.2.0beta1", will be 1
+			// minor: Integer
+			//		Minor version. If total version is "1.2.0beta1", will be 2
+			// patch: Integer
+			//		Patch version. If total version is "1.2.0beta1", will be 0
+			// flag: String
+			//		Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
+			// revision: Number
+			//		The SVN rev from which dojo was pulled
+			this.major = 0;
+			this.minor = 0;
+			this.patch = 0;
+			this.flag = "";
+			this.revision = 0;
+		}
+	=====*/
+	var rev = "$Rev: 27913 $".match(/\d+/);
+	dojo.version = {
+		major: 1, minor: 7, patch: 2, flag: "",
+		revision: rev ? +rev[0] : NaN,
+		toString: function(){
+			var v = dojo.version;
+			return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")";	// String
+		}
+	};
+
+
+	// If 1 is truthy, then as a dojo module is defined it should push it's definitions
+	// into the dojo object, and conversely. In 2.0, it will likely be unusual to augment another object
+	// as a result of defining a module. This has feature gives a way to force 2.0 behavior as the code
+	// is migrated. Absent specific advice otherwise, set extend-dojo to truthy.
+	true || has.add("extend-dojo", 1);
+
+
+	dojo.eval = function(scriptText){
+		//	summary:
+		//		A legacy method created for use exclusively by internal Dojo methods. Do not use this method
+		//		directly unless you understand its possibly-different implications on the platforms your are targeting.
+		//	description:
+		//		Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers
+		//		that support indirect eval.
+		//
+		//		As usual, IE does not. On IE, the only way to implement global eval is to
+		//		use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval.
+		//		This implementation uses the technique of executing eval in the scope of a function that is a single scope
+		//		frame below the global scope; thereby coming close to the global scope. Note carefully that
+		//
+		//		dojo.eval("var pi = 3.14;");
+		//
+		//		will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want
+		//		to define a global variable using dojo.eval, write something like
+		//
+		//		dojo.eval("window.pi = 3.14;")
+		//	scriptText:
+		//		The text to evaluation.
+		//	returns:
+		//		The result of the evaluation. Often `undefined`
+	};
+
+	(Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
+
+
+	if(0){
+		dojo.exit = function(exitcode){
+			quit(exitcode);
+		};
+	} else{
+		dojo.exit = function(){
+		};
+	}
+
+	true || has.add("dojo-guarantee-console",
+		// ensure that console.log, console.warn, etc. are defined
+		1
+	);
+	if(1){
+		typeof console != "undefined" || (console = {});
+		//	Be careful to leave 'log' always at the end
+		var cn = [
+			"assert", "count", "debug", "dir", "dirxml", "error", "group",
+			"groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
+			"trace", "warn", "log"
+		];
+		var tn;
+		i = 0;
+		while((tn = cn[i++])){
+			if(!console[tn]){
+				(function(){
+					var tcn = tn + "";
+					console[tcn] = ('log' in console) ? function(){
+						var a = Array.apply({}, arguments);
+						a.unshift(tcn + ":");
+						console["log"](a.join(" "));
+					} : function(){};
+					console[tcn]._fake = true;
+				})();
+			}
+		}
+	}
+
+	has.add("dojo-debug-messages",
+		// include dojo.deprecated/dojo.experimental implementations
+		!!config.isDebug
+	);
+	if(has("dojo-debug-messages")){
+		dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
+			//	summary:
+			//		Log a debug message to indicate that a behavior has been
+			//		deprecated.
+			//	behaviour: String
+			//		The API or behavior being deprecated. Usually in the form
+			//		of "myApp.someFunction()".
+			//	extra: String?
+			//		Text to append to the message. Often provides advice on a
+			//		new function or facility to achieve the same goal during
+			//		the deprecation period.
+			//	removal: String?
+			//		Text to indicate when in the future the behavior will be
+			//		removed. Usually a version number.
+			//	example:
+			//	| dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");
+
+			var message = "DEPRECATED: " + behaviour;
+			if(extra){ message += " " + extra; }
+			if(removal){ message += " -- will be removed in version: " + removal; }
+			console.warn(message);
+		};
+
+		dojo.experimental = function(/* String */ moduleName, /* String? */ extra){
+			//	summary: Marks code as experimental.
+			//	description:
+			//		This can be used to mark a function, file, or module as
+			//		experimental.	 Experimental code is not ready to be used, and the
+			//		APIs are subject to change without notice.	Experimental code may be
+			//		completed deleted without going through the normal deprecation
+			//		process.
+			//	moduleName: String
+			//		The name of a module, or the name of a module file or a specific
+			//		function
+			//	extra: String?
+			//		some additional message for the user
+			//	example:
+			//	| dojo.experimental("dojo.data.Result");
+			//	example:
+			//	| dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");
+
+			var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice.";
+			if(extra){ message += " " + extra; }
+			console.warn(message);
+		};
+	}else{
+		dojo.deprecated = dojo.experimental =  function(){};
+	}
+
+	true || has.add("dojo-modulePaths",
+		// consume dojo.modulePaths processing
+		1
+	);
+	if(1){
+		// notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run;
+		// this is the v1.6- behavior.
+		if(config.modulePaths){
+			dojo.deprecated("dojo.modulePaths", "use paths configuration");
+			var paths = {};
+			for(p in config.modulePaths){
+				paths[p.replace(/\./g, "/")] = config.modulePaths[p];
+			}
+			require({paths:paths});
+		}
+	}
+
+	true || has.add("dojo-moduleUrl",
+		// include dojo.moduleUrl
+		1
+	);
+	if(1){
+		dojo.moduleUrl = function(/*String*/module, /*String?*/url){
+			//	summary:
+			//		Returns a URL relative to a module.
+			//	example:
+			//	|	var pngPath = dojo.moduleUrl("acme","images/small.png");
+			//	|	console.dir(pngPath); // list the object properties
+			//	|	// create an image and set it's source to pngPath's value:
+			//	|	var img = document.createElement("img");
+			//	|	img.src = pngPath;
+			//	|	// add our image to the document
+			//	|	dojo.body().appendChild(img);
+			//	example:
+			//		you may de-reference as far as you like down the package
+			//		hierarchy.  This is sometimes handy to avoid lenghty relative
+			//		urls or for building portable sub-packages. In this example,
+			//		the `acme.widget` and `acme.util` directories may be located
+			//		under different roots (see `dojo.registerModulePath`) but the
+			//		the modules which reference them can be unaware of their
+			//		relative locations on the filesystem:
+			//	|	// somewhere in a configuration block
+			//	|	dojo.registerModulePath("acme.widget", "../../acme/widget");
+			//	|	dojo.registerModulePath("acme.util", "../../util");
+			//	|
+			//	|	// ...
+			//	|
+			//	|	// code in a module using acme resources
+			//	|	var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
+			//	|	var dataPath = dojo.moduleUrl("acme.util","resources/data.json");
+
+			dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0");
+
+			// require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then
+			// remove the suffix from the result. This way clients can request a url w/out a filetype. This should be
+			// rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0).
+			// Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config.
+			var result = null;
+			if(module){
+				result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/");
+			}
+			return result;
+		};
+	}
+
+	dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling
+
+	return dojo;
+});
+
+},
+'dojo/io-query':function(){
+define(["./_base/lang"], function(lang){
+	// module:
+	//		dojo/io-query
+	// summary:
+	//		This module defines query string processing functions.
+
+    var backstop = {};
+
+    function objectToQuery(/*Object*/ map){
+        // summary:
+        //		takes a name/value mapping object and returns a string representing
+        //		a URL-encoded version of that object.
+        // example:
+        //		this object:
+        //
+        //	|	{
+        //	|		blah: "blah",
+        //	|		multi: [
+        //	|			"thud",
+        //	|			"thonk"
+        //	|		]
+        //	|	};
+        //
+        // yields the following query string:
+        //
+        //	|	"blah=blah&multi=thud&multi=thonk"
+
+        // FIXME: need to implement encodeAscii!!
+        var enc = encodeURIComponent, pairs = [];
+        for(var name in map){
+            var value = map[name];
+            if(value != backstop[name]){
+                var assign = enc(name) + "=";
+                if(lang.isArray(value)){
+                    for(var i = 0, l = value.length; i < l; ++i){
+                        pairs.push(assign + enc(value[i]));
+                    }
+                }else{
+                    pairs.push(assign + enc(value));
+                }
+            }
+        }
+        return pairs.join("&"); // String
+    }
+
+    function queryToObject(/*String*/ str){
+        // summary:
+        //		Create an object representing a de-serialized query section of a
+        //		URL. Query keys with multiple values are returned in an array.
+        //
+        // example:
+        //		This string:
+        //
+        //	|		"foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&"
+        //
+        //		results in this object structure:
+        //
+        //	|		{
+        //	|			foo: [ "bar", "baz" ],
+        //	|			thinger: " spaces =blah",
+        //	|			zonk: "blarg"
+        //	|		}
+        //
+        //		Note that spaces and other urlencoded entities are correctly
+        //		handled.
+
+        // FIXME: should we grab the URL string if we're not passed one?
+        var dec = decodeURIComponent, qp = str.split("&"), ret = {}, name, val;
+        for(var i = 0, l = qp.length, item; i < l; ++i){
+            item = qp[i];
+            if(item.length){
+                var s = item.indexOf("=");
+                if(s < 0){
+                    name = dec(item);
+                    val = "";
+                }else{
+                    name = dec(item.slice(0, s));
+                    val  = dec(item.slice(s + 1));
+                }
+                if(typeof ret[name] == "string"){ // inline'd type check
+                    ret[name] = [ret[name]];
+                }
+
+                if(lang.isArray(ret[name])){
+                    ret[name].push(val);
+                }else{
+                    ret[name] = val;
+                }
+            }
+        }
+        return ret; // Object
+    }
+
+    return {
+        objectToQuery: objectToQuery,
+        queryToObject: queryToObject
+    };
+});
+},
+'dojo/_base/Deferred':function(){
+define("dojo/_base/Deferred", ["./kernel", "./lang"], function(dojo, lang){
+	// module:
+	//		dojo/_base/Deferred
+	// summary:
+	//		This module defines dojo.Deferred.
+
+	var mutator = function(){};
+	var freeze = Object.freeze || function(){};
+	// A deferred provides an API for creating and resolving a promise.
+	dojo.Deferred = function(/*Function?*/ canceller){
+		// summary:
+		//		Deferreds provide a generic means for encapsulating an asynchronous
+		//		operation and notifying users of the completion and result of the operation.
+		// description:
+		//		The dojo.Deferred API is based on the concept of promises that provide a
+		//		generic interface into the eventual completion of an asynchronous action.
+		//		The motivation for promises fundamentally is about creating a
+		//		separation of concerns that allows one to achieve the same type of
+		//		call patterns and logical data flow in asynchronous code as can be
+		//		achieved in synchronous code. Promises allows one
+		//		to be able to call a function purely with arguments needed for
+		//		execution, without conflating the call with concerns of whether it is
+		//		sync or async. One shouldn't need to alter a call's arguments if the
+		//		implementation switches from sync to async (or vice versa). By having
+		//		async functions return promises, the concerns of making the call are
+		//		separated from the concerns of asynchronous interaction (which are
+		//		handled by the promise).
+		//
+		//		The dojo.Deferred is a type of promise that provides methods for fulfilling the
+		//		promise with a successful result or an error. The most important method for
+		//		working with Dojo's promises is the then() method, which follows the
+		//		CommonJS proposed promise API. An example of using a Dojo promise:
+		//
+		//		|	var resultingPromise = someAsyncOperation.then(function(result){
+		//		|		... handle result ...
+		//		|	},
+		//		|	function(error){
+		//		|		... handle error ...
+		//		|	});
+		//
+		//		The .then() call returns a new promise that represents the result of the
+		//		execution of the callback. The callbacks will never affect the original promises value.
+		//
+		//		The dojo.Deferred instances also provide the following functions for backwards compatibility:
+		//
+		//			* addCallback(handler)
+		//			* addErrback(handler)
+		//			* callback(result)
+		//			* errback(result)
+		//
+		//		Callbacks are allowed to return promises themselves, so
+		//		you can build complicated sequences of events with ease.
+		//
+		//		The creator of the Deferred may specify a canceller.  The canceller
+		//		is a function that will be called if Deferred.cancel is called
+		//		before the Deferred fires. You can use this to implement clean
+		//		aborting of an XMLHttpRequest, etc. Note that cancel will fire the
+		//		deferred with a CancelledError (unless your canceller returns
+		//		another kind of error), so the errbacks should be prepared to
+		//		handle that error for cancellable Deferreds.
+		// example:
+		//	|	var deferred = new dojo.Deferred();
+		//	|	setTimeout(function(){ deferred.callback({success: true}); }, 1000);
+		//	|	return deferred;
+		// example:
+		//		Deferred objects are often used when making code asynchronous. It
+		//		may be easiest to write functions in a synchronous manner and then
+		//		split code using a deferred to trigger a response to a long-lived
+		//		operation. For example, instead of register a callback function to
+		//		denote when a rendering operation completes, the function can
+		//		simply return a deferred:
+		//
+		//		|	// callback style:
+		//		|	function renderLotsOfData(data, callback){
+		//		|		var success = false
+		//		|		try{
+		//		|			for(var x in data){
+		//		|				renderDataitem(data[x]);
+		//		|			}
+		//		|			success = true;
+		//		|		}catch(e){ }
+		//		|		if(callback){
+		//		|			callback(success);
+		//		|		}
+		//		|	}
+		//
+		//		|	// using callback style
+		//		|	renderLotsOfData(someDataObj, function(success){
+		//		|		// handles success or failure
+		//		|		if(!success){
+		//		|			promptUserToRecover();
+		//		|		}
+		//		|	});
+		//		|	// NOTE: no way to add another callback here!!
+		// example:
+		//		Using a Deferred doesn't simplify the sending code any, but it
+		//		provides a standard interface for callers and senders alike,
+		//		providing both with a simple way to service multiple callbacks for
+		//		an operation and freeing both sides from worrying about details
+		//		such as "did this get called already?". With Deferreds, new
+		//		callbacks can be added at any time.
+		//
+		//		|	// Deferred style:
+		//		|	function renderLotsOfData(data){
+		//		|		var d = new dojo.Deferred();
+		//		|		try{
+		//		|			for(var x in data){
+		//		|				renderDataitem(data[x]);
+		//		|			}
+		//		|			d.callback(true);
+		//		|		}catch(e){
+		//		|			d.errback(new Error("rendering failed"));
+		//		|		}
+		//		|		return d;
+		//		|	}
+		//
+		//		|	// using Deferred style
+		//		|	renderLotsOfData(someDataObj).then(null, function(){
+		//		|		promptUserToRecover();
+		//		|	});
+		//		|	// NOTE: addErrback and addCallback both return the Deferred
+		//		|	// again, so we could chain adding callbacks or save the
+		//		|	// deferred for later should we need to be notified again.
+		// example:
+		//		In this example, renderLotsOfData is synchronous and so both
+		//		versions are pretty artificial. Putting the data display on a
+		//		timeout helps show why Deferreds rock:
+		//
+		//		|	// Deferred style and async func
+		//		|	function renderLotsOfData(data){
+		//		|		var d = new dojo.Deferred();
+		//		|		setTimeout(function(){
+		//		|			try{
+		//		|				for(var x in data){
+		//		|					renderDataitem(data[x]);
+		//		|				}
+		//		|				d.callback(true);
+		//		|			}catch(e){
+		//		|				d.errback(new Error("rendering failed"));
+		//		|			}
+		//		|		}, 100);
+		//		|		return d;
+		//		|	}
+		//
+		//		|	// using Deferred style
+		//		|	renderLotsOfData(someDataObj).then(null, function(){
+		//		|		promptUserToRecover();
+		//		|	});
+		//
+		//		Note that the caller doesn't have to change his code at all to
+		//		handle the asynchronous case.
+
+		var result, finished, isError, head, nextListener;
+		var promise = (this.promise = {});
+
+		function complete(value){
+			if(finished){
+				throw new Error("This deferred has already been resolved");
+			}
+			result = value;
+			finished = true;
+			notify();
+		}
+		function notify(){
+			var mutated;
+			while(!mutated && nextListener){
+				var listener = nextListener;
+				nextListener = nextListener.next;
+				if((mutated = (listener.progress == mutator))){ // assignment and check
+					finished = false;
+				}
+				var func = (isError ? listener.error : listener.resolved);
+				if(func){
+					try{
+						var newResult = func(result);
+						if (newResult && typeof newResult.then === "function"){
+							newResult.then(lang.hitch(listener.deferred, "resolve"), lang.hitch(listener.deferred, "reject"), lang.hitch(listener.deferred, "progress"));
+							continue;
+						}
+						var unchanged = mutated && newResult === undefined;
+						if(mutated && !unchanged){
+							isError = newResult instanceof Error;
+						}
+						listener.deferred[unchanged && isError ? "reject" : "resolve"](unchanged ? result : newResult);
+					}catch(e){
+						listener.deferred.reject(e);
+					}
+				}else{
+					if(isError){
+						listener.deferred.reject(result);
+					}else{
+						listener.deferred.resolve(result);
+					}
+				}
+			}
+		}
+		// calling resolve will resolve the promise
+		this.resolve = this.callback = function(value){
+			// summary:
+			//		Fulfills the Deferred instance successfully with the provide value
+			this.fired = 0;
+			this.results = [value, null];
+			complete(value);
+		};
+
+
+		// calling error will indicate that the promise failed
+		this.reject = this.errback = function(error){
+			// summary:
+			//		Fulfills the Deferred instance as an error with the provided error
+			isError = true;
+			this.fired = 1;
+			complete(error);
+			this.results = [null, error];
+			if(!error || error.log !== false){
+				(dojo.config.deferredOnError || function(x){ console.error(x); })(error);
+			}
+		};
+		// call progress to provide updates on the progress on the completion of the promise
+		this.progress = function(update){
+			// summary:
+			//		Send progress events to all listeners
+			var listener = nextListener;
+			while(listener){
+				var progress = listener.progress;
+				progress && progress(update);
+				listener = listener.next;
+			}
+		};
+		this.addCallbacks = function(callback, errback){
+			// summary:
+			//		Adds callback and error callback for this deferred instance.
+			// callback: Function?
+			// 		The callback attached to this deferred object.
+			// errback: Function?
+			// 		The error callback attached to this deferred object.
+			// returns:
+			// 		Returns this deferred object.
+			this.then(callback, errback, mutator);
+			return this;	// dojo.Deferred
+		};
+		// provide the implementation of the promise
+		promise.then = this.then = function(/*Function?*/resolvedCallback, /*Function?*/errorCallback, /*Function?*/progressCallback){
+			// summary:
+			//		Adds a fulfilledHandler, errorHandler, and progressHandler to be called for
+			//		completion of a promise. The fulfilledHandler is called when the promise
+			//		is fulfilled. The errorHandler is called when a promise fails. The
+			//		progressHandler is called for progress events. All arguments are optional
+			//		and non-function values are ignored. The progressHandler is not only an
+			//		optional argument, but progress events are purely optional. Promise
+			//		providers are not required to ever create progress events.
+			//
+			//		This function will return a new promise that is fulfilled when the given
+			//		fulfilledHandler or errorHandler callback is finished. This allows promise
+			//		operations to be chained together. The value returned from the callback
+			//		handler is the fulfillment value for the returned promise. If the callback
+			//		throws an error, the returned promise will be moved to failed state.
+			//
+			// returns: 
+			//		Returns a new promise that represents the result of the
+			//		execution of the callback. The callbacks will never affect the original promises value.
+			// example:
+			//		An example of using a CommonJS compliant promise:
+			//		|	asyncComputeTheAnswerToEverything().
+			//		|		then(addTwo).
+			//		|		then(printResult, onError);
+			//		|	>44
+			//
+			var returnDeferred = progressCallback == mutator ? this : new dojo.Deferred(promise.cancel);
+			var listener = {
+				resolved: resolvedCallback,
+				error: errorCallback,
+				progress: progressCallback,
+				deferred: returnDeferred
+			};
+			if(nextListener){
+				head = head.next = listener;
+			}
+			else{
+				nextListener = head = listener;
+			}
+			if(finished){
+				notify();
+			}
+			return returnDeferred.promise; // Promise
+		};
+		var deferred = this;
+		promise.cancel = this.cancel = function (){
+			// summary:
+			//		Cancels the asynchronous operation
+			if(!finished){
+				var error = canceller && canceller(deferred);
+				if(!finished){
+					if (!(error instanceof Error)){
+						error = new Error(error);
+					}
+					error.log = false;
+					deferred.reject(error);
+				}
+			}
+		};
+		freeze(promise);
+	};
+	lang.extend(dojo.Deferred, {
+		addCallback: function (/*Function*/ callback){
+			// summary:
+			// 		Adds successful callback for this deferred instance.
+			// returns:
+			// 		Returns this deferred object.
+			return this.addCallbacks(lang.hitch.apply(dojo, arguments));	// dojo.Deferred
+		},
+
+		addErrback: function (/*Function*/ errback){
+			// summary:
+			// 		Adds error callback for this deferred instance.
+			// returns:
+			// 		Returns this deferred object.
+			return this.addCallbacks(null, lang.hitch.apply(dojo, arguments));	// dojo.Deferred
+		},
+
+		addBoth: function (/*Function*/ callback){
+			// summary:
+			// 		Add handler as both successful callback and error callback for this deferred instance.
+			// returns:
+			// 		Returns this deferred object.
+			var enclosed = lang.hitch.apply(dojo, arguments);
+			return this.addCallbacks(enclosed, enclosed);	// dojo.Deferred
+		},
+		fired: -1
+	});
+
+	dojo.Deferred.when = dojo.when = function(promiseOrValue, /*Function?*/ callback, /*Function?*/ errback, /*Function?*/ progressHandler){
+		// summary:
+		//		This provides normalization between normal synchronous values and
+		//		asynchronous promises, so you can interact with them in a common way
+		// returns:
+		// 		Returns a new promise that represents the result of the execution of callback 
+		// 		when parameter "promiseOrValue" is promise.
+		// 		Returns the execution result of callback when parameter "promiseOrValue" is value.
+		// example:
+		//		|	function printFirstAndLast(items){
+		//		|		dojo.when(findFirst(items), console.log);
+		//		|		dojo.when(findLast(items), console.log);
+		//		|	}
+		//		|	function findFirst(items){
+		//		|		return dojo.when(items, function(items){
+		//		|			return items[0];
+		//		|		});
+		//		|	}
+		//		|	function findLast(items){
+		//		|		return dojo.when(items, function(items){
+		//		|			return items[items.length - 1];
+		//		|		});
+		//		|	}
+		//		And now all three of his functions can be used sync or async.
+		//		|	printFirstAndLast([1,2,3,4]) will work just as well as
+		//		|	printFirstAndLast(dojo.xhrGet(...));
+
+		if(promiseOrValue && typeof promiseOrValue.then === "function"){
+			return promiseOrValue.then(callback, errback, progressHandler);
+		}
+		return callback ? callback(promiseOrValue) : promiseOrValue;	// Promise
+	};
+
+	return dojo.Deferred;
+});
+
+},
+'dojo/NodeList-dom':function(){
+define(["./_base/kernel", "./query", "./_base/array", "./_base/lang", "./dom-class", "./dom-construct", "./dom-geometry", "./dom-attr", "./dom-style"], function(dojo, query, array, lang, domCls, domCtr, domGeom, domAttr, domStyle){
+	/*===== var NodeList = dojo.NodeList; =====*/
+	var magicGuard = function(a){
+		// summary:
+		//		the guard function for dojo.attr() and dojo.style()
+		return a.length == 1 && (typeof a[0] == "string"); // inline'd type check
+	};
+
+	var orphan = function(node){
+		// summary:
+		//		function to orphan nodes
+		var p = node.parentNode;
+		if(p){
+			p.removeChild(node);
+		}
+	};
+	// FIXME: should we move orphan() to dojo.html?
+
+	var NodeList = query.NodeList,
+		awc = NodeList._adaptWithCondition,
+		aafe = NodeList._adaptAsForEach,
+		aam = NodeList._adaptAsMap;
+
+	function getSet(module){
+		return function(node, name, value){
+			if(arguments.length == 2){
+				return module[typeof name == "string" ? "get" : "set"](node, name);
+			}
+			// setter
+			return module.set(node, name, value);
+		};
+	}
+
+	lang.extend(NodeList, {
+		_normalize: function(/*String||Element||Object||NodeList*/content, /*DOMNode?*/refNode){
+			// summary:
+			//		normalizes data to an array of items to insert.
+			// description:
+			//		If content is an object, it can have special properties "template" and
+			//		"parse". If "template" is defined, then the template value is run through
+			//		dojo.string.substitute (if dojo.string.substitute has been dojo.required elsewhere),
+			//		or if templateFunc is a function on the content, that function will be used to
+			//		transform the template into a final string to be used for for passing to dojo._toDom.
+			//		If content.parse is true, then it is remembered for later, for when the content
+			//		nodes are inserted into the DOM. At that point, the nodes will be parsed for widgets
+			//		(if dojo.parser has been dojo.required elsewhere).
+
+			//Wanted to just use a DocumentFragment, but for the array/NodeList
+			//case that meant using cloneNode, but we may not want that.
+			//Cloning should only happen if the node operations span
+			//multiple refNodes. Also, need a real array, not a NodeList from the
+			//DOM since the node movements could change those NodeLists.
+
+			var parse = content.parse === true;
+
+			//Do we have an object that needs to be run through a template?
+			if(typeof content.template == "string"){
+				var templateFunc = content.templateFunc || (dojo.string && dojo.string.substitute);
+				content = templateFunc ? templateFunc(content.template, content) : content;
+			}
+
+			var type = (typeof content);
+			if(type == "string" || type == "number"){
+				content = domCtr.toDom(content, (refNode && refNode.ownerDocument));
+				if(content.nodeType == 11){
+					//DocumentFragment. It cannot handle cloneNode calls, so pull out the children.
+					content = lang._toArray(content.childNodes);
+				}else{
+					content = [content];
+				}
+			}else if(!lang.isArrayLike(content)){
+				content = [content];
+			}else if(!lang.isArray(content)){
+				//To get to this point, content is array-like, but
+				//not an array, which likely means a DOM NodeList. Convert it now.
+				content = lang._toArray(content);
+			}
+
+			//Pass around the parse info
+			if(parse){
+				content._runParse = true;
+			}
+			return content; //Array
+		},
+
+		_cloneNode: function(/*DOMNode*/ node){
+			// summary:
+			//		private utility to clone a node. Not very interesting in the vanilla
+			//		dojo.NodeList case, but delegates could do interesting things like
+			//		clone event handlers if that is derivable from the node.
+			return node.cloneNode(true);
+		},
+
+		_place: function(/*Array*/ary, /*DOMNode*/refNode, /*String*/position, /*Boolean*/useClone){
+			// summary:
+			//		private utility to handle placing an array of nodes relative to another node.
+			// description:
+			//		Allows for cloning the nodes in the array, and for
+			//		optionally parsing widgets, if ary._runParse is true.
+
+			//Avoid a disallowed operation if trying to do an innerHTML on a non-element node.
+			if(refNode.nodeType != 1 && position == "only"){
+				return;
+			}
+			var rNode = refNode, tempNode;
+
+			//Always cycle backwards in case the array is really a
+			//DOM NodeList and the DOM operations take it out of the live collection.
+			var length = ary.length;
+			for(var i = length - 1; i >= 0; i--){
+				var node = (useClone ? this._cloneNode(ary[i]) : ary[i]);
+
+				//If need widget parsing, use a temp node, instead of waiting after inserting into
+				//real DOM because we need to start widget parsing at one node up from current node,
+				//which could cause some already parsed widgets to be parsed again.
+				if(ary._runParse && dojo.parser && dojo.parser.parse){
+					if(!tempNode){
+						tempNode = rNode.ownerDocument.createElement("div");
+					}
+					tempNode.appendChild(node);
+					dojo.parser.parse(tempNode);
+					node = tempNode.firstChild;
+					while(tempNode.firstChild){
+						tempNode.removeChild(tempNode.firstChild);
+					}
+				}
+
+				if(i == length - 1){
+					domCtr.place(node, rNode, position);
+				}else{
+					rNode.parentNode.insertBefore(node, rNode);
+				}
+				rNode = node;
+			}
+		},
+
+		/*=====
+		position: function(){
+			// summary:
+			//		Returns border-box objects (x/y/w/h) of all elements in a node list
+			//		as an Array (*not* a NodeList). Acts like `dojo.position`, though
+			//		assumes the node passed is each node in this list.
+
+			return dojo.map(this, dojo.position); // Array
+		},
+
+		attr: function(property, value){
+			// summary:
+			//		gets or sets the DOM attribute for every element in the
+			//		NodeList. See also `dojo.attr`
+			// property: String
+			//		the attribute to get/set
+			// value: String?
+			//		optional. The value to set the property to
+			// returns:
+			//		if no value is passed, the result is an array of attribute values
+			//		If a value is passed, the return is this NodeList
+			// example:
+			//		Make all nodes with a particular class focusable:
+			//	|	dojo.query(".focusable").attr("tabIndex", -1);
+			// example:
+			//		Disable a group of buttons:
+			//	|	dojo.query("button.group").attr("disabled", true);
+			// example:
+			//		innerHTML can be assigned or retrieved as well:
+			//	|	// get the innerHTML (as an array) for each list item
+			//	|	var ih = dojo.query("li.replaceable").attr("innerHTML");
+			return; // dojo.NodeList
+			return; // Array
+		},
+
+		style: function(property, value){
+			// summary:
+			//		gets or sets the CSS property for every element in the NodeList
+			// property: String
+			//		the CSS property to get/set, in JavaScript notation
+			//		("lineHieght" instead of "line-height")
+			// value: String?
+			//		optional. The value to set the property to
+			// returns:
+			//		if no value is passed, the result is an array of strings.
+			//		If a value is passed, the return is this NodeList
+			return; // dojo.NodeList
+			return; // Array
+		},
+
+		addClass: function(className){
+			// summary:
+			//		adds the specified class to every node in the list
+			// className: String|Array
+			//		A String class name to add, or several space-separated class names,
+			//		or an array of class names.
+			return; // dojo.NodeList
+		},
+
+		removeClass: function(className){
+			// summary:
+			//		removes the specified class from every node in the list
+			// className: String|Array?
+			//		An optional String class name to remove, or several space-separated
+			//		class names, or an array of class names. If omitted, all class names
+			//		will be deleted.
+			// returns:
+			//		dojo.NodeList, this list
+			return; // dojo.NodeList
+		},
+
+		toggleClass: function(className, condition){
+			// summary:
+			//		Adds a class to node if not present, or removes if present.
+			//		Pass a boolean condition if you want to explicitly add or remove.
+			// condition: Boolean?
+			//		If passed, true means to add the class, false means to remove.
+			// className: String
+			//		the CSS class to add
+			return; // dojo.NodeList
+		},
+
+		empty: function(){
+			// summary:
+			//		clears all content from each node in the list. Effectively
+			//		equivalent to removing all child nodes from every item in
+			//		the list.
+			return this.forEach("item.innerHTML='';"); // dojo.NodeList
+			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
+		},
+		=====*/
+
+		// useful html methods
+		attr: awc(getSet(domAttr), magicGuard),
+		style: awc(getSet(domStyle), magicGuard),
+
+		addClass: aafe(domCls.add),
+		removeClass: aafe(domCls.remove),
+		replaceClass: aafe(domCls.replace),
+		toggleClass: aafe(domCls.toggle),
+
+		empty: aafe(domCtr.empty),
+		removeAttr: aafe(domAttr.remove),
+
+		position: aam(domGeom.position),
+		marginBox: aam(domGeom.getMarginBox),
+
+		// FIXME: connectPublisher()? connectRunOnce()?
+
+		/*
+		destroy: function(){
+			// summary:
+			//		destroys every item in the list.
+			this.forEach(d.destroy);
+			// FIXME: should we be checking for and/or disposing of widgets below these nodes?
+		},
+		*/
+
+		place: function(/*String||Node*/ queryOrNode, /*String*/ position){
+			// summary:
+			//		places elements of this node list relative to the first element matched
+			//		by queryOrNode. Returns the original NodeList. See: `dojo.place`
+			// queryOrNode:
+			//		may be a string representing any valid CSS3 selector or a DOM node.
+			//		In the selector case, only the first matching element will be used
+			//		for relative positioning.
+			// position:
+			//		can be one of:
+			//		|	"last" (default)
+			//		|	"first"
+			//		|	"before"
+			//		|	"after"
+			//		|	"only"
+			//		|	"replace"
+			//		or an offset in the childNodes property
+			var item = query(queryOrNode)[0];
+			return this.forEach(function(node){ domCtr.place(node, item, position); }); // dojo.NodeList
+		},
+
+		orphan: function(/*String?*/ filter){
+			// summary:
+			//		removes elements in this list that match the filter
+			//		from their parents and returns them as a new NodeList.
+			// filter:
+			//		CSS selector like ".foo" or "div > span"
+			// returns:
+			//		`dojo.NodeList` containing the orphaned elements
+			return (filter ? query._filterResult(this, filter) : this).forEach(orphan); // dojo.NodeList
+		},
+
+		adopt: function(/*String||Array||DomNode*/ queryOrListOrNode, /*String?*/ position){
+			// summary:
+			//		places any/all elements in queryOrListOrNode at a
+			//		position relative to the first element in this list.
+			//		Returns a dojo.NodeList of the adopted elements.
+			// queryOrListOrNode:
+			//		a DOM node or a query string or a query result.
+			//		Represents the nodes to be adopted relative to the
+			//		first element of this NodeList.
+			// position:
+			//		can be one of:
+			//		|	"last" (default)
+			//		|	"first"
+			//		|	"before"
+			//		|	"after"
+			//		|	"only"
+			//		|	"replace"
+			//		or an offset in the childNodes property
+			return query(queryOrListOrNode).place(this[0], position)._stash(this);	// dojo.NodeList
+		},
+
+		// FIXME: do we need this?
+		query: function(/*String*/ queryStr){
+			// summary:
+			//		Returns a new list whose members match the passed query,
+			//		assuming elements of the current NodeList as the root for
+			//		each search.
+			// example:
+			//		assume a DOM created by this markup:
+			//	|	<div id="foo">
+			//	|		<p>
+			//	|			bacon is tasty, <span>dontcha think?</span>
+			//	|		</p>
+			//	|	</div>
+			//	|	<div id="bar">
+			//	|		<p>great comedians may not be funny <span>in person</span></p>
+			//	|	</div>
+			//		If we are presented with the following definition for a NodeList:
+			//	|	var l = new dojo.NodeList(dojo.byId("foo"), dojo.byId("bar"));
+			//		it's possible to find all span elements under paragraphs
+			//		contained by these elements with this sub-query:
+			//	|	var spans = l.query("p span");
+
+			// FIXME: probably slow
+			if(!queryStr){ return this; }
+			var ret = new NodeList;
+			this.map(function(node){
+				// FIXME: why would we ever get undefined here?
+				query(queryStr, node).forEach(function(subNode){
+					if(subNode !== undefined){
+						ret.push(subNode);
+					}
+				});
+			});
+			return ret._stash(this);	// dojo.NodeList
+		},
+
+		filter: function(/*String|Function*/ filter){
+			// summary:
+			//		"masks" the built-in javascript filter() method (supported
+			//		in Dojo via `dojo.filter`) to support passing a simple
+			//		string filter in addition to supporting filtering function
+			//		objects.
+			// filter:
+			//		If a string, a CSS rule like ".thinger" or "div > span".
+			// example:
+			//		"regular" JS filter syntax as exposed in dojo.filter:
+			//		|	dojo.query("*").filter(function(item){
+			//		|		// highlight every paragraph
+			//		|		return (item.nodeName == "p");
+			//		|	}).style("backgroundColor", "yellow");
+			// example:
+			//		the same filtering using a CSS selector
+			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
+
+			var a = arguments, items = this, start = 0;
+			if(typeof filter == "string"){ // inline'd type check
+				items = query._filterResult(this, a[0]);
+				if(a.length == 1){
+					// if we only got a string query, pass back the filtered results
+					return items._stash(this); // dojo.NodeList
+				}
+				// if we got a callback, run it over the filtered items
+				start = 1;
+			}
+			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo.NodeList
+		},
+
+		/*
+		// FIXME: should this be "copyTo" and include parenting info?
+		clone: function(){
+			// summary:
+			//		creates node clones of each element of this list
+			//		and returns a new list containing the clones
+		},
+		*/
+
+		addContent: function(/*String||DomNode||Object||dojo.NodeList*/ content, /*String||Integer?*/ position){
+			// summary:
+			//		add a node, NodeList or some HTML as a string to every item in the
+			//		list.  Returns the original list.
+			// description:
+			//		a copy of the HTML content is added to each item in the
+			//		list, with an optional position argument. If no position
+			//		argument is provided, the content is appended to the end of
+			//		each item.
+			// content:
+			//		DOM node, HTML in string format, a NodeList or an Object. If a DOM node or
+			//		NodeList, the content will be cloned if the current NodeList has more than one
+			//		element. Only the DOM nodes are cloned, no event handlers. If it is an Object,
+			//		it should be an object with at "template" String property that has the HTML string
+			//		to insert. If dojo.string has already been dojo.required, then dojo.string.substitute
+			//		will be used on the "template" to generate the final HTML string. Other allowed
+			//		properties on the object are: "parse" if the HTML
+			//		string should be parsed for widgets (dojo.require("dojo.parser") to get that
+			//		option to work), and "templateFunc" if a template function besides dojo.string.substitute
+			//		should be used to transform the "template".
+			// position:
+			//		can be one of:
+			//		|	"last"||"end" (default)
+			//		|	"first||"start"
+			//		|	"before"
+			//		|	"after"
+			//		|	"replace" (replaces nodes in this NodeList with new content)
+			//		|	"only" (removes other children of the nodes so new content is the only child)
+			//		or an offset in the childNodes property
+			// example:
+			//		appends content to the end if the position is omitted
+			//	|	dojo.query("h3 > p").addContent("hey there!");
+			// example:
+			//		add something to the front of each element that has a
+			//		"thinger" property:
+			//	|	dojo.query("[thinger]").addContent("...", "first");
+			// example:
+			//		adds a header before each element of the list
+			//	|	dojo.query(".note").addContent("<h4>NOTE:</h4>", "before");
+			// example:
+			//		add a clone of a DOM node to the end of every element in
+			//		the list, removing it from its existing parent.
+			//	|	dojo.query(".note").addContent(dojo.byId("foo"));
+			// example:
+			//		Append nodes from a templatized string.
+			//		dojo.require("dojo.string");
+			//		dojo.query(".note").addContent({
+			//			template: '<b>${id}: </b><span>${name}</span>',
+			//			id: "user332",
+			//			name: "Mr. Anderson"
+			//		});
+			// example:
+			//		Append nodes from a templatized string that also has widgets parsed.
+			//		dojo.require("dojo.string");
+			//		dojo.require("dojo.parser");
+			//		var notes = dojo.query(".note").addContent({
+			//			template: '<button dojoType="dijit.form.Button">${text}</button>',
+			//			parse: true,
+			//			text: "Send"
+			//		});
+			content = this._normalize(content, this[0]);
+			for(var i = 0, node; (node = this[i]); i++){
+				this._place(content, node, position, i > 0);
+			}
+			return this; //dojo.NodeList
+		}
+	});
+
+	/*===== return dojo.NodeList; =====*/
+	return NodeList;
+});
+
+},
+'dojo/query':function(){
+define(["./_base/kernel", "./has", "./dom", "./on", "./_base/array", "./_base/lang", "./selector/_loader", "./selector/_loader!default"],
+	function(dojo, has, dom, on, array, lang, loader, defaultEngine){
+"use strict";
+
+	has.add("array-extensible", function(){
+		// test to see if we can extend an array (not supported in old IE)
+		return lang.delegate([], {length: 1}).length == 1 && !has("bug-for-in-skips-shadowed");
+	});
+	
+	var ap = Array.prototype, aps = ap.slice, apc = ap.concat, forEach = array.forEach;
+
+	var tnl = function(/*Array*/ a, /*dojo.NodeList?*/ parent, /*Function?*/ NodeListCtor){
+		// summary:
+		//		decorate an array to make it look like a `dojo.NodeList`.
+		// a:
+		//		Array of nodes to decorate.
+		// parent:
+		//		An optional parent NodeList that generated the current
+		//		list of nodes. Used to call _stash() so the parent NodeList
+		//		can be accessed via end() later.
+		// NodeListCtor:
+		//		An optional constructor function to use for any
+		//		new NodeList calls. This allows a certain chain of
+		//		NodeList calls to use a different object than dojo.NodeList.
+		var nodeList = new (NodeListCtor || this._NodeListCtor || nl)(a);
+		return parent ? nodeList._stash(parent) : nodeList;
+	};
+
+	var loopBody = function(f, a, o){
+		a = [0].concat(aps.call(a, 0));
+		o = o || dojo.global;
+		return function(node){
+			a[0] = node;
+			return f.apply(o, a);
+		};
+	};
+
+	// adapters
+
+	var adaptAsForEach = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the forEach-type
+		//		actions. The initial object is returned from the specialized
+		//		function.
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			this.forEach(loopBody(f, arguments, o));
+			return this;	// Object
+		};
+	};
+
+	var adaptAsMap = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the map-type
+		//		actions. The return is a new array of values, as via `dojo.map`
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			return this.map(loopBody(f, arguments, o));
+		};
+	};
+
+	var adaptAsFilter = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the filter-type actions
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			return this.filter(loopBody(f, arguments, o));
+		};
+	};
+
+	var adaptWithCondition = function(f, g, o){
+		// summary:
+		//		adapts a single node function to be used in the map-type
+		//		actions, behaves like forEach() or map() depending on arguments
+		// f: Function
+		//		a function to adapt
+		// g: Function
+		//		a condition function, if true runs as map(), otherwise runs as forEach()
+		// o: Object?
+		//		an optional context for f and g
+		return function(){
+			var a = arguments, body = loopBody(f, a, o);
+			if(g.call(o || dojo.global, a)){
+				return this.map(body);	// self
+			}
+			this.forEach(body);
+			return this;	// self
+		};
+	};
+
+	var NodeList = function(array){
+		// summary:
+		//		dojo.NodeList is an of Array-like object which adds syntactic
+		//		sugar for chaining, common iteration operations, animation, and
+		//		node manipulation. NodeLists are most often returned as the
+		//		result of dojo.query() calls.
+		// description:
+		//		dojo.NodeList instances provide many utilities that reflect
+		//		core Dojo APIs for Array iteration and manipulation, DOM
+		//		manipulation, and event handling. Instead of needing to dig up
+		//		functions in the dojo.* namespace, NodeLists generally make the
+		//		full power of Dojo available for DOM manipulation tasks in a
+		//		simple, chainable way.
+		// example:
+		//		create a node list from a node
+		//		|	new dojo.NodeList(dojo.byId("foo"));
+		// example:
+		//		get a NodeList from a CSS query and iterate on it
+		//		|	var l = dojo.query(".thinger");
+		//		|	l.forEach(function(node, index, nodeList){
+		//		|		console.log(index, node.innerHTML);
+		//		|	});
+		// example:
+		//		use native and Dojo-provided array methods to manipulate a
+		//		NodeList without needing to use dojo.* functions explicitly:
+		//		|	var l = dojo.query(".thinger");
+		//		|	// since NodeLists are real arrays, they have a length
+		//		|	// property that is both readable and writable and
+		//		|	// push/pop/shift/unshift methods
+		//		|	console.log(l.length);
+		//		|	l.push(dojo.create("span"));
+		//		|
+		//		|	// dojo's normalized array methods work too:
+		//		|	console.log( l.indexOf(dojo.byId("foo")) );
+		//		|	// ...including the special "function as string" shorthand
+		//		|	console.log( l.every("item.nodeType == 1") );
+		//		|
+		//		|	// NodeLists can be [..] indexed, or you can use the at()
+		//		|	// function to get specific items wrapped in a new NodeList:
+		//		|	var node = l[3]; // the 4th element
+		//		|	var newList = l.at(1, 3); // the 2nd and 4th elements
+		// example:
+		//		the style functions you expect are all there too:
+		//		|	// style() as a getter...
+		//		|	var borders = dojo.query(".thinger").style("border");
+		//		|	// ...and as a setter:
+		//		|	dojo.query(".thinger").style("border", "1px solid black");
+		//		|	// class manipulation
+		//		|	dojo.query("li:nth-child(even)").addClass("even");
+		//		|	// even getting the coordinates of all the items
+		//		|	var coords = dojo.query(".thinger").coords();
+		// example:
+		//		DOM manipulation functions from the dojo.* namespace area also
+		//		available:
+		//		|	// remove all of the elements in the list from their
+		//		|	// parents (akin to "deleting" them from the document)
+		//		|	dojo.query(".thinger").orphan();
+		//		|	// place all elements in the list at the front of #foo
+		//		|	dojo.query(".thinger").place("foo", "first");
+		// example:
+		//		Event handling couldn't be easier. `dojo.connect` is mapped in,
+		//		and shortcut handlers are provided for most DOM events:
+		//		|	// like dojo.connect(), but with implicit scope
+		//		|	dojo.query("li").connect("onclick", console, "log");
+		//		|
+		//		|	// many common event handlers are already available directly:
+		//		|	dojo.query("li").onclick(console, "log");
+		//		|	var toggleHovered = dojo.hitch(dojo, "toggleClass", "hovered");
+		//		|	dojo.query("p")
+		//		|		.onmouseenter(toggleHovered)
+		//		|		.onmouseleave(toggleHovered);
+		// example:
+		//		chainability is a key advantage of NodeLists:
+		//		|	dojo.query(".thinger")
+		//		|		.onclick(function(e){ /* ... */ })
+		//		|		.at(1, 3, 8) // get a subset
+		//		|			.style("padding", "5px")
+		//		|			.forEach(console.log);
+		var isNew = this instanceof nl && has("array-extensible");
+		if(typeof array == "number"){
+			array = Array(array);
+		}
+		var nodeArray = (array && "length" in array) ? array : arguments;
+		if(isNew || !nodeArray.sort){
+			// make sure it's a real array before we pass it on to be wrapped 
+			var target = isNew ? this : [],
+				l = target.length = nodeArray.length;
+			for(var i = 0; i < l; i++){
+				target[i] = nodeArray[i];
+			}
+			if(isNew){
+				// called with new operator, this means we are going to use this instance and push
+				// the nodes on to it. This is usually much faster since the NodeList properties
+				//	don't need to be copied (unless the list of nodes is extremely large).
+				return target;
+			}
+			nodeArray = target;
+		}
+		// called without new operator, use a real array and copy prototype properties,
+		// this is slower and exists for back-compat. Should be removed in 2.0.
+		lang._mixin(nodeArray, nlp);
+		nodeArray._NodeListCtor = function(array){
+			// call without new operator to preserve back-compat behavior
+			return nl(array);
+		};
+		return nodeArray;
+	};
+	
+	var nl = NodeList, nlp = nl.prototype = 
+		has("array-extensible") ? [] : {};// extend an array if it is extensible
+
+	// expose adapters and the wrapper as private functions
+
+	nl._wrap = nlp._wrap = tnl;
+	nl._adaptAsMap = adaptAsMap;
+	nl._adaptAsForEach = adaptAsForEach;
+	nl._adaptAsFilter  = adaptAsFilter;
+	nl._adaptWithCondition = adaptWithCondition;
+
+	// mass assignment
+
+	// add array redirectors
+	forEach(["slice", "splice"], function(name){
+		var f = ap[name];
+		//Use a copy of the this array via this.slice() to allow .end() to work right in the splice case.
+		// CANNOT apply ._stash()/end() to splice since it currently modifies
+		// the existing this array -- it would break backward compatibility if we copy the array before
+		// the splice so that we can use .end(). So only doing the stash option to this._wrap for slice.
+		nlp[name] = function(){ return this._wrap(f.apply(this, arguments), name == "slice" ? this : null); };
+	});
+	// concat should be here but some browsers with native NodeList have problems with it
+
+	// add array.js redirectors
+	forEach(["indexOf", "lastIndexOf", "every", "some"], function(name){
+		var f = array[name];
+		nlp[name] = function(){ return f.apply(dojo, [this].concat(aps.call(arguments, 0))); };
+	});
+
+	/*===== var NodeList = dojo.NodeList; =====*/
+	lang.extend(NodeList, {
+		// copy the constructors
+		constructor: nl,
+		_NodeListCtor: nl,
+		toString: function(){
+			// Array.prototype.toString can't be applied to objects, so we use join
+			return this.join(",");
+		},
+		_stash: function(parent){
+			// summary:
+			//		private function to hold to a parent NodeList. end() to return the parent NodeList.
+			//
+			// example:
+			// How to make a `dojo.NodeList` method that only returns the third node in
+			// the dojo.NodeList but allows access to the original NodeList by using this._stash:
+			//	|	dojo.extend(dojo.NodeList, {
+			//	|		third: function(){
+			//	|			var newNodeList = dojo.NodeList(this[2]);
+			//	|			return newNodeList._stash(this);
+			//	|		}
+			//	|	});
+			//	|	// then see how _stash applies a sub-list, to be .end()'ed out of
+			//	|	dojo.query(".foo")
+			//	|		.third()
+			//	|			.addClass("thirdFoo")
+			//	|		.end()
+			//	|		// access to the orig .foo list
+			//	|		.removeClass("foo")
+			//	|
+			//
+			this._parent = parent;
+			return this; //dojo.NodeList
+		},
+
+		on: function(eventName, listener){
+			// summary:
+			//		Listen for events on the nodes in the NodeList. Basic usage is:
+			//		| query(".my-class").on("click", listener);
+			// 		This supports event delegation by using selectors as the first argument with the event names as
+			//		pseudo selectors. For example:
+			//		| dojo.query("#my-list").on("li:click", listener);
+			//		This will listen for click events within <li> elements that are inside the #my-list element.
+			//		Because on supports CSS selector syntax, we can use comma-delimited events as well:
+			//		| dojo.query("#my-list").on("li button:mouseover, li:click", listener);
+			var handles = this.map(function(node){
+				return on(node, eventName, listener); // TODO: apply to the NodeList so the same selector engine is used for matches
+			});
+			handles.remove = function(){
+				for(var i = 0; i < handles.length; i++){
+					handles[i].remove();
+				}
+			};
+			return handles;
+		},
+
+		end: function(){
+			// summary:
+			//		Ends use of the current `dojo.NodeList` by returning the previous dojo.NodeList
+			//		that generated the current dojo.NodeList.
+			// description:
+			//		Returns the `dojo.NodeList` that generated the current `dojo.NodeList`. If there
+			//		is no parent dojo.NodeList, an empty dojo.NodeList is returned.
+			// example:
+			//	|	dojo.query("a")
+			//	|		.filter(".disabled")
+			//	|			// operate on the anchors that only have a disabled class
+			//	|			.style("color", "grey")
+			//	|		.end()
+			//	|		// jump back to the list of anchors
+			//	|		.style(...)
+			//
+			if(this._parent){
+				return this._parent;
+			}else{
+				//Just return empty list.
+				return new this._NodeListCtor(0);
+			}
+		},
+
+		// http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods
+
+		// FIXME: handle return values for #3244
+		//		http://trac.dojotoolkit.org/ticket/3244
+
+		// FIXME:
+		//		need to wrap or implement:
+		//			join (perhaps w/ innerHTML/outerHTML overload for toString() of items?)
+		//			reduce
+		//			reduceRight
+
+		/*=====
+		slice: function(begin, end){
+			// summary:
+			//		Returns a new NodeList, maintaining this one in place
+			// description:
+			//		This method behaves exactly like the Array.slice method
+			//		with the caveat that it returns a dojo.NodeList and not a
+			//		raw Array. For more details, see Mozilla's (slice
+			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:slice]
+			// begin: Integer
+			//		Can be a positive or negative integer, with positive
+			//		integers noting the offset to begin at, and negative
+			//		integers denoting an offset from the end (i.e., to the left
+			//		of the end)
+			// end: Integer?
+			//		Optional parameter to describe what position relative to
+			//		the NodeList's zero index to end the slice at. Like begin,
+			//		can be positive or negative.
+			return this._wrap(a.slice.apply(this, arguments));
+		},
+
+		splice: function(index, howmany, item){
+			// summary:
+			//		Returns a new NodeList, manipulating this NodeList based on
+			//		the arguments passed, potentially splicing in new elements
+			//		at an offset, optionally deleting elements
+			// description:
+			//		This method behaves exactly like the Array.splice method
+			//		with the caveat that it returns a dojo.NodeList and not a
+			//		raw Array. For more details, see Mozilla's (splice
+			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:splice]
+			//		For backwards compatibility, calling .end() on the spliced NodeList
+			//		does not return the original NodeList -- splice alters the NodeList in place.
+			// index: Integer
+			//		begin can be a positive or negative integer, with positive
+			//		integers noting the offset to begin at, and negative
+			//		integers denoting an offset from the end (i.e., to the left
+			//		of the end)
+			// howmany: Integer?
+			//		Optional parameter to describe what position relative to
+			//		the NodeList's zero index to end the slice at. Like begin,
+			//		can be positive or negative.
+			// item: Object...?
+			//		Any number of optional parameters may be passed in to be
+			//		spliced into the NodeList
+			// returns:
+			//		dojo.NodeList
+			return this._wrap(a.splice.apply(this, arguments));
+		},
+
+		indexOf: function(value, fromIndex){
+			// summary:
+			//		see dojo.indexOf(). The primary difference is that the acted-on
+			//		array is implicitly this NodeList
+			// value: Object:
+			//		The value to search for.
+			// fromIndex: Integer?:
+			//		The location to start searching from. Optional. Defaults to 0.
+			// description:
+			//		For more details on the behavior of indexOf, see Mozilla's
+			//		(indexOf
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf]
+			// returns:
+			//		Positive Integer or 0 for a match, -1 of not found.
+			return d.indexOf(this, value, fromIndex); // Integer
+		},
+
+		lastIndexOf: function(value, fromIndex){
+			// summary:
+			//		see dojo.lastIndexOf(). The primary difference is that the
+			//		acted-on array is implicitly this NodeList
+			// description:
+			//		For more details on the behavior of lastIndexOf, see
+			//		Mozilla's (lastIndexOf
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf]
+			// value: Object
+			//		The value to search for.
+			// fromIndex: Integer?
+			//		The location to start searching from. Optional. Defaults to 0.
+			// returns:
+			//		Positive Integer or 0 for a match, -1 of not found.
+			return d.lastIndexOf(this, value, fromIndex); // Integer
+		},
+
+		every: function(callback, thisObject){
+			// summary:
+			//		see `dojo.every()` and the (Array.every
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every].
+			//		Takes the same structure of arguments and returns as
+			//		dojo.every() with the caveat that the passed array is
+			//		implicitly this NodeList
+			// callback: Function: the callback
+			// thisObject: Object?: the context
+			return d.every(this, callback, thisObject); // Boolean
+		},
+
+		some: function(callback, thisObject){
+			// summary:
+			//		Takes the same structure of arguments and returns as
+			//		`dojo.some()` with the caveat that the passed array is
+			//		implicitly this NodeList.  See `dojo.some()` and Mozilla's
+			//		(Array.some
+			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some].
+			// callback: Function: the callback
+			// thisObject: Object?: the context
+			return d.some(this, callback, thisObject); // Boolean
+		},
+		=====*/
+
+		concat: function(item){
+			// summary:
+			//		Returns a new NodeList comprised of items in this NodeList
+			//		as well as items passed in as parameters
+			// description:
+			//		This method behaves exactly like the Array.concat method
+			//		with the caveat that it returns a `dojo.NodeList` and not a
+			//		raw Array. For more details, see the (Array.concat
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:concat]
+			// item: Object?
+			//		Any number of optional parameters may be passed in to be
+			//		spliced into the NodeList
+			// returns:
+			//		dojo.NodeList
+
+			//return this._wrap(apc.apply(this, arguments));
+			// the line above won't work for the native NodeList :-(
+
+			// implementation notes:
+			// 1) Native NodeList is not an array, and cannot be used directly
+			// in concat() --- the latter doesn't recognize it as an array, and
+			// does not inline it, but append as a single entity.
+			// 2) On some browsers (e.g., Safari) the "constructor" property is
+			// read-only and cannot be changed. So we have to test for both
+			// native NodeList and dojo.NodeList in this property to recognize
+			// the node list.
+
+			var t = lang.isArray(this) ? this : aps.call(this, 0),
+				m = array.map(arguments, function(a){
+					return a && !lang.isArray(a) &&
+						(typeof NodeList != "undefined" && a.constructor === NodeList || a.constructor === this._NodeListCtor) ?
+							aps.call(a, 0) : a;
+				});
+			return this._wrap(apc.apply(t, m), this);	// dojo.NodeList
+		},
+
+		map: function(/*Function*/ func, /*Function?*/ obj){
+			// summary:
+			//		see dojo.map(). The primary difference is that the acted-on
+			//		array is implicitly this NodeList and the return is a
+			//		dojo.NodeList (a subclass of Array)
+			///return d.map(this, func, obj, d.NodeList); // dojo.NodeList
+			return this._wrap(array.map(this, func, obj), this); // dojo.NodeList
+		},
+
+		forEach: function(callback, thisObj){
+			// summary:
+			//		see `dojo.forEach()`. The primary difference is that the acted-on
+			//		array is implicitly this NodeList. If you want the option to break out
+			//		of the forEach loop, use every() or some() instead.
+			forEach(this, callback, thisObj);
+			// non-standard return to allow easier chaining
+			return this; // dojo.NodeList
+		},
+		filter: function(/*String|Function*/ filter){
+			// summary:
+			//		"masks" the built-in javascript filter() method (supported
+			//		in Dojo via `dojo.filter`) to support passing a simple
+			//		string filter in addition to supporting filtering function
+			//		objects.
+			// filter:
+			//		If a string, a CSS rule like ".thinger" or "div > span".
+			// example:
+			//		"regular" JS filter syntax as exposed in dojo.filter:
+			//		|	dojo.query("*").filter(function(item){
+			//		|		// highlight every paragraph
+			//		|		return (item.nodeName == "p");
+			//		|	}).style("backgroundColor", "yellow");
+			// example:
+			//		the same filtering using a CSS selector
+			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
+
+			var a = arguments, items = this, start = 0;
+			if(typeof filter == "string"){ // inline'd type check
+				items = query._filterResult(this, a[0]);
+				if(a.length == 1){
+					// if we only got a string query, pass back the filtered results
+					return items._stash(this); // dojo.NodeList
+				}
+				// if we got a callback, run it over the filtered items
+				start = 1;
+			}
+			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo.NodeList
+		},
+		instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){
+			// summary:
+			//		Create a new instance of a specified class, using the
+			//		specified properties and each node in the nodeList as a
+			//		srcNodeRef.
+			// example:
+			//		Grabs all buttons in the page and converts them to diji.form.Buttons.
+			//	|	var buttons = dojo.query("button").instantiate("dijit.form.Button", {showLabel: true});
+			var c = lang.isFunction(declaredClass) ? declaredClass : lang.getObject(declaredClass);
+			properties = properties || {};
+			return this.forEach(function(node){
+				new c(properties, node);
+			});	// dojo.NodeList
+		},
+		at: function(/*===== index =====*/){
+			// summary:
+			//		Returns a new NodeList comprised of items in this NodeList
+			//		at the given index or indices.
+			//
+			// index: Integer...
+			//		One or more 0-based indices of items in the current
+			//		NodeList. A negative index will start at the end of the
+			//		list and go backwards.
+			//
+			// example:
+			//	Shorten the list to the first, second, and third elements
+			//	|	dojo.query("a").at(0, 1, 2).forEach(fn);
+			//
+			// example:
+			//	Retrieve the first and last elements of a unordered list:
+			//	|	dojo.query("ul > li").at(0, -1).forEach(cb);
+			//
+			// example:
+			//	Do something for the first element only, but end() out back to
+			//	the original list and continue chaining:
+			//	|	dojo.query("a").at(0).onclick(fn).end().forEach(function(n){
+			//	|		console.log(n); // all anchors on the page.
+			//	|	})
+			//
+			// returns:
+			//		dojo.NodeList
+			var t = new this._NodeListCtor(0);
+			forEach(arguments, function(i){
+				if(i < 0){ i = this.length + i; }
+				if(this[i]){ t.push(this[i]); }
+			}, this);
+			return t._stash(this); // dojo.NodeList
+		}
+	});
+
+
+/*===== 
+dojo.query = function(selector, context){
+	// summary:
+	//		This modules provides DOM querying functionality. The module export is a function
+	//		that can be used to query for DOM nodes by CSS selector and returns a dojo.NodeList
+	//		representing the matching nodes.
+	//
+	// selector: String
+	//		A CSS selector to search for.
+	// context: String|DomNode?
+	//		An optional context to limit the searching scope. Only nodes under `context` will be 
+	//		scanned. 
+	// 
+	//	example:
+	//		add an onclick handler to every submit button in the document
+	//		which causes the form to be sent via Ajax instead:
+	//	|	define(["dojo/query"], function(query){
+	// 	|	query("input[type='submit']").on("click", function(e){
+	//	|		dojo.stopEvent(e); // prevent sending the form
+	//	|		var btn = e.target;
+	//	|		dojo.xhrPost({
+	//	|			form: btn.form,
+	//	|			load: function(data){
+	//	|				// replace the form with the response
+	//	|				var div = dojo.doc.createElement("div");
+	//	|				dojo.place(div, btn.form, "after");
+	//	|				div.innerHTML = data;
+	//	|				dojo.style(btn.form, "display", "none");
+	//	|			}
+	//	|		});
+	//	|	}); 
+	//
+	// description:
+	//		dojo/query is responsible for loading the appropriate query engine and wrapping 
+	//		its results with a `dojo.NodeList`. You can use dojo/query with a specific selector engine
+	//		by using it as a plugin. For example, if you installed the sizzle package, you could
+	//		use it as the selector engine with:
+	//		|	define("dojo/query!sizzle", function(query){
+	//		|		query("div")...
+	//
+	//		The id after the ! can be a module id of the selector engine or one of the following values:
+	//		|	+ acme: This is the default engine used by Dojo base, and will ensure that the full
+	//		|	Acme engine is always loaded. 
+	//		|	
+	//		|	+ css2: If the browser has a native selector engine, this will be used, otherwise a
+	//		|	very minimal lightweight selector engine will be loaded that can do simple CSS2 selectors
+	//		|	(by #id, .class, tag, and [name=value] attributes, with standard child or descendant (>)
+	//		|	operators) and nothing more.
+	//		|
+	//		|	+ css2.1: If the browser has a native selector engine, this will be used, otherwise the
+	//		|	full Acme engine will be loaded. 
+	//		|	
+	//		|	+ css3: If the browser has a native selector engine with support for CSS3 pseudo
+	//		|	selectors (most modern browsers except IE8), this will be used, otherwise the
+	//		|	full Acme engine will be loaded.
+	//		|	
+	//		|	+ Or the module id of a selector engine can be used to explicitly choose the selector engine
+	//		
+	//		For example, if you are using CSS3 pseudo selectors in module, you can specify that
+	//		you will need support them with:
+	//		|	define("dojo/query!css3", function(query){
+	//		|		query('#t > h3:nth-child(odd)')...
+	//
+	//		You can also choose the selector engine/load configuration by setting the <FIXME:what is the configuration setting?>.
+	//		For example:
+	//		|	<script data-dojo-config="query-selector:'css3'" src="dojo.js"></script>
+	//		
+	return new dojo.NodeList(); // dojo.NodeList
+};
+=====*/
+
+function queryForEngine(engine, NodeList){
+	var query = function(/*String*/ query, /*String|DOMNode?*/ root){
+		//	summary:
+		//		Returns nodes which match the given CSS selector, searching the
+		//		entire document by default but optionally taking a node to scope
+		//		the search by. Returns an instance of dojo.NodeList.
+		if(typeof root == "string"){
+			root = dom.byId(root);
+			if(!root){
+				return new NodeList([]);
+			}
+		}
+		var results = typeof query == "string" ? engine(query, root) : query.orphan ? query : [query];
+		if(results.orphan){
+			// already wrapped
+			return results; 
+		}
+		return new NodeList(results);
+	};
+	query.matches = engine.match || function(node, selector, root){
+		// summary:
+		//		Test to see if a node matches a selector
+		return query.filter([node], selector, root).length > 0;
+	};
+	// the engine provides a filtering function, use it to for matching
+	query.filter = engine.filter || function(nodes, selector, root){
+		// summary:
+		//		Filters an array of nodes. Note that this does not guarantee to return a dojo.NodeList, just an array.
+		return query(selector, root).filter(function(node){
+			return array.indexOf(nodes, node) > -1;
+		});
+	};
+	if(typeof engine != "function"){
+		var search = engine.search;
+		engine = function(selector, root){
+			// Slick does it backwards (or everyone else does it backwards, probably the latter)
+			return search(root || document, selector);
+		};
+	}
+	return query;
+}
+var query = queryForEngine(defaultEngine, NodeList);
+// the query that is returned from this module is slightly different than dojo.query,
+// because dojo.query has to maintain backwards compatibility with returning a
+// true array which has performance problems. The query returned from the module
+// does not use true arrays, but rather inherits from Array, making it much faster to
+// instantiate.
+dojo.query = queryForEngine(defaultEngine, function(array){
+	// call it without the new operator to invoke the back-compat behavior that returns a true array
+	return NodeList(array);
+});
+
+query.load = /*===== dojo.query.load= ======*/ function(id, parentRequire, loaded, config){
+	// summary: can be used as AMD plugin to conditionally load new query engine
+	// example:
+	//	|	define(["dojo/query!custom"], function(qsa){ 
+	//	|		// loaded selector/custom.js as engine
+	//	|		qsa("#foobar").forEach(...);
+	//	|	});
+	loader.load(id, parentRequire, function(engine){
+		loaded(queryForEngine(engine, NodeList));
+	});
+};
+
+dojo._filterQueryResult = query._filterResult = function(nodes, selector, root){
+	return new NodeList(query.filter(nodes, selector, root));
+};
+dojo.NodeList = query.NodeList = NodeList;
+return query;
+});
+
+},
+'dojo/has':function(){
+define(["require"], function(require) {
+	// module:
+	//		dojo/has
+	// summary:
+	//		Defines the has.js API and several feature tests used by dojo.
+	// description:
+	//		This module defines the has API as described by the project has.js with the following additional features:
+	//
+	//			* the has test cache is exposed at has.cache.
+	//			* the method has.add includes a forth parameter that controls whether or not existing tests are replaced
+	//			* the loader's has cache may be optionally copied into this module's has cahce.
+	//
+	//		This module adopted from https://github.com/phiggins42/has.js; thanks has.js team!
+
+	// try to pull the has implementation from the loader; both the dojo loader and bdLoad provide one
+	// WARNING: if a foreign loader defines require.has to be something other than the has.js API, then this implementation fail
+	var has = require.has || function(){};
+	if(!1){
+		// notice the condition is written so that if 1 is transformed to 1 during a build
+		// the conditional will be (!1 && typeof has=="function") which is statically false and the closure
+		// compiler will discard the block.
+		var
+			isBrowser =
+				// the most fundamental decision: are we in the browser?
+				typeof window != "undefined" &&
+				typeof location != "undefined" &&
+				typeof document != "undefined" &&
+				window.location == location && window.document == document,
+
+			// has API variables
+			global = this,
+			doc = isBrowser && document,
+			element = doc && doc.createElement("DiV"),
+			cache = {};
+
+		has = /*===== dojo.has= =====*/ function(name){
+			//	summary:
+			//		Return the current value of the named feature.
+			//
+			//	name: String|Integer
+			//		The name (if a string) or identifier (if an integer) of the feature to test.
+			//
+			//	description:
+			//		Returns the value of the feature named by name. The feature must have been
+			//		previously added to the cache by has.add.
+
+			return typeof cache[name] == "function" ? (cache[name] = cache[name](global, doc, element)) : cache[name]; // Boolean
+		};
+
+		has.cache = cache;
+
+		has.add = /*====== dojo.has.add= ======*/ function(name, test, now, force){
+			// summary:
+			//	 Register a new feature test for some named feature.
+			//
+			// name: String|Integer
+			//	 The name (if a string) or identifier (if an integer) of the feature to test.
+			//
+			// test: Function
+			//	 A test function to register. If a function, queued for testing until actually
+			//	 needed. The test function should return a boolean indicating
+			//	 the presence of a feature or bug.
+			//
+			// now: Boolean?
+			//	 Optional. Omit if `test` is not a function. Provides a way to immediately
+			//	 run the test and cache the result.
+			//
+			// force: Boolean?
+			//	 Optional. If the test already exists and force is truthy, then the existing
+			//	 test will be replaced; otherwise, add does not replace an existing test (that
+			//	 is, by default, the first test advice wins).
+			//
+			// example:
+			//			A redundant test, testFn with immediate execution:
+			//	|				has.add("javascript", function(){ return true; }, true);
+			//
+			// example:
+			//			Again with the redundantness. You can do this in your tests, but we should
+			//			not be doing this in any internal has.js tests
+			//	|				has.add("javascript", true);
+			//
+			// example:
+			//			Three things are passed to the testFunction. `global`, `document`, and a generic element
+			//			from which to work your test should the need arise.
+			//	|				has.add("bug-byid", function(g, d, el){
+			//	|						// g	== global, typically window, yadda yadda
+			//	|						// d	== document object
+			//	|						// el == the generic element. a `has` element.
+			//	|						return false; // fake test, byid-when-form-has-name-matching-an-id is slightly longer
+			//	|				});
+
+			(typeof cache[name]=="undefined" || force) && (cache[name]= test);
+			return now && has(name);
+		};
+
+		// since we're operating under a loader that doesn't provide a has API, we must explicitly initialize
+		// has as it would have otherwise been initialized by the dojo loader; use has.add to the builder
+		// can optimize these away iff desired
+		true || has.add("host-browser", isBrowser);
+		true || has.add("dom", isBrowser);
+		true || has.add("dojo-dom-ready-api", 1);
+		true || has.add("dojo-sniff", 1);
+	}
+
+	if(1){
+		var agent = navigator.userAgent;
+		// Common application level tests
+		has.add("dom-addeventlistener", !!document.addEventListener);
+		has.add("touch", "ontouchstart" in document);
+		// I don't know if any of these tests are really correct, just a rough guess
+		has.add("device-width", screen.availWidth || innerWidth);
+		has.add("agent-ios", !!agent.match(/iPhone|iP[ao]d/));
+		has.add("agent-android", agent.indexOf("android") > 1);
+	}
+
+	has.clearElement = /*===== dojo.has.clearElement= ======*/ function(element) {
+		// summary:
+		//	 Deletes the contents of the element passed to test functions.
+		element.innerHTML= "";
+		return element;
+	};
+
+	has.normalize = /*===== dojo.has.normalize= ======*/ function(id, toAbsMid){
+		// summary:
+		//	 Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s).
+		//
+		// toAbsMid: Function
+		//	 Resolves a relative module id into an absolute module id
+		var
+			tokens = id.match(/[\?:]|[^:\?]*/g), i = 0,
+			get = function(skip){
+				var term = tokens[i++];
+				if(term == ":"){
+					// empty string module name, resolves to 0
+					return 0;
+				}else{
+					// postfixed with a ? means it is a feature to branch on, the term is the name of the feature
+					if(tokens[i++] == "?"){
+						if(!skip && has(term)){
+							// matched the feature, get the first value from the options
+							return get();
+						}else{
+							// did not match, get the second value, passing over the first
+							get(true);
+							return get(skip);
+						}
+					}
+					// a module
+					return term || 0;
+				}
+			};
+		id = get();
+		return id && toAbsMid(id);
+	};
+
+	has.load = /*===== dojo.has.load= ======*/ function(id, parentRequire, loaded){
+		// summary:
+		//	 Conditional loading of AMD modules based on a has feature test value.
+		//
+		// id: String
+		//	 Gives the resolved module id to load.
+		//
+		// parentRequire: Function
+		//	 The loader require function with respect to the module that contained the plugin resource in it's
+		//	 dependency list.
+		//
+		// loaded: Function
+		//	 Callback to loader that consumes result of plugin demand.
+
+		if(id){
+			parentRequire([id], loaded);
+		}else{
+			loaded();
+		}
+	};
+
+	return has;
+});
+
+},
+'dojo/_base/loader':function(){
+define(["./kernel", "../has", "require", "module", "./json", "./lang", "./array"], function(dojo, has, require, thisModule, json, lang, array) {
+	// module:
+	//		dojo/_base/lader
+	// summary:
+	//		This module defines the v1.x synchronous loader API.
+
+	// signal the loader in sync mode...
+	//>>pure-amd
+
+	if (!1){
+		console.error("cannot load the Dojo v1.x loader with a foreign loader");
+		return 0;
+	}
+
+	var makeErrorToken = function(id){
+			return {src:thisModule.id, id:id};
+		},
+
+		slashName = function(name){
+			return name.replace(/\./g, "/");
+		},
+
+		buildDetectRe = /\/\/>>built/,
+
+		dojoRequireCallbacks = [],
+		dojoRequireModuleStack = [],
+
+		dojoRequirePlugin = function(mid, require, loaded){
+			dojoRequireCallbacks.push(loaded);
+			array.forEach(mid.split(","), function(mid){
+				var module = getModule(mid, require.module);
+				dojoRequireModuleStack.push(module);
+				injectModule(module);
+			});
+			checkDojoRequirePlugin();
+		},
+
+		touched,
+
+		traverse = function(m){
+			if(touched[m.mid] || /loadInit\!/.test(m.mid)){
+				// loadInit plugin modules are dependencies of modules in dojoRequireModuleStack...
+				// which would cause a circular dependency chain that would never be resolved if checked here
+				// notice all dependencies of any particular loadInit plugin module will already
+				// be checked since those are pushed into dojoRequireModuleStack explicitly by the
+				// plugin...so if a particular loadInitPlugin module's dependencies are not really
+				// on board, that *will* be detected elsewhere in the traversal.
+				return true;
+			}
+		    touched[m.mid] = 1;
+			if(m.injected!==arrived && !m.executed){
+				return false;
+			}
+			for(var deps = m.deps || [], i= 0; i<deps.length; i++){
+				if(!traverse(deps[i])){
+					return false;
+				}
+			}
+			return true;
+		},
+
+		checkDojoRequirePlugin = function(){
+			touched = {};
+			dojoRequireModuleStack = array.filter(dojoRequireModuleStack, function(module){
+				return !traverse(module);
+			});
+			if(!dojoRequireModuleStack.length){
+				loaderVars.holdIdle();
+				var oldCallbacks = dojoRequireCallbacks;
+				dojoRequireCallbacks = [];
+				array.forEach(oldCallbacks, function(cb){cb(1);});
+				loaderVars.releaseIdle();
+			}
+		},
+
+		dojoLoadInitPlugin = function(mid, require, loaded){
+			// mid names a module that defines a "dojo load init" bundle, an object with two properties:
+			//
+			//   * names: a vector of module ids that give top-level names to define in the lexical scope of def
+			//   * def: a function that contains some some legacy loader API applications
+			//
+			// The point of def is to possibly cause some modules to be loaded (but not executed) by dojo/require! where the module
+			// ids are possibly-determined at runtime. For example, here is dojox.gfx from v1.6 expressed as an AMD module using the dojo/loadInit
+			// and dojo/require plugins.
+			//
+			// // dojox/gfx:
+			//
+			//   define("*loadInit_12, {
+			//     names:["dojo", "dijit", "dojox"],
+			//     def: function(){
+			//       dojo.loadInit(function(){
+			//         var gfx = lang.getObject("dojox.gfx", true);
+			//
+			//         //
+			//         // code required to set gfx properties ommitted...
+			//         //
+			//
+			//         // now use the calculations to include the runtime-dependent module
+			//         dojo.require("dojox.gfx." + gfx.renderer);
+			//       });
+			//	   }
+			//   });
+			//
+			//   define(["dojo", "dojo/loadInit!" + id].concat("dojo/require!dojox/gfx/matric,dojox/gfx/_base"), function(dojo){
+			//     // when this AMD factory function is executed, the following modules are guaranteed downloaded but not executed:
+			//     //   "dojox.gfx." + gfx.renderer
+			//     //   dojox.gfx.matrix
+			//     //   dojox.gfx._base
+			//     dojo.provide("dojo.gfx");
+			//     dojo.require("dojox.gfx.matrix");
+			//     dojo.require("dojox.gfx._base");
+			//     dojo.require("dojox.gfx." + gfx.renderer);
+			//     return lang.getObject("dojo.gfx");
+			//   });
+			//  })();
+			//
+			// The idea is to run the legacy loader API with global variables shadowed, which allows these variables to
+			// be relocated. For example, dojox and dojo could be relocated to different names by giving a packageMap and the code above will
+			// execute properly (because the plugin below resolves the load init bundle.names module with respect to the module that demanded
+			// the plugin resource).
+			//
+			// Note that the relocation is specified in the runtime configuration; relocated names need not be set at build-time.
+			//
+			// Warning: this is not the best way to express dojox.gfx as and AMD module. In fact, the module has been properly converted in
+			// v1.7. However, this technique allows the builder to convert legacy modules into AMD modules and guarantee the codepath is the
+			// same in the converted AMD module.
+			require([mid], function(bundle){
+				// notice how names is resolved with respect to the module that demanded the plugin resource
+				require(bundle.names, function(){
+					// bring the bundle names into scope
+					for(var scopeText = "", args= [], i = 0; i<arguments.length; i++){
+						scopeText+= "var " + bundle.names[i] + "= arguments[" + i + "]; ";
+						args.push(arguments[i]);
+					}
+					eval(scopeText);
+
+					var callingModule = require.module,
+						deps = [],
+						hold = {},
+						requireList = [],
+						p,
+						syncLoaderApi = {
+							provide:function(moduleName){
+								// mark modules that arrive consequent to multiple provides in this module as arrived since they can't be injected
+								moduleName = slashName(moduleName);
+								var providedModule = getModule(moduleName, callingModule);
+								if(providedModule!==callingModule){
+									setArrived(providedModule);
+								}
+							},
+							require:function(moduleName, omitModuleCheck){
+								moduleName = slashName(moduleName);
+								omitModuleCheck && (getModule(moduleName, callingModule).result = nonmodule);
+								requireList.push(moduleName);
+							},
+							requireLocalization:function(moduleName, bundleName, locale){
+								// since we're going to need dojo/i8n, add it to deps if not already there
+								deps.length || (deps = ["dojo/i18n"]);
+
+								// figure out if the bundle is xdomain; if so, add it to the depsSet
+								locale = (locale || dojo.locale).toLowerCase();
+								moduleName = slashName(moduleName) + "/nls/" + (/root/i.test(locale) ? "" : locale + "/") + slashName(bundleName);
+								if(getModule(moduleName, callingModule).isXd){
+									deps.push("dojo/i18n!" + moduleName);
+								}// else the bundle will be loaded synchronously when the module is evaluated
+							},
+							loadInit:function(f){
+								f();
+							}
+						};
+
+					// hijack the correct dojo and apply bundle.def
+					try{
+						for(p in syncLoaderApi){
+							hold[p] = dojo[p];
+							dojo[p] = syncLoaderApi[p];
+						}
+						bundle.def.apply(null, args);
+					}catch(e){
+						signal("error", [makeErrorToken("failedDojoLoadInit"), e]);
+					}finally{
+						for(p in syncLoaderApi){
+							dojo[p] = hold[p];
+						}
+					}
+
+					// requireList is the list of modules that need to be downloaded but not executed before the callingModule can be executed
+					requireList.length && deps.push("dojo/require!" + requireList.join(","));
+
+					dojoRequireCallbacks.push(loaded);
+					array.forEach(requireList, function(mid){
+						var module = getModule(mid, require.module);
+						dojoRequireModuleStack.push(module);
+						injectModule(module);
+					});
+					checkDojoRequirePlugin();
+				});
+			});
+		},
+
+		extractApplication = function(
+			text,             // the text to search
+			startSearch,      // the position in text to start looking for the closing paren
+			startApplication  // the position in text where the function application expression starts
+		){
+			// find end of the call by finding the matching end paren
+			// Warning: as usual, this will fail in the presense of unmatched right parans contained in strings, regexs, or unremoved comments
+			var parenRe = /\(|\)/g,
+				matchCount = 1,
+				match;
+			parenRe.lastIndex = startSearch;
+			while((match = parenRe.exec(text))){
+				if(match[0] == ")"){
+					matchCount -= 1;
+				}else{
+					matchCount += 1;
+				}
+				if(matchCount == 0){
+					break;
+				}
+			}
+
+			if(matchCount != 0){
+				throw "unmatched paren around character " + parenRe.lastIndex + " in: " + text;
+			}
+
+			//Put the master matching string in the results.
+			return [dojo.trim(text.substring(startApplication, parenRe.lastIndex))+";\n", parenRe.lastIndex];
+		},
+
+		// the following regex is taken from 1.6. It is a very poor technique to remove comments and
+		// will fail in some cases; for example, consider the code...
+		//
+		//    var message = "Category-1 */* Category-2";
+		//
+		// The regex that follows will see a /* comment and trash the code accordingly. In fact, there are all
+		// kinds of cases like this with strings and regexs that will cause this design to fail miserably.
+		//
+		// Alternative regex designs exist that will result in less-likely failures, but will still fail in many cases.
+		// The only solution guaranteed 100% correct is to parse the code and that seems overkill for this
+		// backcompat/unbuilt-xdomain layer. In the end, since it's been this way for a while, we won't change it.
+		// See the opening paragraphs of Chapter 7 or ECME-262 which describes the lexical abiguity further.
+		removeCommentRe = /(\/\*([\s\S]*?)\*\/|\/\/(.*)$)/mg,
+
+		syncLoaderApiRe = /(^|\s)dojo\.(loadInit|require|provide|requireLocalization|requireIf|requireAfterIf|platformRequire)\s*\(/mg,
+
+		amdLoaderApiRe = /(^|\s)(require|define)\s*\(/m,
+
+		extractLegacyApiApplications = function(text, noCommentText){
+			// scan the noCommentText for any legacy loader API applications. Copy such applications into result (this is
+			// used by the builder). Move dojo.loadInit applications to loadInitApplications string. Copy all other applications
+			// to otherApplications string. If no applications were found, return 0, signalling an AMD module. Otherwise, return
+			// loadInitApplications + otherApplications. Fixup text by replacing
+			//
+			//   dojo.loadInit(// etc...
+			//
+			// with
+			//
+			//   \n 0 && dojo.loadInit(// etc...
+			//
+			// Which results in the dojo.loadInit from *not* being applied. This design goes a long way towards protecting the
+			// code from an over-agressive removeCommentRe. However...
+			//
+			// WARNING: the removeCommentRe will cause an error if a detected comment removes all or part of a legacy-loader application
+			// that is not in a comment.
+
+			var match, startSearch, startApplication, application,
+				loadInitApplications = [],
+				otherApplications = [],
+				allApplications = [];
+
+			// noCommentText may be provided by a build app with comments extracted by a better method than regex (hopefully)
+			noCommentText = noCommentText || text.replace(removeCommentRe, function(match){
+				// remove iff the detected comment has text that looks like a sync loader API application; this helps by
+				// removing as little as possible, minimizing the changes the janky regex will kill the module
+				syncLoaderApiRe.lastIndex = amdLoaderApiRe.lastIndex = 0;
+				return (syncLoaderApiRe.test(match) || amdLoaderApiRe.test(match)) ? "" : match;
+			});
+
+			// find and extract all dojo.loadInit applications
+			while((match = syncLoaderApiRe.exec(noCommentText))){
+				startSearch = syncLoaderApiRe.lastIndex;
+				startApplication = startSearch  - match[0].length;
+				application = extractApplication(noCommentText, startSearch, startApplication);
+				if(match[2]=="loadInit"){
+					loadInitApplications.push(application[0]);
+				}else{
+					otherApplications.push(application[0]);
+				}
+				syncLoaderApiRe.lastIndex = application[1];
+			}
+			allApplications = loadInitApplications.concat(otherApplications);
+			if(allApplications.length || !amdLoaderApiRe.test(noCommentText)){
+				// either there were some legacy loader API applications or there were no AMD API applications
+				return [text.replace(/(^|\s)dojo\.loadInit\s*\(/g, "\n0 && dojo.loadInit("), allApplications.join(""), allApplications];
+			}else{
+				// legacy loader API *was not* detected and AMD API *was* detected; therefore, assume it's an AMD module
+				return 0;
+			}
+		},
+
+		transformToAmd = function(module, text){
+			// This is roughly the equivalent of dojo._xdCreateResource in 1.6-; however, it expresses a v1.6- dojo
+			// module in terms of AMD define instead of creating the dojo proprietary xdomain module expression.
+			// The module could have originated from several sources:
+			//
+			//   * amd require() a module, e.g., require(["my/module"])
+			//   * amd require() a nonmodule, e.g., require(["my/resource.js"')
+			//   * amd define() deps vector (always a module)
+			//   * dojo.require() a module, e.g. dojo.require("my.module")
+			//   * dojo.require() a nonmodule, e.g., dojo.require("my.module", true)
+			//   * dojo.requireIf/requireAfterIf/platformRequire a module
+			//
+			// The module is scanned for legacy loader API applications; if none are found, then assume the module is an
+			// AMD module and return 0. Otherwise, a synthetic dojo/loadInit plugin resource is created and the module text
+			// is rewritten as an AMD module with the single dependency of this synthetic resource. When the dojo/loadInit
+			// plugin loaded the synthetic resource, it will cause all dojo.loadInit's to be executed, find all dojo.require's
+			// (either directly consequent to dojo.require or indirectly consequent to dojo.require[After]If or
+			// dojo.platformRequire, and finally cause loading of all dojo.required modules with the dojo/require plugin. Thus,
+			// when the dojo/loadInit plugin reports it has been loaded, all modules required by the given module are guaranteed
+			// loaded (but not executed). This then allows the module to execute it's code path without interupts, thereby
+			// following the synchronous code path.
+
+			var extractResult, id, names = [], namesAsStrings = [];
+			if(buildDetectRe.test(text) || !(extractResult = extractLegacyApiApplications(text))){
+				// buildDetectRe.test(text) => a built module, always AMD
+				// extractResult==0 => no sync API
+				return 0;
+			}
+
+			// manufacture a synthetic module id that can never be a real mdule id (just like require does)
+			id = module.mid + "-*loadInit";
+
+			// construct the dojo/loadInit names vector which causes any relocated names to be defined as lexical variables under their not-relocated name
+			// the dojo/loadInit plugin assumes the first name in names is "dojo"
+
+			for(var p in getModule("dojo", module).result.scopeMap){
+				names.push(p);
+				namesAsStrings.push('"' + p + '"');
+			}
+
+			// rewrite the module as a synthetic dojo/loadInit plugin resource + the module expressed as an AMD module that depends on this synthetic resource
+			return "// xdomain rewrite of " + module.path + "\n" +
+				"define('" + id + "',{\n" +
+				"\tnames:" + dojo.toJson(names) + ",\n" +
+				"\tdef:function(" + names.join(",") + "){" + extractResult[1] + "}" +
+				"});\n\n" +
+			    "define(" + dojo.toJson(names.concat(["dojo/loadInit!"+id])) + ", function(" + names.join(",") + "){\n" + extractResult[0] + "});";
+		},
+
+		loaderVars = require.initSyncLoader(dojoRequirePlugin, checkDojoRequirePlugin, transformToAmd),
+
+		sync =
+			loaderVars.sync,
+
+		xd =
+			loaderVars.xd,
+
+		arrived =
+			loaderVars.arrived,
+
+		nonmodule =
+			loaderVars.nonmodule,
+
+		executing =
+			loaderVars.executing,
+
+		executed =
+			loaderVars.executed,
+
+		syncExecStack =
+			loaderVars.syncExecStack,
+
+		modules =
+			loaderVars.modules,
+
+		execQ =
+			loaderVars.execQ,
+
+		getModule =
+			loaderVars.getModule,
+
+		injectModule =
+			loaderVars.injectModule,
+
+		setArrived =
+			loaderVars.setArrived,
+
+		signal =
+			loaderVars.signal,
+
+		finishExec =
+			loaderVars.finishExec,
+
+		execModule =
+			loaderVars.execModule,
+
+		getLegacyMode =
+			loaderVars.getLegacyMode;
+
+	dojo.provide = function(mid){
+		var executingModule = syncExecStack[0],
+			module = lang.mixin(getModule(slashName(mid), require.module), {
+				executed:executing,
+				result:lang.getObject(mid, true)
+			});
+		setArrived(module);
+		if(executingModule){
+			(executingModule.provides || (executingModule.provides = [])).push(function(){
+				module.result = lang.getObject(mid);
+				delete module.provides;
+				module.executed!==executed && finishExec(module);
+			});
+		}// else dojo.provide called not consequent to loading; therefore, give up trying to publish module value to loader namespace
+		return module.result;
+	};
+
+	has.add("config-publishRequireResult", 1, 0, 0);
+
+	dojo.require = function(moduleName, omitModuleCheck) {
+		//	summary:
+		//		loads a Javascript module from the appropriate URI
+		//
+		//	moduleName: String
+		//		module name to load, using periods for separators,
+		//		 e.g. "dojo.date.locale".  Module paths are de-referenced by dojo's
+		//		internal mapping of locations to names and are disambiguated by
+		//		longest prefix. See `dojo.registerModulePath()` for details on
+		//		registering new modules.
+		//
+		//	omitModuleCheck: Boolean?
+		//		if `true`, omitModuleCheck skips the step of ensuring that the
+		//		loaded file actually defines the symbol it is referenced by.
+		//		For example if it called as `dojo.require("a.b.c")` and the
+		//		file located at `a/b/c.js` does not define an object `a.b.c`,
+		//		and exception will be throws whereas no exception is raised
+		//		when called as `dojo.require("a.b.c", true)`
+		//
+		//	description:
+		// 		Modules are loaded via dojo.require by using one of two loaders: the normal loader
+		// 		and the xdomain loader. The xdomain loader is used when dojo was built with a
+		// 		custom build that specified loader=xdomain and the module lives on a modulePath
+		// 		that is a whole URL, with protocol and a domain. The versions of Dojo that are on
+		// 		the Google and AOL CDNs use the xdomain loader.
+		//
+		// 		If the module is loaded via the xdomain loader, it is an asynchronous load, since
+		// 		the module is added via a dynamically created script tag. This
+		// 		means that dojo.require() can return before the module has loaded. However, this
+		// 		should only happen in the case where you do dojo.require calls in the top-level
+		// 		HTML page, or if you purposely avoid the loader checking for dojo.require
+		// 		dependencies in your module by using a syntax like dojo["require"] to load the module.
+		//
+		// 		Sometimes it is useful to not have the loader detect the dojo.require calls in the
+		// 		module so that you can dynamically load the modules as a result of an action on the
+		// 		page, instead of right at module load time.
+		//
+		// 		Also, for script blocks in an HTML page, the loader does not pre-process them, so
+		// 		it does not know to download the modules before the dojo.require calls occur.
+		//
+		// 		So, in those two cases, when you want on-the-fly module loading or for script blocks
+		// 		in the HTML page, special care must be taken if the dojo.required code is loaded
+		// 		asynchronously. To make sure you can execute code that depends on the dojo.required
+		// 		modules, be sure to add the code that depends on the modules in a dojo.addOnLoad()
+		// 		callback. dojo.addOnLoad waits for all outstanding modules to finish loading before
+		// 		executing.
+		//
+		// 		This type of syntax works with both xdomain and normal loaders, so it is good
+		// 		practice to always use this idiom for on-the-fly code loading and in HTML script
+		// 		blocks. If at some point you change loaders and where the code is loaded from,
+		// 		it will all still work.
+		//
+		// 		More on how dojo.require
+		//		`dojo.require("A.B")` first checks to see if symbol A.B is
+		//		defined. If it is, it is simply returned (nothing to do).
+		//
+		//		If it is not defined, it will look for `A/B.js` in the script root
+		//		directory.
+		//
+		//		`dojo.require` throws an exception if it cannot find a file
+		//		to load, or if the symbol `A.B` is not defined after loading.
+		//
+		//		It returns the object `A.B`, but note the caveats above about on-the-fly loading and
+		// 		HTML script blocks when the xdomain loader is loading a module.
+		//
+		//		`dojo.require()` does nothing about importing symbols into
+		//		the current namespace.  It is presumed that the caller will
+		//		take care of that.
+		//
+		// 	example:
+		// 		To use dojo.require in conjunction with dojo.ready:
+		//
+		//		|	dojo.require("foo");
+		//		|	dojo.require("bar");
+		//	   	|	dojo.addOnLoad(function(){
+		//	   	|		//you can now safely do something with foo and bar
+		//	   	|	});
+		//
+		//	example:
+		//		For example, to import all symbols into a local block, you might write:
+		//
+		//		|	with (dojo.require("A.B")) {
+		//		|		...
+		//		|	}
+		//
+		//		And to import just the leaf symbol to a local variable:
+		//
+		//		|	var B = dojo.require("A.B");
+		//	   	|	...
+		//
+		//	returns:
+		//		the required namespace object
+		function doRequire(mid, omitModuleCheck){
+			var module = getModule(slashName(mid), require.module);
+			if(syncExecStack.length && syncExecStack[0].finish){
+				// switched to async loading in the middle of evaluating a legacy module; stop
+				// applying dojo.require so the remaining dojo.requires are applied in order
+				syncExecStack[0].finish.push(mid);
+				return undefined;
+			}
+
+			// recall module.executed has values {0, executing, executed}; therefore, truthy indicates executing or executed
+			if(module.executed){
+				return module.result;
+			}
+			omitModuleCheck && (module.result = nonmodule);
+
+			var currentMode = getLegacyMode();
+
+			// recall, in sync mode to inject is to *eval* the module text
+			// if the module is a legacy module, this is the same as executing
+			// but if the module is an AMD module, this means defining, not executing
+			injectModule(module);
+			// the inject may have changed the mode
+			currentMode = getLegacyMode();
+
+			// in sync mode to dojo.require is to execute
+			if(module.executed!==executed && module.injected===arrived){
+				// the module was already here before injectModule was called probably finishing up a xdomain
+				// load, but maybe a module given to the loader directly rather than having the loader retrieve it
+				loaderVars.holdIdle();
+				execModule(module);
+				loaderVars.releaseIdle();
+			}
+			if(module.executed){
+				return module.result;
+			}
+
+			if(currentMode==sync){
+				// the only way to get here is in sync mode and dojo.required a module that
+				//   * was loaded async in the injectModule application a few lines up
+				//   * was an AMD module that had deps that are being loaded async and therefore couldn't execute
+				if(module.cjs){
+					// the module was an AMD module; unshift, not push, which causes the current traversal to be reattempted from the top
+					execQ.unshift(module);
+				}else{
+					// the module was a legacy module
+					syncExecStack.length && (syncExecStack[0].finish= [mid]);
+				}
+			}else{
+				// the loader wasn't in sync mode on entry; probably async mode; therefore, no expectation of getting
+				// the module value synchronously; make sure it gets executed though
+				execQ.push(module);
+			}
+			return undefined;
+		}
+
+		var result = doRequire(moduleName, omitModuleCheck);
+		if(has("config-publishRequireResult") && !lang.exists(moduleName) && result!==undefined){
+			lang.setObject(moduleName, result);
+		}
+		return result;
+	};
+
+	dojo.loadInit = function(f) {
+		f();
+	};
+
+	dojo.registerModulePath = function(/*String*/moduleName, /*String*/prefix){
+		//	summary:
+		//		Maps a module name to a path
+		//	description:
+		//		An unregistered module is given the default path of ../[module],
+		//		relative to Dojo root. For example, module acme is mapped to
+		//		../acme.  If you want to use a different module name, use
+		//		dojo.registerModulePath.
+		//	example:
+		//		If your dojo.js is located at this location in the web root:
+		//	|	/myapp/js/dojo/dojo/dojo.js
+		//		and your modules are located at:
+		//	|	/myapp/js/foo/bar.js
+		//	|	/myapp/js/foo/baz.js
+		//	|	/myapp/js/foo/thud/xyzzy.js
+		//		Your application can tell Dojo to locate the "foo" namespace by calling:
+		//	|	dojo.registerModulePath("foo", "../../foo");
+		//		At which point you can then use dojo.require() to load the
+		//		modules (assuming they provide() the same things which are
+		//		required). The full code might be:
+		//	|	<script type="text/javascript"
+		//	|		src="/myapp/js/dojo/dojo/dojo.js"></script>
+		//	|	<script type="text/javascript">
+		//	|		dojo.registerModulePath("foo", "../../foo");
+		//	|		dojo.require("foo.bar");
+		//	|		dojo.require("foo.baz");
+		//	|		dojo.require("foo.thud.xyzzy");
+		//	|	</script>
+
+		var paths = {};
+		paths[moduleName.replace(/\./g, "/")] = prefix;
+		require({paths:paths});
+	};
+
+	dojo.platformRequire = function(/*Object*/modMap){
+		//	summary:
+		//		require one or more modules based on which host environment
+		//		Dojo is currently operating in
+		//	description:
+		//		This method takes a "map" of arrays which one can use to
+		//		optionally load dojo modules. The map is indexed by the
+		//		possible dojo.name_ values, with two additional values:
+		//		"default" and "common". The items in the "default" array will
+		//		be loaded if none of the other items have been choosen based on
+		//		dojo.name_, set by your host environment. The items in the
+		//		"common" array will *always* be loaded, regardless of which
+		//		list is chosen.
+		//	example:
+ 		//		|	dojo.platformRequire({
+		//		|		browser: [
+		//		|			"foo.sample", // simple module
+		//		|			"foo.test",
+		//		|			["foo.bar.baz", true] // skip object check in _loadModule (dojo.require)
+		//		|		],
+		//		|		default: [ "foo.sample._base" ],
+		//		|		common: [ "important.module.common" ]
+		//		|	});
+
+		var result = (modMap.common || []).concat(modMap[dojo._name] || modMap["default"] || []),
+			temp;
+		while(result.length){
+			if(lang.isArray(temp = result.shift())){
+				dojo.require.apply(dojo, temp);
+			}else{
+				dojo.require(temp);
+			}
+		}
+	};
+
+	dojo.requireIf = dojo.requireAfterIf = function(/*Boolean*/ condition, /*String*/ moduleName, /*Boolean?*/omitModuleCheck){
+		// summary:
+		//		If the condition is true then call `dojo.require()` for the specified
+		//		resource
+		//
+		// example:
+		//	|	dojo.requireIf(dojo.isBrowser, "my.special.Module");
+
+		if(condition){
+			dojo.require(moduleName, omitModuleCheck);
+		}
+	};
+
+	dojo.requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale){
+		require(["../i18n"], function(i18n){
+			i18n.getLocalization(moduleName, bundleName, locale);
+		});
+	};
+
+	return {
+		extractLegacyApiApplications:extractLegacyApiApplications,
+		require:loaderVars.dojoRequirePlugin,
+		loadInit:dojoLoadInitPlugin
+	};
+});
+
+},
+'dojo/json':function(){
+define(["./has"], function(has){
+	"use strict";
+	var hasJSON = typeof JSON != "undefined";
+	has.add("json-parse", hasJSON); // all the parsers work fine
+		// Firefox 3.5/Gecko 1.9 fails to use replacer in stringify properly https://bugzilla.mozilla.org/show_bug.cgi?id=509184
+	has.add("json-stringify", hasJSON && JSON.stringify({a:0}, function(k,v){return v||1;}) == '{"a":1}'); 
+	if(has("json-stringify")){
+		return JSON;
+	}
+	else{
+		var escapeString = function(/*String*/str){
+			//summary:
+			//		Adds escape sequences for non-visual characters, double quote and
+			//		backslash and surrounds with double quotes to form a valid string
+			//		literal.
+			return ('"' + str.replace(/(["\\])/g, '\\$1') + '"').
+				replace(/[\f]/g, "\\f").replace(/[\b]/g, "\\b").replace(/[\n]/g, "\\n").
+				replace(/[\t]/g, "\\t").replace(/[\r]/g, "\\r"); // string
+		};
+		return {
+			parse: has("json-parse") ? JSON.parse : function(str, strict){
+				// summary:
+				// 		Parses a [JSON](http://json.org) string to return a JavaScript object.
+				// description:
+				//		This function follows [native JSON API](https://developer.mozilla.org/en/JSON)
+				// 		Throws for invalid JSON strings. This delegates to eval() if native JSON
+				// 		support is not available. By default this will evaluate any valid JS expression.
+				//		With the strict parameter set to true, the parser will ensure that only
+				//		valid JSON strings are parsed (otherwise throwing an error). Without the strict
+				// 		parameter, the content passed to this method must come
+				//		from a trusted source.
+				// str:
+				//		a string literal of a JSON item, for instance:
+				//			`'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
+				//	strict: 
+				//		When set to true, this will ensure that only valid, secure JSON is ever parsed.
+				// 		Make sure this is set to true for untrusted content. Note that on browsers/engines
+				//		without native JSON support, setting this to true will run slower.
+				if(strict && !/^([\s\[\{]*(?:"(?:\\.|[^"])+"|-?\d[\d\.]*(?:[Ee][+-]?\d+)?|null|true|false|)[\s\]\}]*(?:,|:|$))+$/.test(str)){
+					throw new SyntaxError("Invalid characters in JSON");
+				}
+				return eval('(' + str + ')');
+			},
+			stringify: function(value, replacer, spacer){
+				//	summary:
+				//		Returns a [JSON](http://json.org) serialization of an object.
+				//	description:
+				//		Returns a [JSON](http://json.org) serialization of an object.
+				//		This function follows [native JSON API](https://developer.mozilla.org/en/JSON)
+				//		Note that this doesn't check for infinite recursion, so don't do that!
+				//	value:
+				//		A value to be serialized. 
+				//	replacer:
+				//		A replacer function that is called for each value and can return a replacement
+				//	spacer:
+				//		A spacer string to be used for pretty printing of JSON
+				//		
+				//	example:
+				//		simple serialization of a trivial object
+				//		|	define(["dojo/json"], function(JSON){
+				// 		|		var jsonStr = JSON.stringify({ howdy: "stranger!", isStrange: true });
+				//		|		doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
+				var undef;
+				if(typeof replacer == "string"){
+					spacer = replacer;
+					replacer = null;
+				}
+				function stringify(it, indent, key){
+					if(replacer){
+						it = replacer(key, it);
+					}
+					var val, objtype = typeof it;
+					if(objtype == "number"){
+						return isFinite(it) ? it + "" : "null";
+					}
+					if(objtype == "boolean"){
+						return it + "";
+					}
+					if(it === null){
+						return "null";
+					}
+					if(typeof it == "string"){
+						return escapeString(it);
+					}
+					if(objtype == "function" || objtype == "undefined"){
+						return undef; // undefined
+					}
+					// short-circuit for objects that support "json" serialization
+					// if they return "self" then just pass-through...
+					if(typeof it.toJSON == "function"){
+						return stringify(it.toJSON(key), indent, key);
+					}
+					if(it instanceof Date){
+						return '"{FullYear}-{Month+}-{Date}T{Hours}:{Minutes}:{Seconds}Z"'.replace(/\{(\w+)(\+)?\}/g, function(t, prop, plus){
+							var num = it["getUTC" + prop]() + (plus ? 1 : 0);
+							return num < 10 ? "0" + num : num;
+						});
+					}
+					if(it.valueOf() !== it){
+						// primitive wrapper, try again unwrapped:
+						return stringify(it.valueOf(), indent, key);
+					}
+					var nextIndent= spacer ? (indent + spacer) : "";
+					/* we used to test for DOM nodes and throw, but FF serializes them as {}, so cross-browser consistency is probably not efficiently attainable */ 
+				
+					var sep = spacer ? " " : "";
+					var newLine = spacer ? "\n" : "";
+				
+					// array
+					if(it instanceof Array){
+						var itl = it.length, res = [];
+						for(key = 0; key < itl; key++){
+							var obj = it[key];
+							val = stringify(obj, nextIndent, key);
+							if(typeof val != "string"){
+								val = "null";
+							}
+							res.push(newLine + nextIndent + val);
+						}
+						return "[" + res.join(",") + newLine + indent + "]";
+					}
+					// generic object code path
+					var output = [];
+					for(key in it){
+						var keyStr;
+						if(typeof key == "number"){
+							keyStr = '"' + key + '"';
+						}else if(typeof key == "string"){
+							keyStr = escapeString(key);
+						}else{
+							// skip non-string or number keys
+							continue;
+						}
+						val = stringify(it[key], nextIndent, key);
+						if(typeof val != "string"){
+							// skip non-serializable values
+							continue;
+						}
+						// At this point, the most non-IE browsers don't get in this branch 
+						// (they have native JSON), so push is definitely the way to
+						output.push(newLine + nextIndent + keyStr + ":" + sep + val);
+					}
+					return "{" + output.join(",") + newLine + indent + "}"; // String
+				}
+				return stringify(value, "", "");
+			}
+		};
+	}
+});
+
+},
+'dojo/_base/declare':function(){
+define(["./kernel", "../has", "./lang"], function(dojo, has, lang){
+	// module:
+	//		dojo/_base/declare
+	// summary:
+	//		This module defines dojo.declare.
+
+	var mix = lang.mixin, op = Object.prototype, opts = op.toString,
+		xtor = new Function, counter = 0, cname = "constructor";
+
+	function err(msg, cls){ throw new Error("declare" + (cls ? " " + cls : "") + ": " + msg); }
+
+	// C3 Method Resolution Order (see http://www.python.org/download/releases/2.3/mro/)
+	function c3mro(bases, className){
+		var result = [], roots = [{cls: 0, refs: []}], nameMap = {}, clsCount = 1,
+			l = bases.length, i = 0, j, lin, base, top, proto, rec, name, refs;
+
+		// build a list of bases naming them if needed
+		for(; i < l; ++i){
+			base = bases[i];
+			if(!base){
+				err("mixin #" + i + " is unknown. Did you use dojo.require to pull it in?", className);
+			}else if(opts.call(base) != "[object Function]"){
+				err("mixin #" + i + " is not a callable constructor.", className);
+			}
+			lin = base._meta ? base._meta.bases : [base];
+			top = 0;
+			// add bases to the name map
+			for(j = lin.length - 1; j >= 0; --j){
+				proto = lin[j].prototype;
+				if(!proto.hasOwnProperty("declaredClass")){
+					proto.declaredClass = "uniqName_" + (counter++);
+				}
+				name = proto.declaredClass;
+				if(!nameMap.hasOwnProperty(name)){
+					nameMap[name] = {count: 0, refs: [], cls: lin[j]};
+					++clsCount;
+				}
+				rec = nameMap[name];
+				if(top && top !== rec){
+					rec.refs.push(top);
+					++top.count;
+				}
+				top = rec;
+			}
+			++top.count;
+			roots[0].refs.push(top);
+		}
+
+		// remove classes without external references recursively
+		while(roots.length){
+			top = roots.pop();
+			result.push(top.cls);
+			--clsCount;
+			// optimization: follow a single-linked chain
+			while(refs = top.refs, refs.length == 1){
+				top = refs[0];
+				if(!top || --top.count){
+					// branch or end of chain => do not end to roots
+					top = 0;
+					break;
+				}
+				result.push(top.cls);
+				--clsCount;
+			}
+			if(top){
+				// branch
+				for(i = 0, l = refs.length; i < l; ++i){
+					top = refs[i];
+					if(!--top.count){
+						roots.push(top);
+					}
+				}
+			}
+		}
+		if(clsCount){
+			err("can't build consistent linearization", className);
+		}
+
+		// calculate the superclass offset
+		base = bases[0];
+		result[0] = base ?
+			base._meta && base === result[result.length - base._meta.bases.length] ?
+				base._meta.bases.length : 1 : 0;
+
+		return result;
+	}
+
+	function inherited(args, a, f){
+		var name, chains, bases, caller, meta, base, proto, opf, pos,
+			cache = this._inherited = this._inherited || {};
+
+		// crack arguments
+		if(typeof args == "string"){
+			name = args;
+			args = a;
+			a = f;
+		}
+		f = 0;
+
+		caller = args.callee;
+		name = name || caller.nom;
+		if(!name){
+			err("can't deduce a name to call inherited()", this.declaredClass);
+		}
+
+		meta = this.constructor._meta;
+		bases = meta.bases;
+
+		pos = cache.p;
+		if(name != cname){
+			// method
+			if(cache.c !== caller){
+				// cache bust
+				pos = 0;
+				base = bases[0];
+				meta = base._meta;
+				if(meta.hidden[name] !== caller){
+					// error detection
+					chains = meta.chains;
+					if(chains && typeof chains[name] == "string"){
+						err("calling chained method with inherited: " + name, this.declaredClass);
+					}
+					// find caller
+					do{
+						meta = base._meta;
+						proto = base.prototype;
+						if(meta && (proto[name] === caller && proto.hasOwnProperty(name) || meta.hidden[name] === caller)){
+							break;
+						}
+					}while(base = bases[++pos]); // intentional assignment
+					pos = base ? pos : -1;
+				}
+			}
+			// find next
+			base = bases[++pos];
+			if(base){
+				proto = base.prototype;
+				if(base._meta && proto.hasOwnProperty(name)){
+					f = proto[name];
+				}else{
+					opf = op[name];
+					do{
+						proto = base.prototype;
+						f = proto[name];
+						if(f && (base._meta ? proto.hasOwnProperty(name) : f !== opf)){
+							break;
+						}
+					}while(base = bases[++pos]); // intentional assignment
+				}
+			}
+			f = base && f || op[name];
+		}else{
+			// constructor
+			if(cache.c !== caller){
+				// cache bust
+				pos = 0;
+				meta = bases[0]._meta;
+				if(meta && meta.ctor !== caller){
+					// error detection
+					chains = meta.chains;
+					if(!chains || chains.constructor !== "manual"){
+						err("calling chained constructor with inherited", this.declaredClass);
+					}
+					// find caller
+					while(base = bases[++pos]){ // intentional assignment
+						meta = base._meta;
+						if(meta && meta.ctor === caller){
+							break;
+						}
+					}
+					pos = base ? pos : -1;
+				}
+			}
+			// find next
+			while(base = bases[++pos]){	// intentional assignment
+				meta = base._meta;
+				f = meta ? meta.ctor : base;
+				if(f){
+					break;
+				}
+			}
+			f = base && f;
+		}
+
+		// cache the found super method
+		cache.c = f;
+		cache.p = pos;
+
+		// now we have the result
+		if(f){
+			return a === true ? f : f.apply(this, a || args);
+		}
+		// intentionally no return if a super method was not found
+	}
+
+	function getInherited(name, args){
+		if(typeof name == "string"){
+			return this.__inherited(name, args, true);
+		}
+		return this.__inherited(name, true);
+	}
+
+	function inherited__debug(args, a1, a2){
+		var f = this.getInherited(args, a1);
+		if(f){ return f.apply(this, a2 || a1 || args); }
+		// intentionally no return if a super method was not found
+	}
+
+	var inheritedImpl = dojo.config.isDebug ? inherited__debug : inherited;
+
+	// emulation of "instanceof"
+	function isInstanceOf(cls){
+		var bases = this.constructor._meta.bases;
+		for(var i = 0, l = bases.length; i < l; ++i){
+			if(bases[i] === cls){
+				return true;
+			}
+		}
+		return this instanceof cls;
+	}
+
+	function mixOwn(target, source){
+		// add props adding metadata for incoming functions skipping a constructor
+		for(var name in source){
+			if(name != cname && source.hasOwnProperty(name)){
+				target[name] = source[name];
+			}
+		}
+		if(has("bug-for-in-skips-shadowed")){
+			for(var extraNames= lang._extraNames, i= extraNames.length; i;){
+				name = extraNames[--i];
+				if(name != cname && source.hasOwnProperty(name)){
+					  target[name] = source[name];
+				}
+			}
+		}
+	}
+
+	// implementation of safe mixin function
+	function safeMixin(target, source){
+		var name, t;
+		// add props adding metadata for incoming functions skipping a constructor
+		for(name in source){
+			t = source[name];
+			if((t !== op[name] || !(name in op)) && name != cname){
+				if(opts.call(t) == "[object Function]"){
+					// non-trivial function method => attach its name
+					t.nom = name;
+				}
+				target[name] = t;
+			}
+		}
+		if(has("bug-for-in-skips-shadowed")){
+			for(var extraNames= lang._extraNames, i= extraNames.length; i;){
+				name = extraNames[--i];
+				t = source[name];
+				if((t !== op[name] || !(name in op)) && name != cname){
+					if(opts.call(t) == "[object Function]"){
+						// non-trivial function method => attach its name
+						  t.nom = name;
+					}
+					target[name] = t;
+				}
+			}
+		}
+		return target;
+	}
+
+	function extend(source){
+		declare.safeMixin(this.prototype, source);
+		return this;
+	}
+
+	// chained constructor compatible with the legacy dojo.declare()
+	function chainedConstructor(bases, ctorSpecial){
+		return function(){
+			var a = arguments, args = a, a0 = a[0], f, i, m,
+				l = bases.length, preArgs;
+
+			if(!(this instanceof a.callee)){
+				// not called via new, so force it
+				return applyNew(a);
+			}
+
+			//this._inherited = {};
+			// perform the shaman's rituals of the original dojo.declare()
+			// 1) call two types of the preamble
+			if(ctorSpecial && (a0 && a0.preamble || this.preamble)){
+				// full blown ritual
+				preArgs = new Array(bases.length);
+				// prepare parameters
+				preArgs[0] = a;
+				for(i = 0;;){
+					// process the preamble of the 1st argument
+					a0 = a[0];
+					if(a0){
+						f = a0.preamble;
+						if(f){
+							a = f.apply(this, a) || a;
+						}
+					}
+					// process the preamble of this class
+					f = bases[i].prototype;
+					f = f.hasOwnProperty("preamble") && f.preamble;
+					if(f){
+						a = f.apply(this, a) || a;
+					}
+					// one peculiarity of the preamble:
+					// it is called if it is not needed,
+					// e.g., there is no constructor to call
+					// let's watch for the last constructor
+					// (see ticket #9795)
+					if(++i == l){
+						break;
+					}
+					preArgs[i] = a;
+				}
+			}
+			// 2) call all non-trivial constructors using prepared arguments
+			for(i = l - 1; i >= 0; --i){
+				f = bases[i];
+				m = f._meta;
+				f = m ? m.ctor : f;
+				if(f){
+					f.apply(this, preArgs ? preArgs[i] : a);
+				}
+			}
+			// 3) continue the original ritual: call the postscript
+			f = this.postscript;
+			if(f){
+				f.apply(this, args);
+			}
+		};
+	}
+
+
+	// chained constructor compatible with the legacy dojo.declare()
+	function singleConstructor(ctor, ctorSpecial){
+		return function(){
+			var a = arguments, t = a, a0 = a[0], f;
+
+			if(!(this instanceof a.callee)){
+				// not called via new, so force it
+				return applyNew(a);
+			}
+
+			//this._inherited = {};
+			// perform the shaman's rituals of the original dojo.declare()
+			// 1) call two types of the preamble
+			if(ctorSpecial){
+				// full blown ritual
+				if(a0){
+					// process the preamble of the 1st argument
+					f = a0.preamble;
+					if(f){
+						t = f.apply(this, t) || t;
+					}
+				}
+				f = this.preamble;
+				if(f){
+					// process the preamble of this class
+					f.apply(this, t);
+					// one peculiarity of the preamble:
+					// it is called even if it is not needed,
+					// e.g., there is no constructor to call
+					// let's watch for the last constructor
+					// (see ticket #9795)
+				}
+			}
+			// 2) call a constructor
+			if(ctor){
+				ctor.apply(this, a);
+			}
+			// 3) continue the original ritual: call the postscript
+			f = this.postscript;
+			if(f){
+				f.apply(this, a);
+			}
+		};
+	}
+
+	// plain vanilla constructor (can use inherited() to call its base constructor)
+	function simpleConstructor(bases){
+		return function(){
+			var a = arguments, i = 0, f, m;
+
+			if(!(this instanceof a.callee)){
+				// not called via new, so force it
+				return applyNew(a);
+			}
+
+			//this._inherited = {};
+			// perform the shaman's rituals of the original dojo.declare()
+			// 1) do not call the preamble
+			// 2) call the top constructor (it can use this.inherited())
+			for(; f = bases[i]; ++i){ // intentional assignment
+				m = f._meta;
+				f = m ? m.ctor : f;
+				if(f){
+					f.apply(this, a);
+					break;
+				}
+			}
+			// 3) call the postscript
+			f = this.postscript;
+			if(f){
+				f.apply(this, a);
+			}
+		};
+	}
+
+	function chain(name, bases, reversed){
+		return function(){
+			var b, m, f, i = 0, step = 1;
+			if(reversed){
+				i = bases.length - 1;
+				step = -1;
+			}
+			for(; b = bases[i]; i += step){ // intentional assignment
+				m = b._meta;
+				f = (m ? m.hidden : b.prototype)[name];
+				if(f){
+					f.apply(this, arguments);
+				}
+			}
+		};
+	}
+
+	// forceNew(ctor)
+	// return a new object that inherits from ctor.prototype but
+	// without actually running ctor on the object.
+	function forceNew(ctor){
+		// create object with correct prototype using a do-nothing
+		// constructor
+		xtor.prototype = ctor.prototype;
+		var t = new xtor;
+		xtor.prototype = null;	// clean up
+		return t;
+	}
+
+	// applyNew(args)
+	// just like 'new ctor()' except that the constructor and its arguments come
+	// from args, which must be an array or an arguments object
+	function applyNew(args){
+		// create an object with ctor's prototype but without
+		// calling ctor on it.
+		var ctor = args.callee, t = forceNew(ctor);
+		// execute the real constructor on the new object
+		ctor.apply(t, args);
+		return t;
+	}
+
+	function declare(className, superclass, props){
+		// crack parameters
+		if(typeof className != "string"){
+			props = superclass;
+			superclass = className;
+			className = "";
+		}
+		props = props || {};
+
+		var proto, i, t, ctor, name, bases, chains, mixins = 1, parents = superclass;
+
+		// build a prototype
+		if(opts.call(superclass) == "[object Array]"){
+			// C3 MRO
+			bases = c3mro(superclass, className);
+			t = bases[0];
+			mixins = bases.length - t;
+			superclass = bases[mixins];
+		}else{
+			bases = [0];
+			if(superclass){
+				if(opts.call(superclass) == "[object Function]"){
+					t = superclass._meta;
+					bases = bases.concat(t ? t.bases : superclass);
+				}else{
+					err("base class is not a callable constructor.", className);
+				}
+			}else if(superclass !== null){
+				err("unknown base class. Did you use dojo.require to pull it in?", className);
+			}
+		}
+		if(superclass){
+			for(i = mixins - 1;; --i){
+				proto = forceNew(superclass);
+				if(!i){
+					// stop if nothing to add (the last base)
+					break;
+				}
+				// mix in properties
+				t = bases[i];
+				(t._meta ? mixOwn : mix)(proto, t.prototype);
+				// chain in new constructor
+				ctor = new Function;
+				ctor.superclass = superclass;
+				ctor.prototype = proto;
+				superclass = proto.constructor = ctor;
+			}
+		}else{
+			proto = {};
+		}
+		// add all properties
+		declare.safeMixin(proto, props);
+		// add constructor
+		t = props.constructor;
+		if(t !== op.constructor){
+			t.nom = cname;
+			proto.constructor = t;
+		}
+
+		// collect chains and flags
+		for(i = mixins - 1; i; --i){ // intentional assignment
+			t = bases[i]._meta;
+			if(t && t.chains){
+				chains = mix(chains || {}, t.chains);
+			}
+		}
+		if(proto["-chains-"]){
+			chains = mix(chains || {}, proto["-chains-"]);
+		}
+
+		// build ctor
+		t = !chains || !chains.hasOwnProperty(cname);
+		bases[0] = ctor = (chains && chains.constructor === "manual") ? simpleConstructor(bases) :
+			(bases.length == 1 ? singleConstructor(props.constructor, t) : chainedConstructor(bases, t));
+
+		// add meta information to the constructor
+		ctor._meta  = {bases: bases, hidden: props, chains: chains,
+			parents: parents, ctor: props.constructor};
+		ctor.superclass = superclass && superclass.prototype;
+		ctor.extend = extend;
+		ctor.prototype = proto;
+		proto.constructor = ctor;
+
+		// add "standard" methods to the prototype
+		proto.getInherited = getInherited;
+		proto.isInstanceOf = isInstanceOf;
+		proto.inherited    = inheritedImpl;
+		proto.__inherited  = inherited;
+
+		// add name if specified
+		if(className){
+			proto.declaredClass = className;
+			lang.setObject(className, ctor);
+		}
+
+		// build chains and add them to the prototype
+		if(chains){
+			for(name in chains){
+				if(proto[name] && typeof chains[name] == "string" && name != cname){
+					t = proto[name] = chain(name, bases, chains[name] === "after");
+					t.nom = name;
+				}
+			}
+		}
+		// chained methods do not return values
+		// no need to chain "invisible" functions
+
+		return ctor;	// Function
+	}
+
+	/*=====
+	dojo.declare = function(className, superclass, props){
+		//	summary:
+		//		Create a feature-rich constructor from compact notation.
+		//	className: String?:
+		//		The optional name of the constructor (loosely, a "class")
+		//		stored in the "declaredClass" property in the created prototype.
+		//		It will be used as a global name for a created constructor.
+		//	superclass: Function|Function[]:
+		//		May be null, a Function, or an Array of Functions. This argument
+		//		specifies a list of bases (the left-most one is the most deepest
+		//		base).
+		//	props: Object:
+		//		An object whose properties are copied to the created prototype.
+		//		Add an instance-initialization function by making it a property
+		//		named "constructor".
+		//	returns:
+		//		New constructor function.
+		//	description:
+		//		Create a constructor using a compact notation for inheritance and
+		//		prototype extension.
+		//
+		//		Mixin ancestors provide a type of multiple inheritance.
+		//		Prototypes of mixin ancestors are copied to the new class:
+		//		changes to mixin prototypes will not affect classes to which
+		//		they have been mixed in.
+		//
+		//		Ancestors can be compound classes created by this version of
+		//		dojo.declare. In complex cases all base classes are going to be
+		//		linearized according to C3 MRO algorithm
+		//		(see http://www.python.org/download/releases/2.3/mro/ for more
+		//		details).
+		//
+		//		"className" is cached in "declaredClass" property of the new class,
+		//		if it was supplied. The immediate super class will be cached in
+		//		"superclass" property of the new class.
+		//
+		//		Methods in "props" will be copied and modified: "nom" property
+		//		(the declared name of the method) will be added to all copied
+		//		functions to help identify them for the internal machinery. Be
+		//		very careful, while reusing methods: if you use the same
+		//		function under different names, it can produce errors in some
+		//		cases.
+		//
+		//		It is possible to use constructors created "manually" (without
+		//		dojo.declare) as bases. They will be called as usual during the
+		//		creation of an instance, their methods will be chained, and even
+		//		called by "this.inherited()".
+		//
+		//		Special property "-chains-" governs how to chain methods. It is
+		//		a dictionary, which uses method names as keys, and hint strings
+		//		as values. If a hint string is "after", this method will be
+		//		called after methods of its base classes. If a hint string is
+		//		"before", this method will be called before methods of its base
+		//		classes.
+		//
+		//		If "constructor" is not mentioned in "-chains-" property, it will
+		//		be chained using the legacy mode: using "after" chaining,
+		//		calling preamble() method before each constructor, if available,
+		//		and calling postscript() after all constructors were executed.
+		//		If the hint is "after", it is chained as a regular method, but
+		//		postscript() will be called after the chain of constructors.
+		//		"constructor" cannot be chained "before", but it allows
+		//		a special hint string: "manual", which means that constructors
+		//		are not going to be chained in any way, and programmer will call
+		//		them manually using this.inherited(). In the latter case
+		//		postscript() will be called after the construction.
+		//
+		//		All chaining hints are "inherited" from base classes and
+		//		potentially can be overridden. Be very careful when overriding
+		//		hints! Make sure that all chained methods can work in a proposed
+		//		manner of chaining.
+		//
+		//		Once a method was chained, it is impossible to unchain it. The
+		//		only exception is "constructor". You don't need to define a
+		//		method in order to supply a chaining hint.
+		//
+		//		If a method is chained, it cannot use this.inherited() because
+		//		all other methods in the hierarchy will be called automatically.
+		//
+		//		Usually constructors and initializers of any kind are chained
+		//		using "after" and destructors of any kind are chained as
+		//		"before". Note that chaining assumes that chained methods do not
+		//		return any value: any returned value will be discarded.
+		//
+		//	example:
+		//	|	dojo.declare("my.classes.bar", my.classes.foo, {
+		//	|		// properties to be added to the class prototype
+		//	|		someValue: 2,
+		//	|		// initialization function
+		//	|		constructor: function(){
+		//	|			this.myComplicatedObject = new ReallyComplicatedObject();
+		//	|		},
+		//	|		// other functions
+		//	|		someMethod: function(){
+		//	|			doStuff();
+		//	|		}
+		//	|	});
+		//
+		//	example:
+		//	|	var MyBase = dojo.declare(null, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var MyClass1 = dojo.declare(MyBase, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var MyClass2 = dojo.declare(MyBase, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var MyDiamond = dojo.declare([MyClass1, MyClass2], {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//
+		//	example:
+		//	|	var F = function(){ console.log("raw constructor"); };
+		//	|	F.prototype.method = function(){
+		//	|		console.log("raw method");
+		//	|	};
+		//	|	var A = dojo.declare(F, {
+		//	|		constructor: function(){
+		//	|			console.log("A.constructor");
+		//	|		},
+		//	|		method: function(){
+		//	|			console.log("before calling F.method...");
+		//	|			this.inherited(arguments);
+		//	|			console.log("...back in A");
+		//	|		}
+		//	|	});
+		//	|	new A().method();
+		//	|	// will print:
+		//	|	// raw constructor
+		//	|	// A.constructor
+		//	|	// before calling F.method...
+		//	|	// raw method
+		//	|	// ...back in A
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		"-chains-": {
+		//	|			destroy: "before"
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		constructor: function(){
+		//	|			console.log("B.constructor");
+		//	|		},
+		//	|		destroy: function(){
+		//	|			console.log("B.destroy");
+		//	|		}
+		//	|	});
+		//	|	var C = dojo.declare(B, {
+		//	|		constructor: function(){
+		//	|			console.log("C.constructor");
+		//	|		},
+		//	|		destroy: function(){
+		//	|			console.log("C.destroy");
+		//	|		}
+		//	|	});
+		//	|	new C().destroy();
+		//	|	// prints:
+		//	|	// B.constructor
+		//	|	// C.constructor
+		//	|	// C.destroy
+		//	|	// B.destroy
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		"-chains-": {
+		//	|			constructor: "manual"
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		constructor: function(){
+		//	|			// ...
+		//	|			// call the base constructor with new parameters
+		//	|			this.inherited(arguments, [1, 2, 3]);
+		//	|			// ...
+		//	|		}
+		//	|	});
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		"-chains-": {
+		//	|			m1: "before"
+		//	|		},
+		//	|		m1: function(){
+		//	|			console.log("A.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			console.log("A.m2");
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		"-chains-": {
+		//	|			m2: "after"
+		//	|		},
+		//	|		m1: function(){
+		//	|			console.log("B.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			console.log("B.m2");
+		//	|		}
+		//	|	});
+		//	|	var x = new B();
+		//	|	x.m1();
+		//	|	// prints:
+		//	|	// B.m1
+		//	|	// A.m1
+		//	|	x.m2();
+		//	|	// prints:
+		//	|	// A.m2
+		//	|	// B.m2
+		return new Function(); // Function
+	};
+	=====*/
+
+	/*=====
+	dojo.safeMixin = function(target, source){
+		//	summary:
+		//		Mix in properties skipping a constructor and decorating functions
+		//		like it is done by dojo.declare.
+		//	target: Object
+		//		Target object to accept new properties.
+		//	source: Object
+		//		Source object for new properties.
+		//	description:
+		//		This function is used to mix in properties like lang.mixin does,
+		//		but it skips a constructor property and decorates functions like
+		//		dojo.declare does.
+		//
+		//		It is meant to be used with classes and objects produced with
+		//		dojo.declare. Functions mixed in with dojo.safeMixin can use
+		//		this.inherited() like normal methods.
+		//
+		//		This function is used to implement extend() method of a constructor
+		//		produced with dojo.declare().
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		m1: function(){
+		//	|			console.log("A.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			console.log("A.m2");
+		//	|		}
+		//	|	});
+		//	|	var B = dojo.declare(A, {
+		//	|		m1: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("B.m1");
+		//	|		}
+		//	|	});
+		//	|	B.extend({
+		//	|		m2: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("B.m2");
+		//	|		}
+		//	|	});
+		//	|	var x = new B();
+		//	|	dojo.safeMixin(x, {
+		//	|		m1: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("X.m1");
+		//	|		},
+		//	|		m2: function(){
+		//	|			this.inherited(arguments);
+		//	|			console.log("X.m2");
+		//	|		}
+		//	|	});
+		//	|	x.m2();
+		//	|	// prints:
+		//	|	// A.m1
+		//	|	// B.m1
+		//	|	// X.m1
+	};
+	=====*/
+
+	/*=====
+	Object.inherited = function(name, args, newArgs){
+		//	summary:
+		//		Calls a super method.
+		//	name: String?
+		//		The optional method name. Should be the same as the caller's
+		//		name. Usually "name" is specified in complex dynamic cases, when
+		//		the calling method was dynamically added, undecorated by
+		//		dojo.declare, and it cannot be determined.
+		//	args: Arguments
+		//		The caller supply this argument, which should be the original
+		//		"arguments".
+		//	newArgs: Object?
+		//		If "true", the found function will be returned without
+		//		executing it.
+		//		If Array, it will be used to call a super method. Otherwise
+		//		"args" will be used.
+		//	returns:
+		//		Whatever is returned by a super method, or a super method itself,
+		//		if "true" was specified as newArgs.
+		//	description:
+		//		This method is used inside method of classes produced with
+		//		dojo.declare to call a super method (next in the chain). It is
+		//		used for manually controlled chaining. Consider using the regular
+		//		chaining, because it is faster. Use "this.inherited()" only in
+		//		complex cases.
+		//
+		//		This method cannot me called from automatically chained
+		//		constructors including the case of a special (legacy)
+		//		constructor chaining. It cannot be called from chained methods.
+		//
+		//		If "this.inherited()" cannot find the next-in-chain method, it
+		//		does nothing and returns "undefined". The last method in chain
+		//		can be a default method implemented in Object, which will be
+		//		called last.
+		//
+		//		If "name" is specified, it is assumed that the method that
+		//		received "args" is the parent method for this call. It is looked
+		//		up in the chain list and if it is found the next-in-chain method
+		//		is called. If it is not found, the first-in-chain method is
+		//		called.
+		//
+		//		If "name" is not specified, it will be derived from the calling
+		//		method (using a methoid property "nom").
+		//
+		//	example:
+		//	|	var B = dojo.declare(A, {
+		//	|		method1: function(a, b, c){
+		//	|			this.inherited(arguments);
+		//	|		},
+		//	|		method2: function(a, b){
+		//	|			return this.inherited(arguments, [a + b]);
+		//	|		}
+		//	|	});
+		//	|	// next method is not in the chain list because it is added
+		//	|	// manually after the class was created.
+		//	|	B.prototype.method3 = function(){
+		//	|		console.log("This is a dynamically-added method.");
+		//	|		this.inherited("method3", arguments);
+		//	|	};
+		//	example:
+		//	|	var B = dojo.declare(A, {
+		//	|		method: function(a, b){
+		//	|			var super = this.inherited(arguments, true);
+		//	|			// ...
+		//	|			if(!super){
+		//	|				console.log("there is no super method");
+		//	|				return 0;
+		//	|			}
+		//	|			return super.apply(this, arguments);
+		//	|		}
+		//	|	});
+		return	{};	// Object
+	}
+	=====*/
+
+	/*=====
+	Object.getInherited = function(name, args){
+		//	summary:
+		//		Returns a super method.
+		//	name: String?
+		//		The optional method name. Should be the same as the caller's
+		//		name. Usually "name" is specified in complex dynamic cases, when
+		//		the calling method was dynamically added, undecorated by
+		//		dojo.declare, and it cannot be determined.
+		//	args: Arguments
+		//		The caller supply this argument, which should be the original
+		//		"arguments".
+		//	returns:
+		//		Returns a super method (Function) or "undefined".
+		//	description:
+		//		This method is a convenience method for "this.inherited()".
+		//		It uses the same algorithm but instead of executing a super
+		//		method, it returns it, or "undefined" if not found.
+		//
+		//	example:
+		//	|	var B = dojo.declare(A, {
+		//	|		method: function(a, b){
+		//	|			var super = this.getInherited(arguments);
+		//	|			// ...
+		//	|			if(!super){
+		//	|				console.log("there is no super method");
+		//	|				return 0;
+		//	|			}
+		//	|			return super.apply(this, arguments);
+		//	|		}
+		//	|	});
+		return	{};	// Object
+	}
+	=====*/
+
+	/*=====
+	Object.isInstanceOf = function(cls){
+		//	summary:
+		//		Checks the inheritance chain to see if it is inherited from this
+		//		class.
+		//	cls: Function
+		//		Class constructor.
+		//	returns:
+		//		"true", if this object is inherited from this class, "false"
+		//		otherwise.
+		//	description:
+		//		This method is used with instances of classes produced with
+		//		dojo.declare to determine of they support a certain interface or
+		//		not. It models "instanceof" operator.
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var B = dojo.declare(null, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var C = dojo.declare([A, B], {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|	var D = dojo.declare(A, {
+		//	|		// constructor, properties, and methods go here
+		//	|		// ...
+		//	|	});
+		//	|
+		//	|	var a = new A(), b = new B(), c = new C(), d = new D();
+		//	|
+		//	|	console.log(a.isInstanceOf(A)); // true
+		//	|	console.log(b.isInstanceOf(A)); // false
+		//	|	console.log(c.isInstanceOf(A)); // true
+		//	|	console.log(d.isInstanceOf(A)); // true
+		//	|
+		//	|	console.log(a.isInstanceOf(B)); // false
+		//	|	console.log(b.isInstanceOf(B)); // true
+		//	|	console.log(c.isInstanceOf(B)); // true
+		//	|	console.log(d.isInstanceOf(B)); // false
+		//	|
+		//	|	console.log(a.isInstanceOf(C)); // false
+		//	|	console.log(b.isInstanceOf(C)); // false
+		//	|	console.log(c.isInstanceOf(C)); // true
+		//	|	console.log(d.isInstanceOf(C)); // false
+		//	|
+		//	|	console.log(a.isInstanceOf(D)); // false
+		//	|	console.log(b.isInstanceOf(D)); // false
+		//	|	console.log(c.isInstanceOf(D)); // false
+		//	|	console.log(d.isInstanceOf(D)); // true
+		return	{};	// Object
+	}
+	=====*/
+
+	/*=====
+	Object.extend = function(source){
+		//	summary:
+		//		Adds all properties and methods of source to constructor's
+		//		prototype, making them available to all instances created with
+		//		constructor. This method is specific to constructors created with
+		//		dojo.declare.
+		//	source: Object
+		//		Source object which properties are going to be copied to the
+		//		constructor's prototype.
+		//	description:
+		//		Adds source properties to the constructor's prototype. It can
+		//		override existing properties.
+		//
+		//		This method is similar to dojo.extend function, but it is specific
+		//		to constructors produced by dojo.declare. It is implemented
+		//		using dojo.safeMixin, and it skips a constructor property,
+		//		and properly decorates copied functions.
+		//
+		//	example:
+		//	|	var A = dojo.declare(null, {
+		//	|		m1: function(){},
+		//	|		s1: "Popokatepetl"
+		//	|	});
+		//	|	A.extend({
+		//	|		m1: function(){},
+		//	|		m2: function(){},
+		//	|		f1: true,
+		//	|		d1: 42
+		//	|	});
+	};
+	=====*/
+
+	dojo.safeMixin = declare.safeMixin = safeMixin;
+	dojo.declare = declare;
+
+	return declare;
+});
+
+},
+'dojo/dom':function(){
+define(["./_base/sniff", "./_base/lang", "./_base/window"],
+		function(has, lang, win){
+	// module:
+	//		dojo/dom
+	// summary:
+	//		This module defines the core dojo DOM API.
+
+	// FIXME: need to add unit tests for all the semi-public methods
+
+		try{
+		document.execCommand("BackgroundImageCache", false, true);
+	}catch(e){
+		// sane browsers don't have cache "issues"
+	}
+	
+	// =============================
+	// DOM Functions
+	// =============================
+
+	/*=====
+	dojo.byId = function(id, doc){
+		// summary:
+		//		Returns DOM node with matching `id` attribute or `null`
+		//		if not found. If `id` is a DomNode, this function is a no-op.
+		//
+		// id: String|DOMNode
+		//	 	A string to match an HTML id attribute or a reference to a DOM Node
+		//
+		// doc: Document?
+		//		Document to work in. Defaults to the current value of
+		//		dojo.doc.  Can be used to retrieve
+		//		node references from other documents.
+		//
+		// example:
+		//		Look up a node by ID:
+		//	|	var n = dojo.byId("foo");
+		//
+		// example:
+		//		Check if a node exists, and use it.
+		//	|	var n = dojo.byId("bar");
+		//	|	if(n){ doStuff() ... }
+		//
+		// example:
+		//		Allow string or DomNode references to be passed to a custom function:
+		//	|	var foo = function(nodeOrId){
+		//	|		nodeOrId = dojo.byId(nodeOrId);
+		//	|		// ... more stuff
+		//	|	}
+	=====*/
+
+	/*=====
+	dojo.isDescendant = function(node, ancestor){
+		// summary:
+		//		Returns true if node is a descendant of ancestor
+		// node: DOMNode|String
+		//		string id or node reference to test
+		// ancestor: DOMNode|String
+		//		string id or node reference of potential parent to test against
+		//
+		// example:
+		//		Test is node id="bar" is a descendant of node id="foo"
+		//	|	if(dojo.isDescendant("bar", "foo")){ ... }
+	};
+	=====*/
+
+	// TODO: do we need this function in the base?
+
+	/*=====
+	dojo.setSelectable = function(node, selectable){
+		// summary:
+		//		Enable or disable selection on a node
+		// node: DOMNode|String
+		//		id or reference to node
+		// selectable: Boolean
+		//		state to put the node in. false indicates unselectable, true
+		//		allows selection.
+		// example:
+		//		Make the node id="bar" unselectable
+		//	|	dojo.setSelectable("bar");
+		// example:
+		//		Make the node id="bar" selectable
+		//	|	dojo.setSelectable("bar", true);
+	};
+	=====*/
+
+	var dom = {};   // the result object
+
+		if(has("ie")){
+		dom.byId = function(id, doc){
+			if(typeof id != "string"){
+				return id;
+			}
+			var _d = doc || win.doc, te = id && _d.getElementById(id);
+			// attributes.id.value is better than just id in case the
+			// user has a name=id inside a form
+			if(te && (te.attributes.id.value == id || te.id == id)){
+				return te;
+			}else{
+				var eles = _d.all[id];
+				if(!eles || eles.nodeName){
+					eles = [eles];
+				}
+				// if more than 1, choose first with the correct id
+				var i = 0;
+				while((te = eles[i++])){
+					if((te.attributes && te.attributes.id && te.attributes.id.value == id) || te.id == id){
+						return te;
+					}
+				}
+			}
+		};
+	}else{
+			dom.byId = function(id, doc){
+			// inline'd type check.
+			// be sure to return null per documentation, to match IE branch.
+			return ((typeof id == "string") ? (doc || win.doc).getElementById(id) : id) || null; // DOMNode
+		};
+		}
+		/*=====
+	};
+	=====*/
+
+	dom.isDescendant = function(/*DOMNode|String*/node, /*DOMNode|String*/ancestor){
+		try{
+			node = dom.byId(node);
+			ancestor = dom.byId(ancestor);
+			while(node){
+				if(node == ancestor){
+					return true; // Boolean
+				}
+				node = node.parentNode;
+			}
+		}catch(e){ /* squelch, return false */ }
+		return false; // Boolean
+	};
+
+	// TODO: do we need this function in the base?
+
+	dom.setSelectable = function(/*DOMNode|String*/node, /*Boolean*/selectable){
+		node = dom.byId(node);
+				if(has("mozilla")){
+			node.style.MozUserSelect = selectable ? "" : "none";
+		}else if(has("khtml") || has("webkit")){
+					node.style.KhtmlUserSelect = selectable ? "auto" : "none";
+				}else if(has("ie")){
+			var v = (node.unselectable = selectable ? "" : "on"),
+				cs = node.getElementsByTagName("*"), i = 0, l = cs.length;
+			for(; i < l; ++i){
+				cs.item(i).unselectable = v;
+			}
+		}
+				//FIXME: else?  Opera?
+	};
+
+	return dom;
+});
+
+},
+'dojo/_base/browser':function(){
+if(require.has){
+	require.has.add("config-selectorEngine", "acme");
+}
+define("dojo/_base/browser", [
+	"../ready",
+	"./kernel",
+	"./connect", // until we decide if connect is going back into non-browser environments
+	"./unload",
+	"./window",
+	"./event",
+	"./html",
+	"./NodeList",
+	"../query",
+	"./xhr",
+	"./fx"], function(dojo) {
+	// module:
+	//		dojo/_base/browser
+	// summary:
+	//		This module causes the browser-only base modules to be loaded.
+	return dojo;
+});
+
+},
+'dojo/selector/acme':function(){
+define(["../_base/kernel", "../has", "../dom", "../_base/sniff", "../_base/array", "../_base/lang", "../_base/window"], function(dojo, has, dom){
+  //  module:
+  //    dojo/selector/acme
+  //  summary:
+  //    This module defines the Acme selector engine
+
+/*
+	acme architectural overview:
+
+		acme is a relatively full-featured CSS3 query library. It is
+		designed to take any valid CSS3 selector and return the nodes matching
+		the selector. To do this quickly, it processes queries in several
+		steps, applying caching where profitable.
+
+		The steps (roughly in reverse order of the way they appear in the code):
+			1.) check to see if we already have a "query dispatcher"
+				- if so, use that with the given parameterization. Skip to step 4.
+			2.) attempt to determine which branch to dispatch the query to:
+				- JS (optimized DOM iteration)
+				- native (FF3.1+, Safari 3.1+, IE 8+)
+			3.) tokenize and convert to executable "query dispatcher"
+				- this is where the lion's share of the complexity in the
+					system lies. In the DOM version, the query dispatcher is
+					assembled as a chain of "yes/no" test functions pertaining to
+					a section of a simple query statement (".blah:nth-child(odd)"
+					but not "div div", which is 2 simple statements). Individual
+					statement dispatchers are cached (to prevent re-definition)
+					as are entire dispatch chains (to make re-execution of the
+					same query fast)
+			4.) the resulting query dispatcher is called in the passed scope
+					(by default the top-level document)
+				- for DOM queries, this results in a recursive, top-down
+					evaluation of nodes based on each simple query section
+				- for native implementations, this may mean working around spec
+					bugs. So be it.
+			5.) matched nodes are pruned to ensure they are unique (if necessary)
+*/
+
+
+	////////////////////////////////////////////////////////////////////////
+	// Toolkit aliases
+	////////////////////////////////////////////////////////////////////////
+
+	// if you are extracting acme for use in your own system, you will
+	// need to provide these methods and properties. No other porting should be
+	// necessary, save for configuring the system to use a class other than
+	// dojo.NodeList as the return instance instantiator
+	var trim = 			dojo.trim;
+	var each = 			dojo.forEach;
+	// 					d.isIE; // float
+	// 					d.isSafari; // float
+	// 					d.isOpera; // float
+	// 					d.isWebKit; // float
+	// 					d.doc ; // document element
+
+	var getDoc = function(){ return dojo.doc; };
+	// NOTE(alex): the spec is idiotic. CSS queries should ALWAYS be case-sensitive, but nooooooo
+	var cssCaseBug = ((dojo.isWebKit||dojo.isMozilla) && ((getDoc().compatMode) == "BackCompat"));
+
+	////////////////////////////////////////////////////////////////////////
+	// Global utilities
+	////////////////////////////////////////////////////////////////////////
+
+
+	var specials = ">~+";
+
+	// global thunk to determine whether we should treat the current query as
+	// case sensitive or not. This switch is flipped by the query evaluator
+	// based on the document passed as the context to search.
+	var caseSensitive = false;
+
+	// how high?
+	var yesman = function(){ return true; };
+
+	////////////////////////////////////////////////////////////////////////
+	// Tokenizer
+	////////////////////////////////////////////////////////////////////////
+
+	var getQueryParts = function(query){
+		//	summary:
+		//		state machine for query tokenization
+		//	description:
+		//		instead of using a brittle and slow regex-based CSS parser,
+		//		acme implements an AST-style query representation. This
+		//		representation is only generated once per query. For example,
+		//		the same query run multiple times or under different root nodes
+		//		does not re-parse the selector expression but instead uses the
+		//		cached data structure. The state machine implemented here
+		//		terminates on the last " " (space) character and returns an
+		//		ordered array of query component structures (or "parts"). Each
+		//		part represents an operator or a simple CSS filtering
+		//		expression. The structure for parts is documented in the code
+		//		below.
+
+
+		// NOTE:
+		//		this code is designed to run fast and compress well. Sacrifices
+		//		to readability and maintainability have been made.  Your best
+		//		bet when hacking the tokenizer is to put The Donnas on *really*
+		//		loud (may we recommend their "Spend The Night" release?) and
+		//		just assume you're gonna make mistakes. Keep the unit tests
+		//		open and run them frequently. Knowing is half the battle ;-)
+		if(specials.indexOf(query.slice(-1)) >= 0){
+			// if we end with a ">", "+", or "~", that means we're implicitly
+			// searching all children, so make it explicit
+			query += " * "
+		}else{
+			// if you have not provided a terminator, one will be provided for
+			// you...
+			query += " ";
+		}
+
+		var ts = function(/*Integer*/ s, /*Integer*/ e){
+			// trim and slice.
+
+			// take an index to start a string slice from and an end position
+			// and return a trimmed copy of that sub-string
+			return trim(query.slice(s, e));
+		};
+
+		// the overall data graph of the full query, as represented by queryPart objects
+		var queryParts = [];
+
+
+		// state keeping vars
+		var inBrackets = -1, inParens = -1, inMatchFor = -1,
+			inPseudo = -1, inClass = -1, inId = -1, inTag = -1,
+			lc = "", cc = "", pStart;
+
+		// iteration vars
+		var x = 0, // index in the query
+			ql = query.length,
+			currentPart = null, // data structure representing the entire clause
+			_cp = null; // the current pseudo or attr matcher
+
+		// several temporary variables are assigned to this structure during a
+		// potential sub-expression match:
+		//		attr:
+		//			a string representing the current full attribute match in a
+		//			bracket expression
+		//		type:
+		//			if there's an operator in a bracket expression, this is
+		//			used to keep track of it
+		//		value:
+		//			the internals of parenthetical expression for a pseudo. for
+		//			:nth-child(2n+1), value might be "2n+1"
+
+		var endTag = function(){
+			// called when the tokenizer hits the end of a particular tag name.
+			// Re-sets state variables for tag matching and sets up the matcher
+			// to handle the next type of token (tag or operator).
+			if(inTag >= 0){
+				var tv = (inTag == x) ? null : ts(inTag, x); // .toLowerCase();
+				currentPart[ (specials.indexOf(tv) < 0) ? "tag" : "oper" ] = tv;
+				inTag = -1;
+			}
+		};
+
+		var endId = function(){
+			// called when the tokenizer might be at the end of an ID portion of a match
+			if(inId >= 0){
+				currentPart.id = ts(inId, x).replace(/\\/g, "");
+				inId = -1;
+			}
+		};
+
+		var endClass = function(){
+			// called when the tokenizer might be at the end of a class name
+			// match. CSS allows for multiple classes, so we augment the
+			// current item with another class in its list
+			if(inClass >= 0){
+				currentPart.classes.push(ts(inClass + 1, x).replace(/\\/g, ""));
+				inClass = -1;
+			}
+		};
+
+		var endAll = function(){
+			// at the end of a simple fragment, so wall off the matches
+			endId();
+			endTag();
+			endClass();
+		};
+
+		var endPart = function(){
+			endAll();
+			if(inPseudo >= 0){
+				currentPart.pseudos.push({ name: ts(inPseudo + 1, x) });
+			}
+			// hint to the selector engine to tell it whether or not it
+			// needs to do any iteration. Many simple selectors don't, and
+			// we can avoid significant construction-time work by advising
+			// the system to skip them
+			currentPart.loops = (
+					currentPart.pseudos.length ||
+					currentPart.attrs.length ||
+					currentPart.classes.length	);
+
+			currentPart.oquery = currentPart.query = ts(pStart, x); // save the full expression as a string
+
+
+			// otag/tag are hints to suggest to the system whether or not
+			// it's an operator or a tag. We save a copy of otag since the
+			// tag name is cast to upper-case in regular HTML matches. The
+			// system has a global switch to figure out if the current
+			// expression needs to be case sensitive or not and it will use
+			// otag or tag accordingly
+			currentPart.otag = currentPart.tag = (currentPart["oper"]) ? null : (currentPart.tag || "*");
+
+			if(currentPart.tag){
+				// if we're in a case-insensitive HTML doc, we likely want
+				// the toUpperCase when matching on element.tagName. If we
+				// do it here, we can skip the string op per node
+				// comparison
+				currentPart.tag = currentPart.tag.toUpperCase();
+			}
+
+			// add the part to the list
+			if(queryParts.length && (queryParts[queryParts.length-1].oper)){
+				// operators are always infix, so we remove them from the
+				// list and attach them to the next match. The evaluator is
+				// responsible for sorting out how to handle them.
+				currentPart.infixOper = queryParts.pop();
+				currentPart.query = currentPart.infixOper.query + " " + currentPart.query;
+				/*
+				console.debug(	"swapping out the infix",
+								currentPart.infixOper,
+								"and attaching it to",
+								currentPart);
+				*/
+			}
+			queryParts.push(currentPart);
+
+			currentPart = null;
+		};
+
+		// iterate over the query, character by character, building up a
+		// list of query part objects
+		for(; lc=cc, cc=query.charAt(x), x < ql; x++){
+			//		cc: the current character in the match
+			//		lc: the last character (if any)
+
+			// someone is trying to escape something, so don't try to match any
+			// fragments. We assume we're inside a literal.
+			if(lc == "\\"){ continue; }
+			if(!currentPart){ // a part was just ended or none has yet been created
+				// NOTE: I hate all this alloc, but it's shorter than writing tons of if's
+				pStart = x;
+				//	rules describe full CSS sub-expressions, like:
+				//		#someId
+				//		.className:first-child
+				//	but not:
+				//		thinger > div.howdy[type=thinger]
+				//	the indidual components of the previous query would be
+				//	split into 3 parts that would be represented a structure
+				//	like:
+				//		[
+				//			{
+				//				query: "thinger",
+				//				tag: "thinger",
+				//			},
+				//			{
+				//				query: "div.howdy[type=thinger]",
+				//				classes: ["howdy"],
+				//				infixOper: {
+				//					query: ">",
+				//					oper: ">",
+				//				}
+				//			},
+				//		]
+				currentPart = {
+					query: null, // the full text of the part's rule
+					pseudos: [], // CSS supports multiple pseud-class matches in a single rule
+					attrs: [],	// CSS supports multi-attribute match, so we need an array
+					classes: [], // class matches may be additive, e.g.: .thinger.blah.howdy
+					tag: null,	// only one tag...
+					oper: null, // ...or operator per component. Note that these wind up being exclusive.
+					id: null,	// the id component of a rule
+					getTag: function(){
+						return (caseSensitive) ? this.otag : this.tag;
+					}
+				};
+
+				// if we don't have a part, we assume we're going to start at
+				// the beginning of a match, which should be a tag name. This
+				// might fault a little later on, but we detect that and this
+				// iteration will still be fine.
+				inTag = x;
+			}
+
+			if(inBrackets >= 0){
+				// look for a the close first
+				if(cc == "]"){ // if we're in a [...] clause and we end, do assignment
+					if(!_cp.attr){
+						// no attribute match was previously begun, so we
+						// assume this is an attribute existence match in the
+						// form of [someAttributeName]
+						_cp.attr = ts(inBrackets+1, x);
+					}else{
+						// we had an attribute already, so we know that we're
+						// matching some sort of value, as in [attrName=howdy]
+						_cp.matchFor = ts((inMatchFor||inBrackets+1), x);
+					}
+					var cmf = _cp.matchFor;
+					if(cmf){
+						// try to strip quotes from the matchFor value. We want
+						// [attrName=howdy] to match the same
+						//	as [attrName = 'howdy' ]
+						if(	(cmf.charAt(0) == '"') || (cmf.charAt(0) == "'") ){
+							_cp.matchFor = cmf.slice(1, -1);
+						}
+					}
+					// end the attribute by adding it to the list of attributes.
+					currentPart.attrs.push(_cp);
+					_cp = null; // necessary?
+					inBrackets = inMatchFor = -1;
+				}else if(cc == "="){
+					// if the last char was an operator prefix, make sure we
+					// record it along with the "=" operator.
+					var addToCc = ("|~^$*".indexOf(lc) >=0 ) ? lc : "";
+					_cp.type = addToCc+cc;
+					_cp.attr = ts(inBrackets+1, x-addToCc.length);
+					inMatchFor = x+1;
+				}
+				// now look for other clause parts
+			}else if(inParens >= 0){
+				// if we're in a parenthetical expression, we need to figure
+				// out if it's attached to a pseudo-selector rule like
+				// :nth-child(1)
+				if(cc == ")"){
+					if(inPseudo >= 0){
+						_cp.value = ts(inParens+1, x);
+					}
+					inPseudo = inParens = -1;
+				}
+			}else if(cc == "#"){
+				// start of an ID match
+				endAll();
+				inId = x+1;
+			}else if(cc == "."){
+				// start of a class match
+				endAll();
+				inClass = x;
+			}else if(cc == ":"){
+				// start of a pseudo-selector match
+				endAll();
+				inPseudo = x;
+			}else if(cc == "["){
+				// start of an attribute match.
+				endAll();
+				inBrackets = x;
+				// provide a new structure for the attribute match to fill-in
+				_cp = {
+					/*=====
+					attr: null, type: null, matchFor: null
+					=====*/
+				};
+			}else if(cc == "("){
+				// we really only care if we've entered a parenthetical
+				// expression if we're already inside a pseudo-selector match
+				if(inPseudo >= 0){
+					// provide a new structure for the pseudo match to fill-in
+					_cp = {
+						name: ts(inPseudo+1, x),
+						value: null
+					};
+					currentPart.pseudos.push(_cp);
+				}
+				inParens = x;
+			}else if(
+				(cc == " ") &&
+				// if it's a space char and the last char is too, consume the
+				// current one without doing more work
+				(lc != cc)
+			){
+				endPart();
+			}
+		}
+		return queryParts;
+	};
+
+
+	////////////////////////////////////////////////////////////////////////
+	// DOM query infrastructure
+	////////////////////////////////////////////////////////////////////////
+
+	var agree = function(first, second){
+		// the basic building block of the yes/no chaining system. agree(f1,
+		// f2) generates a new function which returns the boolean results of
+		// both of the passed functions to a single logical-anded result. If
+		// either are not passed, the other is used exclusively.
+		if(!first){ return second; }
+		if(!second){ return first; }
+
+		return function(){
+			return first.apply(window, arguments) && second.apply(window, arguments);
+		}
+	};
+
+	var getArr = function(i, arr){
+		// helps us avoid array alloc when we don't need it
+		var r = arr||[]; // FIXME: should this be 'new d._NodeListCtor()' ?
+		if(i){ r.push(i); }
+		return r;
+	};
+
+	var _isElement = function(n){ return (1 == n.nodeType); };
+
+	// FIXME: need to coalesce _getAttr with defaultGetter
+	var blank = "";
+	var _getAttr = function(elem, attr){
+		if(!elem){ return blank; }
+		if(attr == "class"){
+			return elem.className || blank;
+		}
+		if(attr == "for"){
+			return elem.htmlFor || blank;
+		}
+		if(attr == "style"){
+			return elem.style.cssText || blank;
+		}
+		return (caseSensitive ? elem.getAttribute(attr) : elem.getAttribute(attr, 2)) || blank;
+	};
+
+	var attrs = {
+		"*=": function(attr, value){
+			return function(elem){
+				// E[foo*="bar"]
+				//		an E element whose "foo" attribute value contains
+				//		the substring "bar"
+				return (_getAttr(elem, attr).indexOf(value)>=0);
+			}
+		},
+		"^=": function(attr, value){
+			// E[foo^="bar"]
+			//		an E element whose "foo" attribute value begins exactly
+			//		with the string "bar"
+			return function(elem){
+				return (_getAttr(elem, attr).indexOf(value)==0);
+			}
+		},
+		"$=": function(attr, value){
+			// E[foo$="bar"]
+			//		an E element whose "foo" attribute value ends exactly
+			//		with the string "bar"
+			return function(elem){
+				var ea = " "+_getAttr(elem, attr);
+				return (ea.lastIndexOf(value)==(ea.length-value.length));
+			}
+		},
+		"~=": function(attr, value){
+			// E[foo~="bar"]
+			//		an E element whose "foo" attribute value is a list of
+			//		space-separated values, one of which is exactly equal
+			//		to "bar"
+
+			// return "[contains(concat(' ',@"+attr+",' '), ' "+ value +" ')]";
+			var tval = " "+value+" ";
+			return function(elem){
+				var ea = " "+_getAttr(elem, attr)+" ";
+				return (ea.indexOf(tval)>=0);
+			}
+		},
+		"|=": function(attr, value){
+			// E[hreflang|="en"]
+			//		an E element whose "hreflang" attribute has a
+			//		hyphen-separated list of values beginning (from the
+			//		left) with "en"
+			var valueDash = value+"-";
+			return function(elem){
+				var ea = _getAttr(elem, attr);
+				return (
+					(ea == value) ||
+					(ea.indexOf(valueDash)==0)
+				);
+			}
+		},
+		"=": function(attr, value){
+			return function(elem){
+				return (_getAttr(elem, attr) == value);
+			}
+		}
+	};
+
+	// avoid testing for node type if we can. Defining this in the negative
+	// here to avoid negation in the fast path.
+	var _noNES = (typeof getDoc().firstChild.nextElementSibling == "undefined");
+	var _ns = !_noNES ? "nextElementSibling" : "nextSibling";
+	var _ps = !_noNES ? "previousElementSibling" : "previousSibling";
+	var _simpleNodeTest = (_noNES ? _isElement : yesman);
+
+	var _lookLeft = function(node){
+		// look left
+		while(node = node[_ps]){
+			if(_simpleNodeTest(node)){ return false; }
+		}
+		return true;
+	};
+
+	var _lookRight = function(node){
+		// look right
+		while(node = node[_ns]){
+			if(_simpleNodeTest(node)){ return false; }
+		}
+		return true;
+	};
+
+	var getNodeIndex = function(node){
+		var root = node.parentNode;
+		var i = 0,
+			tret = root.children || root.childNodes,
+			ci = (node["_i"]||-1),
+			cl = (root["_l"]||-1);
+
+		if(!tret){ return -1; }
+		var l = tret.length;
+
+		// we calculate the parent length as a cheap way to invalidate the
+		// cache. It's not 100% accurate, but it's much more honest than what
+		// other libraries do
+		if( cl == l && ci >= 0 && cl >= 0 ){
+			// if it's legit, tag and release
+			return ci;
+		}
+
+		// else re-key things
+		root["_l"] = l;
+		ci = -1;
+		for(var te = root["firstElementChild"]||root["firstChild"]; te; te = te[_ns]){
+			if(_simpleNodeTest(te)){
+				te["_i"] = ++i;
+				if(node === te){
+					// NOTE:
+					//	shortcutting the return at this step in indexing works
+					//	very well for benchmarking but we avoid it here since
+					//	it leads to potential O(n^2) behavior in sequential
+					//	getNodexIndex operations on a previously un-indexed
+					//	parent. We may revisit this at a later time, but for
+					//	now we just want to get the right answer more often
+					//	than not.
+					ci = i;
+				}
+			}
+		}
+		return ci;
+	};
+
+	var isEven = function(elem){
+		return !((getNodeIndex(elem)) % 2);
+	};
+
+	var isOdd = function(elem){
+		return ((getNodeIndex(elem)) % 2);
+	};
+
+	var pseudos = {
+		"checked": function(name, condition){
+			return function(elem){
+				return !!("checked" in elem ? elem.checked : elem.selected);
+			}
+		},
+		"first-child": function(){ return _lookLeft; },
+		"last-child": function(){ return _lookRight; },
+		"only-child": function(name, condition){
+			return function(node){
+				return _lookLeft(node) && _lookRight(node);
+			};
+		},
+		"empty": function(name, condition){
+			return function(elem){
+				// DomQuery and jQuery get this wrong, oddly enough.
+				// The CSS 3 selectors spec is pretty explicit about it, too.
+				var cn = elem.childNodes;
+				var cnl = elem.childNodes.length;
+				// if(!cnl){ return true; }
+				for(var x=cnl-1; x >= 0; x--){
+					var nt = cn[x].nodeType;
+					if((nt === 1)||(nt == 3)){ return false; }
+				}
+				return true;
+			}
+		},
+		"contains": function(name, condition){
+			var cz = condition.charAt(0);
+			if( cz == '"' || cz == "'" ){ //remove quote
+				condition = condition.slice(1, -1);
+			}
+			return function(elem){
+				return (elem.innerHTML.indexOf(condition) >= 0);
+			}
+		},
+		"not": function(name, condition){
+			var p = getQueryParts(condition)[0];
+			var ignores = { el: 1 };
+			if(p.tag != "*"){
+				ignores.tag = 1;
+			}
+			if(!p.classes.length){
+				ignores.classes = 1;
+			}
+			var ntf = getSimpleFilterFunc(p, ignores);
+			return function(elem){
+				return (!ntf(elem));
+			}
+		},
+		"nth-child": function(name, condition){
+			var pi = parseInt;
+			// avoid re-defining function objects if we can
+			if(condition == "odd"){
+				return isOdd;
+			}else if(condition == "even"){
+				return isEven;
+			}
+			// FIXME: can we shorten this?
+			if(condition.indexOf("n") != -1){
+				var tparts = condition.split("n", 2);
+				var pred = tparts[0] ? ((tparts[0] == '-') ? -1 : pi(tparts[0])) : 1;
+				var idx = tparts[1] ? pi(tparts[1]) : 0;
+				var lb = 0, ub = -1;
+				if(pred > 0){
+					if(idx < 0){
+						idx = (idx % pred) && (pred + (idx % pred));
+					}else if(idx>0){
+						if(idx >= pred){
+							lb = idx - idx % pred;
+						}
+						idx = idx % pred;
+					}
+				}else if(pred<0){
+					pred *= -1;
+					// idx has to be greater than 0 when pred is negative;
+					// shall we throw an error here?
+					if(idx > 0){
+						ub = idx;
+						idx = idx % pred;
+					}
+				}
+				if(pred > 0){
+					return function(elem){
+						var i = getNodeIndex(elem);
+						return (i>=lb) && (ub<0 || i<=ub) && ((i % pred) == idx);
+					}
+				}else{
+					condition = idx;
+				}
+			}
+			var ncount = pi(condition);
+			return function(elem){
+				return (getNodeIndex(elem) == ncount);
+			}
+		}
+	};
+
+	var defaultGetter = (dojo.isIE && (dojo.isIE < 9 || dojo.isQuirks)) ? function(cond){
+		var clc = cond.toLowerCase();
+		if(clc == "class"){ cond = "className"; }
+		return function(elem){
+			return (caseSensitive ? elem.getAttribute(cond) : elem[cond]||elem[clc]);
+		}
+	} : function(cond){
+		return function(elem){
+			return (elem && elem.getAttribute && elem.hasAttribute(cond));
+		}
+	};
+
+	var getSimpleFilterFunc = function(query, ignores){
+		// generates a node tester function based on the passed query part. The
+		// query part is one of the structures generated by the query parser
+		// when it creates the query AST. The "ignores" object specifies which
+		// (if any) tests to skip, allowing the system to avoid duplicating
+		// work where it may have already been taken into account by other
+		// factors such as how the nodes to test were fetched in the first
+		// place
+		if(!query){ return yesman; }
+		ignores = ignores||{};
+
+		var ff = null;
+
+		if(!("el" in ignores)){
+			ff = agree(ff, _isElement);
+		}
+
+		if(!("tag" in ignores)){
+			if(query.tag != "*"){
+				ff = agree(ff, function(elem){
+					return (elem && (elem.tagName == query.getTag()));
+				});
+			}
+		}
+
+		if(!("classes" in ignores)){
+			each(query.classes, function(cname, idx, arr){
+				// get the class name
+				/*
+				var isWildcard = cname.charAt(cname.length-1) == "*";
+				if(isWildcard){
+					cname = cname.substr(0, cname.length-1);
+				}
+				// I dislike the regex thing, even if memoized in a cache, but it's VERY short
+				var re = new RegExp("(?:^|\\s)" + cname + (isWildcard ? ".*" : "") + "(?:\\s|$)");
+				*/
+				var re = new RegExp("(?:^|\\s)" + cname + "(?:\\s|$)");
+				ff = agree(ff, function(elem){
+					return re.test(elem.className);
+				});
+				ff.count = idx;
+			});
+		}
+
+		if(!("pseudos" in ignores)){
+			each(query.pseudos, function(pseudo){
+				var pn = pseudo.name;
+				if(pseudos[pn]){
+					ff = agree(ff, pseudos[pn](pn, pseudo.value));
+				}
+			});
+		}
+
+		if(!("attrs" in ignores)){
+			each(query.attrs, function(attr){
+				var matcher;
+				var a = attr.attr;
+				// type, attr, matchFor
+				if(attr.type && attrs[attr.type]){
+					matcher = attrs[attr.type](a, attr.matchFor);
+				}else if(a.length){
+					matcher = defaultGetter(a);
+				}
+				if(matcher){
+					ff = agree(ff, matcher);
+				}
+			});
+		}
+
+		if(!("id" in ignores)){
+			if(query.id){
+				ff = agree(ff, function(elem){
+					return (!!elem && (elem.id == query.id));
+				});
+			}
+		}
+
+		if(!ff){
+			if(!("default" in ignores)){
+				ff = yesman;
+			}
+		}
+		return ff;
+	};
+
+	var _nextSibling = function(filterFunc){
+		return function(node, ret, bag){
+			while(node = node[_ns]){
+				if(_noNES && (!_isElement(node))){ continue; }
+				if(
+					(!bag || _isUnique(node, bag)) &&
+					filterFunc(node)
+				){
+					ret.push(node);
+				}
+				break;
+			}
+			return ret;
+		}
+	};
+
+	var _nextSiblings = function(filterFunc){
+		return function(root, ret, bag){
+			var te = root[_ns];
+			while(te){
+				if(_simpleNodeTest(te)){
+					if(bag && !_isUnique(te, bag)){
+						break;
+					}
+					if(filterFunc(te)){
+						ret.push(te);
+					}
+				}
+				te = te[_ns];
+			}
+			return ret;
+		}
+	};
+
+	// get an array of child *elements*, skipping text and comment nodes
+	var _childElements = function(filterFunc){
+		filterFunc = filterFunc||yesman;
+		return function(root, ret, bag){
+			// get an array of child elements, skipping text and comment nodes
+			var te, x = 0, tret = root.children || root.childNodes;
+			while(te = tret[x++]){
+				if(
+					_simpleNodeTest(te) &&
+					(!bag || _isUnique(te, bag)) &&
+					(filterFunc(te, x))
+				){
+					ret.push(te);
+				}
+			}
+			return ret;
+		};
+	};
+
+	/*
+	// thanks, Dean!
+	var itemIsAfterRoot = d.isIE ? function(item, root){
+		return (item.sourceIndex > root.sourceIndex);
+	} : function(item, root){
+		return (item.compareDocumentPosition(root) == 2);
+	};
+	*/
+
+	// test to see if node is below root
+	var _isDescendant = function(node, root){
+		var pn = node.parentNode;
+		while(pn){
+			if(pn == root){
+				break;
+			}
+			pn = pn.parentNode;
+		}
+		return !!pn;
+	};
+
+	var _getElementsFuncCache = {};
+
+	var getElementsFunc = function(query){
+		var retFunc = _getElementsFuncCache[query.query];
+		// if we've got a cached dispatcher, just use that
+		if(retFunc){ return retFunc; }
+		// else, generate a new on
+
+		// NOTE:
+		//		this function returns a function that searches for nodes and
+		//		filters them.  The search may be specialized by infix operators
+		//		(">", "~", or "+") else it will default to searching all
+		//		descendants (the " " selector). Once a group of children is
+		//		found, a test function is applied to weed out the ones we
+		//		don't want. Many common cases can be fast-pathed. We spend a
+		//		lot of cycles to create a dispatcher that doesn't do more work
+		//		than necessary at any point since, unlike this function, the
+		//		dispatchers will be called every time. The logic of generating
+		//		efficient dispatchers looks like this in pseudo code:
+		//
+		//		# if it's a purely descendant query (no ">", "+", or "~" modifiers)
+		//		if infixOperator == " ":
+		//			if only(id):
+		//				return def(root):
+		//					return d.byId(id, root);
+		//
+		//			elif id:
+		//				return def(root):
+		//					return filter(d.byId(id, root));
+		//
+		//			elif cssClass && getElementsByClassName:
+		//				return def(root):
+		//					return filter(root.getElementsByClassName(cssClass));
+		//
+		//			elif only(tag):
+		//				return def(root):
+		//					return root.getElementsByTagName(tagName);
+		//
+		//			else:
+		//				# search by tag name, then filter
+		//				return def(root):
+		//					return filter(root.getElementsByTagName(tagName||"*"));
+		//
+		//		elif infixOperator == ">":
+		//			# search direct children
+		//			return def(root):
+		//				return filter(root.children);
+		//
+		//		elif infixOperator == "+":
+		//			# search next sibling
+		//			return def(root):
+		//				return filter(root.nextElementSibling);
+		//
+		//		elif infixOperator == "~":
+		//			# search rightward siblings
+		//			return def(root):
+		//				return filter(nextSiblings(root));
+
+		var io = query.infixOper;
+		var oper = (io ? io.oper : "");
+		// the default filter func which tests for all conditions in the query
+		// part. This is potentially inefficient, so some optimized paths may
+		// re-define it to test fewer things.
+		var filterFunc = getSimpleFilterFunc(query, { el: 1 });
+		var qt = query.tag;
+		var wildcardTag = ("*" == qt);
+		var ecs = getDoc()["getElementsByClassName"];
+
+		if(!oper){
+			// if there's no infix operator, then it's a descendant query. ID
+			// and "elements by class name" variants can be accelerated so we
+			// call them out explicitly:
+			if(query.id){
+				// testing shows that the overhead of yesman() is acceptable
+				// and can save us some bytes vs. re-defining the function
+				// everywhere.
+				filterFunc = (!query.loops && wildcardTag) ?
+					yesman :
+					getSimpleFilterFunc(query, { el: 1, id: 1 });
+
+				retFunc = function(root, arr){
+					var te = dom.byId(query.id, (root.ownerDocument||root));
+					if(!te || !filterFunc(te)){ return; }
+					if(9 == root.nodeType){ // if root's a doc, we just return directly
+						return getArr(te, arr);
+					}else{ // otherwise check ancestry
+						if(_isDescendant(te, root)){
+							return getArr(te, arr);
+						}
+					}
+				}
+			}else if(
+				ecs &&
+				// isAlien check. Workaround for Prototype.js being totally evil/dumb.
+				/\{\s*\[native code\]\s*\}/.test(String(ecs)) &&
+				query.classes.length &&
+				!cssCaseBug
+			){
+				// it's a class-based query and we've got a fast way to run it.
+
+				// ignore class and ID filters since we will have handled both
+				filterFunc = getSimpleFilterFunc(query, { el: 1, classes: 1, id: 1 });
+				var classesString = query.classes.join(" ");
+				retFunc = function(root, arr, bag){
+					var ret = getArr(0, arr), te, x=0;
+					var tret = root.getElementsByClassName(classesString);
+					while((te = tret[x++])){
+						if(filterFunc(te, root) && _isUnique(te, bag)){
+							ret.push(te);
+						}
+					}
+					return ret;
+				};
+
+			}else if(!wildcardTag && !query.loops){
+				// it's tag only. Fast-path it.
+				retFunc = function(root, arr, bag){
+					var ret = getArr(0, arr), te, x=0;
+					var tret = root.getElementsByTagName(query.getTag());
+					while((te = tret[x++])){
+						if(_isUnique(te, bag)){
+							ret.push(te);
+						}
+					}
+					return ret;
+				};
+			}else{
+				// the common case:
+				//		a descendant selector without a fast path. By now it's got
+				//		to have a tag selector, even if it's just "*" so we query
+				//		by that and filter
+				filterFunc = getSimpleFilterFunc(query, { el: 1, tag: 1, id: 1 });
+				retFunc = function(root, arr, bag){
+					var ret = getArr(0, arr), te, x=0;
+					// we use getTag() to avoid case sensitivity issues
+					var tret = root.getElementsByTagName(query.getTag());
+					while((te = tret[x++])){
+						if(filterFunc(te, root) && _isUnique(te, bag)){
+							ret.push(te);
+						}
+					}
+					return ret;
+				};
+			}
+		}else{
+			// the query is scoped in some way. Instead of querying by tag we
+			// use some other collection to find candidate nodes
+			var skipFilters = { el: 1 };
+			if(wildcardTag){
+				skipFilters.tag = 1;
+			}
+			filterFunc = getSimpleFilterFunc(query, skipFilters);
+			if("+" == oper){
+				retFunc = _nextSibling(filterFunc);
+			}else if("~" == oper){
+				retFunc = _nextSiblings(filterFunc);
+			}else if(">" == oper){
+				retFunc = _childElements(filterFunc);
+			}
+		}
+		// cache it and return
+		return _getElementsFuncCache[query.query] = retFunc;
+	};
+
+	var filterDown = function(root, queryParts){
+		// NOTE:
+		//		this is the guts of the DOM query system. It takes a list of
+		//		parsed query parts and a root and finds children which match
+		//		the selector represented by the parts
+		var candidates = getArr(root), qp, x, te, qpl = queryParts.length, bag, ret;
+
+		for(var i = 0; i < qpl; i++){
+			ret = [];
+			qp = queryParts[i];
+			x = candidates.length - 1;
+			if(x > 0){
+				// if we have more than one root at this level, provide a new
+				// hash to use for checking group membership but tell the
+				// system not to post-filter us since we will already have been
+				// gauranteed to be unique
+				bag = {};
+				ret.nozip = true;
+			}
+			var gef = getElementsFunc(qp);
+			for(var j = 0; (te = candidates[j]); j++){
+				// for every root, get the elements that match the descendant
+				// selector, adding them to the "ret" array and filtering them
+				// via membership in this level's bag. If there are more query
+				// parts, then this level's return will be used as the next
+				// level's candidates
+				gef(te, ret, bag);
+			}
+			if(!ret.length){ break; }
+			candidates = ret;
+		}
+		return ret;
+	};
+
+	////////////////////////////////////////////////////////////////////////
+	// the query runner
+	////////////////////////////////////////////////////////////////////////
+
+	// these are the primary caches for full-query results. The query
+	// dispatcher functions are generated then stored here for hash lookup in
+	// the future
+	var _queryFuncCacheDOM = {},
+		_queryFuncCacheQSA = {};
+
+	// this is the second level of spliting, from full-length queries (e.g.,
+	// "div.foo .bar") into simple query expressions (e.g., ["div.foo",
+	// ".bar"])
+	var getStepQueryFunc = function(query){
+		var qparts = getQueryParts(trim(query));
+
+		// if it's trivial, avoid iteration and zipping costs
+		if(qparts.length == 1){
+			// we optimize this case here to prevent dispatch further down the
+			// chain, potentially slowing things down. We could more elegantly
+			// handle this in filterDown(), but it's slower for simple things
+			// that need to be fast (e.g., "#someId").
+			var tef = getElementsFunc(qparts[0]);
+			return function(root){
+				var r = tef(root, []);
+				if(r){ r.nozip = true; }
+				return r;
+			}
+		}
+
+		// otherwise, break it up and return a runner that iterates over the parts recursively
+		return function(root){
+			return filterDown(root, qparts);
+		}
+	};
+
+	// NOTES:
+	//	* we can't trust QSA for anything but document-rooted queries, so
+	//	  caching is split into DOM query evaluators and QSA query evaluators
+	//	* caching query results is dirty and leak-prone (or, at a minimum,
+	//	  prone to unbounded growth). Other toolkits may go this route, but
+	//	  they totally destroy their own ability to manage their memory
+	//	  footprint. If we implement it, it should only ever be with a fixed
+	//	  total element reference # limit and an LRU-style algorithm since JS
+	//	  has no weakref support. Caching compiled query evaluators is also
+	//	  potentially problematic, but even on large documents the size of the
+	//	  query evaluators is often < 100 function objects per evaluator (and
+	//	  LRU can be applied if it's ever shown to be an issue).
+	//	* since IE's QSA support is currently only for HTML documents and even
+	//	  then only in IE 8's "standards mode", we have to detect our dispatch
+	//	  route at query time and keep 2 separate caches. Ugg.
+
+	// we need to determine if we think we can run a given query via
+	// querySelectorAll or if we'll need to fall back on DOM queries to get
+	// there. We need a lot of information about the environment and the query
+	// to make the determiniation (e.g. does it support QSA, does the query in
+	// question work in the native QSA impl, etc.).
+	var nua = navigator.userAgent;
+	// some versions of Safari provided QSA, but it was buggy and crash-prone.
+	// We need te detect the right "internal" webkit version to make this work.
+	var wk = "WebKit/";
+	var is525 = (
+		dojo.isWebKit &&
+		(nua.indexOf(wk) > 0) &&
+		(parseFloat(nua.split(wk)[1]) > 528)
+	);
+
+	// IE QSA queries may incorrectly include comment nodes, so we throw the
+	// zipping function into "remove" comments mode instead of the normal "skip
+	// it" which every other QSA-clued browser enjoys
+	var noZip = dojo.isIE ? "commentStrip" : "nozip";
+
+	var qsa = "querySelectorAll";
+	var qsaAvail = (
+		!!getDoc()[qsa] &&
+		// see #5832
+		(!dojo.isSafari || (dojo.isSafari > 3.1) || is525 )
+	);
+
+	//Don't bother with n+3 type of matches, IE complains if we modify those.
+	var infixSpaceRe = /n\+\d|([^ ])?([>~+])([^ =])?/g;
+	var infixSpaceFunc = function(match, pre, ch, post){
+		return ch ? (pre ? pre + " " : "") + ch + (post ? " " + post : "") : /*n+3*/ match;
+	};
+
+	var getQueryFunc = function(query, forceDOM){
+		//Normalize query. The CSS3 selectors spec allows for omitting spaces around
+		//infix operators, >, ~ and +
+		//Do the work here since detection for spaces is used as a simple "not use QSA"
+		//test below.
+		query = query.replace(infixSpaceRe, infixSpaceFunc);
+
+		if(qsaAvail){
+			// if we've got a cached variant and we think we can do it, run it!
+			var qsaCached = _queryFuncCacheQSA[query];
+			if(qsaCached && !forceDOM){ return qsaCached; }
+		}
+
+		// else if we've got a DOM cached variant, assume that we already know
+		// all we need to and use it
+		var domCached = _queryFuncCacheDOM[query];
+		if(domCached){ return domCached; }
+
+		// TODO:
+		//		today we're caching DOM and QSA branches separately so we
+		//		recalc useQSA every time. If we had a way to tag root+query
+		//		efficiently, we'd be in good shape to do a global cache.
+
+		var qcz = query.charAt(0);
+		var nospace = (-1 == query.indexOf(" "));
+
+		// byId searches are wicked fast compared to QSA, even when filtering
+		// is required
+		if( (query.indexOf("#") >= 0) && (nospace) ){
+			forceDOM = true;
+		}
+
+		var useQSA = (
+			qsaAvail && (!forceDOM) &&
+			// as per CSS 3, we can't currently start w/ combinator:
+			//		http://www.w3.org/TR/css3-selectors/#w3cselgrammar
+			(specials.indexOf(qcz) == -1) &&
+			// IE's QSA impl sucks on pseudos
+			(!dojo.isIE || (query.indexOf(":") == -1)) &&
+
+			(!(cssCaseBug && (query.indexOf(".") >= 0))) &&
+
+			// FIXME:
+			//		need to tighten up browser rules on ":contains" and "|=" to
+			//		figure out which aren't good
+			//		Latest webkit (around 531.21.8) does not seem to do well with :checked on option
+			//		elements, even though according to spec, selected options should
+			//		match :checked. So go nonQSA for it:
+			//		http://bugs.dojotoolkit.org/ticket/5179
+			(query.indexOf(":contains") == -1) && (query.indexOf(":checked") == -1) &&
+			(query.indexOf("|=") == -1) // some browsers don't grok it
+		);
+
+		// TODO:
+		//		if we've got a descendant query (e.g., "> .thinger" instead of
+		//		just ".thinger") in a QSA-able doc, but are passed a child as a
+		//		root, it should be possible to give the item a synthetic ID and
+		//		trivially rewrite the query to the form "#synid > .thinger" to
+		//		use the QSA branch
+
+
+		if(useQSA){
+			var tq = (specials.indexOf(query.charAt(query.length-1)) >= 0) ?
+						(query + " *") : query;
+			return _queryFuncCacheQSA[query] = function(root){
+				try{
+					// the QSA system contains an egregious spec bug which
+					// limits us, effectively, to only running QSA queries over
+					// entire documents.  See:
+					//		http://ejohn.org/blog/thoughts-on-queryselectorall/
+					//	despite this, we can also handle QSA runs on simple
+					//	selectors, but we don't want detection to be expensive
+					//	so we're just checking for the presence of a space char
+					//	right now. Not elegant, but it's cheaper than running
+					//	the query parser when we might not need to
+					if(!((9 == root.nodeType) || nospace)){ throw ""; }
+					var r = root[qsa](tq);
+					// skip expensive duplication checks and just wrap in a NodeList
+					r[noZip] = true;
+					return r;
+				}catch(e){
+					// else run the DOM branch on this query, ensuring that we
+					// default that way in the future
+					return getQueryFunc(query, true)(root);
+				}
+			}
+		}else{
+			// DOM branch
+			var parts = query.split(/\s*,\s*/);
+			return _queryFuncCacheDOM[query] = ((parts.length < 2) ?
+				// if not a compound query (e.g., ".foo, .bar"), cache and return a dispatcher
+				getStepQueryFunc(query) :
+				// if it *is* a complex query, break it up into its
+				// constituent parts and return a dispatcher that will
+				// merge the parts when run
+				function(root){
+					var pindex = 0, // avoid array alloc for every invocation
+						ret = [],
+						tp;
+					while((tp = parts[pindex++])){
+						ret = ret.concat(getStepQueryFunc(tp)(root));
+					}
+					return ret;
+				}
+			);
+		}
+	};
+
+	var _zipIdx = 0;
+
+	// NOTE:
+	//		this function is Moo inspired, but our own impl to deal correctly
+	//		with XML in IE
+	var _nodeUID = dojo.isIE ? function(node){
+		if(caseSensitive){
+			// XML docs don't have uniqueID on their nodes
+			return (node.getAttribute("_uid") || node.setAttribute("_uid", ++_zipIdx) || _zipIdx);
+
+		}else{
+			return node.uniqueID;
+		}
+	} :
+	function(node){
+		return (node._uid || (node._uid = ++_zipIdx));
+	};
+
+	// determine if a node in is unique in a "bag". In this case we don't want
+	// to flatten a list of unique items, but rather just tell if the item in
+	// question is already in the bag. Normally we'd just use hash lookup to do
+	// this for us but IE's DOM is busted so we can't really count on that. On
+	// the upside, it gives us a built in unique ID function.
+	var _isUnique = function(node, bag){
+		if(!bag){ return 1; }
+		var id = _nodeUID(node);
+		if(!bag[id]){ return bag[id] = 1; }
+		return 0;
+	};
+
+	// attempt to efficiently determine if an item in a list is a dupe,
+	// returning a list of "uniques", hopefully in doucment order
+	var _zipIdxName = "_zipIdx";
+	var _zip = function(arr){
+		if(arr && arr.nozip){
+			return arr;
+		}
+		var ret = [];
+		if(!arr || !arr.length){ return ret; }
+		if(arr[0]){
+			ret.push(arr[0]);
+		}
+		if(arr.length < 2){ return ret; }
+
+		_zipIdx++;
+
+		// we have to fork here for IE and XML docs because we can't set
+		// expandos on their nodes (apparently). *sigh*
+		if(dojo.isIE && caseSensitive){
+			var szidx = _zipIdx+"";
+			arr[0].setAttribute(_zipIdxName, szidx);
+			for(var x = 1, te; te = arr[x]; x++){
+				if(arr[x].getAttribute(_zipIdxName) != szidx){
+					ret.push(te);
+				}
+				te.setAttribute(_zipIdxName, szidx);
+			}
+		}else if(dojo.isIE && arr.commentStrip){
+			try{
+				for(var x = 1, te; te = arr[x]; x++){
+					if(_isElement(te)){
+						ret.push(te);
+					}
+				}
+			}catch(e){ /* squelch */ }
+		}else{
+			if(arr[0]){ arr[0][_zipIdxName] = _zipIdx; }
+			for(var x = 1, te; te = arr[x]; x++){
+				if(arr[x][_zipIdxName] != _zipIdx){
+					ret.push(te);
+				}
+				te[_zipIdxName] = _zipIdx;
+			}
+		}
+		return ret;
+	};
+
+	// the main executor
+	var query = function(/*String*/ query, /*String|DOMNode?*/ root){
+		//	summary:
+		//		Returns nodes which match the given CSS3 selector, searching the
+		//		entire document by default but optionally taking a node to scope
+		//		the search by. Returns an array.
+		//	description:
+		//		dojo.query() is the swiss army knife of DOM node manipulation in
+		//		Dojo. Much like Prototype's "$$" (bling-bling) function or JQuery's
+		//		"$" function, dojo.query provides robust, high-performance
+		//		CSS-based node selector support with the option of scoping searches
+		//		to a particular sub-tree of a document.
+		//
+		//		Supported Selectors:
+		//		--------------------
+		//
+		//		acme supports a rich set of CSS3 selectors, including:
+		//
+		//			* class selectors (e.g., `.foo`)
+		//			* node type selectors like `span`
+		//			* ` ` descendant selectors
+		//			* `>` child element selectors
+		//			* `#foo` style ID selectors
+		//			* `*` universal selector
+		//			* `~`, the preceded-by sibling selector
+		//			* `+`, the immediately preceded-by sibling selector
+		//			* attribute queries:
+		//			|	* `[foo]` attribute presence selector
+		//			|	* `[foo='bar']` attribute value exact match
+		//			|	* `[foo~='bar']` attribute value list item match
+		//			|	* `[foo^='bar']` attribute start match
+		//			|	* `[foo$='bar']` attribute end match
+		//			|	* `[foo*='bar']` attribute substring match
+		//			* `:first-child`, `:last-child`, and `:only-child` positional selectors
+		//			* `:empty` content emtpy selector
+		//			* `:checked` pseudo selector
+		//			* `:nth-child(n)`, `:nth-child(2n+1)` style positional calculations
+		//			* `:nth-child(even)`, `:nth-child(odd)` positional selectors
+		//			* `:not(...)` negation pseudo selectors
+		//
+		//		Any legal combination of these selectors will work with
+		//		`dojo.query()`, including compound selectors ("," delimited).
+		//		Very complex and useful searches can be constructed with this
+		//		palette of selectors and when combined with functions for
+		//		manipulation presented by dojo.NodeList, many types of DOM
+		//		manipulation operations become very straightforward.
+		//
+		//		Unsupported Selectors:
+		//		----------------------
+		//
+		//		While dojo.query handles many CSS3 selectors, some fall outside of
+		//		what's reasonable for a programmatic node querying engine to
+		//		handle. Currently unsupported selectors include:
+		//
+		//			* namespace-differentiated selectors of any form
+		//			* all `::` pseduo-element selectors
+		//			* certain pseduo-selectors which don't get a lot of day-to-day use:
+		//			|	* `:root`, `:lang()`, `:target`, `:focus`
+		//			* all visual and state selectors:
+		//			|	* `:root`, `:active`, `:hover`, `:visisted`, `:link`,
+		//				  `:enabled`, `:disabled`
+		//			* `:*-of-type` pseudo selectors
+		//
+		//		dojo.query and XML Documents:
+		//		-----------------------------
+		//
+		//		`dojo.query` (as of dojo 1.2) supports searching XML documents
+		//		in a case-sensitive manner. If an HTML document is served with
+		//		a doctype that forces case-sensitivity (e.g., XHTML 1.1
+		//		Strict), dojo.query() will detect this and "do the right
+		//		thing". Case sensitivity is dependent upon the document being
+		//		searched and not the query used. It is therefore possible to
+		//		use case-sensitive queries on strict sub-documents (iframes,
+		//		etc.) or XML documents while still assuming case-insensitivity
+		//		for a host/root document.
+		//
+		//		Non-selector Queries:
+		//		---------------------
+		//
+		//		If something other than a String is passed for the query,
+		//		`dojo.query` will return a new `dojo.NodeList` instance
+		//		constructed from that parameter alone and all further
+		//		processing will stop. This means that if you have a reference
+		//		to a node or NodeList, you can quickly construct a new NodeList
+		//		from the original by calling `dojo.query(node)` or
+		//		`dojo.query(list)`.
+		//
+		//	query:
+		//		The CSS3 expression to match against. For details on the syntax of
+		//		CSS3 selectors, see <http://www.w3.org/TR/css3-selectors/#selectors>
+		//	root:
+		//		A DOMNode (or node id) to scope the search from. Optional.
+		//	returns: Array
+		//	example:
+		//		search the entire document for elements with the class "foo":
+		//	|	dojo.query(".foo");
+		//		these elements will match:
+		//	|	<span class="foo"></span>
+		//	|	<span class="foo bar"></span>
+		//	|	<p class="thud foo"></p>
+		//	example:
+		//		search the entire document for elements with the classes "foo" *and* "bar":
+		//	|	dojo.query(".foo.bar");
+		//		these elements will match:
+		//	|	<span class="foo bar"></span>
+		//		while these will not:
+		//	|	<span class="foo"></span>
+		//	|	<p class="thud foo"></p>
+		//	example:
+		//		find `<span>` elements which are descendants of paragraphs and
+		//		which have a "highlighted" class:
+		//	|	dojo.query("p span.highlighted");
+		//		the innermost span in this fragment matches:
+		//	|	<p class="foo">
+		//	|		<span>...
+		//	|			<span class="highlighted foo bar">...</span>
+		//	|		</span>
+		//	|	</p>
+		//	example:
+		//		set an "odd" class on all odd table rows inside of the table
+		//		`#tabular_data`, using the `>` (direct child) selector to avoid
+		//		affecting any nested tables:
+		//	|	dojo.query("#tabular_data > tbody > tr:nth-child(odd)").addClass("odd");
+		//	example:
+		//		remove all elements with the class "error" from the document
+		//		and store them in a list:
+		//	|	var errors = dojo.query(".error").orphan();
+		//	example:
+		//		add an onclick handler to every submit button in the document
+		//		which causes the form to be sent via Ajax instead:
+		//	|	dojo.query("input[type='submit']").onclick(function(e){
+		//	|		dojo.stopEvent(e); // prevent sending the form
+		//	|		var btn = e.target;
+		//	|		dojo.xhrPost({
+		//	|			form: btn.form,
+		//	|			load: function(data){
+		//	|				// replace the form with the response
+		//	|				var div = dojo.doc.createElement("div");
+		//	|				dojo.place(div, btn.form, "after");
+		//	|				div.innerHTML = data;
+		//	|				dojo.style(btn.form, "display", "none");
+		//	|			}
+		//	|		});
+		//	|	});
+
+		root = root||getDoc();
+		var od = root.ownerDocument||root.documentElement;
+
+		// throw the big case sensitivity switch
+
+		// NOTE:
+		//		Opera in XHTML mode doesn't detect case-sensitivity correctly
+		//		and it's not clear that there's any way to test for it
+		caseSensitive = (root.contentType && root.contentType=="application/xml") ||
+						(dojo.isOpera && (root.doctype || od.toString() == "[object XMLDocument]")) ||
+						(!!od) &&
+				(dojo.isIE ? od.xml : (root.xmlVersion || od.xmlVersion));
+
+		// NOTE:
+		//		adding "true" as the 2nd argument to getQueryFunc is useful for
+		//		testing the DOM branch without worrying about the
+		//		behavior/performance of the QSA branch.
+		var r = getQueryFunc(query)(root);
+
+		// FIXME:
+		//		need to investigate this branch WRT #8074 and #8075
+		if(r && r.nozip){
+			return r;
+		}
+		return _zip(r); // dojo.NodeList
+	};
+	query.filter = function(/*Node[]*/ nodeList, /*String*/ filter, /*String|DOMNode?*/ root){
+		// summary:
+		// 		function for filtering a NodeList based on a selector, optimized for simple selectors
+		var tmpNodeList = [],
+			parts = getQueryParts(filter),
+			filterFunc =
+				(parts.length == 1 && !/[^\w#\.]/.test(filter)) ?
+				getSimpleFilterFunc(parts[0]) :
+				function(node){
+					return dojo.query(filter, root).indexOf(node) != -1;
+				};
+		for(var x = 0, te; te = nodeList[x]; x++){
+			if(filterFunc(te)){ tmpNodeList.push(te); }
+		}
+		return tmpNodeList;
+	};
+	return query;
+});//end defineQuery
+
+},
+'dojo/dom-style':function(){
+define(["./_base/sniff", "./dom"], function(has, dom){
+	// module:
+	//		dojo/dom-style
+	// summary:
+	//		This module defines the core dojo DOM style API.
+
+	// =============================
+	// Style Functions
+	// =============================
+
+	// getComputedStyle drives most of the style code.
+	// Wherever possible, reuse the returned object.
+	//
+	// API functions below that need to access computed styles accept an
+	// optional computedStyle parameter.
+	// If this parameter is omitted, the functions will call getComputedStyle themselves.
+	// This way, calling code can access computedStyle once, and then pass the reference to
+	// multiple API functions.
+
+	/*=====
+	dojo.getComputedStyle = function(node){
+		// summary:
+		//		Returns a "computed style" object.
+		//
+		// description:
+		//		Gets a "computed style" object which can be used to gather
+		//		information about the current state of the rendered node.
+		//
+		//		Note that this may behave differently on different browsers.
+		//		Values may have different formats and value encodings across
+		//		browsers.
+		//
+		//		Note also that this method is expensive.  Wherever possible,
+		//		reuse the returned object.
+		//
+		//		Use the dojo.style() method for more consistent (pixelized)
+		//		return values.
+		//
+		// node: DOMNode
+		//		A reference to a DOM node. Does NOT support taking an
+		//		ID string for speed reasons.
+		// example:
+		//	|	dojo.getComputedStyle(dojo.byId('foo')).borderWidth;
+		//
+		// example:
+		//		Reusing the returned object, avoiding multiple lookups:
+		//	|	var cs = dojo.getComputedStyle(dojo.byId("someNode"));
+		//	|	var w = cs.width, h = cs.height;
+		return; // CSS2Properties
+	}
+	=====*/
+
+	/*=====
+	dojo.toPixelValue = function(node, value){
+		// summary:
+		//      converts style value to pixels on IE or return a numeric value.
+		// node: DOMNode
+		// value: String
+		// returns: Number
+	};
+	=====*/
+
+	/*=====
+	dojo._toPixelValue = function(node, value){
+		// summary:
+		//		Existing alias for `dojo._toPixelValue`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getStyle = function(node, name){
+		// summary:
+		//		Accesses styles on a node.
+		// description:
+		//		Getting the style value uses the computed style for the node, so the value
+		//		will be a calculated value, not just the immediate node.style value.
+		//		Also when getting values, use specific style names,
+		//		like "borderBottomWidth" instead of "border" since compound values like
+		//		"border" are not necessarily reflected as expected.
+		//		If you want to get node dimensions, use `dojo.marginBox()`,
+		//		`dojo.contentBox()` or `dojo.position()`.
+		// node: DOMNode|String
+		//		id or reference to node to get style for
+		// name: String?
+		//		the style property to get
+		// example:
+		//		Passing only an ID or node returns the computed style object of
+		//		the node:
+		//	|	dojo.getStyle("thinger");
+		// example:
+		//		Passing a node and a style property returns the current
+		//		normalized, computed value for that property:
+		//	|	dojo.getStyle("thinger", "opacity"); // 1 by default
+	};
+	=====*/
+
+	/*=====
+	dojo.setStyle = function(node, name, value){
+		// summary:
+		//		Sets styles on a node.
+		// node: DOMNode|String
+		//		id or reference to node to set style for
+		// name: String|Object
+		//		the style property to set in DOM-accessor format
+		//		("borderWidth", not "border-width") or an object with key/value
+		//		pairs suitable for setting each property.
+		// value: String?
+		//		If passed, sets value on the node for style, handling
+		//		cross-browser concerns.  When setting a pixel value,
+		//		be sure to include "px" in the value. For instance, top: "200px".
+		//		Otherwise, in some cases, some browsers will not apply the style.
+		//
+		// example:
+		//		Passing a node, a style property, and a value changes the
+		//		current display of the node and returns the new computed value
+		//	|	dojo.setStyle("thinger", "opacity", 0.5); // == 0.5
+		//
+		// example:
+		//		Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
+		//	|	dojo.setStyle("thinger", {
+		//	|		"opacity": 0.5,
+		//	|		"border": "3px solid black",
+		//	|		"height": "300px"
+		//	|	});
+		//
+		// example:
+		//		When the CSS style property is hyphenated, the JavaScript property is camelCased.
+		//		font-size becomes fontSize, and so on.
+		//	|	dojo.setStyle("thinger",{
+		//	|		fontSize:"14pt",
+		//	|		letterSpacing:"1.2em"
+		//	|	});
+		//
+		// example:
+		//		dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
+		//		dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()`
+		//	|	dojo.query(".someClassName").style("visibility","hidden");
+		//	|	// or
+		//	|	dojo.query("#baz > div").style({
+		//	|		opacity:0.75,
+		//	|		fontSize:"13pt"
+		//	|	});
+	};
+	=====*/
+
+	// Although we normally eschew argument validation at this
+	// level, here we test argument 'node' for (duck)type,
+	// by testing nodeType, ecause 'document' is the 'parentNode' of 'body'
+	// it is frequently sent to this function even
+	// though it is not Element.
+	var getComputedStyle, style = {};
+		if(has("webkit")){
+			getComputedStyle = function(/*DomNode*/node){
+			var s;
+			if(node.nodeType == 1){
+				var dv = node.ownerDocument.defaultView;
+				s = dv.getComputedStyle(node, null);
+				if(!s && node.style){
+					node.style.display = "";
+					s = dv.getComputedStyle(node, null);
+				}
+			}
+			return s || {};
+		};
+		}else if(has("ie") && (has("ie") < 9 || has("quirks"))){
+		getComputedStyle = function(node){
+			// IE (as of 7) doesn't expose Element like sane browsers
+			return node.nodeType == 1 /* ELEMENT_NODE*/ ? node.currentStyle : {};
+		};
+	}else{
+		getComputedStyle = function(node){
+			return node.nodeType == 1 ?
+				node.ownerDocument.defaultView.getComputedStyle(node, null) : {};
+		};
+	}
+		style.getComputedStyle = getComputedStyle;
+
+	var toPixel;
+		if(!has("ie")){
+			toPixel = function(element, value){
+			// style values can be floats, client code may want
+			// to round for integer pixels.
+			return parseFloat(value) || 0;
+		};
+		}else{
+		toPixel = function(element, avalue){
+			if(!avalue){ return 0; }
+			// on IE7, medium is usually 4 pixels
+			if(avalue == "medium"){ return 4; }
+			// style values can be floats, client code may
+			// want to round this value for integer pixels.
+			if(avalue.slice && avalue.slice(-2) == 'px'){ return parseFloat(avalue); }
+			var s = element.style, rs = element.runtimeStyle, cs = element.currentStyle,
+				sLeft = s.left, rsLeft = rs.left;
+			rs.left = cs.left;
+			try{
+				// 'avalue' may be incompatible with style.left, which can cause IE to throw
+				// this has been observed for border widths using "thin", "medium", "thick" constants
+				// those particular constants could be trapped by a lookup
+				// but perhaps there are more
+				s.left = avalue;
+				avalue = s.pixelLeft;
+			}catch(e){
+				avalue = 0;
+			}
+			s.left = sLeft;
+			rs.left = rsLeft;
+			return avalue;
+		}
+	}
+		style.toPixelValue = toPixel;
+
+	// FIXME: there opacity quirks on FF that we haven't ported over. Hrm.
+
+		var astr = "DXImageTransform.Microsoft.Alpha";
+	var af = function(n, f){
+		try{
+			return n.filters.item(astr);
+		}catch(e){
+			return f ? {} : null;
+		}
+	};
+
+		var _getOpacity =
+			has("ie") < 9 || (has("ie") && has("quirks")) ? function(node){
+			try{
+				return af(node).Opacity / 100; // Number
+			}catch(e){
+				return 1; // Number
+			}
+		} :
+			function(node){
+			return getComputedStyle(node).opacity;
+		};
+
+	var _setOpacity =
+				has("ie") < 9 || (has("ie") && has("quirks")) ? function(/*DomNode*/node, /*Number*/opacity){
+			var ov = opacity * 100, opaque = opacity == 1;
+			node.style.zoom = opaque ? "" : 1;
+
+			if(!af(node)){
+				if(opaque){
+					return opacity;
+				}
+				node.style.filter += " progid:" + astr + "(Opacity=" + ov + ")";
+			}else{
+				af(node, 1).Opacity = ov;
+			}
+
+			// on IE7 Alpha(Filter opacity=100) makes text look fuzzy so disable it altogether (bug #2661),
+			//but still update the opacity value so we can get a correct reading if it is read later.
+			af(node, 1).Enabled = !opaque;
+
+			if(node.tagName.toLowerCase() == "tr"){
+				for(var td = node.firstChild; td; td = td.nextSibling){
+					if(td.tagName.toLowerCase() == "td"){
+						_setOpacity(td, opacity);
+					}
+				}
+			}
+			return opacity;
+		} :
+				function(node, opacity){
+			return node.style.opacity = opacity;
+		};
+
+	var _pixelNamesCache = {
+		left: true, top: true
+	};
+	var _pixelRegExp = /margin|padding|width|height|max|min|offset/; // |border
+	function _toStyleValue(node, type, value){
+		//TODO: should we really be doing string case conversion here? Should we cache it? Need to profile!
+		type = type.toLowerCase();
+				if(has("ie")){
+			if(value == "auto"){
+				if(type == "height"){ return node.offsetHeight; }
+				if(type == "width"){ return node.offsetWidth; }
+			}
+			if(type == "fontweight"){
+				switch(value){
+					case 700: return "bold";
+					case 400:
+					default: return "normal";
+				}
+			}
+		}
+				if(!(type in _pixelNamesCache)){
+			_pixelNamesCache[type] = _pixelRegExp.test(type);
+		}
+		return _pixelNamesCache[type] ? toPixel(node, value) : value;
+	}
+
+	var _floatStyle = has("ie") ? "styleFloat" : "cssFloat",
+		_floatAliases = {"cssFloat": _floatStyle, "styleFloat": _floatStyle, "float": _floatStyle};
+
+	// public API
+
+	style.get = function getStyle(/*DOMNode|String*/ node, /*String?*/ name){
+		var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
+		if(l == 2 && op){
+			return _getOpacity(n);
+		}
+		name = _floatAliases[name] || name;
+		var s = style.getComputedStyle(n);
+		return (l == 1) ? s : _toStyleValue(n, name, s[name] || n.style[name]); /* CSS2Properties||String||Number */
+	};
+
+	style.set = function setStyle(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
+		var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
+		name = _floatAliases[name] || name;
+		if(l == 3){
+			return op ? _setOpacity(n, value) : n.style[name] = value; // Number
+		}
+		for(var x in name){
+			style.set(node, x, name[x]);
+		}
+		return style.getComputedStyle(n);
+	};
+
+	return style;
+});
+
+},
+'dojo/dom-geometry':function(){
+define(["./_base/sniff", "./_base/window","./dom", "./dom-style"],
+		function(has, win, dom, style){
+	// module:
+	//		dojo/dom-geometry
+	// summary:
+	//		This module defines the core dojo DOM geometry API.
+
+	var geom = {};  // the result object
+
+	// Box functions will assume this model.
+	// On IE/Opera, BORDER_BOX will be set if the primary document is in quirks mode.
+	// Can be set to change behavior of box setters.
+
+	// can be either:
+	//	"border-box"
+	//	"content-box" (default)
+	geom.boxModel = "content-box";
+
+	// We punt per-node box mode testing completely.
+	// If anybody cares, we can provide an additional (optional) unit
+	// that overrides existing code to include per-node box sensitivity.
+
+	// Opera documentation claims that Opera 9 uses border-box in BackCompat mode.
+	// but experiments (Opera 9.10.8679 on Windows Vista) indicate that it actually continues to use content-box.
+	// IIRC, earlier versions of Opera did in fact use border-box.
+	// Opera guys, this is really confusing. Opera being broken in quirks mode is not our fault.
+
+		if(has("ie") /*|| has("opera")*/){
+		// client code may have to adjust if compatMode varies across iframes
+		geom.boxModel = document.compatMode == "BackCompat" ? "border-box" : "content-box";
+	}
+	
+	// =============================
+	// Box Functions
+	// =============================
+
+	/*=====
+	dojo.getPadExtents = function(node, computedStyle){
+		// summary:
+		//		Returns object with special values specifically useful for node
+		//		fitting.
+		// description:
+		//		Returns an object with `w`, `h`, `l`, `t` properties:
+		//	|		l/t/r/b = left/top/right/bottom padding (respectively)
+		//	|		w = the total of the left and right padding
+		//	|		h = the total of the top and bottom padding
+		//		If 'node' has position, l/t forms the origin for child nodes.
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+
+
+	};
+	=====*/
+
+	/*=====
+	dojo._getPadExtents = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getPadExtents`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getBorderExtents = function(node, computedStyle){
+		// summary:
+		//		returns an object with properties useful for noting the border
+		//		dimensions.
+		// description:
+		//		* l/t/r/b = the sum of left/top/right/bottom border (respectively)
+		//		* w = the sum of the left and right border
+		//		* h = the sum of the top and bottom border
+		//
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+
+
+	};
+	=====*/
+
+	/*=====
+	dojo._getBorderExtents = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getBorderExtents`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getPadBorderExtents = function(node, computedStyle){
+		// summary:
+		//		Returns object with properties useful for box fitting with
+		//		regards to padding.
+		// description:
+		//		* l/t/r/b = the sum of left/top/right/bottom padding and left/top/right/bottom border (respectively)
+		//		* w = the sum of the left and right padding and border
+		//		* h = the sum of the top and bottom padding and border
+		//
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+
+
+	};
+	=====*/
+
+	/*=====
+	dojo._getPadBorderExtents = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getPadBorderExtents`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getMarginExtents = function(node, computedStyle){
+		// summary:
+		//		returns object with properties useful for box fitting with
+		//		regards to box margins (i.e., the outer-box).
+		//
+		//		* l/t = marginLeft, marginTop, respectively
+		//		* w = total width, margin inclusive
+		//		* h = total height, margin inclusive
+		//
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo._getMarginExtents = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getMarginExtents`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getMarginSize = function(node, computedStyle){
+		// summary:
+		//		returns an object that encodes the width and height of
+		//		the node's margin box
+		// node: DOMNode|String
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo._getMarginSize = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getMarginSize`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getMarginBox = function(node, computedStyle){
+		// summary:
+		//		returns an object that encodes the width, height, left and top
+		//		positions of the node's margin box.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo._getMarginBox = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getMarginBox`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.setMarginBox = function(node, box, computedStyle){
+		// summary:
+		//		sets the size of the node's margin box and placement
+		//		(left/top), irrespective of box model. Think of it as a
+		//		passthrough to setBox that handles box-model vagaries for
+		//		you.
+		// node: DOMNode
+		// box: Object
+		//      hash with optional "l", "t", "w", and "h" properties for "left", "right", "width", and "height"
+		//      respectively. All specified properties should have numeric values in whole pixels.
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo.getContentBox = function(node, computedStyle){
+		// summary:
+		//		Returns an object that encodes the width, height, left and top
+		//		positions of the node's content box, irrespective of the
+		//		current box model.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo._getContentBox = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getContentBox`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.setContentSize = function(node, box, computedStyle){
+		// summary:
+		//		Sets the size of the node's contents, irrespective of margins,
+		//		padding, or borders.
+		// node: DOMNode
+		// box: Object
+		//      hash with optional "w", and "h" properties for "width", and "height"
+		//      respectively. All specified properties should have numeric values in whole pixels.
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo.isBodyLtr = function(){
+		// summary:
+		//      Returns true if the current language is left-to-right, and false otherwise.
+		// returns: Boolean
+	};
+	=====*/
+
+	/*=====
+	dojo._isBodyLtr = function(){
+		// summary:
+		//		Existing alias for `dojo.isBodyLtr`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.docScroll = function(){
+		// summary:
+		//      Returns an object with {node, x, y} with corresponding offsets.
+		// returns: Object
+	};
+	=====*/
+
+	/*=====
+	dojo._docScroll = function(){
+		// summary:
+		//		Existing alias for `dojo.docScroll`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getIeDocumentElementOffset = function(){
+		// summary:
+		//		returns the offset in x and y from the document body to the
+		//		visual edge of the page for IE
+		// description:
+		//		The following values in IE contain an offset:
+		//	|		event.clientX
+		//	|		event.clientY
+		//	|		node.getBoundingClientRect().left
+		//	|		node.getBoundingClientRect().top
+		//		But other position related values do not contain this offset,
+		//		such as node.offsetLeft, node.offsetTop, node.style.left and
+		//		node.style.top. The offset is always (2, 2) in LTR direction.
+		//		When the body is in RTL direction, the offset counts the width
+		//		of left scroll bar's width.  This function computes the actual
+		//		offset.
+	};
+	=====*/
+
+	/*=====
+	dojo._getIeDocumentElementOffset = function(){
+		// summary:
+		//		Existing alias for `dojo.getIeDocumentElementOffset`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.fixIeBiDiScrollLeft = function(scrollLeft){
+		// summary:
+		//      In RTL direction, scrollLeft should be a negative value, but IE
+		//      returns a positive one. All codes using documentElement.scrollLeft
+		//      must call this function to fix this error, otherwise the position
+		//      will offset to right when there is a horizontal scrollbar.
+		// scrollLeft: NUmber
+		// returns: Number
+	};
+	=====*/
+
+	/*=====
+	dojo._fixIeBiDiScrollLeft = function(scrollLeft){
+		// summary:
+		//		Existing alias for `dojo.fixIeBiDiScrollLeft`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.position = function(node, includeScroll){
+		// summary:
+		//		Gets the position and size of the passed element relative to
+		//		the viewport (if includeScroll==false), or relative to the
+		//		document root (if includeScroll==true).
+		//
+		// description:
+		//		Returns an object of the form:
+		//			{ x: 100, y: 300, w: 20, h: 15 }
+		//		If includeScroll==true, the x and y values will include any
+		//		document offsets that may affect the position relative to the
+		//		viewport.
+		//		Uses the border-box model (inclusive of border and padding but
+		//		not margin).  Does not act as a setter.
+		// node: DOMNode|String
+		// includeScroll: Boolean?
+		// returns: Object
+	};
+	=====*/
+
+	geom.getPadExtents = function getPadExtents(/*DomNode*/node, /*Object*/computedStyle){
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), px = style.toPixelValue,
+			l = px(node, s.paddingLeft), t = px(node, s.paddingTop), r = px(node, s.paddingRight), b = px(node, s.paddingBottom);
+		return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+	};
+
+	var none = "none";
+
+	geom.getBorderExtents = function getBorderExtents(/*DomNode*/node, /*Object*/computedStyle){
+		node = dom.byId(node);
+		var px = style.toPixelValue, s = computedStyle || style.getComputedStyle(node),
+			l = s.borderLeftStyle != none ? px(node, s.borderLeftWidth) : 0,
+			t = s.borderTopStyle != none ? px(node, s.borderTopWidth) : 0,
+			r = s.borderRightStyle != none ? px(node, s.borderRightWidth) : 0,
+			b = s.borderBottomStyle != none ? px(node, s.borderBottomWidth) : 0;
+		return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+	};
+
+	geom.getPadBorderExtents = function getPadBorderExtents(/*DomNode*/node, /*Object*/computedStyle){
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node),
+			p = geom.getPadExtents(node, s),
+			b = geom.getBorderExtents(node, s);
+		return {
+			l: p.l + b.l,
+			t: p.t + b.t,
+			r: p.r + b.r,
+			b: p.b + b.b,
+			w: p.w + b.w,
+			h: p.h + b.h
+		};
+	};
+
+	geom.getMarginExtents = function getMarginExtents(node, computedStyle){
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), px = style.toPixelValue,
+			l = px(node, s.marginLeft), t = px(node, s.marginTop), r = px(node, s.marginRight), b = px(node, s.marginBottom);
+		if(has("webkit") && (s.position != "absolute")){
+			// FIXME: Safari's version of the computed right margin
+			// is the space between our right edge and the right edge
+			// of our offsetParent.
+			// What we are looking for is the actual margin value as
+			// determined by CSS.
+			// Hack solution is to assume left/right margins are the same.
+			r = l;
+		}
+		return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+	};
+
+	// Box getters work in any box context because offsetWidth/clientWidth
+	// are invariant wrt box context
+	//
+	// They do *not* work for display: inline objects that have padding styles
+	// because the user agent ignores padding (it's bogus styling in any case)
+	//
+	// Be careful with IMGs because they are inline or block depending on
+	// browser and browser mode.
+
+	// Although it would be easier to read, there are not separate versions of
+	// _getMarginBox for each browser because:
+	// 1. the branching is not expensive
+	// 2. factoring the shared code wastes cycles (function call overhead)
+	// 3. duplicating the shared code wastes bytes
+
+	geom.getMarginBox = function getMarginBox(/*DomNode*/node, /*Object*/computedStyle){
+		// summary:
+		//		returns an object that encodes the width, height, left and top
+		//		positions of the node's margin box.
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), me = geom.getMarginExtents(node, s),
+			l = node.offsetLeft - me.l, t = node.offsetTop - me.t, p = node.parentNode, px = style.toPixelValue, pcs;
+				if(has("mozilla")){
+			// Mozilla:
+			// If offsetParent has a computed overflow != visible, the offsetLeft is decreased
+			// by the parent's border.
+			// We don't want to compute the parent's style, so instead we examine node's
+			// computed left/top which is more stable.
+			var sl = parseFloat(s.left), st = parseFloat(s.top);
+			if(!isNaN(sl) && !isNaN(st)){
+				l = sl, t = st;
+			}else{
+				// If child's computed left/top are not parseable as a number (e.g. "auto"), we
+				// have no choice but to examine the parent's computed style.
+				if(p && p.style){
+					pcs = style.getComputedStyle(p);
+					if(pcs.overflow != "visible"){
+						l += pcs.borderLeftStyle != none ? px(node, pcs.borderLeftWidth) : 0;
+						t += pcs.borderTopStyle != none ? px(node, pcs.borderTopWidth) : 0;
+					}
+				}
+			}
+		}else if(has("opera") || (has("ie") == 8 && !has("quirks"))){
+			// On Opera and IE 8, offsetLeft/Top includes the parent's border
+			if(p){
+				pcs = style.getComputedStyle(p);
+				l -= pcs.borderLeftStyle != none ? px(node, pcs.borderLeftWidth) : 0;
+				t -= pcs.borderTopStyle != none ? px(node, pcs.borderTopWidth) : 0;
+			}
+		}
+				return {l: l, t: t, w: node.offsetWidth + me.w, h: node.offsetHeight + me.h};
+	};
+
+	geom.getContentBox = function getContentBox(node, computedStyle){
+		// clientWidth/Height are important since the automatically account for scrollbars
+		// fallback to offsetWidth/Height for special cases (see #3378)
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), w = node.clientWidth, h,
+			pe = geom.getPadExtents(node, s), be = geom.getBorderExtents(node, s);
+		if(!w){
+			w = node.offsetWidth;
+			h = node.offsetHeight;
+		}else{
+			h = node.clientHeight;
+			be.w = be.h = 0;
+		}
+		// On Opera, offsetLeft includes the parent's border
+				if(has("opera")){
+			pe.l += be.l;
+			pe.t += be.t;
+		}
+				return {l: pe.l, t: pe.t, w: w - pe.w - be.w, h: h - pe.h - be.h};
+	};
+
+	// Box setters depend on box context because interpretation of width/height styles
+	// vary wrt box context.
+	//
+	// The value of dojo.boxModel is used to determine box context.
+	// dojo.boxModel can be set directly to change behavior.
+	//
+	// Beware of display: inline objects that have padding styles
+	// because the user agent ignores padding (it's a bogus setup anyway)
+	//
+	// Be careful with IMGs because they are inline or block depending on
+	// browser and browser mode.
+	//
+	// Elements other than DIV may have special quirks, like built-in
+	// margins or padding, or values not detectable via computedStyle.
+	// In particular, margins on TABLE do not seems to appear
+	// at all in computedStyle on Mozilla.
+
+	function setBox(/*DomNode*/node, /*Number?*/l, /*Number?*/t, /*Number?*/w, /*Number?*/h, /*String?*/u){
+		// summary:
+		//		sets width/height/left/top in the current (native) box-model
+		//		dimensions. Uses the unit passed in u.
+		// node:
+		//		DOM Node reference. Id string not supported for performance
+		//		reasons.
+		// l:
+		//		left offset from parent.
+		// t:
+		//		top offset from parent.
+		// w:
+		//		width in current box model.
+		// h:
+		//		width in current box model.
+		// u:
+		//		unit measure to use for other measures. Defaults to "px".
+		u = u || "px";
+		var s = node.style;
+		if(!isNaN(l)){
+			s.left = l + u;
+		}
+		if(!isNaN(t)){
+			s.top = t + u;
+		}
+		if(w >= 0){
+			s.width = w + u;
+		}
+		if(h >= 0){
+			s.height = h + u;
+		}
+	}
+
+	function isButtonTag(/*DomNode*/node){
+		// summary:
+		//		True if the node is BUTTON or INPUT.type="button".
+		return node.tagName.toLowerCase() == "button" ||
+			node.tagName.toLowerCase() == "input" && (node.getAttribute("type") || "").toLowerCase() == "button"; // boolean
+	}
+
+	function usesBorderBox(/*DomNode*/node){
+		// summary:
+		//		True if the node uses border-box layout.
+
+		// We could test the computed style of node to see if a particular box
+		// has been specified, but there are details and we choose not to bother.
+
+		// TABLE and BUTTON (and INPUT type=button) are always border-box by default.
+		// If you have assigned a different box to either one via CSS then
+		// box functions will break.
+
+		return geom.boxModel == "border-box" || node.tagName.toLowerCase() == "table" || isButtonTag(node); // boolean
+	}
+
+	geom.setContentSize = function setContentSize(/*DomNode*/node, /*Object*/box, /*Object*/computedStyle){
+		// summary:
+		//		Sets the size of the node's contents, irrespective of margins,
+		//		padding, or borders.
+
+		node = dom.byId(node);
+		var w = box.w, h = box.h;
+		if(usesBorderBox(node)){
+			var pb = geom.getPadBorderExtents(node, computedStyle);
+			if(w >= 0){
+				w += pb.w;
+			}
+			if(h >= 0){
+				h += pb.h;
+			}
+		}
+		setBox(node, NaN, NaN, w, h);
+	};
+
+	var nilExtents = {l: 0, t: 0, w: 0, h: 0};
+
+	geom.setMarginBox = function setMarginBox(/*DomNode*/node, /*Object*/box, /*Object*/computedStyle){
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), w = box.w, h = box.h,
+		// Some elements have special padding, margin, and box-model settings.
+		// To use box functions you may need to set padding, margin explicitly.
+		// Controlling box-model is harder, in a pinch you might set dojo.boxModel.
+			pb = usesBorderBox(node) ? nilExtents : geom.getPadBorderExtents(node, s),
+			mb = geom.getMarginExtents(node, s);
+		if(has("webkit")){
+			// on Safari (3.1.2), button nodes with no explicit size have a default margin
+			// setting an explicit size eliminates the margin.
+			// We have to swizzle the width to get correct margin reading.
+			if(isButtonTag(node)){
+				var ns = node.style;
+				if(w >= 0 && !ns.width){
+					ns.width = "4px";
+				}
+				if(h >= 0 && !ns.height){
+					ns.height = "4px";
+				}
+			}
+		}
+		if(w >= 0){
+			w = Math.max(w - pb.w - mb.w, 0);
+		}
+		if(h >= 0){
+			h = Math.max(h - pb.h - mb.h, 0);
+		}
+		setBox(node, box.l, box.t, w, h);
+	};
+
+	// =============================
+	// Positioning
+	// =============================
+
+	geom.isBodyLtr = function isBodyLtr(){
+		return (win.body().dir || win.doc.documentElement.dir || "ltr").toLowerCase() == "ltr"; // Boolean
+	};
+
+	geom.docScroll = function docScroll(){
+		var node = win.doc.parentWindow || win.doc.defaultView;   // use UI window, not dojo.global window
+		return "pageXOffset" in node ? {x: node.pageXOffset, y: node.pageYOffset } :
+			(node = has("quirks") ? win.body() : win.doc.documentElement,
+				{x: geom.fixIeBiDiScrollLeft(node.scrollLeft || 0), y: node.scrollTop || 0 });
+	};
+
+		geom.getIeDocumentElementOffset = function getIeDocumentElementOffset(){
+		//NOTE: assumes we're being called in an IE browser
+
+		var de = win.doc.documentElement; // only deal with HTML element here, position() handles body/quirks
+
+		if(has("ie") < 8){
+			var r = de.getBoundingClientRect(), // works well for IE6+
+				l = r.left, t = r.top;
+			if(has("ie") < 7){
+				l += de.clientLeft;	// scrollbar size in strict/RTL, or,
+				t += de.clientTop;	// HTML border size in strict
+			}
+			return {
+				x: l < 0 ? 0 : l, // FRAME element border size can lead to inaccurate negative values
+				y: t < 0 ? 0 : t
+			};
+		}else{
+			return {
+				x: 0,
+				y: 0
+			};
+		}
+	};
+	
+	geom.fixIeBiDiScrollLeft = function fixIeBiDiScrollLeft(/*Integer*/ scrollLeft){
+		// In RTL direction, scrollLeft should be a negative value, but IE
+		// returns a positive one. All codes using documentElement.scrollLeft
+		// must call this function to fix this error, otherwise the position
+		// will offset to right when there is a horizontal scrollbar.
+
+				var ie = has("ie");
+		if(ie && !geom.isBodyLtr()){
+			var qk = has("quirks"),
+				de = qk ? win.body() : win.doc.documentElement;
+			if(ie == 6 && !qk && win.global.frameElement && de.scrollHeight > de.clientHeight){
+				scrollLeft += de.clientLeft; // workaround ie6+strict+rtl+iframe+vertical-scrollbar bug where clientWidth is too small by clientLeft pixels
+			}
+			return (ie < 8 || qk) ? (scrollLeft + de.clientWidth - de.scrollWidth) : -scrollLeft; // Integer
+		}
+				return scrollLeft; // Integer
+	};
+
+	geom.position = function(/*DomNode*/node, /*Boolean?*/includeScroll){
+		node = dom.byId(node);
+		var	db = win.body(),
+			dh = db.parentNode,
+			ret = node.getBoundingClientRect();
+		ret = {x: ret.left, y: ret.top, w: ret.right - ret.left, h: ret.bottom - ret.top};
+				if(has("ie")){
+			// On IE there's a 2px offset that we need to adjust for, see dojo.getIeDocumentElementOffset()
+			var offset = geom.getIeDocumentElementOffset();
+
+			// fixes the position in IE, quirks mode
+			ret.x -= offset.x + (has("quirks") ? db.clientLeft + db.offsetLeft : 0);
+			ret.y -= offset.y + (has("quirks") ? db.clientTop + db.offsetTop : 0);
+		}else if(has("ff") == 3){
+			// In FF3 you have to subtract the document element margins.
+			// Fixed in FF3.5 though.
+			var cs = style.getComputedStyle(dh), px = style.toPixelValue;
+			ret.x -= px(dh, cs.marginLeft) + px(dh, cs.borderLeftWidth);
+			ret.y -= px(dh, cs.marginTop) + px(dh, cs.borderTopWidth);
+		}
+				// account for document scrolling
+		// if offsetParent is used, ret value already includes scroll position
+		// so we may have to actually remove that value if !includeScroll
+		if(includeScroll){
+			var scroll = geom.docScroll();
+			ret.x += scroll.x;
+			ret.y += scroll.y;
+		}
+
+		return ret; // Object
+	};
+
+	// random "private" functions wildly used throughout the toolkit
+
+	geom.getMarginSize = function getMarginSize(/*DomNode*/node, /*Object*/computedStyle){
+		node = dom.byId(node);
+		var me = geom.getMarginExtents(node, computedStyle || style.getComputedStyle(node));
+		var size = node.getBoundingClientRect();
+		return {
+			w: (size.right - size.left) + me.w,
+			h: (size.bottom - size.top) + me.h
+		}
+	};
+
+	geom.normalizeEvent = function(event){
+		// summary:
+		// 		Normalizes the geometry of a DOM event, normalizing the pageX, pageY,
+		// 		offsetX, offsetY, layerX, and layerX properties
+		// event: Object
+		if(!("layerX" in event)){
+			event.layerX = event.offsetX;
+			event.layerY = event.offsetY;
+		}
+		if(!has("dom-addeventlistener")){
+			// old IE version
+			// FIXME: scroll position query is duped from dojo.html to
+			// avoid dependency on that entire module. Now that HTML is in
+			// Base, we should convert back to something similar there.
+			var se = event.target;
+			var doc = (se && se.ownerDocument) || document;
+			// DO NOT replace the following to use dojo.body(), in IE, document.documentElement should be used
+			// here rather than document.body
+			var docBody = has("quirks") ? doc.body : doc.documentElement;
+			var offset = geom.getIeDocumentElementOffset();
+			event.pageX = event.clientX + geom.fixIeBiDiScrollLeft(docBody.scrollLeft || 0) - offset.x;
+			event.pageY = event.clientY + (docBody.scrollTop || 0) - offset.y;
+		}
+	};
+
+	// TODO: evaluate separate getters/setters for position and sizes?
+
+	return geom;
+});
+
+},
+'dojo/dom-prop':function(){
+define("dojo/dom-prop", ["exports", "./_base/kernel", "./_base/sniff", "./_base/lang", "./dom", "./dom-style", "./dom-construct", "./_base/connect"],
+		function(exports, dojo, has, lang, dom, style, ctr, conn){
+	// module:
+	//		dojo/dom-prop
+	// summary:
+	//		This module defines the core dojo DOM properties API.
+	//      Indirectly depends on dojo.empty() and dojo.toDom().
+
+	// =============================
+	// Element properties Functions
+	// =============================
+
+	/*=====
+	prop.get = function(node, name){
+		// summary:
+		//		Gets a property on an HTML element.
+		// description:
+		//		Handles normalized getting of properties on DOM nodes.
+		//
+		// node: DOMNode|String
+		//		id or reference to the element to get the property on
+		// name: String
+		//		the name of the property to get.
+		// returns:
+		//		the value of the requested property or its default value
+		//
+		// example:
+		//	|	// get the current value of the "foo" property on a node
+		//	|	dojo.getProp(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.getProp("nodeId", "foo");
+	};
+	=====*/
+
+	/*=====
+	prop.set = function(node, name, value){
+		// summary:
+		//		Sets a property on an HTML element.
+		// description:
+		//		Handles normalized setting of properties on DOM nodes.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to set the property on
+		// name: String|Object
+		//		the name of the property to set, or a hash object to set
+		//		multiple properties at once.
+		// value: String?
+		//		The value to set for the property
+		// returns:
+		//		the DOM node
+		//
+		// example:
+		//	|	// use prop() to set the tab index
+		//	|	dojo.setProp("nodeId", "tabIndex", 3);
+		//	|
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.setProp("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.setProp("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.setProp("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.style("someNode", obj);
+	};
+	=====*/
+
+	// helper to connect events
+	var _evtHdlrMap = {}, _ctr = 0, _attrId = dojo._scopeName + "attrid";
+
+		// the next dictionary lists elements with read-only innerHTML on IE
+	var _roInnerHtml = {col: 1, colgroup: 1,
+			// frameset: 1, head: 1, html: 1, style: 1,
+			table: 1, tbody: 1, tfoot: 1, thead: 1, tr: 1, title: 1};
+	
+	exports.names = {
+		// properties renamed to avoid clashes with reserved words
+		"class": "className",
+		"for": "htmlFor",
+		// properties written as camelCase
+		tabindex: "tabIndex",
+		readonly: "readOnly",
+		colspan: "colSpan",
+		frameborder: "frameBorder",
+		rowspan: "rowSpan",
+		valuetype: "valueType"
+	};
+
+	exports.get = function getProp(/*DOMNode|String*/node, /*String*/name){
+		node = dom.byId(node);
+		var lc = name.toLowerCase(), propName = exports.names[lc] || name;
+		return node[propName];	// Anything
+	};
+
+	exports.set = function setProp(/*DOMNode|String*/node, /*String|Object*/name, /*String?*/value){
+		node = dom.byId(node);
+		var l = arguments.length;
+		if(l == 2 && typeof name != "string"){ // inline'd type check
+			// the object form of setter: the 2nd argument is a dictionary
+			for(var x in name){
+				exports.set(node, x, name[x]);
+			}
+			return node; // DomNode
+		}
+		var lc = name.toLowerCase(), propName = exports.names[lc] || name;
+		if(propName == "style" && typeof value != "string"){ // inline'd type check
+			// special case: setting a style
+			style.style(node, value);
+			return node; // DomNode
+		}
+		if(propName == "innerHTML"){
+			// special case: assigning HTML
+						if(has("ie") && node.tagName.toLowerCase() in _roInnerHtml){
+				ctr.empty(node);
+				node.appendChild(ctr.toDom(value, node.ownerDocument));
+			}else{
+							node[propName] = value;
+						}
+						return node; // DomNode
+		}
+		if(lang.isFunction(value)){
+			// special case: assigning an event handler
+			// clobber if we can
+			var attrId = node[_attrId];
+			if(!attrId){
+				attrId = _ctr++;
+				node[_attrId] = attrId;
+			}
+			if(!_evtHdlrMap[attrId]){
+				_evtHdlrMap[attrId] = {};
+			}
+			var h = _evtHdlrMap[attrId][propName];
+			if(h){
+				//h.remove();
+				conn.disconnect(h);
+			}else{
+				try{
+					delete node[propName];
+				}catch(e){}
+			}
+			// ensure that event objects are normalized, etc.
+			if(value){
+				//_evtHdlrMap[attrId][propName] = on(node, propName, value);
+				_evtHdlrMap[attrId][propName] = conn.connect(node, propName, value);
+			}else{
+				node[propName] = null;
+			}
+			return node; // DomNode
+		}
+		node[propName] = value;
+		return node;	// DomNode
+	};
+});
+
+},
+'dojo/dom-attr':function(){
+define(["exports", "./_base/sniff", "./_base/lang", "./dom", "./dom-style", "./dom-prop"],
+		function(exports, has, lang, dom, style, prop){
+	// module:
+	//		dojo/dom-attr
+	// summary:
+	//		This module defines the core dojo DOM attributes API.
+
+	// =============================
+	// Element attribute Functions
+	// =============================
+
+	// This module will be obsolete soon. Use dojo.prop instead.
+
+	// dojo.attr() should conform to http://www.w3.org/TR/DOM-Level-2-Core/
+
+	// attribute-related functions (to be obsolete soon)
+
+	/*=====
+	dojo.hasAttr = function(node, name){
+		// summary:
+		//		Returns true if the requested attribute is specified on the
+		//		given element, and false otherwise.
+		// node: DOMNode|String
+		//		id or reference to the element to check
+		// name: String
+		//		the name of the attribute
+		// returns: Boolean
+		//		true if the requested attribute is specified on the
+		//		given element, and false otherwise
+	};
+	=====*/
+
+	/*=====
+	dojo.getAttr = function(node, name){
+		// summary:
+		//		Gets an attribute on an HTML element.
+		// description:
+		//		Handles normalized getting of attributes on DOM Nodes.
+		// node: DOMNode|String
+		//		id or reference to the element to get the attribute on
+		// name: String
+		//		the name of the attribute to get.
+		// returns:
+		//		the value of the requested attribute or null if that attribute does not have a specified or
+		//		default value;
+		//
+		// example:
+		//	|	// get the current value of the "foo" attribute on a node
+		//	|	dojo.getAttr(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.getAttr("nodeId", "foo");
+	};
+	=====*/
+
+	/*=====
+	dojo.setAttr = function(node, name, value){
+		// summary:
+		//		Sets an attribute on an HTML element.
+		// description:
+		//		Handles normalized setting of attributes on DOM Nodes.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to set the attribute on
+		// name: String|Object
+		//		the name of the attribute to set, or a hash of key-value pairs to set.
+		// value: String?
+		//		the value to set for the attribute, if the name is a string.
+		// returns:
+		//		the DOM node
+		//
+		// example:
+		//	|	// use attr() to set the tab index
+		//	|	dojo.setAttr("nodeId", "tabIndex", 3);
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.setAttr("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.setAttr("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.setAttr("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.setStyle("someNode", obj);
+	};
+	=====*/
+
+	/*=====
+	dojo.removeAttr = function(node, name){
+		// summary:
+		//		Removes an attribute from an HTML element.
+		// node: DOMNode|String
+		//		id or reference to the element to remove the attribute from
+		// name: String
+		//		the name of the attribute to remove
+	};
+	=====*/
+
+	/*=====
+	dojo.getNodeProp = function(node, name){
+		// summary:
+		//		Returns an effective value of a property or an attribute.
+		// node: DOMNode|String
+		//		id or reference to the element to remove the attribute from
+		// name: String
+		//		the name of the attribute
+		// returns:
+		//      the value of the attribute
+	};
+	=====*/
+
+	var forcePropNames = {
+			innerHTML:	1,
+			className:	1,
+			htmlFor:	has("ie"),
+			value:		1
+		},
+		attrNames = {
+			// original attribute names
+			classname: "class",
+			htmlfor: "for",
+			// for IE
+			tabindex: "tabIndex",
+			readonly: "readOnly"
+		};
+
+	function _hasAttr(node, name){
+		var attr = node.getAttributeNode && node.getAttributeNode(name);
+		return attr && attr.specified; // Boolean
+	}
+
+	// There is a difference in the presence of certain properties and their default values
+	// between browsers. For example, on IE "disabled" is present on all elements,
+	// but it is value is "false"; "tabIndex" of <div> returns 0 by default on IE, yet other browsers
+	// can return -1.
+
+	exports.has = function hasAttr(/*DOMNode|String*/node, /*String*/name){
+		var lc = name.toLowerCase();
+		return forcePropNames[prop.names[lc] || name] || _hasAttr(dom.byId(node), attrNames[lc] || name);	// Boolean
+	};
+
+	exports.get = function getAttr(/*DOMNode|String*/node, /*String*/name){
+		node = dom.byId(node);
+		var lc = name.toLowerCase(),
+			propName = prop.names[lc] || name,
+			forceProp = forcePropNames[propName];
+		// should we access this attribute via a property or via getAttribute()?
+		value = node[propName];
+		if(forceProp && typeof value != "undefined"){
+			// node's property
+			return value;	// Anything
+		}
+		if(propName != "href" && (typeof value == "boolean" || lang.isFunction(value))){
+			// node's property
+			return value;	// Anything
+		}
+		// node's attribute
+		// we need _hasAttr() here to guard against IE returning a default value
+		var attrName = attrNames[lc] || name;
+		return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
+	};
+
+	exports.set = function setAttr(/*DOMNode|String*/node, /*String|Object*/name, /*String?*/value){
+		node = dom.byId(node);
+		if(arguments.length == 2){ // inline'd type check
+			// the object form of setter: the 2nd argument is a dictionary
+			for(var x in name){
+				exports.set(node, x, name[x]);
+			}
+			return node; // DomNode
+		}
+		var lc = name.toLowerCase(),
+			propName = prop.names[lc] || name,
+			forceProp = forcePropNames[propName];
+		if(propName == "style" && typeof value != "string"){ // inline'd type check
+			// special case: setting a style
+			style.set(node, value);
+			return node; // DomNode
+		}
+		if(forceProp || typeof value == "boolean" || lang.isFunction(value)){
+			return prop.set(node, name, value)
+		}
+		// node's attribute
+		node.setAttribute(attrNames[lc] || name, value);
+		return node; // DomNode
+	};
+
+	exports.remove = function removeAttr(/*DOMNode|String*/ node, /*String*/ name){
+		dom.byId(node).removeAttribute(attrNames[name.toLowerCase()] || name);
+	};
+
+	exports.getNodeProp = function getNodeProp(/*DomNode|String*/ node, /*String*/ name){
+		node = dom.byId(node);
+		var lc = name.toLowerCase(), propName = prop.names[lc] || name;
+		if((propName in node) && propName != "href"){
+			// node's property
+			return node[propName];	// Anything
+		}
+		// node's attribute
+		var attrName = attrNames[lc] || name;
+		return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
+	};
+});
+
+},
+'dojo/dom-construct':function(){
+define("dojo/dom-construct", ["exports", "./_base/kernel", "./_base/sniff", "./_base/window", "./dom", "./dom-attr", "./on"],
+		function(exports, dojo, has, win, dom, attr, on){
+	// module:
+	//		dojo/dom-construct
+	// summary:
+	//		This module defines the core dojo DOM construction API.
+
+	/*=====
+	dojo.toDom = function(frag, doc){
+		// summary:
+		//		instantiates an HTML fragment returning the corresponding DOM.
+		// frag: String
+		//		the HTML fragment
+		// doc: DocumentNode?
+		//		optional document to use when creating DOM nodes, defaults to
+		//		dojo.doc if not specified.
+		// returns: DocumentFragment
+		//
+		// example:
+		//		Create a table row:
+		//	|	var tr = dojo.toDom("<tr><td>First!</td></tr>");
+	};
+	=====*/
+
+	/*=====
+	dojo._toDom = function(frag, doc){
+		// summary:
+		//		Existing alias for `dojo.toDom`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.place = function(node, refNode, position){
+		// summary:
+		//		Attempt to insert node into the DOM, choosing from various positioning options.
+		//		Returns the first argument resolved to a DOM node.
+		//
+		// node: DOMNode|String
+		//		id or node reference, or HTML fragment starting with "<" to place relative to refNode
+		//
+		// refNode: DOMNode|String
+		//		id or node reference to use as basis for placement
+		//
+		// position: String|Number?
+		//		string noting the position of node relative to refNode or a
+		//		number indicating the location in the childNodes collection of refNode.
+		//		Accepted string values are:
+		//	|	* before
+		//	|	* after
+		//	|	* replace
+		//	|	* only
+		//	|	* first
+		//	|	* last
+		//		"first" and "last" indicate positions as children of refNode, "replace" replaces refNode,
+		//		"only" replaces all children.  position defaults to "last" if not specified
+		//
+		// returns: DOMNode
+		//		Returned values is the first argument resolved to a DOM node.
+		//
+		//		.place() is also a method of `dojo.NodeList`, allowing `dojo.query` node lookups.
+		//
+		// example:
+		//		Place a node by string id as the last child of another node by string id:
+		//	|	dojo.place("someNode", "anotherNode");
+		//
+		// example:
+		//		Place a node by string id before another node by string id
+		//	|	dojo.place("someNode", "anotherNode", "before");
+		//
+		// example:
+		//		Create a Node, and place it in the body element (last child):
+		//	|	dojo.place("<div></div>", dojo.body());
+		//
+		// example:
+		//		Put a new LI as the first child of a list by id:
+		//	|	dojo.place("<li></li>", "someUl", "first");
+	};
+	=====*/
+
+	/*=====
+	dojo.create = function(tag, attrs, refNode, pos){
+		// summary:
+		//		Create an element, allowing for optional attribute decoration
+		//		and placement.
+		//
+		// description:
+		//		A DOM Element creation function. A shorthand method for creating a node or
+		//		a fragment, and allowing for a convenient optional attribute setting step,
+		//		as well as an optional DOM placement reference.
+		//|
+		//		Attributes are set by passing the optional object through `dojo.setAttr`.
+		//		See `dojo.setAttr` for noted caveats and nuances, and API if applicable.
+		//|
+		//		Placement is done via `dojo.place`, assuming the new node to be the action
+		//		node, passing along the optional reference node and position.
+		//
+		// tag: DOMNode|String
+		//		A string of the element to create (eg: "div", "a", "p", "li", "script", "br"),
+		//		or an existing DOM node to process.
+		//
+		// attrs: Object
+		//		An object-hash of attributes to set on the newly created node.
+		//		Can be null, if you don't want to set any attributes/styles.
+		//		See: `dojo.setAttr` for a description of available attributes.
+		//
+		// refNode: DOMNode?|String?
+		//		Optional reference node. Used by `dojo.place` to place the newly created
+		//		node somewhere in the dom relative to refNode. Can be a DomNode reference
+		//		or String ID of a node.
+		//
+		// pos: String?
+		//		Optional positional reference. Defaults to "last" by way of `dojo.place`,
+		//		though can be set to "first","after","before","last", "replace" or "only"
+		//		to further control the placement of the new node relative to the refNode.
+		//		'refNode' is required if a 'pos' is specified.
+		//
+		// returns: DOMNode
+		//
+		// example:
+		//		Create a DIV:
+		//	|	var n = dojo.create("div");
+		//
+		// example:
+		//		Create a DIV with content:
+		//	|	var n = dojo.create("div", { innerHTML:"<p>hi</p>" });
+		//
+		// example:
+		//		Place a new DIV in the BODY, with no attributes set
+		//	|	var n = dojo.create("div", null, dojo.body());
+		//
+		// example:
+		//		Create an UL, and populate it with LI's. Place the list as the first-child of a
+		//		node with id="someId":
+		//	|	var ul = dojo.create("ul", null, "someId", "first");
+		//	|	var items = ["one", "two", "three", "four"];
+		//	|	dojo.forEach(items, function(data){
+		//	|		dojo.create("li", { innerHTML: data }, ul);
+		//	|	});
+		//
+		// example:
+		//		Create an anchor, with an href. Place in BODY:
+		//	|	dojo.create("a", { href:"foo.html", title:"Goto FOO!" }, dojo.body());
+		//
+		// example:
+		//		Create a `dojo.NodeList()` from a new element (for syntatic sugar):
+		//	|	dojo.query(dojo.create('div'))
+		//	|		.addClass("newDiv")
+		//	|		.onclick(function(e){ console.log('clicked', e.target) })
+		//	|		.place("#someNode"); // redundant, but cleaner.
+	};
+	=====*/
+
+	/*=====
+	dojo.empty = function(node){
+			// summary:
+			//		safely removes all children of the node.
+			// node: DOMNode|String
+			//		a reference to a DOM node or an id.
+			// example:
+			//		Destroy node's children byId:
+			//	|	dojo.empty("someId");
+			//
+			// example:
+			//		Destroy all nodes' children in a list by reference:
+			//	|	dojo.query(".someNode").forEach(dojo.empty);
+	}
+	=====*/
+
+	/*=====
+	dojo.destroy = function(node){
+		// summary:
+		//		Removes a node from its parent, clobbering it and all of its
+		//		children.
+		//
+		// description:
+		//		Removes a node from its parent, clobbering it and all of its
+		//		children. Function only works with DomNodes, and returns nothing.
+		//
+		// node: DOMNode|String
+		//		A String ID or DomNode reference of the element to be destroyed
+		//
+		// example:
+		//		Destroy a node byId:
+		//	|	dojo.destroy("someId");
+		//
+		// example:
+		//		Destroy all nodes in a list by reference:
+		//	|	dojo.query(".someNode").forEach(dojo.destroy);
+	};
+	=====*/
+
+	/*=====
+	dojo._destroyElement = function(node){
+		// summary:
+		//		Existing alias for `dojo.destroy`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	// support stuff for dojo.toDom
+	var tagWrap = {
+			option: ["select"],
+			tbody: ["table"],
+			thead: ["table"],
+			tfoot: ["table"],
+			tr: ["table", "tbody"],
+			td: ["table", "tbody", "tr"],
+			th: ["table", "thead", "tr"],
+			legend: ["fieldset"],
+			caption: ["table"],
+			colgroup: ["table"],
+			col: ["table", "colgroup"],
+			li: ["ul"]
+		},
+		reTag = /<\s*([\w\:]+)/,
+		masterNode = {}, masterNum = 0,
+		masterName = "__" + dojo._scopeName + "ToDomId";
+
+	// generate start/end tag strings to use
+	// for the injection for each special tag wrap case.
+	for(var param in tagWrap){
+		if(tagWrap.hasOwnProperty(param)){
+			var tw = tagWrap[param];
+			tw.pre = param == "option" ? '<select multiple="multiple">' : "<" + tw.join("><") + ">";
+			tw.post = "</" + tw.reverse().join("></") + ">";
+			// the last line is destructive: it reverses the array,
+			// but we don't care at this point
+		}
+	}
+
+	function _insertBefore(/*DomNode*/node, /*DomNode*/ref){
+		var parent = ref.parentNode;
+		if(parent){
+			parent.insertBefore(node, ref);
+		}
+	}
+
+	function _insertAfter(/*DomNode*/node, /*DomNode*/ref){
+		// summary:
+		//		Try to insert node after ref
+		var parent = ref.parentNode;
+		if(parent){
+			if(parent.lastChild == ref){
+				parent.appendChild(node);
+			}else{
+				parent.insertBefore(node, ref.nextSibling);
+			}
+		}
+	}
+
+	var _destroyContainer = null,
+		_destroyDoc;
+		on(window, "unload", function(){
+		_destroyContainer = null; //prevent IE leak
+	});
+	
+	exports.toDom = function toDom(frag, doc){
+		doc = doc || win.doc;
+		var masterId = doc[masterName];
+		if(!masterId){
+			doc[masterName] = masterId = ++masterNum + "";
+			masterNode[masterId] = doc.createElement("div");
+		}
+
+		// make sure the frag is a string.
+		frag += "";
+
+		// find the starting tag, and get node wrapper
+		var match = frag.match(reTag),
+			tag = match ? match[1].toLowerCase() : "",
+			master = masterNode[masterId],
+			wrap, i, fc, df;
+		if(match && tagWrap[tag]){
+			wrap = tagWrap[tag];
+			master.innerHTML = wrap.pre + frag + wrap.post;
+			for(i = wrap.length; i; --i){
+				master = master.firstChild;
+			}
+		}else{
+			master.innerHTML = frag;
+		}
+
+		// one node shortcut => return the node itself
+		if(master.childNodes.length == 1){
+			return master.removeChild(master.firstChild); // DOMNode
+		}
+
+		// return multiple nodes as a document fragment
+		df = doc.createDocumentFragment();
+		while(fc = master.firstChild){ // intentional assignment
+			df.appendChild(fc);
+		}
+		return df; // DOMNode
+	};
+
+	exports.place = function place(/*DOMNode|String*/node, /*DOMNode|String*/refNode, /*String|Number?*/position){
+		refNode = dom.byId(refNode);
+		if(typeof node == "string"){ // inline'd type check
+			node = /^\s*</.test(node) ? exports.toDom(node, refNode.ownerDocument) : dom.byId(node);
+		}
+		if(typeof position == "number"){ // inline'd type check
+			var cn = refNode.childNodes;
+			if(!cn.length || cn.length <= position){
+				refNode.appendChild(node);
+			}else{
+				_insertBefore(node, cn[position < 0 ? 0 : position]);
+			}
+		}else{
+			switch(position){
+				case "before":
+					_insertBefore(node, refNode);
+					break;
+				case "after":
+					_insertAfter(node, refNode);
+					break;
+				case "replace":
+					refNode.parentNode.replaceChild(node, refNode);
+					break;
+				case "only":
+					exports.empty(refNode);
+					refNode.appendChild(node);
+					break;
+				case "first":
+					if(refNode.firstChild){
+						_insertBefore(node, refNode.firstChild);
+						break;
+					}
+					// else fallthrough...
+				default: // aka: last
+					refNode.appendChild(node);
+			}
+		}
+		return node; // DomNode
+	};
+
+	exports.create = function create(/*DOMNode|String*/tag, /*Object*/attrs, /*DOMNode?|String?*/refNode, /*String?*/pos){
+		var doc = win.doc;
+		if(refNode){
+			refNode = dom.byId(refNode);
+			doc = refNode.ownerDocument;
+		}
+		if(typeof tag == "string"){ // inline'd type check
+			tag = doc.createElement(tag);
+		}
+		if(attrs){ attr.set(tag, attrs); }
+		if(refNode){ exports.place(tag, refNode, pos); }
+		return tag; // DomNode
+	};
+
+	exports.empty =
+				has("ie") ? function(node){
+			node = dom.byId(node);
+			for(var c; c = node.lastChild;){ // intentional assignment
+				exports.destroy(c);
+			}
+		} :
+				function(node){
+			dom.byId(node).innerHTML = "";
+		};
+
+	exports.destroy = function destroy(/*DOMNode|String*/node){
+		node = dom.byId(node);
+		try{
+			var doc = node.ownerDocument;
+			// cannot use _destroyContainer.ownerDocument since this can throw an exception on IE
+			if(!_destroyContainer || _destroyDoc != doc){
+				_destroyContainer = doc.createElement("div");
+				_destroyDoc = doc;
+			}
+			_destroyContainer.appendChild(node.parentNode ? node.parentNode.removeChild(node) : node);
+			// NOTE: see http://trac.dojotoolkit.org/ticket/2931. This may be a bug and not a feature
+			_destroyContainer.innerHTML = "";
+		}catch(e){
+			/* squelch */
+		}
+	};
+});
+
+},
+'dojo/text':function(){
+define(["./_base/kernel", "require", "./has", "./_base/xhr"], function(dojo, require, has, xhr){
+	// module:
+	//		dojo/text
+	// summary:
+	//		This module implements the !dojo/text plugin and the dojo.cache API.
+	// description:
+	//		We choose to include our own plugin to leverage functionality already contained in dojo
+	//		and thereby reduce the size of the plugin compared to various foreign loader implementations.
+	//		Also, this allows foreign AMD loaders to be used without their plugins.
+	//
+	//		CAUTION: this module is designed to optionally function synchronously to support the dojo v1.x synchronous
+	//		loader. This feature is outside the scope of the CommonJS plugins specification.
+
+	var getText;
+	if(1){
+		getText= function(url, sync, load){
+			xhr("GET", {url:url, sync:!!sync, load:load});
+		};
+	}else{
+		// TODOC: only works for dojo AMD loader
+		if(require.getText){
+			getText= require.getText;
+		}else{
+			console.error("dojo/text plugin failed to load because loader does not support getText");
+		}
+	}
+
+	var
+		theCache= {},
+
+		strip= function(text){
+			//Strips <?xml ...?> declarations so that external SVG and XML
+			//documents can be added to a document without worry. Also, if the string
+			//is an HTML document, only the part inside the body tag is returned.
+			if(text){
+				text= text.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, "");
+				var matches= text.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+				if(matches){
+					text= matches[1];
+				}
+			}else{
+				text = "";
+			}
+			return text;
+		},
+
+		notFound = {},
+
+		pending = {},
+
+		result= {
+			dynamic:
+				// the dojo/text caches it's own resources because of dojo.cache
+				true,
+
+			normalize:function(id, toAbsMid){
+				// id is something like (path may be relative):
+				//
+				//	 "path/to/text.html"
+				//	 "path/to/text.html!strip"
+				var parts= id.split("!"),
+					url= parts[0];
+				return (/^\./.test(url) ? toAbsMid(url) : url) + (parts[1] ? "!" + parts[1] : "");
+			},
+
+			load:function(id, require, load){
+				// id is something like (path is always absolute):
+				//
+				//	 "path/to/text.html"
+				//	 "path/to/text.html!strip"
+				var
+					parts= id.split("!"),
+					stripFlag= parts.length>1,
+					absMid= parts[0],
+					url = require.toUrl(parts[0]),
+					text = notFound,
+					finish = function(text){
+						load(stripFlag ? strip(text) : text);
+					};
+				if(absMid in theCache){
+					text = theCache[absMid];
+				}else if(url in require.cache){
+					text = require.cache[url];
+				}else if(url in theCache){
+					text = theCache[url];
+				}
+				if(text===notFound){
+					if(pending[url]){
+						pending[url].push(finish);
+					}else{
+						var pendingList = pending[url] = [finish];
+						getText(url, !require.async, function(text){
+							theCache[absMid]= theCache[url]= text;
+							for(var i = 0; i<pendingList.length;){
+								pendingList[i++](text);
+							}
+							delete pending[url];
+						});
+					}
+				}else{
+					finish(text);
+				}
+			}
+		};
+
+	dojo.cache= function(/*String||Object*/module, /*String*/url, /*String||Object?*/value){
+		//	 * (string string [value]) => (module, url, value)
+		//	 * (object [value])        => (module, value), url defaults to ""
+		//
+		//	 * if module is an object, then it must be convertable to a string
+		//	 * (module, url) module + (url ? ("/" + url) : "") must be a legal argument to require.toUrl
+		//	 * value may be a string or an object; if an object then may have the properties "value" and/or "sanitize"
+		var key;
+		if(typeof module=="string"){
+			if(/\//.test(module)){
+				// module is a version 1.7+ resolved path
+				key = module;
+				value = url;
+			}else{
+				// module is a version 1.6- argument to dojo.moduleUrl
+				key = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : ""));
+			}
+		}else{
+			key = module + "";
+			value = url;
+		}
+		var
+			val = (value != undefined && typeof value != "string") ? value.value : value,
+			sanitize = value && value.sanitize;
+
+		if(typeof val == "string"){
+			//We have a string, set cache value
+			theCache[key] = val;
+			return sanitize ? strip(val) : val;
+		}else if(val === null){
+			//Remove cached value
+			delete theCache[key];
+			return null;
+		}else{
+			//Allow cache values to be empty strings. If key property does
+			//not exist, fetch it.
+			if(!(key in theCache)){
+				getText(key, true, function(text){
+					theCache[key]= text;
+				});
+			}
+			return sanitize ? strip(theCache[key]) : theCache[key];
+		}
+	};
+
+	return result;
+
+/*=====
+dojo.cache = function(module, url, value){
+	// summary:
+	//		A getter and setter for storing the string content associated with the
+	//		module and url arguments.
+	// description:
+	//		If module is a string that contains slashes, then it is interpretted as a fully
+	//		resolved path (typically a result returned by require.toUrl), and url should not be
+	//		provided. This is the preferred signature. If module is a string that does not
+	//		contain slashes, then url must also be provided and module and url are used to
+	//		call `dojo.moduleUrl()` to generate a module URL. This signature is deprecated.
+	//		If value is specified, the cache value for the moduleUrl will be set to
+	//		that value. Otherwise, dojo.cache will fetch the moduleUrl and store it
+	//		in its internal cache and return that cached value for the URL. To clear
+	//		a cache value pass null for value. Since XMLHttpRequest (XHR) is used to fetch the
+	//		the URL contents, only modules on the same domain of the page can use this capability.
+	//		The build system can inline the cache values though, to allow for xdomain hosting.
+	// module: String||Object
+	//		If a String with slashes, a fully resolved path; if a String without slashes, the
+	//		module name to use for the base part of the URL, similar to module argument
+	//		to `dojo.moduleUrl`. If an Object, something that has a .toString() method that
+	//		generates a valid path for the cache item. For example, a dojo._Url object.
+	// url: String
+	//		The rest of the path to append to the path derived from the module argument. If
+	//		module is an object, then this second argument should be the "value" argument instead.
+	// value: String||Object?
+	//		If a String, the value to use in the cache for the module/url combination.
+	//		If an Object, it can have two properties: value and sanitize. The value property
+	//		should be the value to use in the cache, and sanitize can be set to true or false,
+	//		to indicate if XML declarations should be removed from the value and if the HTML
+	//		inside a body tag in the value should be extracted as the real value. The value argument
+	//		or the value property on the value argument are usually only used by the build system
+	//		as it inlines cache content.
+	//	example:
+	//		To ask dojo.cache to fetch content and store it in the cache (the dojo["cache"] style
+	//		of call is used to avoid an issue with the build system erroneously trying to intern
+	//		this example. To get the build system to intern your dojo.cache calls, use the
+	//		"dojo.cache" style of call):
+	//		| //If template.html contains "<h1>Hello</h1>" that will be
+	//		| //the value for the text variable.
+	//		| var text = dojo["cache"]("my.module", "template.html");
+	//	example:
+	//		To ask dojo.cache to fetch content and store it in the cache, and sanitize the input
+	//		 (the dojo["cache"] style of call is used to avoid an issue with the build system
+	//		erroneously trying to intern this example. To get the build system to intern your
+	//		dojo.cache calls, use the "dojo.cache" style of call):
+	//		| //If template.html contains "<html><body><h1>Hello</h1></body></html>", the
+	//		| //text variable will contain just "<h1>Hello</h1>".
+	//		| var text = dojo["cache"]("my.module", "template.html", {sanitize: true});
+	//	example:
+	//		Same example as previous, but demostrates how an object can be passed in as
+	//		the first argument, then the value argument can then be the second argument.
+	//		| //If template.html contains "<html><body><h1>Hello</h1></body></html>", the
+	//		| //text variable will contain just "<h1>Hello</h1>".
+	//		| var text = dojo["cache"](new dojo._Url("my/module/template.html"), {sanitize: true});
+	return val; //String
+};
+=====*/
+});
+
+
+},
+'dojo/keys':function(){
+define("dojo/keys", ["./_base/kernel", "./_base/sniff"], function(dojo, has) {
+	// module:
+	//		dojo/keys
+	// summary:
+	//		key constants
+// Constants
+
+// Public: client code should test
+// keyCode against these named constants, as the
+// actual codes can vary by browser.
+return dojo.keys = {
+	// summary:
+	//		Definitions for common key values
+	BACKSPACE: 8,
+	TAB: 9,
+	CLEAR: 12,
+	ENTER: 13,
+	SHIFT: 16,
+	CTRL: 17,
+	ALT: 18,
+	META: has("safari") ? 91 : 224,		// the apple key on macs
+	PAUSE: 19,
+	CAPS_LOCK: 20,
+	ESCAPE: 27,
+	SPACE: 32,
+	PAGE_UP: 33,
+	PAGE_DOWN: 34,
+	END: 35,
+	HOME: 36,
+	LEFT_ARROW: 37,
+	UP_ARROW: 38,
+	RIGHT_ARROW: 39,
+	DOWN_ARROW: 40,
+	INSERT: 45,
+	DELETE: 46,
+	HELP: 47,
+	LEFT_WINDOW: 91,
+	RIGHT_WINDOW: 92,
+	SELECT: 93,
+	NUMPAD_0: 96,
+	NUMPAD_1: 97,
+	NUMPAD_2: 98,
+	NUMPAD_3: 99,
+	NUMPAD_4: 100,
+	NUMPAD_5: 101,
+	NUMPAD_6: 102,
+	NUMPAD_7: 103,
+	NUMPAD_8: 104,
+	NUMPAD_9: 105,
+	NUMPAD_MULTIPLY: 106,
+	NUMPAD_PLUS: 107,
+	NUMPAD_ENTER: 108,
+	NUMPAD_MINUS: 109,
+	NUMPAD_PERIOD: 110,
+	NUMPAD_DIVIDE: 111,
+	F1: 112,
+	F2: 113,
+	F3: 114,
+	F4: 115,
+	F5: 116,
+	F6: 117,
+	F7: 118,
+	F8: 119,
+	F9: 120,
+	F10: 121,
+	F11: 122,
+	F12: 123,
+	F13: 124,
+	F14: 125,
+	F15: 126,
+	NUM_LOCK: 144,
+	SCROLL_LOCK: 145,
+	UP_DPAD: 175,
+	DOWN_DPAD: 176,
+	LEFT_DPAD: 177,
+	RIGHT_DPAD: 178,
+	// virtual key mapping
+	copyKey: has("mac") && !has("air") ? (has("safari") ? 91 : 224 ) : 17
+};
+});
+
+},
+'dojo/domReady':function(){
+define(['./has'], function(has){
+	var global = this,
+		doc = document,
+		readyStates = { 'loaded': 1, 'complete': 1 },
+		fixReadyState = typeof doc.readyState != "string",
+		ready = !!readyStates[doc.readyState];
+
+	// For FF <= 3.5
+	if(fixReadyState){ doc.readyState = "loading"; }
+
+	if(!ready){
+		var readyQ = [], tests = [],
+			detectReady = function(evt){
+				evt = evt || global.event;
+				if(ready || (evt.type == "readystatechange" && !readyStates[doc.readyState])){ return; }
+				ready = 1;
+
+				// For FF <= 3.5
+				if(fixReadyState){ doc.readyState = "complete"; }
+
+				while(readyQ.length){
+					(readyQ.shift())();
+				}
+			},
+			on = function(node, event){
+				node.addEventListener(event, detectReady, false);
+				readyQ.push(function(){ node.removeEventListener(event, detectReady, false); });
+			};
+
+		if(!has("dom-addeventlistener")){
+			on = function(node, event){
+				event = "on" + event;
+				node.attachEvent(event, detectReady);
+				readyQ.push(function(){ node.detachEvent(event, detectReady); });
+			};
+
+			var div = doc.createElement("div");
+			try{
+				if(div.doScroll && global.frameElement === null){
+					// the doScroll test is only useful if we're in the top-most frame
+					tests.push(function(){
+						// Derived with permission from Diego Perini's IEContentLoaded
+						// http://javascript.nwbox.com/IEContentLoaded/
+						try{
+							div.doScroll("left");
+							return 1;
+						}catch(e){}
+					});
+				}
+			}catch(e){}
+		}
+
+		on(doc, "DOMContentLoaded");
+		on(global, "load");
+
+		if("onreadystatechange" in doc){
+			on(doc, "readystatechange");
+		}else if(!fixReadyState){
+			// if the ready state property exists and there's
+			// no readystatechange event, poll for the state
+			// to change
+			tests.push(function(){
+				return readyStates[doc.readyState];
+			});
+		}
+
+		if(tests.length){
+			var poller = function(){
+				if(ready){ return; }
+				var i = tests.length;
+				while(i--){
+					if(tests[i]()){
+						detectReady("poller");
+						return;
+					}
+				}
+				setTimeout(poller, 30);
+			};
+			poller();
+		}
+	}
+
+	function domReady(callback){
+		if(ready){
+			callback(1);
+		}else{
+			readyQ.push(callback);
+		}
+	}
+	domReady.load = function(id, req, load){
+		domReady(load);
+	};
+
+	return domReady;
+});
+
+},
+'dojo/_base/lang':function(){
+define(["./kernel", "../has", "./sniff"], function(dojo, has){
+	//	module:
+	//		dojo/_base/lang
+	//	summary:
+	//		This module defines Javascript language extensions.
+
+	has.add("bug-for-in-skips-shadowed", function(){
+		// if true, the for-in interator skips object properties that exist in Object's prototype (IE 6 - ?)
+		for(var i in {toString: 1}){
+			return 0;
+		}
+		return 1;
+	});
+
+	var _extraNames =
+			has("bug-for-in-skips-shadowed") ?
+				"hasOwnProperty.valueOf.isPrototypeOf.propertyIsEnumerable.toLocaleString.toString.constructor".split(".") : [],
+
+		_extraLen = _extraNames.length,
+
+		_mixin = function(dest, source, copyFunc){
+			var name, s, i, empty = {};
+			for(name in source){
+				// the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source"
+				// inherited from Object.prototype.	 For example, if dest has a custom toString() method,
+				// don't overwrite it with the toString() method that source inherited from Object.prototype
+				s = source[name];
+				if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
+					dest[name] = copyFunc ? copyFunc(s) : s;
+				}
+			}
+
+			if(has("bug-for-in-skips-shadowed")){
+				if(source){
+					for(i = 0; i < _extraLen; ++i){
+						name = _extraNames[i];
+						s = source[name];
+						if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))){
+							dest[name] = copyFunc ? copyFunc(s) : s;
+						}
+					}
+				}
+			}
+
+			return dest; // Object
+		},
+
+		mixin = function(dest, sources){
+			if(!dest){ dest = {}; }
+			for(var i = 1, l = arguments.length; i < l; i++){
+				lang._mixin(dest, arguments[i]);
+			}
+			return dest; // Object
+		},
+
+		getProp = function(/*Array*/parts, /*Boolean*/create, /*Object*/context){
+			var p, i = 0, dojoGlobal = dojo.global;
+			if(!context){
+				if(!parts.length){
+					return dojoGlobal;
+				}else{
+					p = parts[i++];
+					try{
+						context = dojo.scopeMap[p] && dojo.scopeMap[p][1];
+					}catch(e){}
+					context = context || (p in dojoGlobal ? dojoGlobal[p] : (create ? dojoGlobal[p] = {} : undefined));
+				}
+			}
+			while(context && (p = parts[i++])){
+				context = (p in context ? context[p] : (create ? context[p] = {} : undefined));
+			}
+			return context; // mixed
+		},
+
+		setObject = function(name, value, context){
+			var parts = name.split("."), p = parts.pop(), obj = getProp(parts, true, context);
+			return obj && p ? (obj[p] = value) : undefined; // Object
+		},
+
+		getObject = function(name, create, context){
+			return getProp(name.split("."), create, context); // Object
+		},
+
+		exists = function(name, obj){
+			return lang.getObject(name, false, obj) !== undefined; // Boolean
+		},
+
+		opts = Object.prototype.toString,
+
+		// Crockford (ish) functions
+
+		isString = function(it){
+			return (typeof it == "string" || it instanceof String); // Boolean
+		},
+
+		isArray = function(it){
+			return it && (it instanceof Array || typeof it == "array"); // Boolean
+		},
+
+		isFunction = function(it){
+			return opts.call(it) === "[object Function]";
+		},
+
+		isObject = function(it){
+			return it !== undefined &&
+				(it === null || typeof it == "object" || lang.isArray(it) || lang.isFunction(it)); // Boolean
+		},
+
+		isArrayLike = function(it){
+			return it && it !== undefined && // Boolean
+				// keep out built-in constructors (Number, String, ...) which have length
+				// properties
+				!lang.isString(it) && !lang.isFunction(it) &&
+				!(it.tagName && it.tagName.toLowerCase() == 'form') &&
+				(lang.isArray(it) || isFinite(it.length));
+		},
+
+		isAlien = function(it){
+			return it && !lang.isFunction(it) && /\{\s*\[native code\]\s*\}/.test(String(it)); // Boolean
+		},
+
+		extend = function(constructor, props){
+			for(var i=1, l=arguments.length; i<l; i++){
+				lang._mixin(constructor.prototype, arguments[i]);
+			}
+			return constructor; // Object
+		},
+
+		_hitchArgs = function(scope, method){
+			var pre = _toArray(arguments, 2);
+			var named = lang.isString(method);
+			return function(){
+				// arrayify arguments
+				var args = _toArray(arguments);
+				// locate our method
+				var f = named ? (scope||dojo.global)[method] : method;
+				// invoke with collected args
+				return f && f.apply(scope || this, pre.concat(args)); // mixed
+			}; // Function
+		},
+
+		hitch = function(scope, method){
+			if(arguments.length > 2){
+				return lang._hitchArgs.apply(dojo, arguments); // Function
+			}
+			if(!method){
+				method = scope;
+				scope = null;
+			}
+			if(lang.isString(method)){
+				scope = scope || dojo.global;
+				if(!scope[method]){ throw(['dojo.hitch: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
+				return function(){ return scope[method].apply(scope, arguments || []); }; // Function
+			}
+			return !scope ? method : function(){ return method.apply(scope, arguments || []); }; // Function
+		},
+
+		delegate = (function(){
+			// boodman/crockford delegation w/ cornford optimization
+			function TMP(){}
+			return function(obj, props){
+				TMP.prototype = obj;
+				var tmp = new TMP();
+				TMP.prototype = null;
+				if(props){
+					lang._mixin(tmp, props);
+				}
+				return tmp; // Object
+			};
+		})(),
+
+		efficient = function(obj, offset, startWith){
+			return (startWith||[]).concat(Array.prototype.slice.call(obj, offset||0));
+		},
+
+		_toArray =
+			has("ie") ?
+				(function(){
+					function slow(obj, offset, startWith){
+						var arr = startWith||[];
+						for(var x = offset || 0; x < obj.length; x++){
+							arr.push(obj[x]);
+						}
+						return arr;
+					}
+					return function(obj){
+						return ((obj.item) ? slow : efficient).apply(this, arguments);
+					};
+				})() : efficient,
+
+		partial = function(/*Function|String*/method /*, ...*/){
+			var arr = [ null ];
+			return lang.hitch.apply(dojo, arr.concat(lang._toArray(arguments))); // Function
+		},
+
+		clone = function(/*anything*/ src){
+			if(!src || typeof src != "object" || lang.isFunction(src)){
+				// null, undefined, any non-object, or function
+				return src;	// anything
+			}
+			if(src.nodeType && "cloneNode" in src){
+				// DOM Node
+				return src.cloneNode(true); // Node
+			}
+			if(src instanceof Date){
+				// Date
+				return new Date(src.getTime());	// Date
+			}
+			if(src instanceof RegExp){
+				// RegExp
+				return new RegExp(src);   // RegExp
+			}
+			var r, i, l;
+			if(lang.isArray(src)){
+				// array
+				r = [];
+				for(i = 0, l = src.length; i < l; ++i){
+					if(i in src){
+						r.push(clone(src[i]));
+					}
+				}
+	// we don't clone functions for performance reasons
+	//		}else if(d.isFunction(src)){
+	//			// function
+	//			r = function(){ return src.apply(this, arguments); };
+			}else{
+				// generic objects
+				r = src.constructor ? new src.constructor() : {};
+			}
+			return lang._mixin(r, src, clone);
+		},
+
+
+		trim = String.prototype.trim ?
+			function(str){ return str.trim(); } :
+			function(str){ return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); },
+
+
+		_pattern = /\{([^\}]+)\}/g,
+
+		replace = function(tmpl, map, pattern){
+			return tmpl.replace(pattern || _pattern, lang.isFunction(map) ?
+				map : function(_, k){ return getObject(k, false, map); });
+		},
+
+		lang = {
+			_extraNames:_extraNames,
+			_mixin:_mixin,
+			mixin:mixin,
+			setObject:setObject,
+			getObject:getObject,
+			exists:exists,
+			isString:isString,
+			isArray:isArray,
+			isFunction:isFunction,
+			isObject:isObject,
+			isArrayLike:isArrayLike,
+			isAlien:isAlien,
+			extend:extend,
+			_hitchArgs:_hitchArgs,
+			hitch:hitch,
+			delegate:delegate,
+			_toArray:_toArray,
+			partial:partial,
+			clone:clone,
+			trim:trim,
+			replace:replace
+		};
+
+	1 && mixin(dojo, lang);
+	return lang;
+
+	/*=====
+	dojo._extraNames
+	// summary:
+	//		Array of strings. Lists property names that must be explicitly processed during for-in interation
+	//		in environments that have has("bug-for-in-skips-shadowed") true.
+	=====*/
+
+	/*=====
+	dojo._mixin = function(dest, source, copyFunc){
+		//	summary:
+		//		Copies/adds all properties of source to dest; returns dest.
+		//	dest: Object:
+		//		The object to which to copy/add all properties contained in source.
+		//	source: Object:
+		//		The object from which to draw all properties to copy into dest.
+		//	copyFunc: Function?:
+		//		The process used to copy/add a property in source; defaults to the Javascript assignment operator.
+		//	returns:
+		//		dest, as modified
+		//	description:
+		//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
+		//		found in Object.prototype, are copied/added to dest. Copying/adding each particular property is
+		//		delegated to copyFunc (if any); copyFunc defaults to the Javascript assignment operator if not provided.
+		//		Notice that by default, _mixin executes a so-called "shallow copy" and aggregate types are copied/added by reference.
+	}
+	=====*/
+
+	/*=====
+	dojo.mixin = function(dest, sources){
+	//	summary:
+	//		Copies/adds all properties of one or more sources to dest; returns dest.
+	//	dest: Object
+	//		The object to which to copy/add all properties contained in source. If dest is falsy, then
+	//		a new object is manufactured before copying/adding properties begins.
+	//	sources: Object...
+	//		One of more objects from which to draw all properties to copy into dest. sources are processed
+	//		left-to-right and if more than one of these objects contain the same property name, the right-most
+	//		value "wins".
+	//	returns: Object
+	//		dest, as modified
+	//	description:
+	//		All properties, including functions (sometimes termed "methods"), excluding any non-standard extensions
+	//		found in Object.prototype, are copied/added from sources to dest. sources are processed left to right.
+	//		The Javascript assignment operator is used to copy/add each property; therefore, by default, mixin
+	//		executes a so-called "shallow copy" and aggregate types are copied/added by reference.
+	//	example:
+	//		make a shallow copy of an object
+	//	| var copy = lang.mixin({}, source);
+	//	example:
+	//		many class constructors often take an object which specifies
+	//		values to be configured on the object. In this case, it is
+	//		often simplest to call `lang.mixin` on the `this` object:
+	//	| dojo.declare("acme.Base", null, {
+	//	|		constructor: function(properties){
+	//	|			// property configuration:
+	//	|			lang.mixin(this, properties);
+	//	|
+	//	|			console.log(this.quip);
+	//	|			//	...
+	//	|		},
+	//	|		quip: "I wasn't born yesterday, you know - I've seen movies.",
+	//	|		// ...
+	//	| });
+	//	|
+	//	| // create an instance of the class and configure it
+	//	| var b = new acme.Base({quip: "That's what it does!" });
+	//	example:
+	//		copy in properties from multiple objects
+	//	| var flattened = lang.mixin(
+	//	|		{
+	//	|			name: "Frylock",
+	//	|			braces: true
+	//	|		},
+	//	|		{
+	//	|			name: "Carl Brutanananadilewski"
+	//	|		}
+	//	| );
+	//	|
+	//	| // will print "Carl Brutanananadilewski"
+	//	| console.log(flattened.name);
+	//	| // will print "true"
+	//	| console.log(flattened.braces);
+	}
+	=====*/
+
+	/*=====
+	dojo.setObject = function(name, value, context){
+	// summary:
+	//		Set a property from a dot-separated string, such as "A.B.C"
+	//	description:
+	//		Useful for longer api chains where you have to test each object in
+	//		the chain, or when you have an object reference in string format.
+	//		Objects are created as needed along `path`. Returns the passed
+	//		value if setting is successful or `undefined` if not.
+	//	name: String
+	//		Path to a property, in the form "A.B.C".
+	//	value: anything
+	//		value or object to place at location given by name
+	//	context: Object?
+	//		Optional. Object to use as root of path. Defaults to
+	//		`dojo.global`.
+	//	example:
+	//		set the value of `foo.bar.baz`, regardless of whether
+	//		intermediate objects already exist:
+	//	| lang.setObject("foo.bar.baz", value);
+	//	example:
+	//		without `lang.setObject`, we often see code like this:
+	//	| // ensure that intermediate objects are available
+	//	| if(!obj["parent"]){ obj.parent = {}; }
+	//	| if(!obj.parent["child"]){ obj.parent.child = {}; }
+	//	| // now we can safely set the property
+	//	| obj.parent.child.prop = "some value";
+	//		whereas with `lang.setObject`, we can shorten that to:
+	//	| lang.setObject("parent.child.prop", "some value", obj);
+	}
+	=====*/
+
+	/*=====
+	dojo.getObject = function(name, create, context){
+	// summary:
+	//		Get a property from a dot-separated string, such as "A.B.C"
+	//	description:
+	//		Useful for longer api chains where you have to test each object in
+	//		the chain, or when you have an object reference in string format.
+	//	name: String
+	//		Path to an property, in the form "A.B.C".
+	//	create: Boolean?
+	//		Optional. Defaults to `false`. If `true`, Objects will be
+	//		created at any point along the 'path' that is undefined.
+	//	context: Object?
+	//		Optional. Object to use as root of path. Defaults to
+	//		'dojo.global'. Null may be passed.
+	}
+	=====*/
+
+	/*=====
+	dojo.exists = function(name, obj){
+	//	summary:
+	//		determine if an object supports a given method
+	//	description:
+	//		useful for longer api chains where you have to test each object in
+	//		the chain. Useful for object and method detection.
+	//	name: String
+	//		Path to an object, in the form "A.B.C".
+	//	obj: Object?
+	//		Object to use as root of path. Defaults to
+	//		'dojo.global'. Null may be passed.
+	//	example:
+	//	| // define an object
+	//	| var foo = {
+	//	|		bar: { }
+	//	| };
+	//	|
+	//	| // search the global scope
+	//	| lang.exists("foo.bar"); // true
+	//	| lang.exists("foo.bar.baz"); // false
+	//	|
+	//	| // search from a particular scope
+	//	| lang.exists("bar", foo); // true
+	//	| lang.exists("bar.baz", foo); // false
+	}
+	=====*/
+
+	/*=====
+	dojo.isString = function(it){
+	//	summary:
+	//		Return true if it is a String
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.isArray = function(it){
+	//	summary:
+	//		Return true if it is an Array.
+	//		Does not work on Arrays created in other windows.
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.isFunction = function(it){
+	// summary:
+	//		Return true if it is a Function
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.isObject = function(it){
+	// summary:
+	//		Returns true if it is a JavaScript object (or an Array, a Function
+	//		or null)
+	//	it: anything
+	//		Item to test.
+	}
+	=====*/
+
+	/*=====
+	dojo.isArrayLike = function(it){
+	//	summary:
+	//		similar to dojo.isArray() but more permissive
+	//	it: anything
+	//		Item to test.
+	//	returns:
+	//		If it walks like a duck and quacks like a duck, return `true`
+	//	description:
+	//		Doesn't strongly test for "arrayness".  Instead, settles for "isn't
+	//		a string or number and has a length property". Arguments objects
+	//		and DOM collections will return true when passed to
+	//		dojo.isArrayLike(), but will return false when passed to
+	//		dojo.isArray().
+	}
+	=====*/
+
+	/*=====
+	dojo.isAlien = function(it){
+	// summary:
+	//		Returns true if it is a built-in function or some other kind of
+	//		oddball that *should* report as a function but doesn't
+	}
+	=====*/
+
+	/*=====
+	dojo.extend = function(constructor, props){
+	// summary:
+	//		Adds all properties and methods of props to constructor's
+	//		prototype, making them available to all instances created with
+	//		constructor.
+	//	constructor: Object
+	//		Target constructor to extend.
+	//	props: Object...
+	//		One or more objects to mix into constructor.prototype
+	}
+	=====*/
+
+	/*=====
+	dojo.hitch = function(scope, method){
+	//	summary:
+	//		Returns a function that will only ever execute in the a given scope.
+	//		This allows for easy use of object member functions
+	//		in callbacks and other places in which the "this" keyword may
+	//		otherwise not reference the expected scope.
+	//		Any number of default positional arguments may be passed as parameters
+	//		beyond "method".
+	//		Each of these values will be used to "placehold" (similar to curry)
+	//		for the hitched function.
+	//	scope: Object
+	//		The scope to use when method executes. If method is a string,
+	//		scope is also the object containing method.
+	//	method: Function|String...
+	//		A function to be hitched to scope, or the name of the method in
+	//		scope to be hitched.
+	//	example:
+	//	|	dojo.hitch(foo, "bar")();
+	//		runs foo.bar() in the scope of foo
+	//	example:
+	//	|	dojo.hitch(foo, myFunction);
+	//		returns a function that runs myFunction in the scope of foo
+	//	example:
+	//		Expansion on the default positional arguments passed along from
+	//		hitch. Passed args are mixed first, additional args after.
+	//	|	var foo = { bar: function(a, b, c){ console.log(a, b, c); } };
+	//	|	var fn = dojo.hitch(foo, "bar", 1, 2);
+	//	|	fn(3); // logs "1, 2, 3"
+	//	example:
+	//	|	var foo = { bar: 2 };
+	//	|	dojo.hitch(foo, function(){ this.bar = 10; })();
+	//		execute an anonymous function in scope of foo
+	}
+	=====*/
+
+	/*=====
+	dojo.delegate = function(obj, props){
+		//	summary:
+		//		Returns a new object which "looks" to obj for properties which it
+		//		does not have a value for. Optionally takes a bag of properties to
+		//		seed the returned object with initially.
+		//	description:
+		//		This is a small implementaton of the Boodman/Crockford delegation
+		//		pattern in JavaScript. An intermediate object constructor mediates
+		//		the prototype chain for the returned object, using it to delegate
+		//		down to obj for property lookup when object-local lookup fails.
+		//		This can be thought of similarly to ES4's "wrap", save that it does
+		//		not act on types but rather on pure objects.
+		//	obj: Object
+		//		The object to delegate to for properties not found directly on the
+		//		return object or in props.
+		//	props: Object...
+		//		an object containing properties to assign to the returned object
+		//	returns:
+		//		an Object of anonymous type
+		//	example:
+		//	|	var foo = { bar: "baz" };
+		//	|	var thinger = dojo.delegate(foo, { thud: "xyzzy"});
+		//	|	thinger.bar == "baz"; // delegated to foo
+		//	|	foo.thud == undefined; // by definition
+		//	|	thinger.thud == "xyzzy"; // mixed in from props
+		//	|	foo.bar = "thonk";
+		//	|	thinger.bar == "thonk"; // still delegated to foo's bar
+	}
+	=====*/
+
+	/*=====
+	dojo.partial = function(method){
+	//	summary:
+	//		similar to hitch() except that the scope object is left to be
+	//		whatever the execution context eventually becomes.
+	//	method: Function|String
+	//	description:
+	//		Calling dojo.partial is the functional equivalent of calling:
+	//		|	dojo.hitch(null, funcName, ...);
+	}
+	=====*/
+
+	/*=====
+	dojo.trim = function(str){
+		//	summary:
+		//		Trims whitespace from both sides of the string
+		//	str: String
+		//		String to be trimmed
+		//	returns: String
+		//		Returns the trimmed string
+		//	description:
+		//		This version of trim() was selected for inclusion into the base due
+		//		to its compact size and relatively good performance
+		//		(see [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript)
+		//		Uses String.prototype.trim instead, if available.
+		//		The fastest but longest version of this function is located at
+		//		dojo.string.trim()
+	}
+	=====*/
+
+	/*=====
+	dojo.clone = function(src){
+	// summary:
+	//		Clones objects (including DOM nodes) and all children.
+	//		Warning: do not clone cyclic structures.
+	//	src:
+	//		The object to clone
+	}
+	=====*/
+
+	/*=====
+	dojo._toArray = function(obj, offset, startWith){
+		//	summary:
+		//		Converts an array-like object (i.e. arguments, DOMCollection) to an
+		//		array. Returns a new Array with the elements of obj.
+		//	obj: Object
+		//		the object to "arrayify". We expect the object to have, at a
+		//		minimum, a length property which corresponds to integer-indexed
+		//		properties.
+		//	offset: Number?
+		//		the location in obj to start iterating from. Defaults to 0.
+		//		Optional.
+		//	startWith: Array?
+		//		An array to pack with the properties of obj. If provided,
+		//		properties in obj are appended at the end of startWith and
+		//		startWith is the returned array.
+	}
+	=====*/
+
+	/*=====
+	dojo.replace = function(tmpl, map, pattern){
+		//	summary:
+		//		Performs parameterized substitutions on a string. Throws an
+		//		exception if any parameter is unmatched.
+		//	tmpl: String
+		//		String to be used as a template.
+		//	map: Object|Function
+		//		If an object, it is used as a dictionary to look up substitutions.
+		//		If a function, it is called for every substitution with following
+		//		parameters: a whole match, a name, an offset, and the whole template
+		//		string (see https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace
+		//		for more details).
+		//	pattern: RegEx?
+		//		Optional regular expression objects that overrides the default pattern.
+		//		Must be global and match one item. The default is: /\{([^\}]+)\}/g,
+		//		which matches patterns like that: "{xxx}", where "xxx" is any sequence
+		//		of characters, which doesn't include "}".
+		//	returns: String
+		//		Returns the substituted string.
+		//	example:
+		//	|	// uses a dictionary for substitutions:
+		//	|	dojo.replace("Hello, {name.first} {name.last} AKA {nick}!",
+		//	|		{
+		//	|			nick: "Bob",
+		//	|			name: {
+		//	|				first:	"Robert",
+		//	|				middle: "X",
+		//	|				last:		"Cringely"
+		//	|			}
+		//	|		});
+		//	|	// returns: Hello, Robert Cringely AKA Bob!
+		//	example:
+		//	|	// uses an array for substitutions:
+		//	|	dojo.replace("Hello, {0} {2}!",
+		//	|		["Robert", "X", "Cringely"]);
+		//	|	// returns: Hello, Robert Cringely!
+		//	example:
+		//	|	// uses a function for substitutions:
+		//	|	function sum(a){
+		//	|		var t = 0;
+		//	|		dojo.forEach(a, function(x){ t += x; });
+		//	|		return t;
+		//	|	}
+		//	|	dojo.replace(
+		//	|		"{count} payments averaging {avg} USD per payment.",
+		//	|		dojo.hitch(
+		//	|			{ payments: [11, 16, 12] },
+		//	|			function(_, key){
+		//	|				switch(key){
+		//	|					case "count": return this.payments.length;
+		//	|					case "min":		return Math.min.apply(Math, this.payments);
+		//	|					case "max":		return Math.max.apply(Math, this.payments);
+		//	|					case "sum":		return sum(this.payments);
+		//	|					case "avg":		return sum(this.payments) / this.payments.length;
+		//	|				}
+		//	|			}
+		//	|		)
+		//	|	);
+		//	|	// prints: 3 payments averaging 13 USD per payment.
+		//	example:
+		//	|	// uses an alternative PHP-like pattern for substitutions:
+		//	|	dojo.replace("Hello, ${0} ${2}!",
+		//	|		["Robert", "X", "Cringely"], /\$\{([^\}]+)\}/g);
+		//	|	// returns: Hello, Robert Cringely!
+		return "";	// String
+	}
+	=====*/
+});
+
+
+},
+'dojo/Evented':function(){
+define(["./aspect", "./on"], function(aspect, on){
+	// summary:
+	//		The export of this module is a class that can be used as a mixin or base class, 
+	// 		to add on() and emit() methods to a class
+	// 		for listening for events and emiting events:
+	// 		|define(["dojo/Evented"], function(Evented){
+	// 		|	var EventedWidget = dojo.declare([Evented, dijit._Widget], {...});
+	//		|	widget = new EventedWidget();
+	//		|	widget.on("open", function(event){
+	//		|	... do something with event
+	//		|	 });
+	//		|
+	//		|	widget.emit("open", {name:"some event", ...});
+
+ 	"use strict";
+ 	var after = aspect.after;
+	function Evented(){
+	}
+	Evented.prototype = {
+		on: function(type, listener){
+			return on.parse(this, type, listener, function(target, type){
+				return after(target, 'on' + type, listener, true);
+			});
+		},
+		emit: function(type, event){
+			var args = [this];
+			args.push.apply(args, arguments);
+			return on.emit.apply(on, args);
+		}
+	};
+	return Evented;
+});
+
+},
+'dojo/mouse':function(){
+define(["./_base/kernel", "./on", "./has", "./dom", "./_base/window"], function(dojo, on, has, dom, win){
+
+	/*=====
+	dojo.mouse = {
+	// summary:
+	//		This module provide mouse event handling utility functions and exports
+	//		mouseenter and mouseleave event emulation.
+	// enter: Synthetic Event
+	//		This is an extension event for the mouseenter that IE provides, emulating the
+	//		behavior on other browsers.
+	// leave: Synthetic Event
+	//		This is an extension event for the mouseleave that IE provides, emulating the
+	//		behavior on other browsers.
+	// isLeft: Function
+	//		Test an event object (from a mousedown event) to see if the left button was pressed.
+	// isMiddle: Function
+	//		Test an event object (from a mousedown event) to see if the middle button was pressed.
+	// isRight: Function
+	//		Test an event object (from a mousedown event) to see if the right button was pressed.
+	// example:
+	//		To use these events, you register a mouseenter like this:
+	//		|	define(["dojo/on", dojo/mouse"], function(on, mouse){
+	//		|		on(targetNode, mouse.enter, function(event){
+	//		|			dojo.addClass(targetNode, "highlighted");
+	//		|		});
+	//		|		on(targetNode, mouse.leave, function(event){
+	//		|			dojo.removeClass(targetNode, "highlighted");
+	//		|		});
+	};
+	======*/
+
+    has.add("dom-quirks", win.doc && win.doc.compatMode == "BackCompat");
+ 	has.add("events-mouseenter", win.doc && "onmouseenter" in win.doc.createElement("div"));
+
+	var mouseButtons;
+	if(has("dom-quirks") || !has("dom-addeventlistener")){
+		mouseButtons = {
+			LEFT:   1,
+			MIDDLE: 4,
+			RIGHT:  2,
+			// helper functions
+			isButton: function(e, button){ return e.button & button; },
+			isLeft:   function(e){ return e.button & 1; },
+			isMiddle: function(e){ return e.button & 4; },
+			isRight:  function(e){ return e.button & 2; }
+		};
+	}else{
+		mouseButtons = {
+			LEFT:   0,
+			MIDDLE: 1,
+			RIGHT:  2,
+			// helper functions
+			isButton: function(e, button){ return e.button == button; },
+			isLeft:   function(e){ return e.button == 0; },
+			isMiddle: function(e){ return e.button == 1; },
+			isRight:  function(e){ return e.button == 2; }
+		};
+	}
+	dojo.mouseButtons = mouseButtons;
+
+/*=====
+	dojo.mouseButtons = {
+		// LEFT: Number
+		//		Numeric value of the left mouse button for the platform.
+		LEFT:   0,
+		// MIDDLE: Number
+		//		Numeric value of the middle mouse button for the platform.
+		MIDDLE: 1,
+		// RIGHT: Number
+		//		Numeric value of the right mouse button for the platform.
+		RIGHT:  2,
+
+		isButton: function(e, button){
+			// summary:
+			//		Checks an event object for a pressed button
+			// e: Event
+			//		Event object to examine
+			// button: Number
+			//		The button value (example: dojo.mouseButton.LEFT)
+			return e.button == button; // Boolean
+		},
+		isLeft: function(e){
+			// summary:
+			//		Checks an event object for the pressed left button
+			// e: Event
+			//		Event object to examine
+			return e.button == 0; // Boolean
+		},
+		isMiddle: function(e){
+			// summary:
+			//		Checks an event object for the pressed middle button
+			// e: Event
+			//		Event object to examine
+			return e.button == 1; // Boolean
+		},
+		isRight: function(e){
+			// summary:
+			//		Checks an event object for the pressed right button
+			// e: Event
+			//		Event object to examine
+			return e.button == 2; // Boolean
+		}
+	};
+=====*/
+
+	function eventHandler(type, mustBubble){
+		// emulation of mouseenter/leave with mouseover/out using descendant checking
+		var handler = function(node, listener){
+			return on(node, type, function(evt){
+				if(!dom.isDescendant(evt.relatedTarget, mustBubble ? evt.target : node)){
+					return listener.call(this, evt);
+				}
+			});
+		};
+		if(!mustBubble){
+			handler.bubble = eventHandler(type, true);
+		}
+		return handler;
+	}
+	return {
+		enter: eventHandler("mouseover"),
+		leave: eventHandler("mouseout"),
+		isLeft: mouseButtons.isLeft,
+		isMiddle: mouseButtons.isMiddle,
+		isRight: mouseButtons.isRight
+	};
+});
+
+},
+'dojo/topic':function(){
+define(["./Evented"], function(Evented){
+	// summary:
+	//		The export of this module is a pubsub hub
+	//		You can also use listen function itself as a pub/sub hub:
+	//		| 	topic.subscribe("some/topic", function(event){
+	//		|	... do something with event
+	//		|	});
+	//		|	topic.publish("some/topic", {name:"some event", ...});
+
+	var hub = new Evented;
+	return {
+		publish: function(topic, event){
+			// summary:
+			//		Publishes a message to a topic on the pub/sub hub. All arguments after
+			// 		the first will be passed to the subscribers, so any number of arguments
+			// 		can be provided (not just event).
+			// topic: String
+			//		The name of the topic to publish to
+			// event: Object
+			//		An event to distribute to the topic listeners
+			return hub.emit.apply(hub, arguments);
+		},
+		subscribe: function(topic, listener){
+			// summary:
+			//		Subcribes to a topic on the pub/sub hub
+			// topic: String
+			//		The topic to subscribe to
+			//	listener: Function
+			//		A function to call when a message is published to the given topic
+			return hub.on.apply(hub, arguments);
+		}
+	}
+});
+
+},
+'dojo/_base/xhr':function(){
+define([
+	"./kernel", "./sniff", "require", "../io-query", "../dom", "../dom-form", "./Deferred", "./json", "./lang", "./array", "../on"
+], function(dojo, has, require, ioq, dom, domForm, deferred, json, lang, array, on){
+	//	module:
+	//		dojo/_base.xhr
+	// summary:
+	//		This modules defines the dojo.xhr* API.
+
+	has.add("native-xhr", function() {
+		// if true, the environment has a native XHR implementation
+		return typeof XMLHttpRequest !== 'undefined';
+	});
+
+	if(1){
+		dojo._xhrObj = require.getXhr;
+	}else if (has("native-xhr")){
+		dojo._xhrObj = function(){
+			// summary:
+			//		does the work of portably generating a new XMLHTTPRequest object.
+			try{
+				return new XMLHttpRequest();
+			}catch(e){
+				throw new Error("XMLHTTP not available: "+e);
+			}
+		};
+	}else{
+		// PROGIDs are in order of decreasing likelihood; this will change in time.
+		for(var XMLHTTP_PROGIDS = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'], progid, i = 0; i < 3;){
+			try{
+				progid = XMLHTTP_PROGIDS[i++];
+				if (new ActiveXObject(progid)) {
+					// this progid works; therefore, use it from now on
+					break;
+				}
+			}catch(e){
+				// squelch; we're just trying to find a good ActiveX PROGID
+				// if they all fail, then progid ends up as the last attempt and that will signal the error
+				// the first time the client actually tries to exec an xhr
+			}
+		}
+		dojo._xhrObj= function() {
+			return new ActiveXObject(progid);
+		};
+	}
+
+	var cfg = dojo.config;
+
+	// mix in io-query and dom-form
+	dojo.objectToQuery = ioq.objectToQuery;
+	dojo.queryToObject = ioq.queryToObject;
+	dojo.fieldToObject = domForm.fieldToObject;
+	dojo.formToObject = domForm.toObject;
+	dojo.formToQuery = domForm.toQuery;
+	dojo.formToJson = domForm.toJson;
+
+	// need to block async callbacks from snatching this thread as the result
+	// of an async callback might call another sync XHR, this hangs khtml forever
+	// must checked by watchInFlight()
+
+	dojo._blockAsync = false;
+
+	// MOW: remove dojo._contentHandlers alias in 2.0
+	var handlers = dojo._contentHandlers = dojo.contentHandlers = {
+		// summary:
+		//		A map of availble XHR transport handle types. Name matches the
+		//		`handleAs` attribute passed to XHR calls.
+		//
+		// description:
+		//		A map of availble XHR transport handle types. Name matches the
+		//		`handleAs` attribute passed to XHR calls. Each contentHandler is
+		//		called, passing the xhr object for manipulation. The return value
+		//		from the contentHandler will be passed to the `load` or `handle`
+		//		functions defined in the original xhr call.
+		//
+		// example:
+		//		Creating a custom content-handler:
+		//	|	dojo.contentHandlers.makeCaps = function(xhr){
+		//	|		return xhr.responseText.toUpperCase();
+		//	|	}
+		//	|	// and later:
+		//	|	dojo.xhrGet({
+		//	|		url:"foo.txt",
+		//	|		handleAs:"makeCaps",
+		//	|		load: function(data){ /* data is a toUpper version of foo.txt */ }
+		//	|	});
+
+		"text": function(xhr){
+			// summary: A contentHandler which simply returns the plaintext response data
+			return xhr.responseText;
+		},
+		"json": function(xhr){
+			// summary: A contentHandler which returns a JavaScript object created from the response data
+			return json.fromJson(xhr.responseText || null);
+		},
+		"json-comment-filtered": function(xhr){
+			// summary: A contentHandler which expects comment-filtered JSON.
+			// description:
+			//		A contentHandler which expects comment-filtered JSON.
+			//		the json-comment-filtered option was implemented to prevent
+			//		"JavaScript Hijacking", but it is less secure than standard JSON. Use
+			//		standard JSON instead. JSON prefixing can be used to subvert hijacking.
+			//
+			//		Will throw a notice suggesting to use application/json mimetype, as
+			//		json-commenting can introduce security issues. To decrease the chances of hijacking,
+			//		use the standard `json` contentHandler, and prefix your "JSON" with: {}&&
+			//
+			//		use djConfig.useCommentedJson = true to turn off the notice
+			if(!dojo.config.useCommentedJson){
+				console.warn("Consider using the standard mimetype:application/json."
+					+ " json-commenting can introduce security issues. To"
+					+ " decrease the chances of hijacking, use the standard the 'json' handler and"
+					+ " prefix your json with: {}&&\n"
+					+ "Use djConfig.useCommentedJson=true to turn off this message.");
+			}
+
+			var value = xhr.responseText;
+			var cStartIdx = value.indexOf("\/*");
+			var cEndIdx = value.lastIndexOf("*\/");
+			if(cStartIdx == -1 || cEndIdx == -1){
+				throw new Error("JSON was not comment filtered");
+			}
+			return json.fromJson(value.substring(cStartIdx+2, cEndIdx));
+		},
+		"javascript": function(xhr){
+			// summary: A contentHandler which evaluates the response data, expecting it to be valid JavaScript
+
+			// FIXME: try Moz and IE specific eval variants?
+			return dojo.eval(xhr.responseText);
+		},
+		"xml": function(xhr){
+			// summary: A contentHandler returning an XML Document parsed from the response data
+			var result = xhr.responseXML;
+
+			if(has("ie")){
+				if((!result || !result.documentElement)){
+					//WARNING: this branch used by the xml handling in dojo.io.iframe,
+					//so be sure to test dojo.io.iframe if making changes below.
+					var ms = function(n){ return "MSXML" + n + ".DOMDocument"; };
+					var dp = ["Microsoft.XMLDOM", ms(6), ms(4), ms(3), ms(2)];
+					array.some(dp, function(p){
+						try{
+							var dom = new ActiveXObject(p);
+							dom.async = false;
+							dom.loadXML(xhr.responseText);
+							result = dom;
+						}catch(e){ return false; }
+						return true;
+					});
+				}
+		 }
+			return result; // DOMDocument
+		},
+		"json-comment-optional": function(xhr){
+			// summary: A contentHandler which checks the presence of comment-filtered JSON and
+			//		alternates between the `json` and `json-comment-filtered` contentHandlers.
+			if(xhr.responseText && /^[^{\[]*\/\*/.test(xhr.responseText)){
+				return handlers["json-comment-filtered"](xhr);
+			}else{
+				return handlers["json"](xhr);
+			}
+		}
+	};
+
+	/*=====
+	dojo.__IoArgs = function(){
+		//	url: String
+		//		URL to server endpoint.
+		//	content: Object?
+		//		Contains properties with string values. These
+		//		properties will be serialized as name1=value2 and
+		//		passed in the request.
+		//	timeout: Integer?
+		//		Milliseconds to wait for the response. If this time
+		//		passes, the then error callbacks are called.
+		//	form: DOMNode?
+		//		DOM node for a form. Used to extract the form values
+		//		and send to the server.
+		//	preventCache: Boolean?
+		//		Default is false. If true, then a
+		//		"dojo.preventCache" parameter is sent in the request
+		//		with a value that changes with each request
+		//		(timestamp). Useful only with GET-type requests.
+		//	handleAs: String?
+		//		Acceptable values depend on the type of IO
+		//		transport (see specific IO calls for more information).
+		//	rawBody: String?
+		//		Sets the raw body for an HTTP request. If this is used, then the content
+		//		property is ignored. This is mostly useful for HTTP methods that have
+		//		a body to their requests, like PUT or POST. This property can be used instead
+		//		of postData and putData for dojo.rawXhrPost and dojo.rawXhrPut respectively.
+		//	ioPublish: Boolean?
+		//		Set this explicitly to false to prevent publishing of topics related to
+		//		IO operations. Otherwise, if djConfig.ioPublish is set to true, topics
+		//		will be published via dojo.publish for different phases of an IO operation.
+		//		See dojo.__IoPublish for a list of topics that are published.
+		//	load: Function?
+		//		This function will be
+		//		called on a successful HTTP response code.
+		//	error: Function?
+		//		This function will
+		//		be called when the request fails due to a network or server error, the url
+		//		is invalid, etc. It will also be called if the load or handle callback throws an
+		//		exception, unless djConfig.debugAtAllCosts is true.	 This allows deployed applications
+		//		to continue to run even when a logic error happens in the callback, while making
+		//		it easier to troubleshoot while in debug mode.
+		//	handle: Function?
+		//		This function will
+		//		be called at the end of every request, whether or not an error occurs.
+		this.url = url;
+		this.content = content;
+		this.timeout = timeout;
+		this.form = form;
+		this.preventCache = preventCache;
+		this.handleAs = handleAs;
+		this.ioPublish = ioPublish;
+		this.load = function(response, ioArgs){
+			// ioArgs: dojo.__IoCallbackArgs
+			//		Provides additional information about the request.
+			// response: Object
+			//		The response in the format as defined with handleAs.
+		}
+		this.error = function(response, ioArgs){
+			// ioArgs: dojo.__IoCallbackArgs
+			//		Provides additional information about the request.
+			// response: Object
+			//		The response in the format as defined with handleAs.
+		}
+		this.handle = function(loadOrError, response, ioArgs){
+			// loadOrError: String
+			//		Provides a string that tells you whether this function
+			//		was called because of success (load) or failure (error).
+			// response: Object
+			//		The response in the format as defined with handleAs.
+			// ioArgs: dojo.__IoCallbackArgs
+			//		Provides additional information about the request.
+		}
+	}
+	=====*/
+
+	/*=====
+	dojo.__IoCallbackArgs = function(args, xhr, url, query, handleAs, id, canDelete, json){
+		//	args: Object
+		//		the original object argument to the IO call.
+		//	xhr: XMLHttpRequest
+		//		For XMLHttpRequest calls only, the
+		//		XMLHttpRequest object that was used for the
+		//		request.
+		//	url: String
+		//		The final URL used for the call. Many times it
+		//		will be different than the original args.url
+		//		value.
+		//	query: String
+		//		For non-GET requests, the
+		//		name1=value1&name2=value2 parameters sent up in
+		//		the request.
+		//	handleAs: String
+		//		The final indicator on how the response will be
+		//		handled.
+		//	id: String
+		//		For dojo.io.script calls only, the internal
+		//		script ID used for the request.
+		//	canDelete: Boolean
+		//		For dojo.io.script calls only, indicates
+		//		whether the script tag that represents the
+		//		request can be deleted after callbacks have
+		//		been called. Used internally to know when
+		//		cleanup can happen on JSONP-type requests.
+		//	json: Object
+		//		For dojo.io.script calls only: holds the JSON
+		//		response for JSONP-type requests. Used
+		//		internally to hold on to the JSON responses.
+		//		You should not need to access it directly --
+		//		the same object should be passed to the success
+		//		callbacks directly.
+		this.args = args;
+		this.xhr = xhr;
+		this.url = url;
+		this.query = query;
+		this.handleAs = handleAs;
+		this.id = id;
+		this.canDelete = canDelete;
+		this.json = json;
+	}
+	=====*/
+
+
+	/*=====
+	dojo.__IoPublish = function(){
+		//	summary:
+		//		This is a list of IO topics that can be published
+		//		if djConfig.ioPublish is set to true. IO topics can be
+		//		published for any Input/Output, network operation. So,
+		//		dojo.xhr, dojo.io.script and dojo.io.iframe can all
+		//		trigger these topics to be published.
+		//	start: String
+		//		"/dojo/io/start" is sent when there are no outstanding IO
+		//		requests, and a new IO request is started. No arguments
+		//		are passed with this topic.
+		//	send: String
+		//		"/dojo/io/send" is sent whenever a new IO request is started.
+		//		It passes the dojo.Deferred for the request with the topic.
+		//	load: String
+		//		"/dojo/io/load" is sent whenever an IO request has loaded
+		//		successfully. It passes the response and the dojo.Deferred
+		//		for the request with the topic.
+		//	error: String
+		//		"/dojo/io/error" is sent whenever an IO request has errored.
+		//		It passes the error and the dojo.Deferred
+		//		for the request with the topic.
+		//	done: String
+		//		"/dojo/io/done" is sent whenever an IO request has completed,
+		//		either by loading or by erroring. It passes the error and
+		//		the dojo.Deferred for the request with the topic.
+		//	stop: String
+		//		"/dojo/io/stop" is sent when all outstanding IO requests have
+		//		finished. No arguments are passed with this topic.
+		this.start = "/dojo/io/start";
+		this.send = "/dojo/io/send";
+		this.load = "/dojo/io/load";
+		this.error = "/dojo/io/error";
+		this.done = "/dojo/io/done";
+		this.stop = "/dojo/io/stop";
+	}
+	=====*/
+
+
+	dojo._ioSetArgs = function(/*dojo.__IoArgs*/args,
+			/*Function*/canceller,
+			/*Function*/okHandler,
+			/*Function*/errHandler){
+		//	summary:
+		//		sets up the Deferred and ioArgs property on the Deferred so it
+		//		can be used in an io call.
+		//	args:
+		//		The args object passed into the public io call. Recognized properties on
+		//		the args object are:
+		//	canceller:
+		//		The canceller function used for the Deferred object. The function
+		//		will receive one argument, the Deferred object that is related to the
+		//		canceller.
+		//	okHandler:
+		//		The first OK callback to be registered with Deferred. It has the opportunity
+		//		to transform the OK response. It will receive one argument -- the Deferred
+		//		object returned from this function.
+		//	errHandler:
+		//		The first error callback to be registered with Deferred. It has the opportunity
+		//		to do cleanup on an error. It will receive two arguments: error (the
+		//		Error object) and dfd, the Deferred object returned from this function.
+
+		var ioArgs = {args: args, url: args.url};
+
+		//Get values from form if requestd.
+		var formObject = null;
+		if(args.form){
+			var form = dom.byId(args.form);
+			//IE requires going through getAttributeNode instead of just getAttribute in some form cases,
+			//so use it for all. See #2844
+			var actnNode = form.getAttributeNode("action");
+			ioArgs.url = ioArgs.url || (actnNode ? actnNode.value : null);
+			formObject = domForm.toObject(form);
+		}
+
+		// set up the query params
+		var miArgs = [{}];
+
+		if(formObject){
+			// potentially over-ride url-provided params w/ form values
+			miArgs.push(formObject);
+		}
+		if(args.content){
+			// stuff in content over-rides what's set by form
+			miArgs.push(args.content);
+		}
+		if(args.preventCache){
+			miArgs.push({"dojo.preventCache": new Date().valueOf()});
+		}
+		ioArgs.query = ioq.objectToQuery(lang.mixin.apply(null, miArgs));
+
+		// .. and the real work of getting the deferred in order, etc.
+		ioArgs.handleAs = args.handleAs || "text";
+		var d = new deferred(canceller);
+		d.addCallbacks(okHandler, function(error){
+			return errHandler(error, d);
+		});
+
+		//Support specifying load, error and handle callback functions from the args.
+		//For those callbacks, the "this" object will be the args object.
+		//The callbacks will get the deferred result value as the
+		//first argument and the ioArgs object as the second argument.
+		var ld = args.load;
+		if(ld && lang.isFunction(ld)){
+			d.addCallback(function(value){
+				return ld.call(args, value, ioArgs);
+			});
+		}
+		var err = args.error;
+		if(err && lang.isFunction(err)){
+			d.addErrback(function(value){
+				return err.call(args, value, ioArgs);
+			});
+		}
+		var handle = args.handle;
+		if(handle && lang.isFunction(handle)){
+			d.addBoth(function(value){
+				return handle.call(args, value, ioArgs);
+			});
+		}
+
+		//Plug in topic publishing, if dojo.publish is loaded.
+		if(cfg.ioPublish && dojo.publish && ioArgs.args.ioPublish !== false){
+			d.addCallbacks(
+				function(res){
+					dojo.publish("/dojo/io/load", [d, res]);
+					return res;
+				},
+				function(res){
+					dojo.publish("/dojo/io/error", [d, res]);
+					return res;
+				}
+			);
+			d.addBoth(function(res){
+				dojo.publish("/dojo/io/done", [d, res]);
+				return res;
+			});
+		}
+
+		d.ioArgs = ioArgs;
+
+		// FIXME: need to wire up the xhr object's abort method to something
+		// analagous in the Deferred
+		return d;
+	};
+
+	var _deferredCancel = function(/*Deferred*/dfd){
+		// summary: canceller function for dojo._ioSetArgs call.
+
+		dfd.canceled = true;
+		var xhr = dfd.ioArgs.xhr;
+		var _at = typeof xhr.abort;
+		if(_at == "function" || _at == "object" || _at == "unknown"){
+			xhr.abort();
+		}
+		var err = dfd.ioArgs.error;
+		if(!err){
+			err = new Error("xhr cancelled");
+			err.dojoType="cancel";
+		}
+		return err;
+	};
+	var _deferredOk = function(/*Deferred*/dfd){
+		// summary: okHandler function for dojo._ioSetArgs call.
+
+		var ret = handlers[dfd.ioArgs.handleAs](dfd.ioArgs.xhr);
+		return ret === undefined ? null : ret;
+	};
+	var _deferError = function(/*Error*/error, /*Deferred*/dfd){
+		// summary: errHandler function for dojo._ioSetArgs call.
+
+		if(!dfd.ioArgs.args.failOk){
+			console.error(error);
+		}
+		return error;
+	};
+
+	// avoid setting a timer per request. It degrades performance on IE
+	// something fierece if we don't use unified loops.
+	var _inFlightIntvl = null;
+	var _inFlight = [];
+
+
+	//Use a separate count for knowing if we are starting/stopping io calls.
+	//Cannot use _inFlight.length since it can change at a different time than
+	//when we want to do this kind of test. We only want to decrement the count
+	//after a callback/errback has finished, since the callback/errback should be
+	//considered as part of finishing a request.
+	var _pubCount = 0;
+	var _checkPubCount = function(dfd){
+		if(_pubCount <= 0){
+			_pubCount = 0;
+			if(cfg.ioPublish && dojo.publish && (!dfd || dfd && dfd.ioArgs.args.ioPublish !== false)){
+				dojo.publish("/dojo/io/stop");
+			}
+		}
+	};
+
+	var _watchInFlight = function(){
+		//summary:
+		//		internal method that checks each inflight XMLHttpRequest to see
+		//		if it has completed or if the timeout situation applies.
+
+		var now = (new Date()).getTime();
+		// make sure sync calls stay thread safe, if this callback is called
+		// during a sync call and this results in another sync call before the
+		// first sync call ends the browser hangs
+		if(!dojo._blockAsync){
+			// we need manual loop because we often modify _inFlight (and therefore 'i') while iterating
+			// note: the second clause is an assigment on purpose, lint may complain
+			for(var i = 0, tif; i < _inFlight.length && (tif = _inFlight[i]); i++){
+				var dfd = tif.dfd;
+				var func = function(){
+					if(!dfd || dfd.canceled || !tif.validCheck(dfd)){
+						_inFlight.splice(i--, 1);
+						_pubCount -= 1;
+					}else if(tif.ioCheck(dfd)){
+						_inFlight.splice(i--, 1);
+						tif.resHandle(dfd);
+						_pubCount -= 1;
+					}else if(dfd.startTime){
+						//did we timeout?
+						if(dfd.startTime + (dfd.ioArgs.args.timeout || 0) < now){
+							_inFlight.splice(i--, 1);
+							var err = new Error("timeout exceeded");
+							err.dojoType = "timeout";
+							dfd.errback(err);
+							//Cancel the request so the io module can do appropriate cleanup.
+							dfd.cancel();
+							_pubCount -= 1;
+						}
+					}
+				};
+				if(dojo.config.debugAtAllCosts){
+					func.call(this);
+				}else{
+//					try{
+						func.call(this);
+	/*				}catch(e){
+						dfd.errback(e);
+					}*/
+				}
+			}
+		}
+
+		_checkPubCount(dfd);
+
+		if(!_inFlight.length){
+			clearInterval(_inFlightIntvl);
+			_inFlightIntvl = null;
+		}
+	};
+
+	dojo._ioCancelAll = function(){
+		//summary: Cancels all pending IO requests, regardless of IO type
+		//(xhr, script, iframe).
+		try{
+			array.forEach(_inFlight, function(i){
+				try{
+					i.dfd.cancel();
+				}catch(e){/*squelch*/}
+			});
+		}catch(e){/*squelch*/}
+	};
+
+	//Automatically call cancel all io calls on unload
+	//in IE for trac issue #2357.
+	if(has("ie")){
+		on(window, "unload", dojo._ioCancelAll);
+	}
+
+	dojo._ioNotifyStart = function(/*Deferred*/dfd){
+		// summary:
+		//		If dojo.publish is available, publish topics
+		//		about the start of a request queue and/or the
+		//		the beginning of request.
+		// description:
+		//		Used by IO transports. An IO transport should
+		//		call this method before making the network connection.
+		if(cfg.ioPublish && dojo.publish && dfd.ioArgs.args.ioPublish !== false){
+			if(!_pubCount){
+				dojo.publish("/dojo/io/start");
+			}
+			_pubCount += 1;
+			dojo.publish("/dojo/io/send", [dfd]);
+		}
+	};
+
+	dojo._ioWatch = function(dfd, validCheck, ioCheck, resHandle){
+		// summary:
+		//		Watches the io request represented by dfd to see if it completes.
+		// dfd: Deferred
+		//		The Deferred object to watch.
+		// validCheck: Function
+		//		Function used to check if the IO request is still valid. Gets the dfd
+		//		object as its only argument.
+		// ioCheck: Function
+		//		Function used to check if basic IO call worked. Gets the dfd
+		//		object as its only argument.
+		// resHandle: Function
+		//		Function used to process response. Gets the dfd
+		//		object as its only argument.
+		var args = dfd.ioArgs.args;
+		if(args.timeout){
+			dfd.startTime = (new Date()).getTime();
+		}
+
+		_inFlight.push({dfd: dfd, validCheck: validCheck, ioCheck: ioCheck, resHandle: resHandle});
+		if(!_inFlightIntvl){
+			_inFlightIntvl = setInterval(_watchInFlight, 50);
+		}
+		// handle sync requests
+		//A weakness: async calls in flight
+		//could have their handlers called as part of the
+		//_watchInFlight call, before the sync's callbacks
+		// are called.
+		if(args.sync){
+			_watchInFlight();
+		}
+	};
+
+	var _defaultContentType = "application/x-www-form-urlencoded";
+
+	var _validCheck = function(/*Deferred*/dfd){
+		return dfd.ioArgs.xhr.readyState; //boolean
+	};
+	var _ioCheck = function(/*Deferred*/dfd){
+		return 4 == dfd.ioArgs.xhr.readyState; //boolean
+	};
+	var _resHandle = function(/*Deferred*/dfd){
+		var xhr = dfd.ioArgs.xhr;
+		if(dojo._isDocumentOk(xhr)){
+			dfd.callback(dfd);
+		}else{
+			var err = new Error("Unable to load " + dfd.ioArgs.url + " status:" + xhr.status);
+			err.status = xhr.status;
+			err.responseText = xhr.responseText;
+			err.xhr = xhr;
+			dfd.errback(err);
+		}
+	};
+
+	dojo._ioAddQueryToUrl = function(/*dojo.__IoCallbackArgs*/ioArgs){
+		//summary: Adds query params discovered by the io deferred construction to the URL.
+		//Only use this for operations which are fundamentally GET-type operations.
+		if(ioArgs.query.length){
+			ioArgs.url += (ioArgs.url.indexOf("?") == -1 ? "?" : "&") + ioArgs.query;
+			ioArgs.query = null;
+		}
+	};
+
+	/*=====
+	dojo.declare("dojo.__XhrArgs", dojo.__IoArgs, {
+		constructor: function(){
+			//	summary:
+			//		In addition to the properties listed for the dojo._IoArgs type,
+			//		the following properties are allowed for dojo.xhr* methods.
+			//	handleAs: String?
+			//		Acceptable values are: text (default), json, json-comment-optional,
+			//		json-comment-filtered, javascript, xml. See `dojo.contentHandlers`
+			//	sync: Boolean?
+			//		false is default. Indicates whether the request should
+			//		be a synchronous (blocking) request.
+			//	headers: Object?
+			//		Additional HTTP headers to send in the request.
+			//	failOk: Boolean?
+			//		false is default. Indicates whether a request should be
+			//		allowed to fail (and therefore no console error message in
+			//		the event of a failure)
+			//	contentType: String|Boolean
+			//		"application/x-www-form-urlencoded" is default. Set to false to
+			//		prevent a Content-Type header from being sent, or to a string
+			//		to send a different Content-Type.
+			this.handleAs = handleAs;
+			this.sync = sync;
+			this.headers = headers;
+			this.failOk = failOk;
+		}
+	});
+	=====*/
+
+	dojo.xhr = function(/*String*/ method, /*dojo.__XhrArgs*/ args, /*Boolean?*/ hasBody){
+		//	summary:
+		//		Sends an HTTP request with the given method.
+		//	description:
+		//		Sends an HTTP request with the given method.
+		//		See also dojo.xhrGet(), xhrPost(), xhrPut() and dojo.xhrDelete() for shortcuts
+		//		for those HTTP methods. There are also methods for "raw" PUT and POST methods
+		//		via dojo.rawXhrPut() and dojo.rawXhrPost() respectively.
+		//	method:
+		//		HTTP method to be used, such as GET, POST, PUT, DELETE. Should be uppercase.
+		//	hasBody:
+		//		If the request has an HTTP body, then pass true for hasBody.
+
+		//Make the Deferred object for this xhr request.
+		var dfd = dojo._ioSetArgs(args, _deferredCancel, _deferredOk, _deferError);
+		var ioArgs = dfd.ioArgs;
+
+		//Pass the args to _xhrObj, to allow alternate XHR calls based specific calls, like
+		//the one used for iframe proxies.
+		var xhr = ioArgs.xhr = dojo._xhrObj(ioArgs.args);
+		//If XHR factory fails, cancel the deferred.
+		if(!xhr){
+			dfd.cancel();
+			return dfd;
+		}
+
+		//Allow for specifying the HTTP body completely.
+		if("postData" in args){
+			ioArgs.query = args.postData;
+		}else if("putData" in args){
+			ioArgs.query = args.putData;
+		}else if("rawBody" in args){
+			ioArgs.query = args.rawBody;
+		}else if((arguments.length > 2 && !hasBody) || "POST|PUT".indexOf(method.toUpperCase()) == -1){
+			//Check for hasBody being passed. If no hasBody,
+			//then only append query string if not a POST or PUT request.
+			dojo._ioAddQueryToUrl(ioArgs);
+		}
+
+		// IE 6 is a steaming pile. It won't let you call apply() on the native function (xhr.open).
+		// workaround for IE6's apply() "issues"
+		xhr.open(method, ioArgs.url, args.sync !== true, args.user || undefined, args.password || undefined);
+		if(args.headers){
+			for(var hdr in args.headers){
+				if(hdr.toLowerCase() === "content-type" && !args.contentType){
+					args.contentType = args.headers[hdr];
+				}else if(args.headers[hdr]){
+					//Only add header if it has a value. This allows for instnace, skipping
+					//insertion of X-Requested-With by specifying empty value.
+					xhr.setRequestHeader(hdr, args.headers[hdr]);
+				}
+			}
+		}
+		// FIXME: is this appropriate for all content types?
+		if(args.contentType !== false){
+			xhr.setRequestHeader("Content-Type", args.contentType || _defaultContentType);
+		}
+		if(!args.headers || !("X-Requested-With" in args.headers)){
+			xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+		}
+		// FIXME: set other headers here!
+		dojo._ioNotifyStart(dfd);
+		if(dojo.config.debugAtAllCosts){
+			xhr.send(ioArgs.query);
+		}else{
+			try{
+				xhr.send(ioArgs.query);
+			}catch(e){
+				ioArgs.error = e;
+				dfd.cancel();
+			}
+		}
+		dojo._ioWatch(dfd, _validCheck, _ioCheck, _resHandle);
+		xhr = null;
+		return dfd; // dojo.Deferred
+	};
+
+	dojo.xhrGet = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP GET request to the server.
+		return dojo.xhr("GET", args); // dojo.Deferred
+	};
+
+	dojo.rawXhrPost = dojo.xhrPost = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP POST request to the server. In addtion to the properties
+		//		listed for the dojo.__XhrArgs type, the following property is allowed:
+		//	postData:
+		//		String. Send raw data in the body of the POST request.
+		return dojo.xhr("POST", args, true); // dojo.Deferred
+	};
+
+	dojo.rawXhrPut = dojo.xhrPut = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP PUT request to the server. In addtion to the properties
+		//		listed for the dojo.__XhrArgs type, the following property is allowed:
+		//	putData:
+		//		String. Send raw data in the body of the PUT request.
+		return dojo.xhr("PUT", args, true); // dojo.Deferred
+	};
+
+	dojo.xhrDelete = function(/*dojo.__XhrArgs*/ args){
+		//	summary:
+		//		Sends an HTTP DELETE request to the server.
+		return dojo.xhr("DELETE", args); //dojo.Deferred
+	};
+
+	/*
+	dojo.wrapForm = function(formNode){
+		//summary:
+		//		A replacement for FormBind, but not implemented yet.
+
+		// FIXME: need to think harder about what extensions to this we might
+		// want. What should we allow folks to do w/ this? What events to
+		// set/send?
+		throw new Error("dojo.wrapForm not yet implemented");
+	}
+	*/
+
+	dojo._isDocumentOk = function(http){
+		var stat = http.status || 0;
+		stat =
+			(stat >= 200 && stat < 300) || // allow any 2XX response code
+			stat == 304 ||                 // or, get it out of the cache
+			stat == 1223 ||                // or, Internet Explorer mangled the status code
+			!stat;                         // or, we're Titanium/browser chrome/chrome extension requesting a local file
+		return stat; // Boolean
+	};
+
+	dojo._getText = function(url){
+		var result;
+		dojo.xhrGet({url:url, sync:true, load:function(text){
+			result = text;
+		}});
+		return result;
+	};
+
+	// Add aliases for static functions to dojo.xhr since dojo.xhr is what's returned from this module
+	lang.mixin(dojo.xhr, {
+		_xhrObj: dojo._xhrObj,
+		fieldToObject: domForm.fieldToObject,
+		formToObject: domForm.toObject,
+		objectToQuery: ioq.objectToQuery,
+		formToQuery: domForm.toQuery,
+		formToJson: domForm.toJson,
+		queryToObject: ioq.queryToObject,
+		contentHandlers: handlers,
+		_ioSetArgs: dojo._ioSetArgs,
+		_ioCancelAll: dojo._ioCancelAll,
+		_ioNotifyStart: dojo._ioNotifyStart,
+		_ioWatch: dojo._ioWatch,
+		_ioAddQueryToUrl: dojo._ioAddQueryToUrl,
+		_isDocumentOk: dojo._isDocumentOk,
+		_getText: dojo._getText,
+		get: dojo.xhrGet,
+		post: dojo.xhrPost,
+		put: dojo.xhrPut,
+		del: dojo.xhrDelete	// because "delete" is a reserved word
+	});
+
+	return dojo.xhr;
+});
+
+},
+'dojo/_base/unload':function(){
+define(["./kernel", "./connect"], function(dojo, connect) {
+	// module:
+	//		dojo/unload
+	// summary:
+	//		This module contains the document and window unload detection API.
+
+	var win = window;
+
+	/*=====
+		dojo.windowUnloaded = function(){
+			// summary:
+			//		signal fired by impending window destruction. You may use
+			//		dojo.addOnWindowUnload() to register a listener for this
+			//		event. NOTE: if you wish to dojo.connect() to this method
+			//		to perform page/application cleanup, be aware that this
+			//		event WILL NOT fire if no handler has been registered with
+			//		dojo.addOnWindowUnload. This behavior started in Dojo 1.3.
+			//		Previous versions always triggered dojo.windowUnloaded. See
+			//		dojo.addOnWindowUnload for more info.
+		};
+	=====*/
+
+	dojo.addOnWindowUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){
+		// summary:
+		//		registers a function to be triggered when window.onunload
+		//		fires.
+		//	description:
+		//		The first time that addOnWindowUnload is called Dojo
+		//		will register a page listener to trigger your unload
+		//		handler with. Note that registering these handlers may
+		//		destory "fastback" page caching in browsers that support
+		//		it. Be careful trying to modify the DOM or access
+		//		JavaScript properties during this phase of page unloading:
+		//		they may not always be available. Consider
+		//		dojo.addOnUnload() if you need to modify the DOM or do
+		//		heavy JavaScript work since it fires at the eqivalent of
+		//		the page's "onbeforeunload" event.
+		// example:
+		//	| dojo.addOnWindowUnload(functionPointer)
+		//	| dojo.addOnWindowUnload(object, "functionName");
+		//	| dojo.addOnWindowUnload(object, function(){ /* ... */});
+
+		if (!dojo.windowUnloaded) {
+			connect.connect(win, "unload", (dojo.windowUnloaded= function(){}));
+		}
+		connect.connect(win, "unload", obj, functionName);
+	};
+
+	dojo.addOnUnload = function(/*Object?|Function?*/obj, /*String|Function?*/functionName){
+		// summary:
+		//		registers a function to be triggered when the page unloads.
+		//	description:
+		//		The first time that addOnUnload is called Dojo will
+		//		register a page listener to trigger your unload handler
+		//		with.
+		//
+		//		In a browser enviroment, the functions will be triggered
+		//		during the window.onbeforeunload event. Be careful of doing
+		//		too much work in an unload handler. onbeforeunload can be
+		//		triggered if a link to download a file is clicked, or if
+		//		the link is a javascript: link. In these cases, the
+		//		onbeforeunload event fires, but the document is not
+		//		actually destroyed. So be careful about doing destructive
+		//		operations in a dojo.addOnUnload callback.
+		//
+		//		Further note that calling dojo.addOnUnload will prevent
+		//		browsers from using a "fast back" cache to make page
+		//		loading via back button instantaneous.
+		// example:
+		//	| dojo.addOnUnload(functionPointer)
+		//	| dojo.addOnUnload(object, "functionName")
+		//	| dojo.addOnUnload(object, function(){ /* ... */});
+
+		connect.connect(win, "beforeunload", obj, functionName);
+	};
+
+	return {
+		addOnWindowUnload: dojo.addOnWindowUnload,
+		addOnUnload: dojo.addOnUnload
+	};
+});
+
+},
+'dojo/loadInit':function(){
+define(["./_base/loader"], function(loader){
+	return {
+		dynamic:0,
+		normalize:function(id){return id;},
+		load:loader.loadInit
+	};
+});
+
+},
+'dojo/_base/NodeList':function(){
+define(["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){
+  //  module:
+  //    dojo/_base/NodeList
+  //  summary:
+  //    This module defines dojo.NodeList.
+ 
+var NodeList = query.NodeList;
+
+	/*=====
+	dojo.extend(dojo.NodeList, {
+		connect: function(methodName, objOrFunc, funcName){
+			// summary:
+			//		attach event handlers to every item of the NodeList. Uses dojo.connect()
+			//		so event properties are normalized
+			// methodName: String
+			//		the name of the method to attach to. For DOM events, this should be
+			//		the lower-case name of the event
+			// objOrFunc: Object|Function|String
+			//		if 2 arguments are passed (methodName, objOrFunc), objOrFunc should
+			//		reference a function or be the name of the function in the global
+			//		namespace to attach. If 3 arguments are provided
+			//		(methodName, objOrFunc, funcName), objOrFunc must be the scope to
+			//		locate the bound function in
+			// funcName: String?
+			//		optional. A string naming the function in objOrFunc to bind to the
+			//		event. May also be a function reference.
+			// example:
+			//		add an onclick handler to every button on the page
+			//		|	dojo.query("div:nth-child(odd)").connect("onclick", function(e){
+			//		|		console.log("clicked!");
+			//		|	});
+			// example:
+			//		attach foo.bar() to every odd div's onmouseover
+			//		|	dojo.query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
+		},
+		coords: function(){
+			// summary:
+			//		Deprecated: Use position() for border-box x/y/w/h
+			//		or marginBox() for margin-box w/h/l/t.
+			//		Returns the box objects of all elements in a node list as
+			//		an Array (*not* a NodeList). Acts like `dojo.coords`, though assumes
+			//		the node passed is each node in this list.
+
+			return dojo.map(this, dojo.coords); // Array
+		}
+	 });
+
+	 var NodeList = dojo.NodeList;
+	=====*/
+	var nlp = NodeList.prototype;
+
+	// don't bind early to dojo.connect since we no longer explicitly depend on it
+	nlp.connect = NodeList._adaptAsForEach(function(){
+		return dojo.connect.apply(this, arguments);
+	});
+	nlp.coords = NodeList._adaptAsMap(dojo.coords);
+
+	NodeList.events = [
+		// summary:
+		//		list of all DOM events used in NodeList
+		"blur", "focus", "change", "click", "error", "keydown", "keypress",
+		"keyup", "load", "mousedown", "mouseenter", "mouseleave", "mousemove",
+		"mouseout", "mouseover", "mouseup", "submit"
+	];
+
+	// FIXME: pseudo-doc the above automatically generated on-event functions
+
+	// syntactic sugar for DOM events
+	array.forEach(NodeList.events, function(evt){
+			var _oe = "on" + evt;
+			nlp[_oe] = function(a, b){
+				return this.connect(_oe, a, b);
+			};
+				// FIXME: should these events trigger publishes?
+				/*
+				return (a ? this.connect(_oe, a, b) :
+							this.forEach(function(n){
+								// FIXME:
+								//		listeners get buried by
+								//		addEventListener and can't be dug back
+								//		out to be triggered externally.
+								// see:
+								//		http://developer.mozilla.org/en/docs/DOM:element
+
+								console.log(n, evt, _oe);
+
+								// FIXME: need synthetic event support!
+								var _e = { target: n, faux: true, type: evt };
+								// dojo._event_listener._synthesizeEvent({}, { target: n, faux: true, type: evt });
+								try{ n[evt](_e); }catch(e){ console.log(e); }
+								try{ n[_oe](_e); }catch(e){ console.log(e); }
+							})
+				);
+				*/
+		}
+	);
+
+	dojo.NodeList = NodeList;
+	return dojo.NodeList;
+});
+
+},
+'dojo/_base/Color':function(){
+define(["./kernel", "./lang", "./array", "./config"], function(dojo, lang, ArrayUtil, config){
+
+	var Color = dojo.Color = function(/*Array|String|Object*/ color){
+		// summary:
+		//		Takes a named string, hex string, array of rgb or rgba values,
+		//		an object with r, g, b, and a properties, or another `dojo.Color` object
+		//		and creates a new Color instance to work from.
+		//
+		// example:
+		//		Work with a Color instance:
+		//	 | var c = new dojo.Color();
+		//	 | c.setColor([0,0,0]); // black
+		//	 | var hex = c.toHex(); // #000000
+		//
+		// example:
+		//		Work with a node's color:
+		//	 | var color = dojo.style("someNode", "backgroundColor");
+		//	 | var n = new dojo.Color(color);
+		//	 | // adjust the color some
+		//	 | n.r *= .5;
+		//	 | console.log(n.toString()); // rgb(128, 255, 255);
+		if(color){ this.setColor(color); }
+	};
+
+	/*=====
+	lang.mixin(dojo.Color,{
+		named:{
+			// summary: Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values.
+		}
+	});
+	=====*/
+
+	// FIXME:
+	// there's got to be a more space-efficient way to encode or discover
+	// these!! Use hex?
+	Color.named = {
+		"black":  [0,0,0],
+		"silver": [192,192,192],
+		"gray":	  [128,128,128],
+		"white":  [255,255,255],
+		"maroon": [128,0,0],
+		"red":	  [255,0,0],
+		"purple": [128,0,128],
+		"fuchsia":[255,0,255],
+		"green":  [0,128,0],
+		"lime":	  [0,255,0],
+		"olive":  [128,128,0],
+		"yellow": [255,255,0],
+		"navy":	  [0,0,128],
+		"blue":	  [0,0,255],
+		"teal":	  [0,128,128],
+		"aqua":	  [0,255,255],
+		"transparent": config.transparentColor || [0,0,0,0]
+	};
+
+	lang.extend(Color, {
+		r: 255, g: 255, b: 255, a: 1,
+		_set: function(r, g, b, a){
+			var t = this; t.r = r; t.g = g; t.b = b; t.a = a;
+		},
+		setColor: function(/*Array|String|Object*/ color){
+			// summary:
+			//		Takes a named string, hex string, array of rgb or rgba values,
+			//		an object with r, g, b, and a properties, or another `dojo.Color` object
+			//		and sets this color instance to that value.
+			//
+			// example:
+			//	|	var c = new dojo.Color(); // no color
+			//	|	c.setColor("#ededed"); // greyish
+			if(lang.isString(color)){
+				Color.fromString(color, this);
+			}else if(lang.isArray(color)){
+				Color.fromArray(color, this);
+			}else{
+				this._set(color.r, color.g, color.b, color.a);
+				if(!(color instanceof Color)){ this.sanitize(); }
+			}
+			return this;	// dojo.Color
+		},
+		sanitize: function(){
+			// summary:
+			//		Ensures the object has correct attributes
+			// description:
+			//		the default implementation does nothing, include dojo.colors to
+			//		augment it with real checks
+			return this;	// dojo.Color
+		},
+		toRgb: function(){
+			// summary:
+			//		Returns 3 component array of rgb values
+			// example:
+			//	|	var c = new dojo.Color("#000000");
+			//	|	console.log(c.toRgb()); // [0,0,0]
+			var t = this;
+			return [t.r, t.g, t.b]; // Array
+		},
+		toRgba: function(){
+			// summary:
+			//		Returns a 4 component array of rgba values from the color
+			//		represented by this object.
+			var t = this;
+			return [t.r, t.g, t.b, t.a];	// Array
+		},
+		toHex: function(){
+			// summary:
+			//		Returns a CSS color string in hexadecimal representation
+			// example:
+			//	|	console.log(new dojo.Color([0,0,0]).toHex()); // #000000
+			var arr = ArrayUtil.map(["r", "g", "b"], function(x){
+				var s = this[x].toString(16);
+				return s.length < 2 ? "0" + s : s;
+			}, this);
+			return "#" + arr.join("");	// String
+		},
+		toCss: function(/*Boolean?*/ includeAlpha){
+			// summary:
+			//		Returns a css color string in rgb(a) representation
+			// example:
+			//	|	var c = new dojo.Color("#FFF").toCss();
+			//	|	console.log(c); // rgb('255','255','255')
+			var t = this, rgb = t.r + ", " + t.g + ", " + t.b;
+			return (includeAlpha ? "rgba(" + rgb + ", " + t.a : "rgb(" + rgb) + ")";	// String
+		},
+		toString: function(){
+			// summary:
+			//		Returns a visual representation of the color
+			return this.toCss(true); // String
+		}
+	});
+
+	Color.blendColors = dojo.blendColors = function(
+		/*dojo.Color*/ start,
+		/*dojo.Color*/ end,
+		/*Number*/ weight,
+		/*dojo.Color?*/ obj
+	){
+		// summary:
+		//		Blend colors end and start with weight from 0 to 1, 0.5 being a 50/50 blend,
+		//		can reuse a previously allocated dojo.Color object for the result
+		var t = obj || new Color();
+		ArrayUtil.forEach(["r", "g", "b", "a"], function(x){
+			t[x] = start[x] + (end[x] - start[x]) * weight;
+			if(x != "a"){ t[x] = Math.round(t[x]); }
+		});
+		return t.sanitize();	// dojo.Color
+	};
+
+	Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){
+		// summary:
+		//		Returns a `dojo.Color` instance from a string of the form
+		//		"rgb(...)" or "rgba(...)". Optionally accepts a `dojo.Color`
+		//		object to update with the parsed value and return instead of
+		//		creating a new object.
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		var m = color.toLowerCase().match(/^rgba?\(([\s\.,0-9]+)\)/);
+		return m && Color.fromArray(m[1].split(/\s*,\s*/), obj);	// dojo.Color
+	};
+
+	Color.fromHex = dojo.colorFromHex = function(/*String*/ color, /*dojo.Color?*/ obj){
+		// summary:
+		//		Converts a hex string with a '#' prefix to a color object.
+		//		Supports 12-bit #rgb shorthand. Optionally accepts a
+		//		`dojo.Color` object to update with the parsed value.
+		//
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		//
+		// example:
+		//	 | var thing = dojo.colorFromHex("#ededed"); // grey, longhand
+		//
+		// example:
+		//	| var thing = dojo.colorFromHex("#000"); // black, shorthand
+		var t = obj || new Color(),
+			bits = (color.length == 4) ? 4 : 8,
+			mask = (1 << bits) - 1;
+		color = Number("0x" + color.substr(1));
+		if(isNaN(color)){
+			return null; // dojo.Color
+		}
+		ArrayUtil.forEach(["b", "g", "r"], function(x){
+			var c = color & mask;
+			color >>= bits;
+			t[x] = bits == 4 ? 17 * c : c;
+		});
+		t.a = 1;
+		return t;	// dojo.Color
+	};
+
+	Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*dojo.Color?*/ obj){
+		// summary:
+		//		Builds a `dojo.Color` from a 3 or 4 element array, mapping each
+		//		element in sequence to the rgb(a) values of the color.
+		// example:
+		//		| var myColor = dojo.colorFromArray([237,237,237,0.5]); // grey, 50% alpha
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		var t = obj || new Color();
+		t._set(Number(a[0]), Number(a[1]), Number(a[2]), Number(a[3]));
+		if(isNaN(t.a)){ t.a = 1; }
+		return t.sanitize();	// dojo.Color
+	};
+
+	Color.fromString = dojo.colorFromString = function(/*String*/ str, /*dojo.Color?*/ obj){
+		// summary:
+		//		Parses `str` for a color value. Accepts hex, rgb, and rgba
+		//		style color values.
+		// description:
+		//		Acceptable input values for str may include arrays of any form
+		//		accepted by dojo.colorFromArray, hex strings such as "#aaaaaa", or
+		//		rgb or rgba strings such as "rgb(133, 200, 16)" or "rgba(10, 10,
+		//		10, 50)"
+		// returns:
+		//		A dojo.Color object. If obj is passed, it will be the return value.
+		var a = Color.named[str];
+		return a && Color.fromArray(a, obj) || Color.fromRgb(str, obj) || Color.fromHex(str, obj);	// dojo.Color
+	};
+
+	return Color;
+});
+
+},
+'dojo/selector/_loader':function(){
+define(["../has", "require"],
+		function(has, require){
+// summary:
+//		This module handles loading the appropriate selector engine for the given browser
+"use strict";
+var testDiv = document.createElement("div");
+has.add("dom-qsa2.1", !!testDiv.querySelectorAll);
+has.add("dom-qsa3", function(){
+			// test to see if we have a reasonable native selector engine available
+			try{
+				testDiv.innerHTML = "<p class='TEST'></p>"; // test kind of from sizzle
+				// Safari can't handle uppercase or unicode characters when
+				// in quirks mode, IE8 can't handle pseudos like :empty
+				return testDiv.querySelectorAll(".TEST:empty").length == 1;
+			}catch(e){}
+		});
+var fullEngine;
+var acme = "./acme", lite = "./lite";
+return {
+	load: function(id, parentRequire, loaded, config){
+		var req = require;
+		// here we implement the default logic for choosing a selector engine
+		id = id == "default" ? has("config-selectorEngine") || "css3" : id;
+		id = id == "css2" || id == "lite" ? lite :
+				id == "css2.1" ? has("dom-qsa2.1") ? lite : acme :
+				id == "css3" ? has("dom-qsa3") ? lite : acme :
+				id == "acme" ? acme : (req = parentRequire) && id;
+		if(id.charAt(id.length-1) == '?'){
+			id = id.substring(0,id.length - 1);
+			var optionalLoad = true;
+		}
+		// the query engine is optional, only load it if a native one is not available or existing one has not been loaded
+		if(optionalLoad && (has("dom-compliant-qsa") || fullEngine)){
+			return loaded(fullEngine);
+		}
+		// load the referenced selector engine
+		req([id], function(engine){
+			if(id != "./lite"){
+				fullEngine = engine;
+			}
+			loaded(engine);
+		});
+	}
+};
+});
+
+},
+'dojo/on':function(){
+define(["./has!dom-addeventlistener?:./aspect", "./_base/kernel", "./has"], function(aspect, dojo, has){
+	// summary:
+	//		The export of this module is a function that provides core event listening functionality. With this function
+	//		you can provide a target, event type, and listener to be notified of
+	//		future matching events that are fired.
+	// target: Element|Object
+	//		This is the target object or DOM element that to receive events from
+	// type: String|Function
+	// 		This is the name of the event to listen for or an extension event type.
+	// listener: Function
+	// 		This is the function that should be called when the event fires.
+	// returns: Object
+	// 		An object with a remove() method that can be used to stop listening for this
+	// 		event.
+	// description:
+	// 		To listen for "click" events on a button node, we can do:
+	// 		|	define(["dojo/on"], function(listen){
+	// 		|		on(button, "click", clickHandler);
+	//		|		...
+	//  	Evented JavaScript objects can also have their own events.
+	// 		|	var obj = new Evented;
+	//		|	on(obj, "foo", fooHandler);
+	//		And then we could publish a "foo" event:
+	//		|	on.emit(obj, "foo", {key: "value"});
+	//		We can use extension events as well. For example, you could listen for a tap gesture:
+	// 		|	define(["dojo/on", "dojo/gesture/tap", function(listen, tap){
+	// 		|		on(button, tap, tapHandler);
+	//		|		...
+	//		which would trigger fooHandler. Note that for a simple object this is equivalent to calling:
+	//		|	obj.onfoo({key:"value"});
+	//		If you use on.emit on a DOM node, it will use native event dispatching when possible.
+
+ 	"use strict";
+	if(1){ // check to make sure we are in a browser, this module should work anywhere
+		var major = window.ScriptEngineMajorVersion;
+		has.add("jscript", major && (major() + ScriptEngineMinorVersion() / 10));
+		has.add("event-orientationchange", has("touch") && !has("android")); // TODO: how do we detect this?
+	}
+	var on = function(target, type, listener, dontFix){
+		if(target.on){ 
+			// delegate to the target's on() method, so it can handle it's own listening if it wants
+			return target.on(type, listener);
+		}
+		// delegate to main listener code
+		return on.parse(target, type, listener, addListener, dontFix, this);
+	};
+	on.pausable =  function(target, type, listener, dontFix){
+		// summary:
+		//		This function acts the same as on(), but with pausable functionality. The
+		// 		returned signal object has pause() and resume() functions. Calling the
+		//		pause() method will cause the listener to not be called for future events. Calling the
+		//		resume() method will cause the listener to again be called for future events.
+		var paused;
+		var signal = on(target, type, function(){
+			if(!paused){
+				return listener.apply(this, arguments);
+			}
+		}, dontFix);
+		signal.pause = function(){
+			paused = true;
+		};
+		signal.resume = function(){
+			paused = false;
+		};
+		return signal;
+	};
+	on.once = function(target, type, listener, dontFix){
+		// summary:
+		//		This function acts the same as on(), but will only call the listener once. The 
+		// 		listener will be called for the first
+		//		event that takes place and then listener will automatically be removed.
+		var signal = on(target, type, function(){
+			// remove this listener
+			signal.remove();
+			// proceed to call the listener
+			return listener.apply(this, arguments);
+		});
+		return signal;
+	};
+	on.parse = function(target, type, listener, addListener, dontFix, matchesTarget){
+		if(type.call){
+			// event handler function
+			// on(node, dojo.touch.press, touchListener);
+			return type.call(matchesTarget, target, listener);
+		}
+
+		if(type.indexOf(",") > -1){
+			// we allow comma delimited event names, so you can register for multiple events at once
+			var events = type.split(/\s*,\s*/);
+			var handles = [];
+			var i = 0;
+			var eventName;
+			while(eventName = events[i++]){
+				handles.push(addListener(target, eventName, listener, dontFix, matchesTarget));
+			}
+			handles.remove = function(){
+				for(var i = 0; i < handles.length; i++){
+					handles[i].remove();
+				}
+			};
+			return handles;
+		}
+		return addListener(target, type, listener, dontFix, matchesTarget)
+	};
+	var touchEvents = /^touch/;
+	function addListener(target, type, listener, dontFix, matchesTarget){		
+		// event delegation:
+		var selector = type.match(/(.*):(.*)/);
+		// if we have a selector:event, the last one is interpreted as an event, and we use event delegation
+		if(selector){
+			type = selector[2];
+			selector = selector[1];
+			// create the extension event for selectors and directly call it
+			return on.selector(selector, type).call(matchesTarget, target, listener);
+		}
+		// test to see if it a touch event right now, so we don't have to do it every time it fires
+		if(has("touch")){
+			if(touchEvents.test(type)){
+				// touch event, fix it
+				listener = fixTouchListener(listener);
+			}
+			if(!has("event-orientationchange") && (type == "orientationchange")){
+				//"orientationchange" not supported <= Android 2.1, 
+				//but works through "resize" on window
+				type = "resize"; 
+				target = window;
+				listener = fixTouchListener(listener);
+			} 
+		}
+		// normal path, the target is |this|
+		if(target.addEventListener){
+			// the target has addEventListener, which should be used if available (might or might not be a node, non-nodes can implement this method as well)
+			// check for capture conversions
+			var capture = type in captures;
+			target.addEventListener(capture ? captures[type] : type, listener, capture);
+			// create and return the signal
+			return {
+				remove: function(){
+					target.removeEventListener(type, listener, capture);
+				}
+			};
+		}
+		type = "on" + type;
+		if(fixAttach && target.attachEvent){
+			return fixAttach(target, type, listener);
+		}
+	 	throw new Error("Target must be an event emitter");
+	}
+
+	on.selector = function(selector, eventType, children){
+		// summary:
+		//		Creates a new extension event with event delegation. This is based on
+		// 		the provided event type (can be extension event) that
+		// 		only calls the listener when the CSS selector matches the target of the event.
+		//	selector:
+		//		The CSS selector to use for filter events and determine the |this| of the event listener.
+		//	eventType:
+		//		The event to listen for
+		// children:
+		//		Indicates if children elements of the selector should be allowed. This defaults to 
+		// 		true (except in the case of normally non-bubbling events like mouse.enter, in which case it defaults to false).
+		//	example:
+		//		define(["dojo/on", "dojo/mouse"], function(listen, mouse){
+		//			on(node, on.selector(".my-class", mouse.enter), handlerForMyHover);
+		return function(target, listener){
+			var matchesTarget = this;
+			var bubble = eventType.bubble;
+			if(bubble){
+				// the event type doesn't naturally bubble, but has a bubbling form, use that
+				eventType = bubble;
+			}else if(children !== false){
+				// for normal bubbling events we default to allowing children of the selector
+				children = true;
+			}
+			return on(target, eventType, function(event){
+				var eventTarget = event.target;
+				// see if we have a valid matchesTarget or default to dojo.query
+				matchesTarget = matchesTarget && matchesTarget.matches ? matchesTarget : dojo.query;
+				// there is a selector, so make sure it matches
+				while(!matchesTarget.matches(eventTarget, selector, target)){
+					if(eventTarget == target || !children || !(eventTarget = eventTarget.parentNode)){ // intentional assignment
+						return;
+					}
+				}
+				return listener.call(eventTarget, event);
+			});
+		};
+	};
+
+	function syntheticPreventDefault(){
+		this.cancelable = false;
+	}
+	function syntheticStopPropagation(){
+		this.bubbles = false;
+	}
+	var slice = [].slice,
+		syntheticDispatch = on.emit = function(target, type, event){
+		// summary:
+		//		Fires an event on the target object.
+		//	target:
+		//		The target object to fire the event on. This can be a DOM element or a plain 
+		// 		JS object. If the target is a DOM element, native event emiting mechanisms
+		//		are used when possible.
+		//	type:
+		//		The event type name. You can emulate standard native events like "click" and 
+		// 		"mouseover" or create custom events like "open" or "finish".
+		//	event:
+		//		An object that provides the properties for the event. See https://developer.mozilla.org/en/DOM/event.initEvent 
+		// 		for some of the properties. These properties are copied to the event object.
+		//		Of particular importance are the cancelable and bubbles properties. The
+		//		cancelable property indicates whether or not the event has a default action
+		// 		that can be cancelled. The event is cancelled by calling preventDefault() on
+		// 		the event object. The bubbles property indicates whether or not the
+		//		event will bubble up the DOM tree. If bubbles is true, the event will be called
+		//		on the target and then each parent successively until the top of the tree
+		//		is reached or stopPropagation() is called. Both bubbles and cancelable 
+		// 		default to false.
+		//	returns:
+		//		If the event is cancelable and the event is not cancelled,
+		// 		emit will return true. If the event is cancelable and the event is cancelled,
+		// 		emit will return false.
+		//	details:
+		//		Note that this is designed to emit events for listeners registered through
+		//		dojo/on. It should actually work with any event listener except those
+		// 		added through IE's attachEvent (IE8 and below's non-W3C event emiting
+		// 		doesn't support custom event types). It should work with all events registered
+		// 		through dojo/on. Also note that the emit method does do any default
+		// 		action, it only returns a value to indicate if the default action should take
+		// 		place. For example, emiting a keypress event would not cause a character
+		// 		to appear in a textbox.
+		//	example:
+		//		To fire our own click event
+		//	|	on.emit(dojo.byId("button"), "click", {
+		//	|		cancelable: true,
+		//	|		bubbles: true,
+		//	|		screenX: 33,
+		//	|		screenY: 44
+		//	|	});
+		//		We can also fire our own custom events:
+		//	|	on.emit(dojo.byId("slider"), "slide", {
+		//	|		cancelable: true,
+		//	|		bubbles: true,
+		//	|		direction: "left-to-right"
+		//	|	});
+		var args = slice.call(arguments, 2);
+		var method = "on" + type;
+		if("parentNode" in target){
+			// node (or node-like), create event controller methods
+			var newEvent = args[0] = {};
+			for(var i in event){
+				newEvent[i] = event[i];
+			}
+			newEvent.preventDefault = syntheticPreventDefault;
+			newEvent.stopPropagation = syntheticStopPropagation;
+			newEvent.target = target;
+			newEvent.type = type;
+			event = newEvent;
+		}
+		do{
+			// call any node which has a handler (note that ideally we would try/catch to simulate normal event propagation but that causes too much pain for debugging)
+			target[method] && target[method].apply(target, args);
+			// and then continue up the parent node chain if it is still bubbling (if started as bubbles and stopPropagation hasn't been called)
+		}while(event && event.bubbles && (target = target.parentNode));
+		return event && event.cancelable && event; // if it is still true (was cancelable and was cancelled), return the event to indicate default action should happen
+	};
+	var captures = {}; 
+	if(has("dom-addeventlistener")){
+		// normalize focusin and focusout
+		captures = {
+			focusin: "focus",
+			focusout: "blur"
+		};
+		if(has("opera")){
+			captures.keydown = "keypress"; // this one needs to be transformed because Opera doesn't support repeating keys on keydown (and keypress works because it incorrectly fires on all keydown events)
+		}
+
+		// emiter that works with native event handling
+		on.emit = function(target, type, event){
+			if(target.dispatchEvent && document.createEvent){
+				// use the native event emiting mechanism if it is available on the target object
+				// create a generic event				
+				// we could create branch into the different types of event constructors, but 
+				// that would be a lot of extra code, with little benefit that I can see, seems 
+				// best to use the generic constructor and copy properties over, making it 
+				// easy to have events look like the ones created with specific initializers
+				var nativeEvent = document.createEvent("HTMLEvents");
+				nativeEvent.initEvent(type, !!event.bubbles, !!event.cancelable);
+				// and copy all our properties over
+				for(var i in event){
+					var value = event[i];
+					if(!(i in nativeEvent)){
+						nativeEvent[i] = event[i];
+					}
+				}
+				return target.dispatchEvent(nativeEvent) && nativeEvent;
+			}
+			return syntheticDispatch.apply(on, arguments); // emit for a non-node
+		};
+	}else{
+		// no addEventListener, basically old IE event normalization
+		on._fixEvent = function(evt, sender){
+			// summary:
+			//		normalizes properties on the event object including event
+			//		bubbling methods, keystroke normalization, and x/y positions
+			// evt:
+			//		native event object
+			// sender:
+			//		node to treat as "currentTarget"
+			if(!evt){
+				var w = sender && (sender.ownerDocument || sender.document || sender).parentWindow || window;
+				evt = w.event;
+			}
+			if(!evt){return(evt);}
+			if(!evt.target){ // check to see if it has been fixed yet
+				evt.target = evt.srcElement;
+				evt.currentTarget = (sender || evt.srcElement);
+				if(evt.type == "mouseover"){
+					evt.relatedTarget = evt.fromElement;
+				}
+				if(evt.type == "mouseout"){
+					evt.relatedTarget = evt.toElement;
+				}
+				if(!evt.stopPropagation){
+					evt.stopPropagation = stopPropagation;
+					evt.preventDefault = preventDefault;
+				}
+				switch(evt.type){
+					case "keypress":
+						var c = ("charCode" in evt ? evt.charCode : evt.keyCode);
+						if (c==10){
+							// CTRL-ENTER is CTRL-ASCII(10) on IE, but CTRL-ENTER on Mozilla
+							c=0;
+							evt.keyCode = 13;
+						}else if(c==13||c==27){
+							c=0; // Mozilla considers ENTER and ESC non-printable
+						}else if(c==3){
+							c=99; // Mozilla maps CTRL-BREAK to CTRL-c
+						}
+						// Mozilla sets keyCode to 0 when there is a charCode
+						// but that stops the event on IE.
+						evt.charCode = c;
+						_setKeyChar(evt);
+						break;
+				}
+			}
+			return evt;
+		};
+		var IESignal = function(handle){
+			this.handle = handle;
+		};
+		IESignal.prototype.remove = function(){
+			delete _dojoIEListeners_[this.handle];
+		};
+		var fixListener = function(listener){
+			// this is a minimal function for closing on the previous listener with as few as variables as possible
+			return function(evt){
+				evt = on._fixEvent(evt, this);
+				return listener.call(this, evt);
+			}
+		}
+		var fixAttach = function(target, type, listener){
+			listener = fixListener(listener);
+			if(((target.ownerDocument ? target.ownerDocument.parentWindow : target.parentWindow || target.window || window) != top || 
+						has("jscript") < 5.8) && 
+					!has("config-_allow_leaks")){
+				// IE will leak memory on certain handlers in frames (IE8 and earlier) and in unattached DOM nodes for JScript 5.7 and below.
+				// Here we use global redirection to solve the memory leaks
+				if(typeof _dojoIEListeners_ == "undefined"){
+					_dojoIEListeners_ = [];
+				}
+				var emiter = target[type];
+				if(!emiter || !emiter.listeners){
+					var oldListener = emiter;
+					target[type] = emiter = Function('event', 'var callee = arguments.callee; for(var i = 0; i<callee.listeners.length; i++){var listener = _dojoIEListeners_[callee.listeners[i]]; if(listener){listener.call(this,event);}}');
+					emiter.listeners = [];
+					emiter.global = this;
+					if(oldListener){
+						emiter.listeners.push(_dojoIEListeners_.push(oldListener) - 1);
+					}
+				}
+				var handle;
+				emiter.listeners.push(handle = (emiter.global._dojoIEListeners_.push(listener) - 1));
+				return new IESignal(handle);
+			}
+			return aspect.after(target, type, listener, true);
+		};
+
+		var _setKeyChar = function(evt){
+			evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
+			evt.charOrCode = evt.keyChar || evt.keyCode;
+		};
+		// Called in Event scope
+		var stopPropagation = function(){
+			this.cancelBubble = true;
+		};
+		var preventDefault = on._preventDefault = function(){
+			// Setting keyCode to 0 is the only way to prevent certain keypresses (namely
+			// ctrl-combinations that correspond to menu accelerator keys).
+			// Otoh, it prevents upstream listeners from getting this information
+			// Try to split the difference here by clobbering keyCode only for ctrl
+			// combinations. If you still need to access the key upstream, bubbledKeyCode is
+			// provided as a workaround.
+			this.bubbledKeyCode = this.keyCode;
+			if(this.ctrlKey){
+				try{
+					// squelch errors when keyCode is read-only
+					// (e.g. if keyCode is ctrl or shift)
+					this.keyCode = 0;
+				}catch(e){
+				}
+			}
+			this.returnValue = false;
+		};
+	}
+	if(has("touch")){ 
+		var Event = function (){};
+		var windowOrientation = window.orientation; 
+		var fixTouchListener = function(listener){ 
+			return function(originalEvent){ 
+				//Event normalization(for ontouchxxx and resize): 
+				//1.incorrect e.pageX|pageY in iOS 
+				//2.there are no "e.rotation", "e.scale" and "onorientationchange" in Andriod
+				//3.More TBD e.g. force | screenX | screenX | clientX | clientY | radiusX | radiusY
+
+				// see if it has already been corrected
+				var event = originalEvent.corrected;
+				if(!event){
+					var type = originalEvent.type;
+					try{
+						delete originalEvent.type; // on some JS engines (android), deleting properties make them mutable
+					}catch(e){} 
+					if(originalEvent.type){
+						// deleting properties doesn't work (older iOS), have to use delegation
+						Event.prototype = originalEvent;
+						var event = new Event;
+						// have to delegate methods to make them work
+						event.preventDefault = function(){
+							originalEvent.preventDefault();
+						};
+						event.stopPropagation = function(){
+							originalEvent.stopPropagation();
+						};
+					}else{
+						// deletion worked, use property as is
+						event = originalEvent;
+						event.type = type;
+					}
+					originalEvent.corrected = event;
+					if(type == 'resize'){
+						if(windowOrientation == window.orientation){ 
+							return null;//double tap causes an unexpected 'resize' in Andriod 
+						} 
+						windowOrientation = window.orientation;
+						event.type = "orientationchange"; 
+						return listener.call(this, event);
+					}
+					// We use the original event and augment, rather than doing an expensive mixin operation
+					if(!("rotation" in event)){ // test to see if it has rotation
+						event.rotation = 0; 
+						event.scale = 1;
+					}
+					//use event.changedTouches[0].pageX|pageY|screenX|screenY|clientX|clientY|target
+					var firstChangeTouch = event.changedTouches[0];
+					for(var i in firstChangeTouch){ // use for-in, we don't need to have dependency on dojo/_base/lang here
+						delete event[i]; // delete it first to make it mutable
+						event[i] = firstChangeTouch[i];
+					}
+				}
+				return listener.call(this, event); 
+			}; 
+		}; 
+	}
+	return on;
+});
+
+},
+'dojo/_base/sniff':function(){
+define(["./kernel", "../has"], function(dojo, has){
+	// module:
+	//		dojo/sniff
+	// summary:
+	//		This module populates the dojo browser version sniffing properties.
+
+	if(!1){
+		return has;
+	}
+
+	dojo.isBrowser = true,
+	dojo._name = "browser";
+
+	var hasAdd = has.add,
+		n = navigator,
+		dua = n.userAgent,
+		dav = n.appVersion,
+		tv = parseFloat(dav),
+		isOpera,
+		isAIR,
+		isKhtml,
+		isWebKit,
+		isChrome,
+		isMac,
+		isSafari,
+		isMozilla ,
+		isMoz,
+		isIE,
+		isFF,
+		isQuirks,
+		isIos,
+		isAndroid,
+		isWii;
+
+	/*=====
+	dojo.isBrowser = {
+		//	example:
+		//	| if(dojo.isBrowser){ ... }
+	};
+
+	dojo.isFF = {
+		//	example:
+		//	| if(dojo.isFF > 1){ ... }
+	};
+
+	dojo.isIE = {
+		// example:
+		//	| if(dojo.isIE > 6){
+		//	|		// we are IE7
+		//	| }
+	};
+
+	dojo.isSafari = {
+		//	example:
+		//	| if(dojo.isSafari){ ... }
+		//	example:
+		//		Detect iPhone:
+		//	| if(dojo.isSafari && navigator.userAgent.indexOf("iPhone") != -1){
+		//	|		// we are iPhone. Note, iPod touch reports "iPod" above and fails this test.
+		//	| }
+	};
+
+	dojo.mixin(dojo, {
+		// isBrowser: Boolean
+		//		True if the client is a web-browser
+		isBrowser: true,
+		//	isFF: Number | undefined
+		//		Version as a Number if client is FireFox. undefined otherwise. Corresponds to
+		//		major detected FireFox version (1.5, 2, 3, etc.)
+		isFF: 2,
+		//	isIE: Number | undefined
+		//		Version as a Number if client is MSIE(PC). undefined otherwise. Corresponds to
+		//		major detected IE version (6, 7, 8, etc.)
+		isIE: 6,
+		//	isKhtml: Number | undefined
+		//		Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major
+		//		detected version.
+		isKhtml: 0,
+		//	isWebKit: Number | undefined
+		//		Version as a Number if client is a WebKit-derived browser (Konqueror,
+		//		Safari, Chrome, etc.). undefined otherwise.
+		isWebKit: 0,
+		//	isMozilla: Number | undefined
+		//		Version as a Number if client is a Mozilla-based browser (Firefox,
+		//		SeaMonkey). undefined otherwise. Corresponds to major detected version.
+		isMozilla: 0,
+		//	isOpera: Number | undefined
+		//		Version as a Number if client is Opera. undefined otherwise. Corresponds to
+		//		major detected version.
+		isOpera: 0,
+		//	isSafari: Number | undefined
+		//		Version as a Number if client is Safari or iPhone. undefined otherwise.
+		isSafari: 0,
+		//	isChrome: Number | undefined
+		//		Version as a Number if client is Chrome browser. undefined otherwise.
+		isChrome: 0,
+		//	isMac: Boolean
+		//		True if the client runs on Mac
+		isMac: 0,
+		// isIos: Boolean
+		//		True if client is iPhone, iPod, or iPad
+		isIos: 0,
+		// isAndroid: Number | undefined
+		//		Version as a Number if client is android browser. undefined otherwise.
+		isAndroid: 0,
+		// isWii: Boolean
+		//		True if client is Wii
+		isWii: 0
+	});
+	=====*/
+
+	// fill in the rendering support information in dojo.render.*
+	if(dua.indexOf("AdobeAIR") >= 0){ isAIR = 1; }
+	isKhtml = (dav.indexOf("Konqueror") >= 0) ? tv : 0;
+	isWebKit = parseFloat(dua.split("WebKit/")[1]) || undefined;
+	isChrome = parseFloat(dua.split("Chrome/")[1]) || undefined;
+	isMac = dav.indexOf("Macintosh") >= 0;
+	isIos = /iPhone|iPod|iPad/.test(dua);
+	isAndroid = parseFloat(dua.split("Android ")[1]) || undefined;
+	isWii = typeof opera != "undefined" && opera.wiiremote;
+
+	// safari detection derived from:
+	//		http://developer.apple.com/internet/safari/faq.html#anchor2
+	//		http://developer.apple.com/internet/safari/uamatrix.html
+	var index = Math.max(dav.indexOf("WebKit"), dav.indexOf("Safari"), 0);
+	if(index && !isChrome){
+		// try to grab the explicit Safari version first. If we don't get
+		// one, look for less than 419.3 as the indication that we're on something
+		// "Safari 2-ish".
+		isSafari = parseFloat(dav.split("Version/")[1]);
+		if(!isSafari || parseFloat(dav.substr(index + 7)) <= 419.3){
+			isSafari = 2;
+		}
+	}
+
+	if (!has("dojo-webkit")) {
+		if(dua.indexOf("Opera") >= 0){
+			isOpera = tv;
+			// see http://dev.opera.com/articles/view/opera-ua-string-changes and http://www.useragentstring.com/pages/Opera/
+			// 9.8 has both styles; <9.8, 9.9 only old style
+			if(isOpera >= 9.8){
+				isOpera = parseFloat(dua.split("Version/")[1]) || tv;
+			}
+		}
+
+		if(dua.indexOf("Gecko") >= 0 && !isKhtml && !isWebKit){
+			isMozilla = isMoz = tv;
+		}
+		if(isMoz){
+			//We really need to get away from this. Consider a sane isGecko approach for the future.
+			isFF = parseFloat(dua.split("Firefox/")[1] || dua.split("Minefield/")[1]) || undefined;
+		}
+		if(document.all && !isOpera){
+			isIE = parseFloat(dav.split("MSIE ")[1]) || undefined;
+			//In cases where the page has an HTTP header or META tag with
+			//X-UA-Compatible, then it is in emulation mode.
+			//Make sure isIE reflects the desired version.
+			//document.documentMode of 5 means quirks mode.
+			//Only switch the value if documentMode's major version
+			//is different from isIE's major version.
+			var mode = document.documentMode;
+			if(mode && mode != 5 && Math.floor(isIE) != mode){
+				isIE = mode;
+			}
+		}
+	}
+
+	isQuirks = document.compatMode == "BackCompat";
+
+	hasAdd("opera", dojo.isOpera = isOpera);
+	hasAdd("air", dojo.isAIR = isAIR);
+	hasAdd("khtml", dojo.isKhtml = isKhtml);
+	hasAdd("webkit", dojo.isWebKit = isWebKit);
+	hasAdd("chrome", dojo.isChrome = isChrome);
+	hasAdd("mac", dojo.isMac = isMac );
+	hasAdd("safari", dojo.isSafari = isSafari);
+	hasAdd("mozilla", dojo.isMozilla = dojo.isMoz = isMozilla );
+	hasAdd("ie", dojo.isIE = isIE );
+	hasAdd("ff", dojo.isFF = isFF);
+	hasAdd("quirks", dojo.isQuirks = isQuirks);
+	hasAdd("ios", dojo.isIos = isIos);
+	hasAdd("android", dojo.isAndroid = isAndroid);
+
+	dojo.locale = dojo.locale || (isIE ? n.userLanguage : n.language).toLowerCase();
+
+	return has;
+});
+
+},
+'dojo/_base/array':function(){
+define("dojo/_base/array", ["./kernel", "../has", "./lang"], function(dojo, has, lang){
+	// module:
+	//		dojo/_base/array
+	// summary:
+	//		This module defines the Javascript v1.6 array extensions.
+
+	/*=====
+	dojo.indexOf = function(arr, value, fromIndex, findLast){
+		// summary:
+		//		locates the first index of the provided value in the
+		//		passed array. If the value is not found, -1 is returned.
+		// description:
+		//		This method corresponds to the JavaScript 1.6 Array.indexOf method, with one difference: when
+		//		run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
+		//		1.6's indexOf skips the holes in the sparse array.
+		//		For details on this method, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/indexOf
+		// arr: Array
+		// value: Object
+		// fromIndex: Integer?
+		// findLast: Boolean?
+		// returns: Number
+	};
+	dojo.lastIndexOf = function(arr, value, fromIndex){
+		// summary:
+		//		locates the last index of the provided value in the passed
+		//		array. If the value is not found, -1 is returned.
+		// description:
+		//		This method corresponds to the JavaScript 1.6 Array.lastIndexOf method, with one difference: when
+		//		run over sparse arrays, the Dojo function invokes the callback for every index whereas JavaScript
+		//		1.6's lastIndexOf skips the holes in the sparse array.
+		//		For details on this method, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/lastIndexOf
+		//	arr: Array,
+		//	value: Object,
+		//	fromIndex: Integer?
+		//	returns: Number
+	};
+	dojo.forEach = function(arr, callback, thisObject){
+		//	summary:
+		//		for every item in arr, callback is invoked. Return values are ignored.
+		//		If you want to break out of the loop, consider using dojo.every() or dojo.some().
+		//		forEach does not allow breaking out of the loop over the items in arr.
+		//	arr:
+		//		the array to iterate over. If a string, operates on individual characters.
+		//	callback:
+		//		a function is invoked with three arguments: item, index, and array
+		//	thisObject:
+		//		may be used to scope the call to callback
+		//	description:
+		//		This function corresponds to the JavaScript 1.6 Array.forEach() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's forEach skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach
+		//	example:
+		//	| // log out all members of the array:
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		function(item){
+		//	|			console.log(item);
+		//	|		}
+		//	| );
+		//	example:
+		//	| // log out the members and their indexes
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		function(item, idx, arr){
+		//	|			console.log(item, "at index:", idx);
+		//	|		}
+		//	| );
+		//	example:
+		//	| // use a scoped object member as the callback
+		//	|
+		//	| var obj = {
+		//	|		prefix: "logged via obj.callback:",
+		//	|		callback: function(item){
+		//	|			console.log(this.prefix, item);
+		//	|		}
+		//	| };
+		//	|
+		//	| // specifying the scope function executes the callback in that scope
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		obj.callback,
+		//	|		obj
+		//	| );
+		//	|
+		//	| // alternately, we can accomplish the same thing with dojo.hitch()
+		//	| dojo.forEach(
+		//	|		[ "thinger", "blah", "howdy", 10 ],
+		//	|		dojo.hitch(obj, "callback")
+		//	| );
+		//	arr: Array|String
+		//	callback: Function|String
+		//	thisObject: Object?
+	};
+	dojo.every = function(arr, callback, thisObject){
+		// summary:
+		//		Determines whether or not every item in arr satisfies the
+		//		condition implemented by callback.
+		// arr: Array|String
+		//		the array to iterate on. If a string, operates on individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments: item, index,
+		//		and array and returns true if the condition is met.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Boolean
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.every() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's every skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/every
+		// example:
+		//	| // returns false
+		//	| dojo.every([1, 2, 3, 4], function(item){ return item>1; });
+		// example:
+		//	| // returns true
+		//	| dojo.every([1, 2, 3, 4], function(item){ return item>0; });
+	};
+	dojo.some = function(arr, callback, thisObject){
+		// summary:
+		//		Determines whether or not any item in arr satisfies the
+		//		condition implemented by callback.
+		// arr: Array|String
+		//		the array to iterate over. If a string, operates on individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments: item, index,
+		//		and array and returns true if the condition is met.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Boolean
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.some() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's some skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/some
+		// example:
+		//	| // is true
+		//	| dojo.some([1, 2, 3, 4], function(item){ return item>1; });
+		// example:
+		//	| // is false
+		//	| dojo.some([1, 2, 3, 4], function(item){ return item<1; });
+	};
+	dojo.map = function(arr, callback, thisObject){
+		// summary:
+		//		applies callback to each element of arr and returns
+		//		an Array with the results
+		// arr: Array|String
+		//		the array to iterate on. If a string, operates on
+		//		individual characters.
+		// callback: Function|String
+		//		a function is invoked with three arguments, (item, index,
+		//		array),	 and returns a value
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Array
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.map() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's map skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
+		// example:
+		//	| // returns [2, 3, 4, 5]
+		//	| dojo.map([1, 2, 3, 4], function(item){ return item+1 });
+	};
+	dojo.filter = function(arr, callback, thisObject){
+		// summary:
+		//		Returns a new Array with those items from arr that match the
+		//		condition implemented by callback.
+		// arr: Array
+		//		the array to iterate over.
+		// callback: Function|String
+		//		a function that is invoked with three arguments (item,
+		//		index, array). The return of this function is expected to
+		//		be a boolean which determines whether the passed-in item
+		//		will be included in the returned array.
+		// thisObject: Object?
+		//		may be used to scope the call to callback
+		// returns: Array
+		// description:
+		//		This function corresponds to the JavaScript 1.6 Array.filter() method, with one difference: when
+		//		run over sparse arrays, this implementation passes the "holes" in the sparse array to
+		//		the callback function with a value of undefined. JavaScript 1.6's filter skips the holes in the sparse array.
+		//		For more details, see:
+		//			https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
+		// example:
+		//	| // returns [2, 3, 4]
+		//	| dojo.filter([1, 2, 3, 4], function(item){ return item>1; });
+	};
+	=====*/
+
+	// our old simple function builder stuff
+	var cache = {}, u, array; // the export object
+
+	function clearCache(){
+		cache = {};
+	}
+
+	function buildFn(fn){
+		return cache[fn] = new Function("item", "index", "array", fn); // Function
+	}
+	// magic snippet: if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+
+	// every & some
+
+	function everyOrSome(some){
+		var every = !some;
+		return function(a, fn, o){
+			var i = 0, l = a && a.length || 0, result;
+			if(l && typeof a == "string") a = a.split("");
+			if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+			if(o){
+				for(; i < l; ++i){
+					result = !fn.call(o, a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}else{
+				for(; i < l; ++i){
+					result = !fn(a[i], i, a);
+					if(some ^ result){
+						return !result;
+					}
+				}
+			}
+			return every; // Boolean
+		}
+	}
+	// var every = everyOrSome(false), some = everyOrSome(true);
+
+	// indexOf, lastIndexOf
+
+	function index(up){
+		var delta = 1, lOver = 0, uOver = 0;
+		if(!up){
+			delta = lOver = uOver = -1;
+		}
+		return function(a, x, from, last){
+			if(last && delta > 0){
+				// TODO: why do we use a non-standard signature? why do we need "last"?
+				return array.lastIndexOf(a, x, from);
+			}
+			var l = a && a.length || 0, end = up ? l + uOver : lOver, i;
+			if(from === u){
+				i = up ? lOver : l + uOver;
+			}else{
+				if(from < 0){
+					i = l + from;
+					if(i < 0){
+						i = lOver;
+					}
+				}else{
+					i = from >= l ? l + uOver : from;
+				}
+			}
+			if(l && typeof a == "string") a = a.split("");
+			for(; i != end; i += delta){
+				if(a[i] == x){
+					return i; // Number
+				}
+			}
+			return -1; // Number
+		}
+	}
+	// var indexOf = index(true), lastIndexOf = index(false);
+
+	function forEach(a, fn, o){
+		var i = 0, l = a && a.length || 0;
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				fn.call(o, a[i], i, a);
+			}
+		}else{
+			for(; i < l; ++i){
+				fn(a[i], i, a);
+			}
+		}
+	}
+
+	function map(a, fn, o, Ctr){
+		// TODO: why do we have a non-standard signature here? do we need "Ctr"?
+		var i = 0, l = a && a.length || 0, out = new (Ctr || Array)(l);
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				out[i] = fn.call(o, a[i], i, a);
+			}
+		}else{
+			for(; i < l; ++i){
+				out[i] = fn(a[i], i, a);
+			}
+		}
+		return out; // Array
+	}
+
+	function filter(a, fn, o){
+		// TODO: do we need "Ctr" here like in map()?
+		var i = 0, l = a && a.length || 0, out = [], value;
+		if(l && typeof a == "string") a = a.split("");
+		if(typeof fn == "string") fn = cache[fn] || buildFn(fn);
+		if(o){
+			for(; i < l; ++i){
+				value = a[i];
+				if(fn.call(o, value, i, a)){
+					out.push(value);
+				}
+			}
+		}else{
+			for(; i < l; ++i){
+				value = a[i];
+				if(fn(value, i, a)){
+					out.push(value);
+				}
+			}
+		}
+		return out; // Array
+	}
+
+	array = {
+		every:       everyOrSome(false),
+		some:        everyOrSome(true),
+		indexOf:     index(true),
+		lastIndexOf: index(false),
+		forEach:     forEach,
+		map:         map,
+		filter:      filter,
+		clearCache:  clearCache
+	};
+
+	1 && lang.mixin(dojo, array);
+
+	/*===== return dojo.array; =====*/
+	return array;
+});
+
+},
+'dojo/_base/json':function(){
+define(["./kernel", "../json"], function(dojo, json){
+  // module:
+  //    dojo/_base/json
+  // summary:
+  //    This module defines the dojo JSON API.
+
+dojo.fromJson = function(/*String*/ js){
+	// summary:
+	//		Parses a JavaScript expression and returns a JavaScript value.
+	// description:
+	//		Throws for invalid JavaScript expressions. It does not use a strict JSON parser. It
+	//		always delegates to eval(). The content passed to this method must therefore come
+	//		from a trusted source.
+	//		It is recommend that you use dojo/json's parse function for an
+	//		implementation uses the (faster) native JSON parse when available.
+	// js:
+	//		a string literal of a JavaScript expression, for instance:
+	//			`'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
+
+	return eval("(" + js + ")"); // Object
+};
+
+/*=====
+dojo._escapeString = function(){
+	// summary:
+	//		Adds escape sequences for non-visual characters, double quote and
+	//		backslash and surrounds with double quotes to form a valid string
+	//		literal.
+};
+=====*/
+dojo._escapeString = json.stringify; // just delegate to json.stringify
+
+dojo.toJsonIndentStr = "\t";
+dojo.toJson = function(/*Object*/ it, /*Boolean?*/ prettyPrint){
+	// summary:
+	//		Returns a [JSON](http://json.org) serialization of an object.
+	// description:
+	//		Returns a [JSON](http://json.org) serialization of an object.
+	//		Note that this doesn't check for infinite recursion, so don't do that!
+	//		It is recommend that you use dojo/json's stringify function for an lighter
+	//		and faster implementation that matches the native JSON API and uses the
+	//		native JSON serializer when available.
+	// it:
+	//		an object to be serialized. Objects may define their own
+	//		serialization via a special "__json__" or "json" function
+	//		property. If a specialized serializer has been defined, it will
+	//		be used as a fallback.
+	//		Note that in 1.6, toJson would serialize undefined, but this no longer supported
+	//		since it is not supported by native JSON serializer.
+	// prettyPrint:
+	//		if true, we indent objects and arrays to make the output prettier.
+	//		The variable `dojo.toJsonIndentStr` is used as the indent string --
+	//		to use something other than the default (tab), change that variable
+	//		before calling dojo.toJson().
+	//		Note that if native JSON support is available, it will be used for serialization,
+	//		and native implementations vary on the exact spacing used in pretty printing.
+	// returns:
+	// 		A JSON string serialization of the passed-in object.
+	// example:
+	//		simple serialization of a trivial object
+	//		|	var jsonStr = dojo.toJson({ howdy: "stranger!", isStrange: true });
+	//		|	doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
+	// example:
+	//		a custom serializer for an objects of a particular class:
+	//		|	dojo.declare("Furby", null, {
+	//		|		furbies: "are strange",
+	//		|		furbyCount: 10,
+	//		|		__json__: function(){
+	//		|		},
+	//		|	});
+
+	// use dojo/json
+	return json.stringify(it, function(key, value){
+		if(value){
+			var tf = value.__json__||value.json;
+			if(typeof tf == "function"){
+				return tf.call(value);
+			}
+		}
+		return value;
+	}, prettyPrint && dojo.toJsonIndentStr);	// String
+};
+
+return dojo;
+});
+
+},
+'dojo/_base/window':function(){
+define(["./kernel", "../has", "./sniff"], function(dojo, has){
+	// module:
+	//		dojo/window
+	// summary:
+	//		This module provides an API to save/set/restore the global/document scope.
+
+/*=====
+dojo.doc = {
+	// summary:
+	//		Alias for the current document. 'dojo.doc' can be modified
+	//		for temporary context shifting. Also see dojo.withDoc().
+	// description:
+	//		Refer to dojo.doc rather
+	//		than referring to 'window.document' to ensure your code runs
+	//		correctly in managed contexts.
+	// example:
+	//	|	n.appendChild(dojo.doc.createElement('div'));
+}
+=====*/
+dojo.doc = this["document"] || null;
+
+dojo.body = function(){
+	// summary:
+	//		Return the body element of the document
+	//		return the body object associated with dojo.doc
+	// example:
+	//	|	dojo.body().appendChild(dojo.doc.createElement('div'));
+
+	// Note: document.body is not defined for a strict xhtml document
+	// Would like to memoize this, but dojo.doc can change vi dojo.withDoc().
+	return dojo.doc.body || dojo.doc.getElementsByTagName("body")[0]; // Node
+};
+
+dojo.setContext = function(/*Object*/globalObject, /*DocumentElement*/globalDocument){
+	// summary:
+	//		changes the behavior of many core Dojo functions that deal with
+	//		namespace and DOM lookup, changing them to work in a new global
+	//		context (e.g., an iframe). The varibles dojo.global and dojo.doc
+	//		are modified as a result of calling this function and the result of
+	//		`dojo.body()` likewise differs.
+	dojo.global = ret.global = globalObject;
+	dojo.doc = ret.doc = globalDocument;
+};
+
+dojo.withGlobal = function(	/*Object*/globalObject,
+							/*Function*/callback,
+							/*Object?*/thisObject,
+							/*Array?*/cbArguments){
+	// summary:
+	//		Invoke callback with globalObject as dojo.global and
+	//		globalObject.document as dojo.doc.
+	// description:
+	//		Invoke callback with globalObject as dojo.global and
+	//		globalObject.document as dojo.doc. If provided, globalObject
+	//		will be executed in the context of object thisObject
+	//		When callback() returns or throws an error, the dojo.global
+	//		and dojo.doc will be restored to its previous state.
+
+	var oldGlob = dojo.global;
+	try{
+		dojo.global = ret.global = globalObject;
+		return dojo.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments);
+	}finally{
+		dojo.global = ret.global = oldGlob;
+	}
+};
+
+dojo.withDoc = function(	/*DocumentElement*/documentObject,
+							/*Function*/callback,
+							/*Object?*/thisObject,
+							/*Array?*/cbArguments){
+	// summary:
+	//		Invoke callback with documentObject as dojo.doc.
+	// description:
+	//		Invoke callback with documentObject as dojo.doc. If provided,
+	//		callback will be executed in the context of object thisObject
+	//		When callback() returns or throws an error, the dojo.doc will
+	//		be restored to its previous state.
+
+	var oldDoc = dojo.doc,
+		oldQ = dojo.isQuirks,
+		oldIE = dojo.isIE, isIE, mode, pwin;
+
+	try{
+		dojo.doc = ret.doc = documentObject;
+		// update dojo.isQuirks and the value of the has feature "quirks"
+		dojo.isQuirks = has.add("quirks", dojo.doc.compatMode == "BackCompat", true, true); // no need to check for QuirksMode which was Opera 7 only
+
+		if(has("ie")){
+			if((pwin = documentObject.parentWindow) && pwin.navigator){
+				// re-run IE detection logic and update dojo.isIE / has("ie")
+				// (the only time parentWindow/navigator wouldn't exist is if we were not
+				// passed an actual legitimate document object)
+				isIE = parseFloat(pwin.navigator.appVersion.split("MSIE ")[1]) || undefined;
+				mode = documentObject.documentMode;
+				if(mode && mode != 5 && Math.floor(isIE) != mode){
+					isIE = mode;
+				}
+				dojo.isIE = has.add("ie", isIE, true, true);
+			}
+		}
+
+		if(thisObject && typeof callback == "string"){
+			callback = thisObject[callback];
+		}
+
+		return callback.apply(thisObject, cbArguments || []);
+	}finally{
+		dojo.doc = ret.doc = oldDoc;
+		dojo.isQuirks = has.add("quirks", oldQ, true, true);
+		dojo.isIE = has.add("ie", oldIE, true, true);
+	}
+};
+
+var ret = {
+	global: dojo.global,
+	doc: dojo.doc,
+	body: dojo.body,
+	setContext: dojo.setContext,
+	withGlobal: dojo.withGlobal,
+	withDoc: dojo.withDoc
+};
+
+return ret;
+
+});
+
+},
+'dojo/dom-class':function(){
+define(["./_base/lang", "./_base/array", "./dom"], function(lang, array, dom){
+	// module:
+	//		dojo/dom-class
+	// summary:
+	//		This module defines the core dojo DOM class API.
+
+	var className = "className";
+
+	/* Part I of classList-based implementation is preserved here for posterity
+	var classList = "classList";
+	has.add("dom-classList", function(){
+		return classList in document.createElement("p");
+	});
+	*/
+
+	// =============================
+	// (CSS) Class Functions
+	// =============================
+
+	/*=====
+	dojo.hasClass = function(node, classStr){
+		// summary:
+		//		Returns whether or not the specified classes are a portion of the
+		//		class list currently applied to the node.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to check the class for.
+		//
+		// classStr: String
+		//		A string class name to look for.
+		//
+		// returns: Boolean
+		//
+		// example:
+		//		Do something if a node with id="someNode" has class="aSillyClassName" present
+		//	|	if(dojo.hasClass("someNode","aSillyClassName")){ ... }
+	};
+	=====*/
+
+	/*=====
+	dojo.addClass = function(node, classStr){
+		// summary:
+		//		Adds the specified classes to the end of the class list on the
+		//		passed node. Will not re-apply duplicate classes.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to add a class string too
+		//
+		// classStr: String|Array
+		//		A String class name to add, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// example:
+		//		Add a class to some node:
+		//	|	dojo.addClass("someNode", "anewClass");
+		//
+		// example:
+		//		Add two classes at once:
+		//	|	dojo.addClass("someNode", "firstClass secondClass");
+		//
+		// example:
+		//		Add two classes at once (using array):
+		//	|	dojo.addClass("someNode", ["firstClass", "secondClass"]);
+		//
+		// example:
+		//		Available in `dojo.NodeList` for multiple additions
+		//	|	dojo.query("ul > li").addClass("firstLevel");
+	};
+	=====*/
+
+	/*=====
+	dojo.removeClass = function(node, classStr){
+		// summary:
+		//		Removes the specified classes from node. No `dojo.hasClass`
+		//		check is required.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to remove the class from.
+		//
+		// classStr: String|Array
+		//		An optional String class name to remove, or several space-separated
+		//		class names, or an array of class names. If omitted, all class names
+		//		will be deleted.
+		//
+		// example:
+		//		Remove a class from some node:
+		//	|	dojo.removeClass("someNode", "firstClass");
+		//
+		// example:
+		//		Remove two classes from some node:
+		//	|	dojo.removeClass("someNode", "firstClass secondClass");
+		//
+		// example:
+		//		Remove two classes from some node (using array):
+		//	|	dojo.removeClass("someNode", ["firstClass", "secondClass"]);
+		//
+		// example:
+		//		Remove all classes from some node:
+		//	|	dojo.removeClass("someNode");
+		//
+		// example:
+		//		Available in `dojo.NodeList()` for multiple removal
+		//	|	dojo.query(".foo").removeClass("foo");
+	};
+	=====*/
+
+	/*=====
+	dojo.replaceClass = function(node, addClassStr, removeClassStr){
+		// summary:
+		//		Replaces one or more classes on a node if not present.
+		//		Operates more quickly than calling dojo.removeClass and dojo.addClass
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to remove the class from.
+		//
+		// addClassStr: String|Array
+		//		A String class name to add, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// removeClassStr: String|Array?
+		//		A String class name to remove, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// example:
+		//	|	dojo.replaceClass("someNode", "add1 add2", "remove1 remove2");
+		//
+		// example:
+		//	Replace all classes with addMe
+		//	|	dojo.replaceClass("someNode", "addMe");
+		//
+		// example:
+		//	Available in `dojo.NodeList()` for multiple toggles
+		//	|	dojo.query(".findMe").replaceClass("addMe", "removeMe");
+	};
+	=====*/
+
+	/*=====
+	dojo.toggleClass = function(node, classStr, condition){
+		// summary:
+		//		Adds a class to node if not present, or removes if present.
+		//		Pass a boolean condition if you want to explicitly add or remove.
+		//      Returns the condition that was specified directly or indirectly.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to toggle a class string
+		//
+		// classStr: String|Array
+		//		A String class name to toggle, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// condition:
+		//		If passed, true means to add the class, false means to remove.
+		//      Otherwise dojo.hasClass(node, classStr) is used to detect the class presence.
+		//
+		// example:
+		//	|	dojo.toggleClass("someNode", "hovered");
+		//
+		// example:
+		//		Forcefully add a class
+		//	|	dojo.toggleClass("someNode", "hovered", true);
+		//
+		// example:
+		//		Available in `dojo.NodeList()` for multiple toggles
+		//	|	dojo.query(".toggleMe").toggleClass("toggleMe");
+	};
+	=====*/
+
+	var cls, // exports object
+		spaces = /\s+/, a1 = [""];
+
+	function str2array(s){
+		if(typeof s == "string" || s instanceof String){
+			if(s && !spaces.test(s)){
+				a1[0] = s;
+				return a1;
+			}
+			var a = s.split(spaces);
+			if(a.length && !a[0]){
+				a.shift();
+			}
+			if(a.length && !a[a.length - 1]){
+				a.pop();
+			}
+			return a;
+		}
+		// assumed to be an array
+		if(!s){
+			return [];
+		}
+		return array.filter(s, function(x){ return x; });
+	}
+
+	/* Part II of classList-based implementation is preserved here for posterity
+	if(has("dom-classList")){
+		// new classList version
+		cls = {
+			contains: function containsClass(node, classStr){
+				var clslst = classStr && dom.byId(node)[classList];
+				return clslst && clslst.contains(classStr); // Boolean
+			},
+
+			add: function addClass(node, classStr){
+				node = dom.byId(node);
+				classStr = str2array(classStr);
+				for(var i = 0, len = classStr.length; i < len; ++i){
+					node[classList].add(classStr[i]);
+				}
+			},
+
+			remove: function removeClass(node, classStr){
+				node = dom.byId(node);
+				if(classStr === undefined){
+					node[className] = "";
+				}else{
+					classStr = str2array(classStr);
+					for(var i = 0, len = classStr.length; i < len; ++i){
+						node[classList].remove(classStr[i]);
+					}
+				}
+			},
+
+			replace: function replaceClass(node, addClassStr, removeClassStr){
+				node = dom.byId(node);
+				if(removeClassStr === undefined){
+					node[className] = "";
+				}else{
+					removeClassStr = str2array(removeClassStr);
+					for(var i = 0, len = removeClassStr.length; i < len; ++i){
+						node[classList].remove(removeClassStr[i]);
+					}
+				}
+				addClassStr = str2array(addClassStr);
+				for(i = 0, len = addClassStr.length; i < len; ++i){
+					node[classList].add(addClassStr[i]);
+				}
+			},
+
+			toggle: function toggleClass(node, classStr, condition){
+				node = dom.byId(node);
+				if(condition === undefined){
+					classStr = str2array(classStr);
+					for(var i = 0, len = classStr.length; i < len; ++i){
+						node[classList].toggle(classStr[i]);
+					}
+				}else{
+					cls[condition ? "add" : "remove"](node, classStr);
+				}
+				return condition;   // Boolean
+			}
+		}
+	}
+	*/
+
+	// regular DOM version
+	var fakeNode = {};  // for effective replacement
+	cls = {
+		contains: function containsClass(/*DomNode|String*/node, /*String*/classStr){
+			return ((" " + dom.byId(node)[className] + " ").indexOf(" " + classStr + " ") >= 0); // Boolean
+		},
+
+		add: function addClass(/*DomNode|String*/node, /*String|Array*/classStr){
+			node = dom.byId(node);
+			classStr = str2array(classStr);
+			var cls = node[className], oldLen;
+			cls = cls ? " " + cls + " " : " ";
+			oldLen = cls.length;
+			for(var i = 0, len = classStr.length, c; i < len; ++i){
+				c = classStr[i];
+				if(c && cls.indexOf(" " + c + " ") < 0){
+					cls += c + " ";
+				}
+			}
+			if(oldLen < cls.length){
+				node[className] = cls.substr(1, cls.length - 2);
+			}
+		},
+
+		remove: function removeClass(/*DomNode|String*/node, /*String|Array?*/classStr){
+			node = dom.byId(node);
+			var cls;
+			if(classStr !== undefined){
+				classStr = str2array(classStr);
+				cls = " " + node[className] + " ";
+				for(var i = 0, len = classStr.length; i < len; ++i){
+					cls = cls.replace(" " + classStr[i] + " ", " ");
+				}
+				cls = lang.trim(cls);
+			}else{
+				cls = "";
+			}
+			if(node[className] != cls){ node[className] = cls; }
+		},
+
+		replace: function replaceClass(/*DomNode|String*/node, /*String|Array*/addClassStr, /*String|Array?*/removeClassStr){
+			node = dom.byId(node);
+			fakeNode[className] = node[className];
+			cls.remove(fakeNode, removeClassStr);
+			cls.add(fakeNode, addClassStr);
+			if(node[className] !== fakeNode[className]){
+				node[className] = fakeNode[className];
+			}
+		},
+
+		toggle: function toggleClass(/*DomNode|String*/node, /*String|Array*/classStr, /*Boolean?*/condition){
+			node = dom.byId(node);
+			if(condition === undefined){
+				classStr = str2array(classStr);
+				for(var i = 0, len = classStr.length, c; i < len; ++i){
+					c = classStr[i];
+					cls[cls.contains(node, c) ? "remove" : "add"](node, c);
+				}
+			}else{
+				cls[condition ? "add" : "remove"](node, classStr);
+			}
+			return condition;   // Boolean
+		}
+	};
+
+	return cls;
+});
+
+},
+'dojo/_base/config':function(){
+define(["../has", "require"], function(has, require){
+	// module:
+	//		dojo/_base/config
+	// summary:
+	//		This module defines the user configuration during bootstrap.
+	// description:
+	//		By defining user configuration as a module value, an entire configuration can be specified in a build,
+    //		thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
+    //		Also, when multiple instances of dojo exist in a single application, each will necessarily be located
+	//		at an unique absolute module identifier as given by the package configuration. Implementing configuration
+	//		as a module allows for specifying unique, per-instance configurations.
+	// example:
+	//		Create a second instance of dojo with a different, instance-uniqe configuration (assume the loader and
+	//		dojo.js are already loaded).
+	//		|	// specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
+	//		|	require({
+	//		|		packages:[{
+	//		|			name:"myDojo",
+	//		|			location:".", //assume baseUrl points to dojo.js
+	//		|	    }]
+	//		|	});
+	//		|
+	//		|	// specify a configuration for the myDojo instance
+	//		|	define("myDojo/config", {
+	//		|		// normal configuration variables go here, e.g.,
+	//		|		locale:"fr-ca"
+	//		|	});
+	//		|
+	//		|	// load and use the new instance of dojo
+	//		|	require(["myDojo"], function(dojo) {
+	//		|		// dojo is the new instance of dojo
+	//		|		// use as required
+	//		|	});
+
+	var result = {};
+	if(1){
+		// must be the dojo loader; take a shallow copy of require.rawConfig
+		var src = require.rawConfig, p;
+		for(p in src){
+			result[p] = src[p];
+		}
+	}else{
+		var adviseHas = function(featureSet, prefix, booting){
+			for(p in featureSet){
+				p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
+			}
+		};
+		result = 1 ?
+			// must be a built version of the dojo loader; all config stuffed in require.rawConfig
+			require.rawConfig :
+			// a foreign loader
+			this.dojoConfig || this.djConfig || {};
+		adviseHas(result, "config", 1);
+		adviseHas(result.has, "", 1);
+	}
+	return result;
+
+/*=====
+// note:
+//		'dojoConfig' does not exist under 'dojo.*' so that it can be set before the
+//		'dojo' variable exists.
+// note:
+//		Setting any of these variables *after* the library has loaded does
+//		nothing at all.
+
+// FIXME: can we document these on dojo.config object and explain they must be set via djConfig/dojoConfig global prior to loading dojo.js
+
+dojoConfig = {
+	// summary:
+	//		Application code can set the global 'dojoConfig' prior to loading
+	//		the library to control certain global settings for how dojo works.
+	//
+	// isDebug: Boolean
+	//		Defaults to `false`. If set to `true`, ensures that Dojo provides
+	//		extended debugging feedback via Firebug. If Firebug is not available
+	//		on your platform, setting `isDebug` to `true` will force Dojo to
+	//		pull in (and display) the version of Firebug Lite which is
+	//		integrated into the Dojo distribution, thereby always providing a
+	//		debugging/logging console when `isDebug` is enabled. Note that
+	//		Firebug's `console.*` methods are ALWAYS defined by Dojo. If
+	//		`isDebug` is false and you are on a platform without Firebug, these
+	//		methods will be defined as no-ops.
+	isDebug: false,
+	// locale: String
+	//		The locale to assume for loading localized resources in this page,
+	//		specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
+	//		Must be specified entirely in lowercase, e.g. `en-us` and `zh-cn`.
+	//		See the documentation for `dojo.i18n` and `dojo.requireLocalization`
+	//		for details on loading localized resources. If no locale is specified,
+	//		Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
+	//		or `navigator.language` properties.
+	locale: undefined,
+	// extraLocale: Array
+	//		No default value. Specifies additional locales whose
+	//		resources should also be loaded alongside the default locale when
+	//		calls to `dojo.requireLocalization()` are processed.
+	extraLocale: undefined,
+	// baseUrl: String
+	//		The directory in which `dojo.js` is located. Under normal
+	//		conditions, Dojo auto-detects the correct location from which it
+	//		was loaded. You may need to manually configure `baseUrl` in cases
+	//		where you have renamed `dojo.js` or in which `<base>` tags confuse
+	//		some browsers (e.g. IE 6). The variable `dojo.baseUrl` is assigned
+	//		either the value of `djConfig.baseUrl` if one is provided or the
+	//		auto-detected root if not. Other modules are located relative to
+	//		this path. The path should end in a slash.
+	baseUrl: undefined,
+	// modulePaths: Object
+	//		A map of module names to paths relative to `dojo.baseUrl`. The
+	//		key/value pairs correspond directly to the arguments which
+	//		`dojo.registerModulePath` accepts. Specifiying
+	//		`djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
+	//		of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
+	//		modules may be configured via `djConfig.modulePaths`.
+	modulePaths: {},
+	// afterOnLoad: Boolean
+	//		Indicates Dojo was added to the page after the page load. In this case
+	//		Dojo will not wait for the page DOMContentLoad/load events and fire
+	//		its dojo.addOnLoad callbacks after making sure all outstanding
+	//		dojo.required modules have loaded. Only works with a built dojo.js,
+	//		it does not work the dojo.js directly from source control.
+	afterOnLoad: false,
+	// addOnLoad: Function or Array
+	//		Adds a callback via dojo.addOnLoad. Useful when Dojo is added after
+	//		the page loads and djConfig.afterOnLoad is true. Supports the same
+	//		arguments as dojo.addOnLoad. When using a function reference, use
+	//		`djConfig.addOnLoad = function(){};`. For object with function name use
+	//		`djConfig.addOnLoad = [myObject, "functionName"];` and for object with
+	//		function reference use
+	//		`djConfig.addOnLoad = [myObject, function(){}];`
+	addOnLoad: null,
+	// require: Array
+	//		An array of module names to be loaded immediately after dojo.js has been included
+	//		in a page.
+	require: [],
+	// defaultDuration: Array
+	//		Default duration, in milliseconds, for wipe and fade animations within dijits.
+	//		Assigned to dijit.defaultDuration.
+	defaultDuration: 200,
+	// dojoBlankHtmlUrl: String
+	//		Used by some modules to configure an empty iframe. Used by dojo.io.iframe and
+	//		dojo.back, and dijit popup support in IE where an iframe is needed to make sure native
+	//		controls do not bleed through the popups. Normally this configuration variable
+	//		does not need to be set, except when using cross-domain/CDN Dojo builds.
+	//		Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
+	//		to the path on your domain your copy of blank.html.
+	dojoBlankHtmlUrl: undefined,
+	//	ioPublish: Boolean?
+	//		Set this to true to enable publishing of topics for the different phases of
+	//		IO operations. Publishing is done via dojo.publish. See dojo.__IoPublish for a list
+	//		of topics that are published.
+	ioPublish: false,
+	//	useCustomLogger: Anything?
+	//		If set to a value that evaluates to true such as a string or array and
+	//		isDebug is true and Firebug is not available or running, then it bypasses
+	//		the creation of Firebug Lite allowing you to define your own console object.
+	useCustomLogger: undefined,
+	// transparentColor: Array
+	//		Array containing the r, g, b components used as transparent color in dojo.Color;
+	//		if undefined, [255,255,255] (white) will be used.
+	transparentColor: undefined,
+	// skipIeDomLoaded: Boolean
+	//		For IE only, skip the DOMContentLoaded hack used. Sometimes it can cause an Operation
+	//		Aborted error if the rest of the page triggers script defers before the DOM is ready.
+	//		If this is config value is set to true, then dojo.addOnLoad callbacks will not be
+	//		triggered until the page load event, which is after images and iframes load. If you
+	//		want to trigger the callbacks sooner, you can put a script block in the bottom of
+	//		your HTML that calls dojo._loadInit();. If you are using multiversion support, change
+	//		"dojo." to the appropriate scope name for dojo.
+	skipIeDomLoaded: false
+}
+=====*/
+});
+
+
+},
+'dojo/_base/event':function(){
+define(["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){
+  //  module:
+  //    dojo/_base/event
+  //  summary:
+  //    This module defines dojo DOM event API.
+	if(on._fixEvent){
+		var fixEvent = on._fixEvent;
+		on._fixEvent = function(evt, se){
+			// add some additional normalization for back-compat, this isn't in on.js because it is somewhat more expensive
+			evt = fixEvent(evt, se);
+			if(evt){
+				dom.normalizeEvent(evt);
+			}
+			return evt;
+		};		
+	}
+	dojo.fixEvent = function(/*Event*/ evt, /*DOMNode*/ sender){
+		// summary:
+		//		normalizes properties on the event object including event
+		//		bubbling methods, keystroke normalization, and x/y positions
+		// evt: Event
+		//		native event object
+		// sender: DOMNode
+		//		node to treat as "currentTarget"
+		if(on._fixEvent){
+			return on._fixEvent(evt, sender);
+		}
+		return evt;	// Event
+	};
+	
+	dojo.stopEvent = function(/*Event*/ evt){
+		// summary:
+		//		prevents propagation and clobbers the default action of the
+		//		passed event
+		// evt: Event
+		//		The event object. If omitted, window.event is used on IE.
+		if(has("dom-addeventlistener") || (evt && evt.preventDefault)){
+			evt.preventDefault();
+			evt.stopPropagation();
+		}else{
+			evt = evt || window.event;
+			evt.cancelBubble = true;
+			on._preventDefault.call(evt);
+		}
+	};
+
+	return {
+		fix: dojo.fixEvent,
+		stop: dojo.stopEvent
+	};
+});
+
+},
+'dojo/main':function(){
+define([
+	"./_base/kernel",
+	"./has",
+	"require",
+	"./_base/sniff",
+	"./_base/lang",
+	"./_base/array",
+	"./ready",
+	"./_base/declare",
+	"./_base/connect",
+	"./_base/Deferred",
+	"./_base/json",
+	"./_base/Color",
+	"./has!dojo-firebug?./_firebug/firebug",
+	"./_base/browser",
+	"./_base/loader"], function(dojo, has, require, sniff, lang, array, ready){
+	// module:
+	//		dojo/main
+	// summary:
+	//		This is the package main module for the dojo package; it loads dojo base appropriate for the execution environment.
+
+	// the preferred way to load the dojo firebug console is by setting has("dojo-firebug") true in dojoConfig
+	// the isDebug config switch is for backcompat and will work fine in sync loading mode; it works in
+	// async mode too, but there's no guarantee when the module is loaded; therefore, if you need a firebug
+	// console guarnanteed at a particular spot in an app, either set config.has["dojo-firebug"] true before
+	// loading dojo.js or explicitly include dojo/_firebug/firebug in a dependency list.
+	if(dojo.config.isDebug){
+		require(["./_firebug/firebug"]);
+	}
+
+	// dojoConfig.require is deprecated; use the loader configuration property deps
+	true || has.add("dojo-config-require", 1);
+	if(1){
+		var deps= dojo.config.require;
+		if(deps){
+			// dojo.config.require may be dot notation
+			deps= array.map(lang.isArray(deps) ? deps : [deps], function(item){ return item.replace(/\./g, "/"); });
+			if(dojo.isAsync){
+				require(deps);
+			}else{
+				// this is a bit janky; in 1.6- dojo is defined before these requires are applied; but in 1.7+
+				// dojo isn't defined until returning from this module; this is only a problem in sync mode
+				// since we're in sync mode, we know we've got our loader with its priority ready queue
+				ready(1, function(){require(deps);});
+			}
+		}
+	}
+
+	return dojo;
+});
+
+},
+'dojo/ready':function(){
+define(["./_base/kernel", "./has", "require", "./domReady", "./_base/lang"], function(dojo, has, require, domReady, lang) {
+	// module:
+	//		dojo/ready
+	// summary:
+	//		This module defines the dojo.ready API.
+	//
+	// note:
+	//		This module should be unnecessary in dojo 2.0
+	var
+		// truthy if DOMContentLoaded or better (e.g., window.onload fired) has been achieved
+		isDomReady = 0,
+
+		// a function to call to cause onLoad to be called when all requested modules have been loaded
+		requestCompleteSignal,
+
+		// The queue of functions waiting to execute as soon as dojo.ready conditions satisfied
+		loadQ = [],
+
+		// prevent recursion in onLoad
+		onLoadRecursiveGuard = 0,
+
+		handleDomReady = function(){
+			isDomReady = 1;
+			dojo._postLoad = dojo.config.afterOnLoad = true;
+			if(loadQ.length){
+				requestCompleteSignal(onLoad);
+			}
+		},
+
+		// run the next function queued with dojo.ready
+		onLoad = function(){
+			if(isDomReady && !onLoadRecursiveGuard && loadQ.length){
+				//guard against recursions into this function
+				onLoadRecursiveGuard = 1;
+				var f = loadQ.shift();
+					try{
+						f();
+					}
+						// FIXME: signal the error via require.on
+					finally{
+						onLoadRecursiveGuard = 0;
+					}
+				onLoadRecursiveGuard = 0;
+				if(loadQ.length){
+					requestCompleteSignal(onLoad);
+				}
+			}
+		};
+
+	// define requireCompleteSignal; impl depends on loader
+	if(1){
+		require.on("idle", onLoad);
+		requestCompleteSignal = function(){
+			if(require.idle()){
+				onLoad();
+			} // else do nothing, onLoad will be called with the next idle signal
+		};
+	}else{
+		// RequireJS or similar
+		requestCompleteSignal = function(){
+			// the next function call will fail if you don't have a loader with require.ready
+			// in that case, either fix your loader, use dojo's loader, or don't call dojo.ready;
+			require.ready(onLoad);
+		};
+	}
+
+	var ready = dojo.ready = dojo.addOnLoad = function(priority, context, callback){
+		// summary: Add a function to execute on DOM content loaded and all requested modules have arrived and been evaluated.
+		// priority: Integer?
+		//		The order in which to exec this callback relative to other callbacks, defaults to 1000
+		// context: Object?|Function
+		//		The context in which to run execute callback, or a callback if not using context
+		// callback: Function?
+		//		The function to execute.
+		//
+		// example:
+		//	Simple DOM and Modules ready syntax
+		//	|	dojo.ready(function(){ alert("Dom ready!"); });
+		//
+		// example:
+		//	Using a priority
+		//	|	dojo.ready(2, function(){ alert("low priority ready!"); })
+		//
+		// example:
+		//	Using context
+		//	|	dojo.ready(foo, function(){
+		//	|		// in here, this == foo
+		//	|	})
+		//
+		// example:
+		//	Using dojo.hitch style args:
+		//	|	var foo = { dojoReady: function(){ console.warn(this, "dojo dom and modules ready."); } };
+		//	|	dojo.ready(foo, "dojoReady");
+
+		var hitchArgs = lang._toArray(arguments);
+		if(typeof priority != "number"){
+			callback = context;
+			context = priority;
+			priority = 1000;
+		}else{
+			hitchArgs.shift();
+		}
+		callback = callback ?
+			lang.hitch.apply(dojo, hitchArgs) :
+			function(){
+				context();
+			};
+		callback.priority = priority;
+		for(var i = 0; i < loadQ.length && priority >= loadQ[i].priority; i++){}
+		loadQ.splice(i, 0, callback);
+		requestCompleteSignal();
+	};
+
+	true || has.add("dojo-config-addOnLoad", 1);
+	if(1){
+		var dca = dojo.config.addOnLoad;
+		if(dca){
+			ready[(lang.isArray(dca) ? "apply" : "call")](dojo, dca);
+		}
+	}
+
+	if(1 && dojo.config.parseOnLoad && !dojo.isAsync){
+		ready(99, function(){
+			if(!dojo.parser){
+				dojo.deprecated("Add explicit require(['dojo/parser']);", "", "2.0");
+				require(["dojo/parser"]);
+			}
+		});
+	}
+
+	if(1){
+		domReady(handleDomReady);
+	}else{
+		handleDomReady();
+	}
+
+	return ready;
+});
+
+},
+'dojo/aspect':function(){
+define([], function(){
+
+// TODOC: after/before/around return object
+// TODOC: after/before/around param types. 
+
+/*=====
+	dojo.aspect = {
+		// summary: provides aspect oriented programming functionality, allowing for
+		//		one to add before, around, or after advice on existing methods.
+		//
+		// example:
+		//	|	define(["dojo/aspect"], function(aspect){
+		//	|		var signal = aspect.after(targetObject, "methodName", function(someArgument){
+		//	|			this will be called when targetObject.methodName() is called, after the original function is called
+		//	|		});
+		//
+		// example:
+		//	The returned signal object can be used to cancel the advice.
+		//	|	signal.remove(); // this will stop the advice from being executed anymore
+		//	|	aspect.before(targetObject, "methodName", function(someArgument){
+		//	|		// this will be called when targetObject.methodName() is called, before the original function is called
+		//	|	 });
+		
+		after: function(target, methodName, advice, receiveArguments){
+			// summary: The "after" export of the aspect module is a function that can be used to attach
+			//		"after" advice to a method. This function will be executed after the original method
+			//		is executed. By default the function will be called with a single argument, the return
+			//		value of the original method, or the the return value of the last executed advice (if a previous one exists).
+			//		The fourth (optional) argument can be set to true to so the function receives the original
+			//		arguments (from when the original method was called) rather than the return value.
+			//		If there are multiple "after" advisors, they are executed in the order they were registered.
+			// target: Object
+			//		This is the target object
+			// methodName: String
+			//		This is the name of the method to attach to.
+			// advice: Function
+			//		This is function to be called after the original method
+			// receiveArguments: Boolean?
+			//		If this is set to true, the advice function receives the original arguments (from when the original mehtod
+			//		was called) rather than the return value of the original/previous method.
+			// returns:
+			//		A signal object that can be used to cancel the advice. If remove() is called on this signal object, it will
+			//		stop the advice function from being executed.
+		},
+		
+		before: function(target, methodName, advice){
+			// summary: The "before" export of the aspect module is a function that can be used to attach
+			//		"before" advice to a method. This function will be executed before the original method
+			//		is executed. This function will be called with the arguments used to call the method.
+			//		This function may optionally return an array as the new arguments to use to call
+			//		the original method (or the previous, next-to-execute before advice, if one exists).
+			//		If the before method doesn't return anything (returns undefined) the original arguments
+			//		will be preserved.
+			//		If there are multiple "before" advisors, they are executed in the reverse order they were registered.
+			//
+			// target: Object
+			//		This is the target object
+			// methodName: String
+			//		This is the name of the method to attach to.
+			// advice: Function
+			//		This is function to be called before the original method	 
+		},
+
+		around: function(target, methodName, advice){
+			// summary: The "around" export of the aspect module is a function that can be used to attach
+			//		"around" advice to a method. The advisor function is immediately executed when
+			//		the around() is called, is passed a single argument that is a function that can be
+			//		called to continue execution of the original method (or the next around advisor).
+			//		The advisor function should return a function, and this function will be called whenever
+			//		the method is called. It will be called with the arguments used to call the method.
+			//		Whatever this function returns will be returned as the result of the method call (unless after advise changes it).
+			//
+			// example:
+			//		If there are multiple "around" advisors, the most recent one is executed first,
+			//		which can then delegate to the next one and so on. For example:
+			//		|	around(obj, "foo", function(originalFoo){
+			//		|		return function(){
+			//		|			var start = new Date().getTime();
+			//		|			var results = originalFoo.apply(this, arguments); // call the original
+			//		|			var end = new Date().getTime();
+			//		|			console.log("foo execution took " + (end - start) + " ms");
+			//		|			return results;
+			//		|		};
+			//		|	});
+			//
+			// target: Object
+			//		This is the target object
+			// methodName: String
+			//		This is the name of the method to attach to.
+			// advice: Function
+			//		This is function to be called around the original method
+		}
+
+	};
+=====*/
+
+	"use strict";
+	var nextId = 0;
+	function advise(dispatcher, type, advice, receiveArguments){
+		var previous = dispatcher[type];
+		var around = type == "around";
+		var signal;
+		if(around){
+			var advised = advice(function(){
+				return previous.advice(this, arguments);
+			});
+			signal = {
+				remove: function(){
+					signal.cancelled = true;
+				},
+				advice: function(target, args){
+					return signal.cancelled ?
+						previous.advice(target, args) : // cancelled, skip to next one
+						advised.apply(target, args);	// called the advised function
+				}
+			};
+		}else{
+			// create the remove handler
+			signal = {
+				remove: function(){
+					var previous = signal.previous;
+					var next = signal.next;
+					if(!next && !previous){
+						delete dispatcher[type];
+					}else{
+						if(previous){
+							previous.next = next;
+						}else{
+							dispatcher[type] = next;
+						}
+						if(next){
+							next.previous = previous;
+						}
+					}
+				},
+				id: nextId++,
+				advice: advice,
+				receiveArguments: receiveArguments
+			};
+		}
+		if(previous && !around){
+			if(type == "after"){
+				// add the listener to the end of the list
+				var next = previous;
+				while(next){
+					previous = next;
+					next = next.next;
+				}
+				previous.next = signal;
+				signal.previous = previous;
+			}else if(type == "before"){
+				// add to beginning
+				dispatcher[type] = signal;
+				signal.next = previous;
+				previous.previous = signal;
+			}
+		}else{
+			// around or first one just replaces
+			dispatcher[type] = signal;
+		}
+		return signal;
+	}
+	function aspect(type){
+		return function(target, methodName, advice, receiveArguments){
+			var existing = target[methodName], dispatcher;
+			if(!existing || existing.target != target){
+				// no dispatcher in place
+				target[methodName] = dispatcher = function(){
+					var executionId = nextId;
+					// before advice
+					var args = arguments;
+					var before = dispatcher.before;
+					while(before){
+						args = before.advice.apply(this, args) || args;
+						before = before.next;
+					}
+					// around advice
+					if(dispatcher.around){
+						var results = dispatcher.around.advice(this, args);
+					}
+					// after advice
+					var after = dispatcher.after;
+					while(after && after.id < executionId){
+						results = after.receiveArguments ? after.advice.apply(this, args) || results :
+								after.advice.call(this, results);
+						after = after.next;
+					}
+					return results;
+				};
+				if(existing){
+					dispatcher.around = {advice: function(target, args){
+						return existing.apply(target, args);
+					}};
+				}
+				dispatcher.target = target;
+			}
+			var results = advise((dispatcher || existing), type, advice, receiveArguments);
+			advice = null;
+			return results;
+		};
+	}
+	return {
+		before: aspect("before"),
+		around: aspect("around"),
+		after: aspect("after")
+	};
+});
+
+},
+'dojo/_base/connect':function(){
+define(["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(kernel, on, hub, aspect, eventModule, mouse, has, lang){
+//  module:
+//    dojo/_base/connect
+//  summary:
+//    This module defines the dojo.connect API.
+//		This modules also provides keyboard event handling helpers.
+//		This module exports an extension event for emulating Firefox's keypress handling.
+//		However, this extension event exists primarily for backwards compatibility and
+//		is not recommended. WebKit and IE uses an alternate keypress handling (only
+//		firing for printable characters, to distinguish from keydown events), and most
+//		consider the WebKit/IE behavior more desirable.
+has.add("events-keypress-typed", function(){ // keypresses should only occur a printable character is hit
+	var testKeyEvent = {charCode: 0};
+	try{
+		testKeyEvent = document.createEvent("KeyboardEvent");
+		(testKeyEvent.initKeyboardEvent || testKeyEvent.initKeyEvent).call(testKeyEvent, "keypress", true, true, null, false, false, false, false, 9, 3);
+	}catch(e){}
+	return testKeyEvent.charCode == 0 && !has("opera");
+});
+
+function connect_(obj, event, context, method, dontFix){
+	method = lang.hitch(context, method);
+	if(!obj || !(obj.addEventListener || obj.attachEvent)){
+		// it is a not a DOM node and we are using the dojo.connect style of treating a
+		// method like an event, must go right to aspect
+		return aspect.after(obj || kernel.global, event, method, true);
+	}
+	if(typeof event == "string" && event.substring(0, 2) == "on"){
+		event = event.substring(2);
+	}
+	if(!obj){
+		obj = kernel.global;
+	}
+	if(!dontFix){
+		switch(event){
+			// dojo.connect has special handling for these event types
+			case "keypress":
+				event = keypress;
+				break;
+			case "mouseenter":
+				event = mouse.enter;
+				break;
+			case "mouseleave":
+				event = mouse.leave;
+				break;
+		}
+	}
+	return on(obj, event, method, dontFix);
+}
+
+var _punctMap = {
+	106:42,
+	111:47,
+	186:59,
+	187:43,
+	188:44,
+	189:45,
+	190:46,
+	191:47,
+	192:96,
+	219:91,
+	220:92,
+	221:93,
+	222:39,
+	229:113
+};
+var evtCopyKey = has("mac") ? "metaKey" : "ctrlKey";
+
+
+var _synthesizeEvent = function(evt, props){
+	var faux = lang.mixin({}, evt, props);
+	setKeyChar(faux);
+	// FIXME: would prefer to use lang.hitch: lang.hitch(evt, evt.preventDefault);
+	// but it throws an error when preventDefault is invoked on Safari
+	// does Event.preventDefault not support "apply" on Safari?
+	faux.preventDefault = function(){ evt.preventDefault(); };
+	faux.stopPropagation = function(){ evt.stopPropagation(); };
+	return faux;
+};
+function setKeyChar(evt){
+	evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
+	evt.charOrCode = evt.keyChar || evt.keyCode;
+}
+var keypress;
+if(has("events-keypress-typed")){
+	// this emulates Firefox's keypress behavior where every keydown can correspond to a keypress
+	var _trySetKeyCode = function(e, code){
+		try{
+			// squelch errors when keyCode is read-only
+			// (e.g. if keyCode is ctrl or shift)
+			return (e.keyCode = code);
+		}catch(e){
+			return 0;
+		}
+	};
+	keypress = function(object, listener){
+		var keydownSignal = on(object, "keydown", function(evt){
+			// munge key/charCode
+			var k=evt.keyCode;
+			// These are Windows Virtual Key Codes
+			// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
+			var unprintable = (k!=13 || (has("ie") >= 9 && !has("quirks"))) && k!=32 && (k!=27||!has("ie")) && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229;
+			// synthesize keypress for most unprintables and CTRL-keys
+			if(unprintable||evt.ctrlKey){
+				var c = unprintable ? 0 : k;
+				if(evt.ctrlKey){
+					if(k==3 || k==13){
+						return listener.call(evt.currentTarget, evt); // IE will post CTRL-BREAK, CTRL-ENTER as keypress natively
+					}else if(c>95 && c<106){
+						c -= 48; // map CTRL-[numpad 0-9] to ASCII
+					}else if((!evt.shiftKey)&&(c>=65&&c<=90)){
+						c += 32; // map CTRL-[A-Z] to lowercase
+					}else{
+						c = _punctMap[c] || c; // map other problematic CTRL combinations to ASCII
+					}
+				}
+				// simulate a keypress event
+				var faux = _synthesizeEvent(evt, {type: 'keypress', faux: true, charCode: c});
+				listener.call(evt.currentTarget, faux);
+				if(has("ie")){
+					_trySetKeyCode(evt, faux.keyCode);
+				}
+			}
+		});
+		var keypressSignal = on(object, "keypress", function(evt){
+			var c = evt.charCode;
+			c = c>=32 ? c : 0;
+			evt = _synthesizeEvent(evt, {charCode: c, faux: true});
+			return listener.call(this, evt);
+		});
+		return {
+			remove: function(){
+				keydownSignal.remove();
+				keypressSignal.remove();
+			}
+		};
+	};
+}else{
+	if(has("opera")){
+		keypress = function(object, listener){
+			return on(object, "keypress", function(evt){
+				var c = evt.which;
+				if(c==3){
+					c=99; // Mozilla maps CTRL-BREAK to CTRL-c
+				}
+				// can't trap some keys at all, like INSERT and DELETE
+				// there is no differentiating info between DELETE and ".", or INSERT and "-"
+				c = c<32 && !evt.shiftKey ? 0 : c;
+				if(evt.ctrlKey && !evt.shiftKey && c>=65 && c<=90){
+					// lowercase CTRL-[A-Z] keys
+					c += 32;
+				}
+				return listener.call(this, _synthesizeEvent(evt, { charCode: c }));
+			});
+		};
+	}else{
+		keypress = function(object, listener){
+			return on(object, "keypress", function(evt){
+				setKeyChar(evt);
+				return listener.call(this, evt);
+			});
+		};
+	}
+}
+
+var connect = {
+	_keypress:keypress,
+
+	connect:function(obj, event, context, method, dontFix){
+		// normalize arguments
+		var a=arguments, args=[], i=0;
+		// if a[0] is a String, obj was omitted
+		args.push(typeof a[0] == "string" ? null : a[i++], a[i++]);
+		// if the arg-after-next is a String or Function, context was NOT omitted
+		var a1 = a[i+1];
+		args.push(typeof a1 == "string" || typeof a1 == "function" ? a[i++] : null, a[i++]);
+		// absorb any additional arguments
+		for(var l=a.length; i<l; i++){	args.push(a[i]); }
+		return connect_.apply(this, args);
+	},
+
+	disconnect:function(handle){
+		if(handle){
+			handle.remove();
+		}
+	},
+
+	subscribe:function(topic, context, method){
+		return hub.subscribe(topic, lang.hitch(context, method));
+	},
+
+	publish:function(topic, args){
+		return hub.publish.apply(hub, [topic].concat(args));
+	},
+
+	connectPublisher:function(topic, obj, event){
+		var pf = function(){ connect.publish(topic, arguments); };
+		return event ? connect.connect(obj, event, pf) : connect.connect(obj, pf); //Handle
+	},
+
+	isCopyKey: function(e){
+		return e[evtCopyKey];	// Boolean
+	}
+};
+connect.unsubscribe = connect.disconnect;
+
+1 && lang.mixin(kernel, connect);
+return connect;
+
+/*=====
+dojo.connect = function(obj, event, context, method, dontFix){
+	// summary:
+	//		`dojo.connect` is the core event handling and delegation method in
+	//		Dojo. It allows one function to "listen in" on the execution of
+	//		any other, triggering the second whenever the first is called. Many
+	//		listeners may be attached to a function, and source functions may
+	//		be either regular function calls or DOM events.
+	//
+	// description:
+	//		Connects listeners to actions, so that after event fires, a
+	//		listener is called with the same arguments passed to the original
+	//		function.
+	//
+	//		Since `dojo.connect` allows the source of events to be either a
+	//		"regular" JavaScript function or a DOM event, it provides a uniform
+	//		interface for listening to all the types of events that an
+	//		application is likely to deal with though a single, unified
+	//		interface. DOM programmers may want to think of it as
+	//		"addEventListener for everything and anything".
+	//
+	//		When setting up a connection, the `event` parameter must be a
+	//		string that is the name of the method/event to be listened for. If
+	//		`obj` is null, `kernel.global` is assumed, meaning that connections
+	//		to global methods are supported but also that you may inadvertently
+	//		connect to a global by passing an incorrect object name or invalid
+	//		reference.
+	//
+	//		`dojo.connect` generally is forgiving. If you pass the name of a
+	//		function or method that does not yet exist on `obj`, connect will
+	//		not fail, but will instead set up a stub method. Similarly, null
+	//		arguments may simply be omitted such that fewer than 4 arguments
+	//		may be required to set up a connection See the examples for details.
+	//
+	//		The return value is a handle that is needed to
+	//		remove this connection with `dojo.disconnect`.
+	//
+	// obj: Object|null:
+	//		The source object for the event function.
+	//		Defaults to `kernel.global` if null.
+	//		If obj is a DOM node, the connection is delegated
+	//		to the DOM event manager (unless dontFix is true).
+	//
+	// event: String:
+	//		String name of the event function in obj.
+	//		I.e. identifies a property `obj[event]`.
+	//
+	// context: Object|null
+	//		The object that method will receive as "this".
+	//
+	//		If context is null and method is a function, then method
+	//		inherits the context of event.
+	//
+	//		If method is a string then context must be the source
+	//		object object for method (context[method]). If context is null,
+	//		kernel.global is used.
+	//
+	// method: String|Function:
+	//		A function reference, or name of a function in context.
+	//		The function identified by method fires after event does.
+	//		method receives the same arguments as the event.
+	//		See context argument comments for information on method's scope.
+	//
+	// dontFix: Boolean?
+	//		If obj is a DOM node, set dontFix to true to prevent delegation
+	//		of this connection to the DOM event manager.
+	//
+	// example:
+	//		When obj.onchange(), do ui.update():
+	//	|	dojo.connect(obj, "onchange", ui, "update");
+	//	|	dojo.connect(obj, "onchange", ui, ui.update); // same
+	//
+	// example:
+	//		Using return value for disconnect:
+	//	|	var link = dojo.connect(obj, "onchange", ui, "update");
+	//	|	...
+	//	|	dojo.disconnect(link);
+	//
+	// example:
+	//		When onglobalevent executes, watcher.handler is invoked:
+	//	|	dojo.connect(null, "onglobalevent", watcher, "handler");
+	//
+	// example:
+	//		When ob.onCustomEvent executes, customEventHandler is invoked:
+	//	|	dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
+	//	|	dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
+	//
+	// example:
+	//		When ob.onCustomEvent executes, customEventHandler is invoked
+	//		with the same scope (this):
+	//	|	dojo.connect(ob, "onCustomEvent", null, customEventHandler);
+	//	|	dojo.connect(ob, "onCustomEvent", customEventHandler); // same
+	//
+	// example:
+	//		When globalEvent executes, globalHandler is invoked
+	//		with the same scope (this):
+	//	|	dojo.connect(null, "globalEvent", null, globalHandler);
+	//	|	dojo.connect("globalEvent", globalHandler); // same
+}
+=====*/
+
+/*=====
+dojo.disconnect = function(handle){
+	// summary:
+	//		Remove a link created by dojo.connect.
+	// description:
+	//		Removes the connection between event and the method referenced by handle.
+	// handle: Handle:
+	//		the return value of the dojo.connect call that created the connection.
+}
+=====*/
+
+/*=====
+dojo.subscribe = function(topic, context, method){
+	//	summary:
+	//		Attach a listener to a named topic. The listener function is invoked whenever the
+	//		named topic is published (see: dojo.publish).
+	//		Returns a handle which is needed to unsubscribe this listener.
+	//	topic: String:
+	//		The topic to which to subscribe.
+	//	context: Object|null:
+	//		Scope in which method will be invoked, or null for default scope.
+	//	method: String|Function:
+	//		The name of a function in context, or a function reference. This is the function that
+	//		is invoked when topic is published.
+	//	example:
+	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); });
+	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
+}
+=====*/
+
+/*=====
+dojo.unsubscribe = function(handle){
+	//	summary:
+	//		Remove a topic listener.
+	//	handle: Handle
+	//		The handle returned from a call to subscribe.
+	//	example:
+	//	|	var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+	//	|	...
+	//	|	dojo.unsubscribe(alerter);
+}
+=====*/
+
+/*=====
+dojo.publish = function(topic, args){
+	//	summary:
+	//		Invoke all listener method subscribed to topic.
+	//	topic: String:
+	//		The name of the topic to publish.
+	//	args: Array?
+	//		An array of arguments. The arguments will be applied
+	//		to each topic subscriber (as first class parameters, via apply).
+	//	example:
+	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
+}
+=====*/
+
+/*=====
+dojo.connectPublisher = function(topic, obj, event){
+	//	summary:
+	//		Ensure that every time obj.event() is called, a message is published
+	//		on the topic. Returns a handle which can be passed to
+	//		dojo.disconnect() to disable subsequent automatic publication on
+	//		the topic.
+	//	topic: String:
+	//		The name of the topic to publish.
+	//	obj: Object|null:
+	//		The source object for the event function. Defaults to kernel.global
+	//		if null.
+	//	event: String:
+	//		The name of the event function in obj.
+	//		I.e. identifies a property obj[event].
+	//	example:
+	//	|	dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
+}
+=====*/
+
+/*=====
+dojo.isCopyKey = function(e){
+	// summary:
+	//		Checks an event for the copy key (meta on Mac, and ctrl anywhere else)
+	// e: Event
+	//		Event object to examine
+}
+=====*/
+
+});
+
+
+
+}}});
+
+(function(){
+	// must use this.require to make this work in node.js
+	var require = this.require;
+	// consume the cached dojo layer
+	require({cache:{}});
+	!require.async && require(["dojo"]);
+	require.boot && require.apply(null, require.boot);
+})();
diff --git a/js/dojo-1.7.2/dojo/dojo.profile.js b/js/dojo-1.7.2/dojo/dojo.profile.js
new file mode 100644
index 0000000..40e45f9
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dojo.profile.js
@@ -0,0 +1,40 @@
+var profile = (function(){
+	var testResourceRe = /^dojo\/tests\//,
+
+		copyOnly = function(filename, mid){
+			var list = {
+				"dojo/dojo.profile":1,
+				"dojo/package.json":1,
+				"dojo/OpenAjax":1,
+				"dojo/tests":1,
+				// these are test modules that are not intended to ever be built
+				"dojo/tests/_base/loader/requirejs/requirejs-setup":1,
+				"dojo/tests/_base/loader/requirejs/dataMain":1,
+				"dojo/tests/_base/loader/requirejs/depoverlap":1,
+				"dojo/tests/_base/loader/requirejs/simple-tests":1,
+				"dojo/tests/_base/loader/requirejs/relative/relative-tests":1,
+				"dojo/tests/_base/loader/requirejs/exports/exports-tests":1
+			};
+			return (mid in list) || /^dojo\/_base\/config\w+$/.test(mid) || (/^dojo\/resources\//.test(mid) && !/\.css$/.test(filename)) || /(png|jpg|jpeg|gif|tiff)$/.test(filename);
+		};
+
+	return {
+		resourceTags:{
+			test: function(filename, mid){
+				return testResourceRe.test(mid) || mid=="dojo/tests" || mid=="dojo/robot" || mid=="dojo/robotx";
+			},
+
+			copyOnly: function(filename, mid){
+				return copyOnly(filename, mid);
+			},
+
+			amd: function(filename, mid){
+				return !testResourceRe.test(mid) && !copyOnly(filename, mid) && /\.js$/.test(filename);
+			}
+		},
+
+		trees:[
+			[".", ".", /(\/\.)|(~$)/]
+		]
+	};
+})();
diff --git a/js/dojo-1.7.2/dojo/dom-attr.js b/js/dojo-1.7.2/dojo/dom-attr.js
new file mode 100644
index 0000000..6d61c6e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dom-attr.js
@@ -0,0 +1,239 @@
+//>>built
+define("dojo/dom-attr", ["exports", "./_base/sniff", "./_base/lang", "./dom", "./dom-style", "./dom-prop"],
+		function(exports, has, lang, dom, style, prop){
+	// module:
+	//		dojo/dom-attr
+	// summary:
+	//		This module defines the core dojo DOM attributes API.
+
+	// =============================
+	// Element attribute Functions
+	// =============================
+
+	// This module will be obsolete soon. Use dojo.prop instead.
+
+	// dojo.attr() should conform to http://www.w3.org/TR/DOM-Level-2-Core/
+
+	// attribute-related functions (to be obsolete soon)
+
+	/*=====
+	dojo.hasAttr = function(node, name){
+		// summary:
+		//		Returns true if the requested attribute is specified on the
+		//		given element, and false otherwise.
+		// node: DOMNode|String
+		//		id or reference to the element to check
+		// name: String
+		//		the name of the attribute
+		// returns: Boolean
+		//		true if the requested attribute is specified on the
+		//		given element, and false otherwise
+	};
+	=====*/
+
+	/*=====
+	dojo.getAttr = function(node, name){
+		// summary:
+		//		Gets an attribute on an HTML element.
+		// description:
+		//		Handles normalized getting of attributes on DOM Nodes.
+		// node: DOMNode|String
+		//		id or reference to the element to get the attribute on
+		// name: String
+		//		the name of the attribute to get.
+		// returns:
+		//		the value of the requested attribute or null if that attribute does not have a specified or
+		//		default value;
+		//
+		// example:
+		//	|	// get the current value of the "foo" attribute on a node
+		//	|	dojo.getAttr(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.getAttr("nodeId", "foo");
+	};
+	=====*/
+
+	/*=====
+	dojo.setAttr = function(node, name, value){
+		// summary:
+		//		Sets an attribute on an HTML element.
+		// description:
+		//		Handles normalized setting of attributes on DOM Nodes.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to set the attribute on
+		// name: String|Object
+		//		the name of the attribute to set, or a hash of key-value pairs to set.
+		// value: String?
+		//		the value to set for the attribute, if the name is a string.
+		// returns:
+		//		the DOM node
+		//
+		// example:
+		//	|	// use attr() to set the tab index
+		//	|	dojo.setAttr("nodeId", "tabIndex", 3);
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.setAttr("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.setAttr("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.setAttr("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.setStyle("someNode", obj);
+	};
+	=====*/
+
+	/*=====
+	dojo.removeAttr = function(node, name){
+		// summary:
+		//		Removes an attribute from an HTML element.
+		// node: DOMNode|String
+		//		id or reference to the element to remove the attribute from
+		// name: String
+		//		the name of the attribute to remove
+	};
+	=====*/
+
+	/*=====
+	dojo.getNodeProp = function(node, name){
+		// summary:
+		//		Returns an effective value of a property or an attribute.
+		// node: DOMNode|String
+		//		id or reference to the element to remove the attribute from
+		// name: String
+		//		the name of the attribute
+		// returns:
+		//      the value of the attribute
+	};
+	=====*/
+
+	var forcePropNames = {
+			innerHTML:	1,
+			className:	1,
+			htmlFor:	has("ie"),
+			value:		1
+		},
+		attrNames = {
+			// original attribute names
+			classname: "class",
+			htmlfor: "for",
+			// for IE
+			tabindex: "tabIndex",
+			readonly: "readOnly"
+		};
+
+	function _hasAttr(node, name){
+		var attr = node.getAttributeNode && node.getAttributeNode(name);
+		return attr && attr.specified; // Boolean
+	}
+
+	// There is a difference in the presence of certain properties and their default values
+	// between browsers. For example, on IE "disabled" is present on all elements,
+	// but it is value is "false"; "tabIndex" of <div> returns 0 by default on IE, yet other browsers
+	// can return -1.
+
+	exports.has = function hasAttr(/*DOMNode|String*/node, /*String*/name){
+		var lc = name.toLowerCase();
+		return forcePropNames[prop.names[lc] || name] || _hasAttr(dom.byId(node), attrNames[lc] || name);	// Boolean
+	};
+
+	exports.get = function getAttr(/*DOMNode|String*/node, /*String*/name){
+		node = dom.byId(node);
+		var lc = name.toLowerCase(),
+			propName = prop.names[lc] || name,
+			forceProp = forcePropNames[propName];
+		// should we access this attribute via a property or via getAttribute()?
+		value = node[propName];
+		if(forceProp && typeof value != "undefined"){
+			// node's property
+			return value;	// Anything
+		}
+		if(propName != "href" && (typeof value == "boolean" || lang.isFunction(value))){
+			// node's property
+			return value;	// Anything
+		}
+		// node's attribute
+		// we need _hasAttr() here to guard against IE returning a default value
+		var attrName = attrNames[lc] || name;
+		return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
+	};
+
+	exports.set = function setAttr(/*DOMNode|String*/node, /*String|Object*/name, /*String?*/value){
+		node = dom.byId(node);
+		if(arguments.length == 2){ // inline'd type check
+			// the object form of setter: the 2nd argument is a dictionary
+			for(var x in name){
+				exports.set(node, x, name[x]);
+			}
+			return node; // DomNode
+		}
+		var lc = name.toLowerCase(),
+			propName = prop.names[lc] || name,
+			forceProp = forcePropNames[propName];
+		if(propName == "style" && typeof value != "string"){ // inline'd type check
+			// special case: setting a style
+			style.set(node, value);
+			return node; // DomNode
+		}
+		if(forceProp || typeof value == "boolean" || lang.isFunction(value)){
+			return prop.set(node, name, value)
+		}
+		// node's attribute
+		node.setAttribute(attrNames[lc] || name, value);
+		return node; // DomNode
+	};
+
+	exports.remove = function removeAttr(/*DOMNode|String*/ node, /*String*/ name){
+		dom.byId(node).removeAttribute(attrNames[name.toLowerCase()] || name);
+	};
+
+	exports.getNodeProp = function getNodeProp(/*DomNode|String*/ node, /*String*/ name){
+		node = dom.byId(node);
+		var lc = name.toLowerCase(), propName = prop.names[lc] || name;
+		if((propName in node) && propName != "href"){
+			// node's property
+			return node[propName];	// Anything
+		}
+		// node's attribute
+		var attrName = attrNames[lc] || name;
+		return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/dom-class.js b/js/dojo-1.7.2/dojo/dom-class.js
new file mode 100644
index 0000000..4e45c68
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dom-class.js
@@ -0,0 +1,321 @@
+//>>built
+define("dojo/dom-class", ["./_base/lang", "./_base/array", "./dom"], function(lang, array, dom){
+	// module:
+	//		dojo/dom-class
+	// summary:
+	//		This module defines the core dojo DOM class API.
+
+	var className = "className";
+
+	/* Part I of classList-based implementation is preserved here for posterity
+	var classList = "classList";
+	has.add("dom-classList", function(){
+		return classList in document.createElement("p");
+	});
+	*/
+
+	// =============================
+	// (CSS) Class Functions
+	// =============================
+
+	/*=====
+	dojo.hasClass = function(node, classStr){
+		// summary:
+		//		Returns whether or not the specified classes are a portion of the
+		//		class list currently applied to the node.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to check the class for.
+		//
+		// classStr: String
+		//		A string class name to look for.
+		//
+		// returns: Boolean
+		//
+		// example:
+		//		Do something if a node with id="someNode" has class="aSillyClassName" present
+		//	|	if(dojo.hasClass("someNode","aSillyClassName")){ ... }
+	};
+	=====*/
+
+	/*=====
+	dojo.addClass = function(node, classStr){
+		// summary:
+		//		Adds the specified classes to the end of the class list on the
+		//		passed node. Will not re-apply duplicate classes.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to add a class string too
+		//
+		// classStr: String|Array
+		//		A String class name to add, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// example:
+		//		Add a class to some node:
+		//	|	dojo.addClass("someNode", "anewClass");
+		//
+		// example:
+		//		Add two classes at once:
+		//	|	dojo.addClass("someNode", "firstClass secondClass");
+		//
+		// example:
+		//		Add two classes at once (using array):
+		//	|	dojo.addClass("someNode", ["firstClass", "secondClass"]);
+		//
+		// example:
+		//		Available in `dojo.NodeList` for multiple additions
+		//	|	dojo.query("ul > li").addClass("firstLevel");
+	};
+	=====*/
+
+	/*=====
+	dojo.removeClass = function(node, classStr){
+		// summary:
+		//		Removes the specified classes from node. No `dojo.hasClass`
+		//		check is required.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to remove the class from.
+		//
+		// classStr: String|Array
+		//		An optional String class name to remove, or several space-separated
+		//		class names, or an array of class names. If omitted, all class names
+		//		will be deleted.
+		//
+		// example:
+		//		Remove a class from some node:
+		//	|	dojo.removeClass("someNode", "firstClass");
+		//
+		// example:
+		//		Remove two classes from some node:
+		//	|	dojo.removeClass("someNode", "firstClass secondClass");
+		//
+		// example:
+		//		Remove two classes from some node (using array):
+		//	|	dojo.removeClass("someNode", ["firstClass", "secondClass"]);
+		//
+		// example:
+		//		Remove all classes from some node:
+		//	|	dojo.removeClass("someNode");
+		//
+		// example:
+		//		Available in `dojo.NodeList()` for multiple removal
+		//	|	dojo.query(".foo").removeClass("foo");
+	};
+	=====*/
+
+	/*=====
+	dojo.replaceClass = function(node, addClassStr, removeClassStr){
+		// summary:
+		//		Replaces one or more classes on a node if not present.
+		//		Operates more quickly than calling dojo.removeClass and dojo.addClass
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to remove the class from.
+		//
+		// addClassStr: String|Array
+		//		A String class name to add, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// removeClassStr: String|Array?
+		//		A String class name to remove, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// example:
+		//	|	dojo.replaceClass("someNode", "add1 add2", "remove1 remove2");
+		//
+		// example:
+		//	Replace all classes with addMe
+		//	|	dojo.replaceClass("someNode", "addMe");
+		//
+		// example:
+		//	Available in `dojo.NodeList()` for multiple toggles
+		//	|	dojo.query(".findMe").replaceClass("addMe", "removeMe");
+	};
+	=====*/
+
+	/*=====
+	dojo.toggleClass = function(node, classStr, condition){
+		// summary:
+		//		Adds a class to node if not present, or removes if present.
+		//		Pass a boolean condition if you want to explicitly add or remove.
+		//      Returns the condition that was specified directly or indirectly.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to toggle a class string
+		//
+		// classStr: String|Array
+		//		A String class name to toggle, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// condition:
+		//		If passed, true means to add the class, false means to remove.
+		//      Otherwise dojo.hasClass(node, classStr) is used to detect the class presence.
+		//
+		// example:
+		//	|	dojo.toggleClass("someNode", "hovered");
+		//
+		// example:
+		//		Forcefully add a class
+		//	|	dojo.toggleClass("someNode", "hovered", true);
+		//
+		// example:
+		//		Available in `dojo.NodeList()` for multiple toggles
+		//	|	dojo.query(".toggleMe").toggleClass("toggleMe");
+	};
+	=====*/
+
+	var cls, // exports object
+		spaces = /\s+/, a1 = [""];
+
+	function str2array(s){
+		if(typeof s == "string" || s instanceof String){
+			if(s && !spaces.test(s)){
+				a1[0] = s;
+				return a1;
+			}
+			var a = s.split(spaces);
+			if(a.length && !a[0]){
+				a.shift();
+			}
+			if(a.length && !a[a.length - 1]){
+				a.pop();
+			}
+			return a;
+		}
+		// assumed to be an array
+		if(!s){
+			return [];
+		}
+		return array.filter(s, function(x){ return x; });
+	}
+
+	/* Part II of classList-based implementation is preserved here for posterity
+	if(has("dom-classList")){
+		// new classList version
+		cls = {
+			contains: function containsClass(node, classStr){
+				var clslst = classStr && dom.byId(node)[classList];
+				return clslst && clslst.contains(classStr); // Boolean
+			},
+
+			add: function addClass(node, classStr){
+				node = dom.byId(node);
+				classStr = str2array(classStr);
+				for(var i = 0, len = classStr.length; i < len; ++i){
+					node[classList].add(classStr[i]);
+				}
+			},
+
+			remove: function removeClass(node, classStr){
+				node = dom.byId(node);
+				if(classStr === undefined){
+					node[className] = "";
+				}else{
+					classStr = str2array(classStr);
+					for(var i = 0, len = classStr.length; i < len; ++i){
+						node[classList].remove(classStr[i]);
+					}
+				}
+			},
+
+			replace: function replaceClass(node, addClassStr, removeClassStr){
+				node = dom.byId(node);
+				if(removeClassStr === undefined){
+					node[className] = "";
+				}else{
+					removeClassStr = str2array(removeClassStr);
+					for(var i = 0, len = removeClassStr.length; i < len; ++i){
+						node[classList].remove(removeClassStr[i]);
+					}
+				}
+				addClassStr = str2array(addClassStr);
+				for(i = 0, len = addClassStr.length; i < len; ++i){
+					node[classList].add(addClassStr[i]);
+				}
+			},
+
+			toggle: function toggleClass(node, classStr, condition){
+				node = dom.byId(node);
+				if(condition === undefined){
+					classStr = str2array(classStr);
+					for(var i = 0, len = classStr.length; i < len; ++i){
+						node[classList].toggle(classStr[i]);
+					}
+				}else{
+					cls[condition ? "add" : "remove"](node, classStr);
+				}
+				return condition;   // Boolean
+			}
+		}
+	}
+	*/
+
+	// regular DOM version
+	var fakeNode = {};  // for effective replacement
+	cls = {
+		contains: function containsClass(/*DomNode|String*/node, /*String*/classStr){
+			return ((" " + dom.byId(node)[className] + " ").indexOf(" " + classStr + " ") >= 0); // Boolean
+		},
+
+		add: function addClass(/*DomNode|String*/node, /*String|Array*/classStr){
+			node = dom.byId(node);
+			classStr = str2array(classStr);
+			var cls = node[className], oldLen;
+			cls = cls ? " " + cls + " " : " ";
+			oldLen = cls.length;
+			for(var i = 0, len = classStr.length, c; i < len; ++i){
+				c = classStr[i];
+				if(c && cls.indexOf(" " + c + " ") < 0){
+					cls += c + " ";
+				}
+			}
+			if(oldLen < cls.length){
+				node[className] = cls.substr(1, cls.length - 2);
+			}
+		},
+
+		remove: function removeClass(/*DomNode|String*/node, /*String|Array?*/classStr){
+			node = dom.byId(node);
+			var cls;
+			if(classStr !== undefined){
+				classStr = str2array(classStr);
+				cls = " " + node[className] + " ";
+				for(var i = 0, len = classStr.length; i < len; ++i){
+					cls = cls.replace(" " + classStr[i] + " ", " ");
+				}
+				cls = lang.trim(cls);
+			}else{
+				cls = "";
+			}
+			if(node[className] != cls){ node[className] = cls; }
+		},
+
+		replace: function replaceClass(/*DomNode|String*/node, /*String|Array*/addClassStr, /*String|Array?*/removeClassStr){
+			node = dom.byId(node);
+			fakeNode[className] = node[className];
+			cls.remove(fakeNode, removeClassStr);
+			cls.add(fakeNode, addClassStr);
+			if(node[className] !== fakeNode[className]){
+				node[className] = fakeNode[className];
+			}
+		},
+
+		toggle: function toggleClass(/*DomNode|String*/node, /*String|Array*/classStr, /*Boolean?*/condition){
+			node = dom.byId(node);
+			if(condition === undefined){
+				classStr = str2array(classStr);
+				for(var i = 0, len = classStr.length, c; i < len; ++i){
+					c = classStr[i];
+					cls[cls.contains(node, c) ? "remove" : "add"](node, c);
+				}
+			}else{
+				cls[condition ? "add" : "remove"](node, classStr);
+			}
+			return condition;   // Boolean
+		}
+	};
+
+	return cls;
+});
diff --git a/js/dojo-1.7.2/dojo/dom-construct.js b/js/dojo-1.7.2/dojo/dom-construct.js
new file mode 100644
index 0000000..ee6a513
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dom-construct.js
@@ -0,0 +1,377 @@
+//>>built
+define("dojo/dom-construct", ["exports", "./_base/kernel", "./_base/sniff", "./_base/window", "./dom", "./dom-attr", "./on"],
+		function(exports, dojo, has, win, dom, attr, on){
+	// module:
+	//		dojo/dom-construct
+	// summary:
+	//		This module defines the core dojo DOM construction API.
+
+	/*=====
+	dojo.toDom = function(frag, doc){
+		// summary:
+		//		instantiates an HTML fragment returning the corresponding DOM.
+		// frag: String
+		//		the HTML fragment
+		// doc: DocumentNode?
+		//		optional document to use when creating DOM nodes, defaults to
+		//		dojo.doc if not specified.
+		// returns: DocumentFragment
+		//
+		// example:
+		//		Create a table row:
+		//	|	var tr = dojo.toDom("<tr><td>First!</td></tr>");
+	};
+	=====*/
+
+	/*=====
+	dojo._toDom = function(frag, doc){
+		// summary:
+		//		Existing alias for `dojo.toDom`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.place = function(node, refNode, position){
+		// summary:
+		//		Attempt to insert node into the DOM, choosing from various positioning options.
+		//		Returns the first argument resolved to a DOM node.
+		//
+		// node: DOMNode|String
+		//		id or node reference, or HTML fragment starting with "<" to place relative to refNode
+		//
+		// refNode: DOMNode|String
+		//		id or node reference to use as basis for placement
+		//
+		// position: String|Number?
+		//		string noting the position of node relative to refNode or a
+		//		number indicating the location in the childNodes collection of refNode.
+		//		Accepted string values are:
+		//	|	* before
+		//	|	* after
+		//	|	* replace
+		//	|	* only
+		//	|	* first
+		//	|	* last
+		//		"first" and "last" indicate positions as children of refNode, "replace" replaces refNode,
+		//		"only" replaces all children.  position defaults to "last" if not specified
+		//
+		// returns: DOMNode
+		//		Returned values is the first argument resolved to a DOM node.
+		//
+		//		.place() is also a method of `dojo.NodeList`, allowing `dojo.query` node lookups.
+		//
+		// example:
+		//		Place a node by string id as the last child of another node by string id:
+		//	|	dojo.place("someNode", "anotherNode");
+		//
+		// example:
+		//		Place a node by string id before another node by string id
+		//	|	dojo.place("someNode", "anotherNode", "before");
+		//
+		// example:
+		//		Create a Node, and place it in the body element (last child):
+		//	|	dojo.place("<div></div>", dojo.body());
+		//
+		// example:
+		//		Put a new LI as the first child of a list by id:
+		//	|	dojo.place("<li></li>", "someUl", "first");
+	};
+	=====*/
+
+	/*=====
+	dojo.create = function(tag, attrs, refNode, pos){
+		// summary:
+		//		Create an element, allowing for optional attribute decoration
+		//		and placement.
+		//
+		// description:
+		//		A DOM Element creation function. A shorthand method for creating a node or
+		//		a fragment, and allowing for a convenient optional attribute setting step,
+		//		as well as an optional DOM placement reference.
+		//|
+		//		Attributes are set by passing the optional object through `dojo.setAttr`.
+		//		See `dojo.setAttr` for noted caveats and nuances, and API if applicable.
+		//|
+		//		Placement is done via `dojo.place`, assuming the new node to be the action
+		//		node, passing along the optional reference node and position.
+		//
+		// tag: DOMNode|String
+		//		A string of the element to create (eg: "div", "a", "p", "li", "script", "br"),
+		//		or an existing DOM node to process.
+		//
+		// attrs: Object
+		//		An object-hash of attributes to set on the newly created node.
+		//		Can be null, if you don't want to set any attributes/styles.
+		//		See: `dojo.setAttr` for a description of available attributes.
+		//
+		// refNode: DOMNode?|String?
+		//		Optional reference node. Used by `dojo.place` to place the newly created
+		//		node somewhere in the dom relative to refNode. Can be a DomNode reference
+		//		or String ID of a node.
+		//
+		// pos: String?
+		//		Optional positional reference. Defaults to "last" by way of `dojo.place`,
+		//		though can be set to "first","after","before","last", "replace" or "only"
+		//		to further control the placement of the new node relative to the refNode.
+		//		'refNode' is required if a 'pos' is specified.
+		//
+		// returns: DOMNode
+		//
+		// example:
+		//		Create a DIV:
+		//	|	var n = dojo.create("div");
+		//
+		// example:
+		//		Create a DIV with content:
+		//	|	var n = dojo.create("div", { innerHTML:"<p>hi</p>" });
+		//
+		// example:
+		//		Place a new DIV in the BODY, with no attributes set
+		//	|	var n = dojo.create("div", null, dojo.body());
+		//
+		// example:
+		//		Create an UL, and populate it with LI's. Place the list as the first-child of a
+		//		node with id="someId":
+		//	|	var ul = dojo.create("ul", null, "someId", "first");
+		//	|	var items = ["one", "two", "three", "four"];
+		//	|	dojo.forEach(items, function(data){
+		//	|		dojo.create("li", { innerHTML: data }, ul);
+		//	|	});
+		//
+		// example:
+		//		Create an anchor, with an href. Place in BODY:
+		//	|	dojo.create("a", { href:"foo.html", title:"Goto FOO!" }, dojo.body());
+		//
+		// example:
+		//		Create a `dojo.NodeList()` from a new element (for syntatic sugar):
+		//	|	dojo.query(dojo.create('div'))
+		//	|		.addClass("newDiv")
+		//	|		.onclick(function(e){ console.log('clicked', e.target) })
+		//	|		.place("#someNode"); // redundant, but cleaner.
+	};
+	=====*/
+
+	/*=====
+	dojo.empty = function(node){
+			// summary:
+			//		safely removes all children of the node.
+			// node: DOMNode|String
+			//		a reference to a DOM node or an id.
+			// example:
+			//		Destroy node's children byId:
+			//	|	dojo.empty("someId");
+			//
+			// example:
+			//		Destroy all nodes' children in a list by reference:
+			//	|	dojo.query(".someNode").forEach(dojo.empty);
+	}
+	=====*/
+
+	/*=====
+	dojo.destroy = function(node){
+		// summary:
+		//		Removes a node from its parent, clobbering it and all of its
+		//		children.
+		//
+		// description:
+		//		Removes a node from its parent, clobbering it and all of its
+		//		children. Function only works with DomNodes, and returns nothing.
+		//
+		// node: DOMNode|String
+		//		A String ID or DomNode reference of the element to be destroyed
+		//
+		// example:
+		//		Destroy a node byId:
+		//	|	dojo.destroy("someId");
+		//
+		// example:
+		//		Destroy all nodes in a list by reference:
+		//	|	dojo.query(".someNode").forEach(dojo.destroy);
+	};
+	=====*/
+
+	/*=====
+	dojo._destroyElement = function(node){
+		// summary:
+		//		Existing alias for `dojo.destroy`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	// support stuff for dojo.toDom
+	var tagWrap = {
+			option: ["select"],
+			tbody: ["table"],
+			thead: ["table"],
+			tfoot: ["table"],
+			tr: ["table", "tbody"],
+			td: ["table", "tbody", "tr"],
+			th: ["table", "thead", "tr"],
+			legend: ["fieldset"],
+			caption: ["table"],
+			colgroup: ["table"],
+			col: ["table", "colgroup"],
+			li: ["ul"]
+		},
+		reTag = /<\s*([\w\:]+)/,
+		masterNode = {}, masterNum = 0,
+		masterName = "__" + dojo._scopeName + "ToDomId";
+
+	// generate start/end tag strings to use
+	// for the injection for each special tag wrap case.
+	for(var param in tagWrap){
+		if(tagWrap.hasOwnProperty(param)){
+			var tw = tagWrap[param];
+			tw.pre = param == "option" ? '<select multiple="multiple">' : "<" + tw.join("><") + ">";
+			tw.post = "</" + tw.reverse().join("></") + ">";
+			// the last line is destructive: it reverses the array,
+			// but we don't care at this point
+		}
+	}
+
+	function _insertBefore(/*DomNode*/node, /*DomNode*/ref){
+		var parent = ref.parentNode;
+		if(parent){
+			parent.insertBefore(node, ref);
+		}
+	}
+
+	function _insertAfter(/*DomNode*/node, /*DomNode*/ref){
+		// summary:
+		//		Try to insert node after ref
+		var parent = ref.parentNode;
+		if(parent){
+			if(parent.lastChild == ref){
+				parent.appendChild(node);
+			}else{
+				parent.insertBefore(node, ref.nextSibling);
+			}
+		}
+	}
+
+	var _destroyContainer = null,
+		_destroyDoc;
+		on(window, "unload", function(){
+		_destroyContainer = null; //prevent IE leak
+	});
+	
+	exports.toDom = function toDom(frag, doc){
+		doc = doc || win.doc;
+		var masterId = doc[masterName];
+		if(!masterId){
+			doc[masterName] = masterId = ++masterNum + "";
+			masterNode[masterId] = doc.createElement("div");
+		}
+
+		// make sure the frag is a string.
+		frag += "";
+
+		// find the starting tag, and get node wrapper
+		var match = frag.match(reTag),
+			tag = match ? match[1].toLowerCase() : "",
+			master = masterNode[masterId],
+			wrap, i, fc, df;
+		if(match && tagWrap[tag]){
+			wrap = tagWrap[tag];
+			master.innerHTML = wrap.pre + frag + wrap.post;
+			for(i = wrap.length; i; --i){
+				master = master.firstChild;
+			}
+		}else{
+			master.innerHTML = frag;
+		}
+
+		// one node shortcut => return the node itself
+		if(master.childNodes.length == 1){
+			return master.removeChild(master.firstChild); // DOMNode
+		}
+
+		// return multiple nodes as a document fragment
+		df = doc.createDocumentFragment();
+		while(fc = master.firstChild){ // intentional assignment
+			df.appendChild(fc);
+		}
+		return df; // DOMNode
+	};
+
+	exports.place = function place(/*DOMNode|String*/node, /*DOMNode|String*/refNode, /*String|Number?*/position){
+		refNode = dom.byId(refNode);
+		if(typeof node == "string"){ // inline'd type check
+			node = /^\s*</.test(node) ? exports.toDom(node, refNode.ownerDocument) : dom.byId(node);
+		}
+		if(typeof position == "number"){ // inline'd type check
+			var cn = refNode.childNodes;
+			if(!cn.length || cn.length <= position){
+				refNode.appendChild(node);
+			}else{
+				_insertBefore(node, cn[position < 0 ? 0 : position]);
+			}
+		}else{
+			switch(position){
+				case "before":
+					_insertBefore(node, refNode);
+					break;
+				case "after":
+					_insertAfter(node, refNode);
+					break;
+				case "replace":
+					refNode.parentNode.replaceChild(node, refNode);
+					break;
+				case "only":
+					exports.empty(refNode);
+					refNode.appendChild(node);
+					break;
+				case "first":
+					if(refNode.firstChild){
+						_insertBefore(node, refNode.firstChild);
+						break;
+					}
+					// else fallthrough...
+				default: // aka: last
+					refNode.appendChild(node);
+			}
+		}
+		return node; // DomNode
+	};
+
+	exports.create = function create(/*DOMNode|String*/tag, /*Object*/attrs, /*DOMNode?|String?*/refNode, /*String?*/pos){
+		var doc = win.doc;
+		if(refNode){
+			refNode = dom.byId(refNode);
+			doc = refNode.ownerDocument;
+		}
+		if(typeof tag == "string"){ // inline'd type check
+			tag = doc.createElement(tag);
+		}
+		if(attrs){ attr.set(tag, attrs); }
+		if(refNode){ exports.place(tag, refNode, pos); }
+		return tag; // DomNode
+	};
+
+	exports.empty =
+				has("ie") ? function(node){
+			node = dom.byId(node);
+			for(var c; c = node.lastChild;){ // intentional assignment
+				exports.destroy(c);
+			}
+		} :
+				function(node){
+			dom.byId(node).innerHTML = "";
+		};
+
+	exports.destroy = function destroy(/*DOMNode|String*/node){
+		node = dom.byId(node);
+		try{
+			var doc = node.ownerDocument;
+			// cannot use _destroyContainer.ownerDocument since this can throw an exception on IE
+			if(!_destroyContainer || _destroyDoc != doc){
+				_destroyContainer = doc.createElement("div");
+				_destroyDoc = doc;
+			}
+			_destroyContainer.appendChild(node.parentNode ? node.parentNode.removeChild(node) : node);
+			// NOTE: see http://trac.dojotoolkit.org/ticket/2931. This may be a bug and not a feature
+			_destroyContainer.innerHTML = "";
+		}catch(e){
+			/* squelch */
+		}
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/dom-form.js b/js/dojo-1.7.2/dojo/dom-form.js
new file mode 100644
index 0000000..56533e7
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dom-form.js
@@ -0,0 +1,167 @@
+//>>built
+define("dojo/dom-form", ["./_base/lang", "./dom", "./io-query", "./json"], function(lang, dom, ioq, json){
+	// module:
+	//		dojo/dom-form
+	// summary:
+	//		This module defines form-processing functions.
+
+	/*=====
+	dojo.fieldToObject = function(inputNode){
+		// summary:
+		//		Serialize a form field to a JavaScript object.
+		// description:
+		//		Returns the value encoded in a form field as
+		//		as a string or an array of strings. Disabled form elements
+		//		and unchecked radio and checkboxes are skipped.	Multi-select
+		//		elements are returned as an array of string values.
+		// inputNode: DOMNode|String
+		// returns: Object
+	};
+	=====*/
+
+	/*=====
+    dojo.formToObject = function(formNode){
+        // summary:
+        //		Serialize a form node to a JavaScript object.
+        // description:
+        //		Returns the values encoded in an HTML form as
+        //		string properties in an object which it then returns. Disabled form
+        //		elements, buttons, and other non-value form elements are skipped.
+        //		Multi-select elements are returned as an array of string values.
+		// formNode: DOMNode|String
+		// returns: Object
+        //
+        // example:
+        //		This form:
+        //		|	<form id="test_form">
+        //		|		<input type="text" name="blah" value="blah">
+        //		|		<input type="text" name="no_value" value="blah" disabled>
+        //		|		<input type="button" name="no_value2" value="blah">
+        //		|		<select type="select" multiple name="multi" size="5">
+        //		|			<option value="blah">blah</option>
+        //		|			<option value="thud" selected>thud</option>
+        //		|			<option value="thonk" selected>thonk</option>
+        //		|		</select>
+        //		|	</form>
+        //
+        //		yields this object structure as the result of a call to
+        //		formToObject():
+        //
+        //		|	{
+        //		|		blah: "blah",
+        //		|		multi: [
+        //		|			"thud",
+        //		|			"thonk"
+        //		|		]
+        //		|	};
+    };
+	=====*/
+
+	/*=====
+    dojo.formToQuery = function(formNode){
+        // summary:
+        //		Returns a URL-encoded string representing the form passed as either a
+        //		node or string ID identifying the form to serialize
+		// formNode: DOMNode|String
+		// returns: String
+    };
+	=====*/
+
+	/*=====
+    dojo.formToJson = function(formNode, prettyPrint){
+        // summary:
+        //		Create a serialized JSON string from a form node or string
+        //		ID identifying the form to serialize
+		// formNode: DOMNode|String
+		// prettyPrint: Boolean?
+		// returns: String
+    };
+	=====*/
+
+    function setValue(/*Object*/obj, /*String*/name, /*String*/value){
+        // summary:
+        //		For the named property in object, set the value. If a value
+        //		already exists and it is a string, convert the value to be an
+        //		array of values.
+
+        // Skip it if there is no value
+        if(value === null){
+            return;
+        }
+
+        var val = obj[name];
+        if(typeof val == "string"){ // inline'd type check
+            obj[name] = [val, value];
+        }else if(lang.isArray(val)){
+            val.push(value);
+        }else{
+            obj[name] = value;
+        }
+    }
+
+	var exclude = "file|submit|image|reset|button";
+
+	var form = {
+		fieldToObject: function fieldToObject(/*DOMNode|String*/ inputNode){
+			var ret = null;
+			inputNode = dom.byId(inputNode);
+			if(inputNode){
+				var _in = inputNode.name, type = (inputNode.type || "").toLowerCase();
+				if(_in && type && !inputNode.disabled){
+					if(type == "radio" || type == "checkbox"){
+						if(inputNode.checked){
+							ret = inputNode.value;
+						}
+					}else if(inputNode.multiple){
+						ret = [];
+						var nodes = [inputNode.firstChild];
+						while(nodes.length){
+							for(var node = nodes.pop(); node; node = node.nextSibling){
+								if(node.nodeType == 1 && node.tagName.toLowerCase() == "option"){
+									if(node.selected){
+										ret.push(node.value);
+									}
+								}else{
+									if(node.nextSibling){
+										nodes.push(node.nextSibling);
+									}
+									if(node.firstChild){
+										nodes.push(node.firstChild);
+									}
+									break;
+								}
+							}
+						}
+					}else{
+						ret = inputNode.value;
+					}
+				}
+			}
+			return ret; // Object
+		},
+
+		toObject: function formToObject(/*DOMNode|String*/ formNode){
+			var ret = {}, elems = dom.byId(formNode).elements;
+			for(var i = 0, l = elems.length; i < l; ++i){
+				var item = elems[i], _in = item.name, type = (item.type || "").toLowerCase();
+				if(_in && type && exclude.indexOf(type) < 0 && !item.disabled){
+					setValue(ret, _in, form.fieldToObject(item));
+					if(type == "image"){
+						ret[_in + ".x"] = ret[_in + ".y"] = ret[_in].x = ret[_in].y = 0;
+					}
+				}
+			}
+			return ret; // Object
+		},
+
+		toQuery: function formToQuery(/*DOMNode|String*/ formNode){
+			return ioq.objectToQuery(form.toObject(formNode)); // String
+		},
+
+		toJson: function formToJson(/*DOMNode|String*/ formNode, /*Boolean?*/prettyPrint){
+			return json.stringify(form.toObject(formNode), null, prettyPrint ? 4 : 0); // String
+		}
+	};
+
+    return form;
+});
diff --git a/js/dojo-1.7.2/dojo/dom-geometry.js b/js/dojo-1.7.2/dojo/dom-geometry.js
new file mode 100644
index 0000000..8f8e0fe
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dom-geometry.js
@@ -0,0 +1,752 @@
+//>>built
+define("dojo/dom-geometry", ["./_base/sniff", "./_base/window","./dom", "./dom-style"],
+		function(has, win, dom, style){
+	// module:
+	//		dojo/dom-geometry
+	// summary:
+	//		This module defines the core dojo DOM geometry API.
+
+	var geom = {};  // the result object
+
+	// Box functions will assume this model.
+	// On IE/Opera, BORDER_BOX will be set if the primary document is in quirks mode.
+	// Can be set to change behavior of box setters.
+
+	// can be either:
+	//	"border-box"
+	//	"content-box" (default)
+	geom.boxModel = "content-box";
+
+	// We punt per-node box mode testing completely.
+	// If anybody cares, we can provide an additional (optional) unit
+	// that overrides existing code to include per-node box sensitivity.
+
+	// Opera documentation claims that Opera 9 uses border-box in BackCompat mode.
+	// but experiments (Opera 9.10.8679 on Windows Vista) indicate that it actually continues to use content-box.
+	// IIRC, earlier versions of Opera did in fact use border-box.
+	// Opera guys, this is really confusing. Opera being broken in quirks mode is not our fault.
+
+		if(has("ie") /*|| has("opera")*/){
+		// client code may have to adjust if compatMode varies across iframes
+		geom.boxModel = document.compatMode == "BackCompat" ? "border-box" : "content-box";
+	}
+	
+	// =============================
+	// Box Functions
+	// =============================
+
+	/*=====
+	dojo.getPadExtents = function(node, computedStyle){
+		// summary:
+		//		Returns object with special values specifically useful for node
+		//		fitting.
+		// description:
+		//		Returns an object with `w`, `h`, `l`, `t` properties:
+		//	|		l/t/r/b = left/top/right/bottom padding (respectively)
+		//	|		w = the total of the left and right padding
+		//	|		h = the total of the top and bottom padding
+		//		If 'node' has position, l/t forms the origin for child nodes.
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+
+
+	};
+	=====*/
+
+	/*=====
+	dojo._getPadExtents = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getPadExtents`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getBorderExtents = function(node, computedStyle){
+		// summary:
+		//		returns an object with properties useful for noting the border
+		//		dimensions.
+		// description:
+		//		* l/t/r/b = the sum of left/top/right/bottom border (respectively)
+		//		* w = the sum of the left and right border
+		//		* h = the sum of the top and bottom border
+		//
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+
+
+	};
+	=====*/
+
+	/*=====
+	dojo._getBorderExtents = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getBorderExtents`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getPadBorderExtents = function(node, computedStyle){
+		// summary:
+		//		Returns object with properties useful for box fitting with
+		//		regards to padding.
+		// description:
+		//		* l/t/r/b = the sum of left/top/right/bottom padding and left/top/right/bottom border (respectively)
+		//		* w = the sum of the left and right padding and border
+		//		* h = the sum of the top and bottom padding and border
+		//
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+
+
+	};
+	=====*/
+
+	/*=====
+	dojo._getPadBorderExtents = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getPadBorderExtents`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getMarginExtents = function(node, computedStyle){
+		// summary:
+		//		returns object with properties useful for box fitting with
+		//		regards to box margins (i.e., the outer-box).
+		//
+		//		* l/t = marginLeft, marginTop, respectively
+		//		* w = total width, margin inclusive
+		//		* h = total height, margin inclusive
+		//
+		//		The w/h are used for calculating boxes.
+		//		Normally application code will not need to invoke this
+		//		directly, and will use the ...box... functions instead.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo._getMarginExtents = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getMarginExtents`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getMarginSize = function(node, computedStyle){
+		// summary:
+		//		returns an object that encodes the width and height of
+		//		the node's margin box
+		// node: DOMNode|String
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo._getMarginSize = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getMarginSize`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getMarginBox = function(node, computedStyle){
+		// summary:
+		//		returns an object that encodes the width, height, left and top
+		//		positions of the node's margin box.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo._getMarginBox = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getMarginBox`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.setMarginBox = function(node, box, computedStyle){
+		// summary:
+		//		sets the size of the node's margin box and placement
+		//		(left/top), irrespective of box model. Think of it as a
+		//		passthrough to setBox that handles box-model vagaries for
+		//		you.
+		// node: DOMNode
+		// box: Object
+		//      hash with optional "l", "t", "w", and "h" properties for "left", "right", "width", and "height"
+		//      respectively. All specified properties should have numeric values in whole pixels.
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo.getContentBox = function(node, computedStyle){
+		// summary:
+		//		Returns an object that encodes the width, height, left and top
+		//		positions of the node's content box, irrespective of the
+		//		current box model.
+		// node: DOMNode
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo._getContentBox = function(node, computedStyle){
+		// summary:
+		//		Existing alias for `dojo.getContentBox`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.setContentSize = function(node, box, computedStyle){
+		// summary:
+		//		Sets the size of the node's contents, irrespective of margins,
+		//		padding, or borders.
+		// node: DOMNode
+		// box: Object
+		//      hash with optional "w", and "h" properties for "width", and "height"
+		//      respectively. All specified properties should have numeric values in whole pixels.
+		// computedStyle: Object?
+		// 		This parameter accepts computed styles object.
+		// 		If this parameter is omitted, the functions will call 
+		//		dojo.getComputedStyle to get one. It is a better way, calling 
+		//		dojo.computedStyle once, and then pass the reference to this 
+		//		computedStyle parameter. Wherever possible, reuse the returned 
+		//		object of dojo.getComputedStyle.
+	};
+	=====*/
+
+	/*=====
+	dojo.isBodyLtr = function(){
+		// summary:
+		//      Returns true if the current language is left-to-right, and false otherwise.
+		// returns: Boolean
+	};
+	=====*/
+
+	/*=====
+	dojo._isBodyLtr = function(){
+		// summary:
+		//		Existing alias for `dojo.isBodyLtr`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.docScroll = function(){
+		// summary:
+		//      Returns an object with {node, x, y} with corresponding offsets.
+		// returns: Object
+	};
+	=====*/
+
+	/*=====
+	dojo._docScroll = function(){
+		// summary:
+		//		Existing alias for `dojo.docScroll`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getIeDocumentElementOffset = function(){
+		// summary:
+		//		returns the offset in x and y from the document body to the
+		//		visual edge of the page for IE
+		// description:
+		//		The following values in IE contain an offset:
+		//	|		event.clientX
+		//	|		event.clientY
+		//	|		node.getBoundingClientRect().left
+		//	|		node.getBoundingClientRect().top
+		//		But other position related values do not contain this offset,
+		//		such as node.offsetLeft, node.offsetTop, node.style.left and
+		//		node.style.top. The offset is always (2, 2) in LTR direction.
+		//		When the body is in RTL direction, the offset counts the width
+		//		of left scroll bar's width.  This function computes the actual
+		//		offset.
+	};
+	=====*/
+
+	/*=====
+	dojo._getIeDocumentElementOffset = function(){
+		// summary:
+		//		Existing alias for `dojo.getIeDocumentElementOffset`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.fixIeBiDiScrollLeft = function(scrollLeft){
+		// summary:
+		//      In RTL direction, scrollLeft should be a negative value, but IE
+		//      returns a positive one. All codes using documentElement.scrollLeft
+		//      must call this function to fix this error, otherwise the position
+		//      will offset to right when there is a horizontal scrollbar.
+		// scrollLeft: NUmber
+		// returns: Number
+	};
+	=====*/
+
+	/*=====
+	dojo._fixIeBiDiScrollLeft = function(scrollLeft){
+		// summary:
+		//		Existing alias for `dojo.fixIeBiDiScrollLeft`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.position = function(node, includeScroll){
+		// summary:
+		//		Gets the position and size of the passed element relative to
+		//		the viewport (if includeScroll==false), or relative to the
+		//		document root (if includeScroll==true).
+		//
+		// description:
+		//		Returns an object of the form:
+		//			{ x: 100, y: 300, w: 20, h: 15 }
+		//		If includeScroll==true, the x and y values will include any
+		//		document offsets that may affect the position relative to the
+		//		viewport.
+		//		Uses the border-box model (inclusive of border and padding but
+		//		not margin).  Does not act as a setter.
+		// node: DOMNode|String
+		// includeScroll: Boolean?
+		// returns: Object
+	};
+	=====*/
+
+	geom.getPadExtents = function getPadExtents(/*DomNode*/node, /*Object*/computedStyle){
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), px = style.toPixelValue,
+			l = px(node, s.paddingLeft), t = px(node, s.paddingTop), r = px(node, s.paddingRight), b = px(node, s.paddingBottom);
+		return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+	};
+
+	var none = "none";
+
+	geom.getBorderExtents = function getBorderExtents(/*DomNode*/node, /*Object*/computedStyle){
+		node = dom.byId(node);
+		var px = style.toPixelValue, s = computedStyle || style.getComputedStyle(node),
+			l = s.borderLeftStyle != none ? px(node, s.borderLeftWidth) : 0,
+			t = s.borderTopStyle != none ? px(node, s.borderTopWidth) : 0,
+			r = s.borderRightStyle != none ? px(node, s.borderRightWidth) : 0,
+			b = s.borderBottomStyle != none ? px(node, s.borderBottomWidth) : 0;
+		return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+	};
+
+	geom.getPadBorderExtents = function getPadBorderExtents(/*DomNode*/node, /*Object*/computedStyle){
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node),
+			p = geom.getPadExtents(node, s),
+			b = geom.getBorderExtents(node, s);
+		return {
+			l: p.l + b.l,
+			t: p.t + b.t,
+			r: p.r + b.r,
+			b: p.b + b.b,
+			w: p.w + b.w,
+			h: p.h + b.h
+		};
+	};
+
+	geom.getMarginExtents = function getMarginExtents(node, computedStyle){
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), px = style.toPixelValue,
+			l = px(node, s.marginLeft), t = px(node, s.marginTop), r = px(node, s.marginRight), b = px(node, s.marginBottom);
+		if(has("webkit") && (s.position != "absolute")){
+			// FIXME: Safari's version of the computed right margin
+			// is the space between our right edge and the right edge
+			// of our offsetParent.
+			// What we are looking for is the actual margin value as
+			// determined by CSS.
+			// Hack solution is to assume left/right margins are the same.
+			r = l;
+		}
+		return {l: l, t: t, r: r, b: b, w: l + r, h: t + b};
+	};
+
+	// Box getters work in any box context because offsetWidth/clientWidth
+	// are invariant wrt box context
+	//
+	// They do *not* work for display: inline objects that have padding styles
+	// because the user agent ignores padding (it's bogus styling in any case)
+	//
+	// Be careful with IMGs because they are inline or block depending on
+	// browser and browser mode.
+
+	// Although it would be easier to read, there are not separate versions of
+	// _getMarginBox for each browser because:
+	// 1. the branching is not expensive
+	// 2. factoring the shared code wastes cycles (function call overhead)
+	// 3. duplicating the shared code wastes bytes
+
+	geom.getMarginBox = function getMarginBox(/*DomNode*/node, /*Object*/computedStyle){
+		// summary:
+		//		returns an object that encodes the width, height, left and top
+		//		positions of the node's margin box.
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), me = geom.getMarginExtents(node, s),
+			l = node.offsetLeft - me.l, t = node.offsetTop - me.t, p = node.parentNode, px = style.toPixelValue, pcs;
+				if(has("mozilla")){
+			// Mozilla:
+			// If offsetParent has a computed overflow != visible, the offsetLeft is decreased
+			// by the parent's border.
+			// We don't want to compute the parent's style, so instead we examine node's
+			// computed left/top which is more stable.
+			var sl = parseFloat(s.left), st = parseFloat(s.top);
+			if(!isNaN(sl) && !isNaN(st)){
+				l = sl, t = st;
+			}else{
+				// If child's computed left/top are not parseable as a number (e.g. "auto"), we
+				// have no choice but to examine the parent's computed style.
+				if(p && p.style){
+					pcs = style.getComputedStyle(p);
+					if(pcs.overflow != "visible"){
+						l += pcs.borderLeftStyle != none ? px(node, pcs.borderLeftWidth) : 0;
+						t += pcs.borderTopStyle != none ? px(node, pcs.borderTopWidth) : 0;
+					}
+				}
+			}
+		}else if(has("opera") || (has("ie") == 8 && !has("quirks"))){
+			// On Opera and IE 8, offsetLeft/Top includes the parent's border
+			if(p){
+				pcs = style.getComputedStyle(p);
+				l -= pcs.borderLeftStyle != none ? px(node, pcs.borderLeftWidth) : 0;
+				t -= pcs.borderTopStyle != none ? px(node, pcs.borderTopWidth) : 0;
+			}
+		}
+				return {l: l, t: t, w: node.offsetWidth + me.w, h: node.offsetHeight + me.h};
+	};
+
+	geom.getContentBox = function getContentBox(node, computedStyle){
+		// clientWidth/Height are important since the automatically account for scrollbars
+		// fallback to offsetWidth/Height for special cases (see #3378)
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), w = node.clientWidth, h,
+			pe = geom.getPadExtents(node, s), be = geom.getBorderExtents(node, s);
+		if(!w){
+			w = node.offsetWidth;
+			h = node.offsetHeight;
+		}else{
+			h = node.clientHeight;
+			be.w = be.h = 0;
+		}
+		// On Opera, offsetLeft includes the parent's border
+				if(has("opera")){
+			pe.l += be.l;
+			pe.t += be.t;
+		}
+				return {l: pe.l, t: pe.t, w: w - pe.w - be.w, h: h - pe.h - be.h};
+	};
+
+	// Box setters depend on box context because interpretation of width/height styles
+	// vary wrt box context.
+	//
+	// The value of dojo.boxModel is used to determine box context.
+	// dojo.boxModel can be set directly to change behavior.
+	//
+	// Beware of display: inline objects that have padding styles
+	// because the user agent ignores padding (it's a bogus setup anyway)
+	//
+	// Be careful with IMGs because they are inline or block depending on
+	// browser and browser mode.
+	//
+	// Elements other than DIV may have special quirks, like built-in
+	// margins or padding, or values not detectable via computedStyle.
+	// In particular, margins on TABLE do not seems to appear
+	// at all in computedStyle on Mozilla.
+
+	function setBox(/*DomNode*/node, /*Number?*/l, /*Number?*/t, /*Number?*/w, /*Number?*/h, /*String?*/u){
+		// summary:
+		//		sets width/height/left/top in the current (native) box-model
+		//		dimensions. Uses the unit passed in u.
+		// node:
+		//		DOM Node reference. Id string not supported for performance
+		//		reasons.
+		// l:
+		//		left offset from parent.
+		// t:
+		//		top offset from parent.
+		// w:
+		//		width in current box model.
+		// h:
+		//		width in current box model.
+		// u:
+		//		unit measure to use for other measures. Defaults to "px".
+		u = u || "px";
+		var s = node.style;
+		if(!isNaN(l)){
+			s.left = l + u;
+		}
+		if(!isNaN(t)){
+			s.top = t + u;
+		}
+		if(w >= 0){
+			s.width = w + u;
+		}
+		if(h >= 0){
+			s.height = h + u;
+		}
+	}
+
+	function isButtonTag(/*DomNode*/node){
+		// summary:
+		//		True if the node is BUTTON or INPUT.type="button".
+		return node.tagName.toLowerCase() == "button" ||
+			node.tagName.toLowerCase() == "input" && (node.getAttribute("type") || "").toLowerCase() == "button"; // boolean
+	}
+
+	function usesBorderBox(/*DomNode*/node){
+		// summary:
+		//		True if the node uses border-box layout.
+
+		// We could test the computed style of node to see if a particular box
+		// has been specified, but there are details and we choose not to bother.
+
+		// TABLE and BUTTON (and INPUT type=button) are always border-box by default.
+		// If you have assigned a different box to either one via CSS then
+		// box functions will break.
+
+		return geom.boxModel == "border-box" || node.tagName.toLowerCase() == "table" || isButtonTag(node); // boolean
+	}
+
+	geom.setContentSize = function setContentSize(/*DomNode*/node, /*Object*/box, /*Object*/computedStyle){
+		// summary:
+		//		Sets the size of the node's contents, irrespective of margins,
+		//		padding, or borders.
+
+		node = dom.byId(node);
+		var w = box.w, h = box.h;
+		if(usesBorderBox(node)){
+			var pb = geom.getPadBorderExtents(node, computedStyle);
+			if(w >= 0){
+				w += pb.w;
+			}
+			if(h >= 0){
+				h += pb.h;
+			}
+		}
+		setBox(node, NaN, NaN, w, h);
+	};
+
+	var nilExtents = {l: 0, t: 0, w: 0, h: 0};
+
+	geom.setMarginBox = function setMarginBox(/*DomNode*/node, /*Object*/box, /*Object*/computedStyle){
+		node = dom.byId(node);
+		var s = computedStyle || style.getComputedStyle(node), w = box.w, h = box.h,
+		// Some elements have special padding, margin, and box-model settings.
+		// To use box functions you may need to set padding, margin explicitly.
+		// Controlling box-model is harder, in a pinch you might set dojo.boxModel.
+			pb = usesBorderBox(node) ? nilExtents : geom.getPadBorderExtents(node, s),
+			mb = geom.getMarginExtents(node, s);
+		if(has("webkit")){
+			// on Safari (3.1.2), button nodes with no explicit size have a default margin
+			// setting an explicit size eliminates the margin.
+			// We have to swizzle the width to get correct margin reading.
+			if(isButtonTag(node)){
+				var ns = node.style;
+				if(w >= 0 && !ns.width){
+					ns.width = "4px";
+				}
+				if(h >= 0 && !ns.height){
+					ns.height = "4px";
+				}
+			}
+		}
+		if(w >= 0){
+			w = Math.max(w - pb.w - mb.w, 0);
+		}
+		if(h >= 0){
+			h = Math.max(h - pb.h - mb.h, 0);
+		}
+		setBox(node, box.l, box.t, w, h);
+	};
+
+	// =============================
+	// Positioning
+	// =============================
+
+	geom.isBodyLtr = function isBodyLtr(){
+		return (win.body().dir || win.doc.documentElement.dir || "ltr").toLowerCase() == "ltr"; // Boolean
+	};
+
+	geom.docScroll = function docScroll(){
+		var node = win.doc.parentWindow || win.doc.defaultView;   // use UI window, not dojo.global window
+		return "pageXOffset" in node ? {x: node.pageXOffset, y: node.pageYOffset } :
+			(node = has("quirks") ? win.body() : win.doc.documentElement,
+				{x: geom.fixIeBiDiScrollLeft(node.scrollLeft || 0), y: node.scrollTop || 0 });
+	};
+
+		geom.getIeDocumentElementOffset = function getIeDocumentElementOffset(){
+		//NOTE: assumes we're being called in an IE browser
+
+		var de = win.doc.documentElement; // only deal with HTML element here, position() handles body/quirks
+
+		if(has("ie") < 8){
+			var r = de.getBoundingClientRect(), // works well for IE6+
+				l = r.left, t = r.top;
+			if(has("ie") < 7){
+				l += de.clientLeft;	// scrollbar size in strict/RTL, or,
+				t += de.clientTop;	// HTML border size in strict
+			}
+			return {
+				x: l < 0 ? 0 : l, // FRAME element border size can lead to inaccurate negative values
+				y: t < 0 ? 0 : t
+			};
+		}else{
+			return {
+				x: 0,
+				y: 0
+			};
+		}
+	};
+	
+	geom.fixIeBiDiScrollLeft = function fixIeBiDiScrollLeft(/*Integer*/ scrollLeft){
+		// In RTL direction, scrollLeft should be a negative value, but IE
+		// returns a positive one. All codes using documentElement.scrollLeft
+		// must call this function to fix this error, otherwise the position
+		// will offset to right when there is a horizontal scrollbar.
+
+				var ie = has("ie");
+		if(ie && !geom.isBodyLtr()){
+			var qk = has("quirks"),
+				de = qk ? win.body() : win.doc.documentElement;
+			if(ie == 6 && !qk && win.global.frameElement && de.scrollHeight > de.clientHeight){
+				scrollLeft += de.clientLeft; // workaround ie6+strict+rtl+iframe+vertical-scrollbar bug where clientWidth is too small by clientLeft pixels
+			}
+			return (ie < 8 || qk) ? (scrollLeft + de.clientWidth - de.scrollWidth) : -scrollLeft; // Integer
+		}
+				return scrollLeft; // Integer
+	};
+
+	geom.position = function(/*DomNode*/node, /*Boolean?*/includeScroll){
+		node = dom.byId(node);
+		var	db = win.body(),
+			dh = db.parentNode,
+			ret = node.getBoundingClientRect();
+		ret = {x: ret.left, y: ret.top, w: ret.right - ret.left, h: ret.bottom - ret.top};
+				if(has("ie")){
+			// On IE there's a 2px offset that we need to adjust for, see dojo.getIeDocumentElementOffset()
+			var offset = geom.getIeDocumentElementOffset();
+
+			// fixes the position in IE, quirks mode
+			ret.x -= offset.x + (has("quirks") ? db.clientLeft + db.offsetLeft : 0);
+			ret.y -= offset.y + (has("quirks") ? db.clientTop + db.offsetTop : 0);
+		}else if(has("ff") == 3){
+			// In FF3 you have to subtract the document element margins.
+			// Fixed in FF3.5 though.
+			var cs = style.getComputedStyle(dh), px = style.toPixelValue;
+			ret.x -= px(dh, cs.marginLeft) + px(dh, cs.borderLeftWidth);
+			ret.y -= px(dh, cs.marginTop) + px(dh, cs.borderTopWidth);
+		}
+				// account for document scrolling
+		// if offsetParent is used, ret value already includes scroll position
+		// so we may have to actually remove that value if !includeScroll
+		if(includeScroll){
+			var scroll = geom.docScroll();
+			ret.x += scroll.x;
+			ret.y += scroll.y;
+		}
+
+		return ret; // Object
+	};
+
+	// random "private" functions wildly used throughout the toolkit
+
+	geom.getMarginSize = function getMarginSize(/*DomNode*/node, /*Object*/computedStyle){
+		node = dom.byId(node);
+		var me = geom.getMarginExtents(node, computedStyle || style.getComputedStyle(node));
+		var size = node.getBoundingClientRect();
+		return {
+			w: (size.right - size.left) + me.w,
+			h: (size.bottom - size.top) + me.h
+		}
+	};
+
+	geom.normalizeEvent = function(event){
+		// summary:
+		// 		Normalizes the geometry of a DOM event, normalizing the pageX, pageY,
+		// 		offsetX, offsetY, layerX, and layerX properties
+		// event: Object
+		if(!("layerX" in event)){
+			event.layerX = event.offsetX;
+			event.layerY = event.offsetY;
+		}
+		if(!has("dom-addeventlistener")){
+			// old IE version
+			// FIXME: scroll position query is duped from dojo.html to
+			// avoid dependency on that entire module. Now that HTML is in
+			// Base, we should convert back to something similar there.
+			var se = event.target;
+			var doc = (se && se.ownerDocument) || document;
+			// DO NOT replace the following to use dojo.body(), in IE, document.documentElement should be used
+			// here rather than document.body
+			var docBody = has("quirks") ? doc.body : doc.documentElement;
+			var offset = geom.getIeDocumentElementOffset();
+			event.pageX = event.clientX + geom.fixIeBiDiScrollLeft(docBody.scrollLeft || 0) - offset.x;
+			event.pageY = event.clientY + (docBody.scrollTop || 0) - offset.y;
+		}
+	};
+
+	// TODO: evaluate separate getters/setters for position and sizes?
+
+	return geom;
+});
diff --git a/js/dojo-1.7.2/dojo/dom-prop.js b/js/dojo-1.7.2/dojo/dom-prop.js
new file mode 100644
index 0000000..7e44a78
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dom-prop.js
@@ -0,0 +1,191 @@
+//>>built
+define("dojo/dom-prop", ["exports", "./_base/kernel", "./_base/sniff", "./_base/lang", "./dom", "./dom-style", "./dom-construct", "./_base/connect"],
+		function(exports, dojo, has, lang, dom, style, ctr, conn){
+	// module:
+	//		dojo/dom-prop
+	// summary:
+	//		This module defines the core dojo DOM properties API.
+	//      Indirectly depends on dojo.empty() and dojo.toDom().
+
+	// =============================
+	// Element properties Functions
+	// =============================
+
+	/*=====
+	prop.get = function(node, name){
+		// summary:
+		//		Gets a property on an HTML element.
+		// description:
+		//		Handles normalized getting of properties on DOM nodes.
+		//
+		// node: DOMNode|String
+		//		id or reference to the element to get the property on
+		// name: String
+		//		the name of the property to get.
+		// returns:
+		//		the value of the requested property or its default value
+		//
+		// example:
+		//	|	// get the current value of the "foo" property on a node
+		//	|	dojo.getProp(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.getProp("nodeId", "foo");
+	};
+	=====*/
+
+	/*=====
+	prop.set = function(node, name, value){
+		// summary:
+		//		Sets a property on an HTML element.
+		// description:
+		//		Handles normalized setting of properties on DOM nodes.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to set the property on
+		// name: String|Object
+		//		the name of the property to set, or a hash object to set
+		//		multiple properties at once.
+		// value: String?
+		//		The value to set for the property
+		// returns:
+		//		the DOM node
+		//
+		// example:
+		//	|	// use prop() to set the tab index
+		//	|	dojo.setProp("nodeId", "tabIndex", 3);
+		//	|
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.setProp("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.setProp("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.setProp("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.style("someNode", obj);
+	};
+	=====*/
+
+	// helper to connect events
+	var _evtHdlrMap = {}, _ctr = 0, _attrId = dojo._scopeName + "attrid";
+
+		// the next dictionary lists elements with read-only innerHTML on IE
+	var _roInnerHtml = {col: 1, colgroup: 1,
+			// frameset: 1, head: 1, html: 1, style: 1,
+			table: 1, tbody: 1, tfoot: 1, thead: 1, tr: 1, title: 1};
+	
+	exports.names = {
+		// properties renamed to avoid clashes with reserved words
+		"class": "className",
+		"for": "htmlFor",
+		// properties written as camelCase
+		tabindex: "tabIndex",
+		readonly: "readOnly",
+		colspan: "colSpan",
+		frameborder: "frameBorder",
+		rowspan: "rowSpan",
+		valuetype: "valueType"
+	};
+
+	exports.get = function getProp(/*DOMNode|String*/node, /*String*/name){
+		node = dom.byId(node);
+		var lc = name.toLowerCase(), propName = exports.names[lc] || name;
+		return node[propName];	// Anything
+	};
+
+	exports.set = function setProp(/*DOMNode|String*/node, /*String|Object*/name, /*String?*/value){
+		node = dom.byId(node);
+		var l = arguments.length;
+		if(l == 2 && typeof name != "string"){ // inline'd type check
+			// the object form of setter: the 2nd argument is a dictionary
+			for(var x in name){
+				exports.set(node, x, name[x]);
+			}
+			return node; // DomNode
+		}
+		var lc = name.toLowerCase(), propName = exports.names[lc] || name;
+		if(propName == "style" && typeof value != "string"){ // inline'd type check
+			// special case: setting a style
+			style.style(node, value);
+			return node; // DomNode
+		}
+		if(propName == "innerHTML"){
+			// special case: assigning HTML
+						if(has("ie") && node.tagName.toLowerCase() in _roInnerHtml){
+				ctr.empty(node);
+				node.appendChild(ctr.toDom(value, node.ownerDocument));
+			}else{
+							node[propName] = value;
+						}
+						return node; // DomNode
+		}
+		if(lang.isFunction(value)){
+			// special case: assigning an event handler
+			// clobber if we can
+			var attrId = node[_attrId];
+			if(!attrId){
+				attrId = _ctr++;
+				node[_attrId] = attrId;
+			}
+			if(!_evtHdlrMap[attrId]){
+				_evtHdlrMap[attrId] = {};
+			}
+			var h = _evtHdlrMap[attrId][propName];
+			if(h){
+				//h.remove();
+				conn.disconnect(h);
+			}else{
+				try{
+					delete node[propName];
+				}catch(e){}
+			}
+			// ensure that event objects are normalized, etc.
+			if(value){
+				//_evtHdlrMap[attrId][propName] = on(node, propName, value);
+				_evtHdlrMap[attrId][propName] = conn.connect(node, propName, value);
+			}else{
+				node[propName] = null;
+			}
+			return node; // DomNode
+		}
+		node[propName] = value;
+		return node;	// DomNode
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/dom-style.js b/js/dojo-1.7.2/dojo/dom-style.js
new file mode 100644
index 0000000..e718451
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dom-style.js
@@ -0,0 +1,322 @@
+//>>built
+define("dojo/dom-style", ["./_base/sniff", "./dom"], function(has, dom){
+	// module:
+	//		dojo/dom-style
+	// summary:
+	//		This module defines the core dojo DOM style API.
+
+	// =============================
+	// Style Functions
+	// =============================
+
+	// getComputedStyle drives most of the style code.
+	// Wherever possible, reuse the returned object.
+	//
+	// API functions below that need to access computed styles accept an
+	// optional computedStyle parameter.
+	// If this parameter is omitted, the functions will call getComputedStyle themselves.
+	// This way, calling code can access computedStyle once, and then pass the reference to
+	// multiple API functions.
+
+	/*=====
+	dojo.getComputedStyle = function(node){
+		// summary:
+		//		Returns a "computed style" object.
+		//
+		// description:
+		//		Gets a "computed style" object which can be used to gather
+		//		information about the current state of the rendered node.
+		//
+		//		Note that this may behave differently on different browsers.
+		//		Values may have different formats and value encodings across
+		//		browsers.
+		//
+		//		Note also that this method is expensive.  Wherever possible,
+		//		reuse the returned object.
+		//
+		//		Use the dojo.style() method for more consistent (pixelized)
+		//		return values.
+		//
+		// node: DOMNode
+		//		A reference to a DOM node. Does NOT support taking an
+		//		ID string for speed reasons.
+		// example:
+		//	|	dojo.getComputedStyle(dojo.byId('foo')).borderWidth;
+		//
+		// example:
+		//		Reusing the returned object, avoiding multiple lookups:
+		//	|	var cs = dojo.getComputedStyle(dojo.byId("someNode"));
+		//	|	var w = cs.width, h = cs.height;
+		return; // CSS2Properties
+	}
+	=====*/
+
+	/*=====
+	dojo.toPixelValue = function(node, value){
+		// summary:
+		//      converts style value to pixels on IE or return a numeric value.
+		// node: DOMNode
+		// value: String
+		// returns: Number
+	};
+	=====*/
+
+	/*=====
+	dojo._toPixelValue = function(node, value){
+		// summary:
+		//		Existing alias for `dojo._toPixelValue`. Deprecated, will be removed in 2.0.
+	};
+	=====*/
+
+	/*=====
+	dojo.getStyle = function(node, name){
+		// summary:
+		//		Accesses styles on a node.
+		// description:
+		//		Getting the style value uses the computed style for the node, so the value
+		//		will be a calculated value, not just the immediate node.style value.
+		//		Also when getting values, use specific style names,
+		//		like "borderBottomWidth" instead of "border" since compound values like
+		//		"border" are not necessarily reflected as expected.
+		//		If you want to get node dimensions, use `dojo.marginBox()`,
+		//		`dojo.contentBox()` or `dojo.position()`.
+		// node: DOMNode|String
+		//		id or reference to node to get style for
+		// name: String?
+		//		the style property to get
+		// example:
+		//		Passing only an ID or node returns the computed style object of
+		//		the node:
+		//	|	dojo.getStyle("thinger");
+		// example:
+		//		Passing a node and a style property returns the current
+		//		normalized, computed value for that property:
+		//	|	dojo.getStyle("thinger", "opacity"); // 1 by default
+	};
+	=====*/
+
+	/*=====
+	dojo.setStyle = function(node, name, value){
+		// summary:
+		//		Sets styles on a node.
+		// node: DOMNode|String
+		//		id or reference to node to set style for
+		// name: String|Object
+		//		the style property to set in DOM-accessor format
+		//		("borderWidth", not "border-width") or an object with key/value
+		//		pairs suitable for setting each property.
+		// value: String?
+		//		If passed, sets value on the node for style, handling
+		//		cross-browser concerns.  When setting a pixel value,
+		//		be sure to include "px" in the value. For instance, top: "200px".
+		//		Otherwise, in some cases, some browsers will not apply the style.
+		//
+		// example:
+		//		Passing a node, a style property, and a value changes the
+		//		current display of the node and returns the new computed value
+		//	|	dojo.setStyle("thinger", "opacity", 0.5); // == 0.5
+		//
+		// example:
+		//		Passing a node, an object-style style property sets each of the values in turn and returns the computed style object of the node:
+		//	|	dojo.setStyle("thinger", {
+		//	|		"opacity": 0.5,
+		//	|		"border": "3px solid black",
+		//	|		"height": "300px"
+		//	|	});
+		//
+		// example:
+		//		When the CSS style property is hyphenated, the JavaScript property is camelCased.
+		//		font-size becomes fontSize, and so on.
+		//	|	dojo.setStyle("thinger",{
+		//	|		fontSize:"14pt",
+		//	|		letterSpacing:"1.2em"
+		//	|	});
+		//
+		// example:
+		//		dojo.NodeList implements .style() using the same syntax, omitting the "node" parameter, calling
+		//		dojo.style() on every element of the list. See: `dojo.query()` and `dojo.NodeList()`
+		//	|	dojo.query(".someClassName").style("visibility","hidden");
+		//	|	// or
+		//	|	dojo.query("#baz > div").style({
+		//	|		opacity:0.75,
+		//	|		fontSize:"13pt"
+		//	|	});
+	};
+	=====*/
+
+	// Although we normally eschew argument validation at this
+	// level, here we test argument 'node' for (duck)type,
+	// by testing nodeType, ecause 'document' is the 'parentNode' of 'body'
+	// it is frequently sent to this function even
+	// though it is not Element.
+	var getComputedStyle, style = {};
+		if(has("webkit")){
+			getComputedStyle = function(/*DomNode*/node){
+			var s;
+			if(node.nodeType == 1){
+				var dv = node.ownerDocument.defaultView;
+				s = dv.getComputedStyle(node, null);
+				if(!s && node.style){
+					node.style.display = "";
+					s = dv.getComputedStyle(node, null);
+				}
+			}
+			return s || {};
+		};
+		}else if(has("ie") && (has("ie") < 9 || has("quirks"))){
+		getComputedStyle = function(node){
+			// IE (as of 7) doesn't expose Element like sane browsers
+			return node.nodeType == 1 /* ELEMENT_NODE*/ ? node.currentStyle : {};
+		};
+	}else{
+		getComputedStyle = function(node){
+			return node.nodeType == 1 ?
+				node.ownerDocument.defaultView.getComputedStyle(node, null) : {};
+		};
+	}
+		style.getComputedStyle = getComputedStyle;
+
+	var toPixel;
+		if(!has("ie")){
+			toPixel = function(element, value){
+			// style values can be floats, client code may want
+			// to round for integer pixels.
+			return parseFloat(value) || 0;
+		};
+		}else{
+		toPixel = function(element, avalue){
+			if(!avalue){ return 0; }
+			// on IE7, medium is usually 4 pixels
+			if(avalue == "medium"){ return 4; }
+			// style values can be floats, client code may
+			// want to round this value for integer pixels.
+			if(avalue.slice && avalue.slice(-2) == 'px'){ return parseFloat(avalue); }
+			var s = element.style, rs = element.runtimeStyle, cs = element.currentStyle,
+				sLeft = s.left, rsLeft = rs.left;
+			rs.left = cs.left;
+			try{
+				// 'avalue' may be incompatible with style.left, which can cause IE to throw
+				// this has been observed for border widths using "thin", "medium", "thick" constants
+				// those particular constants could be trapped by a lookup
+				// but perhaps there are more
+				s.left = avalue;
+				avalue = s.pixelLeft;
+			}catch(e){
+				avalue = 0;
+			}
+			s.left = sLeft;
+			rs.left = rsLeft;
+			return avalue;
+		}
+	}
+		style.toPixelValue = toPixel;
+
+	// FIXME: there opacity quirks on FF that we haven't ported over. Hrm.
+
+		var astr = "DXImageTransform.Microsoft.Alpha";
+	var af = function(n, f){
+		try{
+			return n.filters.item(astr);
+		}catch(e){
+			return f ? {} : null;
+		}
+	};
+
+		var _getOpacity =
+			has("ie") < 9 || (has("ie") && has("quirks")) ? function(node){
+			try{
+				return af(node).Opacity / 100; // Number
+			}catch(e){
+				return 1; // Number
+			}
+		} :
+			function(node){
+			return getComputedStyle(node).opacity;
+		};
+
+	var _setOpacity =
+				has("ie") < 9 || (has("ie") && has("quirks")) ? function(/*DomNode*/node, /*Number*/opacity){
+			var ov = opacity * 100, opaque = opacity == 1;
+			node.style.zoom = opaque ? "" : 1;
+
+			if(!af(node)){
+				if(opaque){
+					return opacity;
+				}
+				node.style.filter += " progid:" + astr + "(Opacity=" + ov + ")";
+			}else{
+				af(node, 1).Opacity = ov;
+			}
+
+			// on IE7 Alpha(Filter opacity=100) makes text look fuzzy so disable it altogether (bug #2661),
+			//but still update the opacity value so we can get a correct reading if it is read later.
+			af(node, 1).Enabled = !opaque;
+
+			if(node.tagName.toLowerCase() == "tr"){
+				for(var td = node.firstChild; td; td = td.nextSibling){
+					if(td.tagName.toLowerCase() == "td"){
+						_setOpacity(td, opacity);
+					}
+				}
+			}
+			return opacity;
+		} :
+				function(node, opacity){
+			return node.style.opacity = opacity;
+		};
+
+	var _pixelNamesCache = {
+		left: true, top: true
+	};
+	var _pixelRegExp = /margin|padding|width|height|max|min|offset/; // |border
+	function _toStyleValue(node, type, value){
+		//TODO: should we really be doing string case conversion here? Should we cache it? Need to profile!
+		type = type.toLowerCase();
+				if(has("ie")){
+			if(value == "auto"){
+				if(type == "height"){ return node.offsetHeight; }
+				if(type == "width"){ return node.offsetWidth; }
+			}
+			if(type == "fontweight"){
+				switch(value){
+					case 700: return "bold";
+					case 400:
+					default: return "normal";
+				}
+			}
+		}
+				if(!(type in _pixelNamesCache)){
+			_pixelNamesCache[type] = _pixelRegExp.test(type);
+		}
+		return _pixelNamesCache[type] ? toPixel(node, value) : value;
+	}
+
+	var _floatStyle = has("ie") ? "styleFloat" : "cssFloat",
+		_floatAliases = {"cssFloat": _floatStyle, "styleFloat": _floatStyle, "float": _floatStyle};
+
+	// public API
+
+	style.get = function getStyle(/*DOMNode|String*/ node, /*String?*/ name){
+		var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
+		if(l == 2 && op){
+			return _getOpacity(n);
+		}
+		name = _floatAliases[name] || name;
+		var s = style.getComputedStyle(n);
+		return (l == 1) ? s : _toStyleValue(n, name, s[name] || n.style[name]); /* CSS2Properties||String||Number */
+	};
+
+	style.set = function setStyle(/*DOMNode|String*/ node, /*String|Object*/ name, /*String?*/ value){
+		var n = dom.byId(node), l = arguments.length, op = (name == "opacity");
+		name = _floatAliases[name] || name;
+		if(l == 3){
+			return op ? _setOpacity(n, value) : n.style[name] = value; // Number
+		}
+		for(var x in name){
+			style.set(node, x, name[x]);
+		}
+		return style.getComputedStyle(n);
+	};
+
+	return style;
+});
diff --git a/js/dojo-1.7.2/dojo/dom.js b/js/dojo-1.7.2/dojo/dom.js
new file mode 100644
index 0000000..bddf5e7
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/dom.js
@@ -0,0 +1,157 @@
+//>>built
+define("dojo/dom", ["./_base/sniff", "./_base/lang", "./_base/window"],
+		function(has, lang, win){
+	// module:
+	//		dojo/dom
+	// summary:
+	//		This module defines the core dojo DOM API.
+
+	// FIXME: need to add unit tests for all the semi-public methods
+
+		try{
+		document.execCommand("BackgroundImageCache", false, true);
+	}catch(e){
+		// sane browsers don't have cache "issues"
+	}
+	
+	// =============================
+	// DOM Functions
+	// =============================
+
+	/*=====
+	dojo.byId = function(id, doc){
+		// summary:
+		//		Returns DOM node with matching `id` attribute or `null`
+		//		if not found. If `id` is a DomNode, this function is a no-op.
+		//
+		// id: String|DOMNode
+		//	 	A string to match an HTML id attribute or a reference to a DOM Node
+		//
+		// doc: Document?
+		//		Document to work in. Defaults to the current value of
+		//		dojo.doc.  Can be used to retrieve
+		//		node references from other documents.
+		//
+		// example:
+		//		Look up a node by ID:
+		//	|	var n = dojo.byId("foo");
+		//
+		// example:
+		//		Check if a node exists, and use it.
+		//	|	var n = dojo.byId("bar");
+		//	|	if(n){ doStuff() ... }
+		//
+		// example:
+		//		Allow string or DomNode references to be passed to a custom function:
+		//	|	var foo = function(nodeOrId){
+		//	|		nodeOrId = dojo.byId(nodeOrId);
+		//	|		// ... more stuff
+		//	|	}
+	=====*/
+
+	/*=====
+	dojo.isDescendant = function(node, ancestor){
+		// summary:
+		//		Returns true if node is a descendant of ancestor
+		// node: DOMNode|String
+		//		string id or node reference to test
+		// ancestor: DOMNode|String
+		//		string id or node reference of potential parent to test against
+		//
+		// example:
+		//		Test is node id="bar" is a descendant of node id="foo"
+		//	|	if(dojo.isDescendant("bar", "foo")){ ... }
+	};
+	=====*/
+
+	// TODO: do we need this function in the base?
+
+	/*=====
+	dojo.setSelectable = function(node, selectable){
+		// summary:
+		//		Enable or disable selection on a node
+		// node: DOMNode|String
+		//		id or reference to node
+		// selectable: Boolean
+		//		state to put the node in. false indicates unselectable, true
+		//		allows selection.
+		// example:
+		//		Make the node id="bar" unselectable
+		//	|	dojo.setSelectable("bar");
+		// example:
+		//		Make the node id="bar" selectable
+		//	|	dojo.setSelectable("bar", true);
+	};
+	=====*/
+
+	var dom = {};   // the result object
+
+		if(has("ie")){
+		dom.byId = function(id, doc){
+			if(typeof id != "string"){
+				return id;
+			}
+			var _d = doc || win.doc, te = id && _d.getElementById(id);
+			// attributes.id.value is better than just id in case the
+			// user has a name=id inside a form
+			if(te && (te.attributes.id.value == id || te.id == id)){
+				return te;
+			}else{
+				var eles = _d.all[id];
+				if(!eles || eles.nodeName){
+					eles = [eles];
+				}
+				// if more than 1, choose first with the correct id
+				var i = 0;
+				while((te = eles[i++])){
+					if((te.attributes && te.attributes.id && te.attributes.id.value == id) || te.id == id){
+						return te;
+					}
+				}
+			}
+		};
+	}else{
+			dom.byId = function(id, doc){
+			// inline'd type check.
+			// be sure to return null per documentation, to match IE branch.
+			return ((typeof id == "string") ? (doc || win.doc).getElementById(id) : id) || null; // DOMNode
+		};
+		}
+		/*=====
+	};
+	=====*/
+
+	dom.isDescendant = function(/*DOMNode|String*/node, /*DOMNode|String*/ancestor){
+		try{
+			node = dom.byId(node);
+			ancestor = dom.byId(ancestor);
+			while(node){
+				if(node == ancestor){
+					return true; // Boolean
+				}
+				node = node.parentNode;
+			}
+		}catch(e){ /* squelch, return false */ }
+		return false; // Boolean
+	};
+
+	// TODO: do we need this function in the base?
+
+	dom.setSelectable = function(/*DOMNode|String*/node, /*Boolean*/selectable){
+		node = dom.byId(node);
+				if(has("mozilla")){
+			node.style.MozUserSelect = selectable ? "" : "none";
+		}else if(has("khtml") || has("webkit")){
+					node.style.KhtmlUserSelect = selectable ? "auto" : "none";
+				}else if(has("ie")){
+			var v = (node.unselectable = selectable ? "" : "on"),
+				cs = node.getElementsByTagName("*"), i = 0, l = cs.length;
+			for(; i < l; ++i){
+				cs.item(i).unselectable = v;
+			}
+		}
+				//FIXME: else?  Opera?
+	};
+
+	return dom;
+});
diff --git a/js/dojo-1.7.2/dojo/domReady.js b/js/dojo-1.7.2/dojo/domReady.js
new file mode 100644
index 0000000..33138b2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/domReady.js
@@ -0,0 +1,96 @@
+//>>built
+define("dojo/domReady", ['./has'], function(has){
+	var global = this,
+		doc = document,
+		readyStates = { 'loaded': 1, 'complete': 1 },
+		fixReadyState = typeof doc.readyState != "string",
+		ready = !!readyStates[doc.readyState];
+
+	// For FF <= 3.5
+	if(fixReadyState){ doc.readyState = "loading"; }
+
+	if(!ready){
+		var readyQ = [], tests = [],
+			detectReady = function(evt){
+				evt = evt || global.event;
+				if(ready || (evt.type == "readystatechange" && !readyStates[doc.readyState])){ return; }
+				ready = 1;
+
+				// For FF <= 3.5
+				if(fixReadyState){ doc.readyState = "complete"; }
+
+				while(readyQ.length){
+					(readyQ.shift())();
+				}
+			},
+			on = function(node, event){
+				node.addEventListener(event, detectReady, false);
+				readyQ.push(function(){ node.removeEventListener(event, detectReady, false); });
+			};
+
+		if(!has("dom-addeventlistener")){
+			on = function(node, event){
+				event = "on" + event;
+				node.attachEvent(event, detectReady);
+				readyQ.push(function(){ node.detachEvent(event, detectReady); });
+			};
+
+			var div = doc.createElement("div");
+			try{
+				if(div.doScroll && global.frameElement === null){
+					// the doScroll test is only useful if we're in the top-most frame
+					tests.push(function(){
+						// Derived with permission from Diego Perini's IEContentLoaded
+						// http://javascript.nwbox.com/IEContentLoaded/
+						try{
+							div.doScroll("left");
+							return 1;
+						}catch(e){}
+					});
+				}
+			}catch(e){}
+		}
+
+		on(doc, "DOMContentLoaded");
+		on(global, "load");
+
+		if("onreadystatechange" in doc){
+			on(doc, "readystatechange");
+		}else if(!fixReadyState){
+			// if the ready state property exists and there's
+			// no readystatechange event, poll for the state
+			// to change
+			tests.push(function(){
+				return readyStates[doc.readyState];
+			});
+		}
+
+		if(tests.length){
+			var poller = function(){
+				if(ready){ return; }
+				var i = tests.length;
+				while(i--){
+					if(tests[i]()){
+						detectReady("poller");
+						return;
+					}
+				}
+				setTimeout(poller, 30);
+			};
+			poller();
+		}
+	}
+
+	function domReady(callback){
+		if(ready){
+			callback(1);
+		}else{
+			readyQ.push(callback);
+		}
+	}
+	domReady.load = function(id, req, load){
+		domReady(load);
+	};
+
+	return domReady;
+});
diff --git a/js/dojo-1.7.2/dojo/fx.js b/js/dojo-1.7.2/dojo/fx.js
new file mode 100644
index 0000000..31f6b6c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/fx.js
@@ -0,0 +1,427 @@
+//>>built
+define("dojo/fx", [
+	"./_base/lang",
+	"./Evented",
+	"./_base/kernel",
+	"./_base/array",
+	"./_base/connect",
+	"./_base/fx",
+	"./dom",
+	"./dom-style",
+	"./dom-geometry",
+	"./ready",
+	"require" // for context sensitive loading of Toggler
+], function(lang, Evented, dojo, arrayUtil, connect, baseFx, dom, domStyle, geom, ready, require) {
+
+	// module:
+	//		dojo/fx
+	// summary:
+	//		TODOC
+
+
+	/*=====
+	dojo.fx = {
+		// summary: Effects library on top of Base animations
+	};
+	var coreFx = dojo.fx;
+	=====*/
+	
+// For back-compat, remove in 2.0.
+if(!dojo.isAsync){
+	ready(0, function(){
+		var requires = ["./fx/Toggler"];
+		require(requires);	// use indirection so modules not rolled into a build
+	});
+}
+
+	var coreFx = dojo.fx = {};
+
+	var _baseObj = {
+			_fire: function(evt, args){
+				if(this[evt]){
+					this[evt].apply(this, args||[]);
+				}
+				return this;
+			}
+		};
+
+	var _chain = function(animations){
+		this._index = -1;
+		this._animations = animations||[];
+		this._current = this._onAnimateCtx = this._onEndCtx = null;
+
+		this.duration = 0;
+		arrayUtil.forEach(this._animations, function(a){
+			this.duration += a.duration;
+			if(a.delay){ this.duration += a.delay; }
+		}, this);
+	};
+	_chain.prototype = new Evented();
+	lang.extend(_chain, {
+		_onAnimate: function(){
+			this._fire("onAnimate", arguments);
+		},
+		_onEnd: function(){
+			connect.disconnect(this._onAnimateCtx);
+			connect.disconnect(this._onEndCtx);
+			this._onAnimateCtx = this._onEndCtx = null;
+			if(this._index + 1 == this._animations.length){
+				this._fire("onEnd");
+			}else{
+				// switch animations
+				this._current = this._animations[++this._index];
+				this._onAnimateCtx = connect.connect(this._current, "onAnimate", this, "_onAnimate");
+				this._onEndCtx = connect.connect(this._current, "onEnd", this, "_onEnd");
+				this._current.play(0, true);
+			}
+		},
+		play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
+			if(!this._current){ this._current = this._animations[this._index = 0]; }
+			if(!gotoStart && this._current.status() == "playing"){ return this; }
+			var beforeBegin = connect.connect(this._current, "beforeBegin", this, function(){
+					this._fire("beforeBegin");
+				}),
+				onBegin = connect.connect(this._current, "onBegin", this, function(arg){
+					this._fire("onBegin", arguments);
+				}),
+				onPlay = connect.connect(this._current, "onPlay", this, function(arg){
+					this._fire("onPlay", arguments);
+					connect.disconnect(beforeBegin);
+					connect.disconnect(onBegin);
+					connect.disconnect(onPlay);
+				});
+			if(this._onAnimateCtx){
+				connect.disconnect(this._onAnimateCtx);
+			}
+			this._onAnimateCtx = connect.connect(this._current, "onAnimate", this, "_onAnimate");
+			if(this._onEndCtx){
+				connect.disconnect(this._onEndCtx);
+			}
+			this._onEndCtx = connect.connect(this._current, "onEnd", this, "_onEnd");
+			this._current.play.apply(this._current, arguments);
+			return this;
+		},
+		pause: function(){
+			if(this._current){
+				var e = connect.connect(this._current, "onPause", this, function(arg){
+						this._fire("onPause", arguments);
+						connect.disconnect(e);
+					});
+				this._current.pause();
+			}
+			return this;
+		},
+		gotoPercent: function(/*Decimal*/percent, /*Boolean?*/ andPlay){
+			this.pause();
+			var offset = this.duration * percent;
+			this._current = null;
+			arrayUtil.some(this._animations, function(a){
+				if(a.duration <= offset){
+					this._current = a;
+					return true;
+				}
+				offset -= a.duration;
+				return false;
+			});
+			if(this._current){
+				this._current.gotoPercent(offset / this._current.duration, andPlay);
+			}
+			return this;
+		},
+		stop: function(/*boolean?*/ gotoEnd){
+			if(this._current){
+				if(gotoEnd){
+					for(; this._index + 1 < this._animations.length; ++this._index){
+						this._animations[this._index].stop(true);
+					}
+					this._current = this._animations[this._index];
+				}
+				var e = connect.connect(this._current, "onStop", this, function(arg){
+						this._fire("onStop", arguments);
+						connect.disconnect(e);
+					});
+				this._current.stop();
+			}
+			return this;
+		},
+		status: function(){
+			return this._current ? this._current.status() : "stopped";
+		},
+		destroy: function(){
+			if(this._onAnimateCtx){ connect.disconnect(this._onAnimateCtx); }
+			if(this._onEndCtx){ connect.disconnect(this._onEndCtx); }
+		}
+	});
+	lang.extend(_chain, _baseObj);
+
+	coreFx.chain = /*===== dojo.fx.chain = =====*/ function(/*dojo.Animation[]*/ animations){
+		// summary:
+		//		Chain a list of `dojo.Animation`s to run in sequence
+		//
+		// description:
+		//		Return a `dojo.Animation` which will play all passed
+		//		`dojo.Animation` instances in sequence, firing its own
+		//		synthesized events simulating a single animation. (eg:
+		//		onEnd of this animation means the end of the chain,
+		//		not the individual animations within)
+		//
+		// example:
+		//	Once `node` is faded out, fade in `otherNode`
+		//	|	dojo.fx.chain([
+		//	|		dojo.fadeIn({ node:node }),
+		//	|		dojo.fadeOut({ node:otherNode })
+		//	|	]).play();
+		//
+		return new _chain(animations); // dojo.Animation
+	};
+
+	var _combine = function(animations){
+		this._animations = animations||[];
+		this._connects = [];
+		this._finished = 0;
+
+		this.duration = 0;
+		arrayUtil.forEach(animations, function(a){
+			var duration = a.duration;
+			if(a.delay){ duration += a.delay; }
+			if(this.duration < duration){ this.duration = duration; }
+			this._connects.push(connect.connect(a, "onEnd", this, "_onEnd"));
+		}, this);
+
+		this._pseudoAnimation = new baseFx.Animation({curve: [0, 1], duration: this.duration});
+		var self = this;
+		arrayUtil.forEach(["beforeBegin", "onBegin", "onPlay", "onAnimate", "onPause", "onStop", "onEnd"],
+			function(evt){
+				self._connects.push(connect.connect(self._pseudoAnimation, evt,
+					function(){ self._fire(evt, arguments); }
+				));
+			}
+		);
+	};
+	lang.extend(_combine, {
+		_doAction: function(action, args){
+			arrayUtil.forEach(this._animations, function(a){
+				a[action].apply(a, args);
+			});
+			return this;
+		},
+		_onEnd: function(){
+			if(++this._finished > this._animations.length){
+				this._fire("onEnd");
+			}
+		},
+		_call: function(action, args){
+			var t = this._pseudoAnimation;
+			t[action].apply(t, args);
+		},
+		play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
+			this._finished = 0;
+			this._doAction("play", arguments);
+			this._call("play", arguments);
+			return this;
+		},
+		pause: function(){
+			this._doAction("pause", arguments);
+			this._call("pause", arguments);
+			return this;
+		},
+		gotoPercent: function(/*Decimal*/percent, /*Boolean?*/ andPlay){
+			var ms = this.duration * percent;
+			arrayUtil.forEach(this._animations, function(a){
+				a.gotoPercent(a.duration < ms ? 1 : (ms / a.duration), andPlay);
+			});
+			this._call("gotoPercent", arguments);
+			return this;
+		},
+		stop: function(/*boolean?*/ gotoEnd){
+			this._doAction("stop", arguments);
+			this._call("stop", arguments);
+			return this;
+		},
+		status: function(){
+			return this._pseudoAnimation.status();
+		},
+		destroy: function(){
+			arrayUtil.forEach(this._connects, connect.disconnect);
+		}
+	});
+	lang.extend(_combine, _baseObj);
+
+	coreFx.combine = /*===== dojo.fx.combine = =====*/ function(/*dojo.Animation[]*/ animations){
+		// summary:
+		//		Combine a list of `dojo.Animation`s to run in parallel
+		//
+		// description:
+		//		Combine an array of `dojo.Animation`s to run in parallel,
+		//		providing a new `dojo.Animation` instance encompasing each
+		//		animation, firing standard animation events.
+		//
+		// example:
+		//	Fade out `node` while fading in `otherNode` simultaneously
+		//	|	dojo.fx.combine([
+		//	|		dojo.fadeIn({ node:node }),
+		//	|		dojo.fadeOut({ node:otherNode })
+		//	|	]).play();
+		//
+		// example:
+		//	When the longest animation ends, execute a function:
+		//	|	var anim = dojo.fx.combine([
+		//	|		dojo.fadeIn({ node: n, duration:700 }),
+		//	|		dojo.fadeOut({ node: otherNode, duration: 300 })
+		//	|	]);
+		//	|	dojo.connect(anim, "onEnd", function(){
+		//	|		// overall animation is done.
+		//	|	});
+		//	|	anim.play(); // play the animation
+		//
+		return new _combine(animations); // dojo.Animation
+	};
+
+	coreFx.wipeIn = /*===== dojo.fx.wipeIn = =====*/ function(/*Object*/ args){
+		// summary:
+		//		Expand a node to it's natural height.
+		//
+		// description:
+		//		Returns an animation that will expand the
+		//		node defined in 'args' object from it's current height to
+		//		it's natural height (with no scrollbar).
+		//		Node must have no margin/border/padding.
+		//
+		// args: Object
+		//		A hash-map of standard `dojo.Animation` constructor properties
+		//		(such as easing: node: duration: and so on)
+		//
+		// example:
+		//	|	dojo.fx.wipeIn({
+		//	|		node:"someId"
+		//	|	}).play()
+		var node = args.node = dom.byId(args.node), s = node.style, o;
+
+		var anim = baseFx.animateProperty(lang.mixin({
+			properties: {
+				height: {
+					// wrapped in functions so we wait till the last second to query (in case value has changed)
+					start: function(){
+						// start at current [computed] height, but use 1px rather than 0
+						// because 0 causes IE to display the whole panel
+						o = s.overflow;
+						s.overflow = "hidden";
+						if(s.visibility == "hidden" || s.display == "none"){
+							s.height = "1px";
+							s.display = "";
+							s.visibility = "";
+							return 1;
+						}else{
+							var height = domStyle.get(node, "height");
+							return Math.max(height, 1);
+						}
+					},
+					end: function(){
+						return node.scrollHeight;
+					}
+				}
+			}
+		}, args));
+
+		var fini = function(){
+			s.height = "auto";
+			s.overflow = o;
+		};
+		connect.connect(anim, "onStop", fini);
+		connect.connect(anim, "onEnd", fini);
+
+		return anim; // dojo.Animation
+	};
+
+	coreFx.wipeOut = /*===== dojo.fx.wipeOut = =====*/ function(/*Object*/ args){
+		// summary:
+		//		Shrink a node to nothing and hide it.
+		//
+		// description:
+		//		Returns an animation that will shrink node defined in "args"
+		//		from it's current height to 1px, and then hide it.
+		//
+		// args: Object
+		//		A hash-map of standard `dojo.Animation` constructor properties
+		//		(such as easing: node: duration: and so on)
+		//
+		// example:
+		//	|	dojo.fx.wipeOut({ node:"someId" }).play()
+
+		var node = args.node = dom.byId(args.node), s = node.style, o;
+
+		var anim = baseFx.animateProperty(lang.mixin({
+			properties: {
+				height: {
+					end: 1 // 0 causes IE to display the whole panel
+				}
+			}
+		}, args));
+
+		connect.connect(anim, "beforeBegin", function(){
+			o = s.overflow;
+			s.overflow = "hidden";
+			s.display = "";
+		});
+		var fini = function(){
+			s.overflow = o;
+			s.height = "auto";
+			s.display = "none";
+		};
+		connect.connect(anim, "onStop", fini);
+		connect.connect(anim, "onEnd", fini);
+
+		return anim; // dojo.Animation
+	};
+
+	coreFx.slideTo = /*===== dojo.fx.slideTo = =====*/ function(/*Object*/ args){
+		// summary:
+		//		Slide a node to a new top/left position
+		//
+		// description:
+		//		Returns an animation that will slide "node"
+		//		defined in args Object from its current position to
+		//		the position defined by (args.left, args.top).
+		//
+		// args: Object
+		//		A hash-map of standard `dojo.Animation` constructor properties
+		//		(such as easing: node: duration: and so on). Special args members
+		//		are `top` and `left`, which indicate the new position to slide to.
+		//
+		// example:
+		//	|	.slideTo({ node: node, left:"40", top:"50", units:"px" }).play()
+
+		var node = args.node = dom.byId(args.node),
+			top = null, left = null;
+
+		var init = (function(n){
+			return function(){
+				var cs = domStyle.getComputedStyle(n);
+				var pos = cs.position;
+				top = (pos == 'absolute' ? n.offsetTop : parseInt(cs.top) || 0);
+				left = (pos == 'absolute' ? n.offsetLeft : parseInt(cs.left) || 0);
+				if(pos != 'absolute' && pos != 'relative'){
+					var ret = geom.position(n, true);
+					top = ret.y;
+					left = ret.x;
+					n.style.position="absolute";
+					n.style.top=top+"px";
+					n.style.left=left+"px";
+				}
+			};
+		})(node);
+		init();
+
+		var anim = baseFx.animateProperty(lang.mixin({
+			properties: {
+				top: args.top || 0,
+				left: args.left || 0
+			}
+		}, args));
+		connect.connect(anim, "beforeBegin", anim, init);
+
+		return anim; // dojo.Animation
+	};
+
+	return coreFx;
+});
diff --git a/js/dojo-1.7.2/dojo/fx/Toggler.js b/js/dojo-1.7.2/dojo/fx/Toggler.js
new file mode 100644
index 0000000..7da1f81
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/fx/Toggler.js
@@ -0,0 +1,104 @@
+//>>built
+define("dojo/fx/Toggler", ["../_base/lang","../_base/declare","../_base/fx", "../_base/connect"], 
+  function(lang, declare, baseFx, connectUtil) {
+	// module:
+	//		dojo/fx/Toggler
+	// summary:
+	//		TODOC
+
+return declare("dojo.fx.Toggler", null, {
+	// summary:
+	//		A simple `dojo.Animation` toggler API.
+	//
+	// description:
+	//		class constructor for an animation toggler. It accepts a packed
+	//		set of arguments about what type of animation to use in each
+	//		direction, duration, etc. All available members are mixed into
+	//		these animations from the constructor (for example, `node`,
+	//		`showDuration`, `hideDuration`).
+	//
+	// example:
+	//	|	var t = new dojo.fx.Toggler({
+	//	|		node: "nodeId",
+	//	|		showDuration: 500,
+	//	|		// hideDuration will default to "200"
+	//	|		showFunc: dojo.fx.wipeIn,
+	//	|		// hideFunc will default to "fadeOut"
+	//	|	});
+	//	|	t.show(100); // delay showing for 100ms
+	//	|	// ...time passes...
+	//	|	t.hide();
+
+	// node: DomNode
+	//		the node to target for the showing and hiding animations
+	node: null,
+
+	// showFunc: Function
+	//		The function that returns the `dojo.Animation` to show the node
+	showFunc: baseFx.fadeIn,
+
+	// hideFunc: Function
+	//		The function that returns the `dojo.Animation` to hide the node
+	hideFunc: baseFx.fadeOut,
+
+	// showDuration:
+	//		Time in milliseconds to run the show Animation
+	showDuration: 200,
+
+	// hideDuration:
+	//		Time in milliseconds to run the hide Animation
+	hideDuration: 200,
+
+	// FIXME: need a policy for where the toggler should "be" the next
+	// time show/hide are called if we're stopped somewhere in the
+	// middle.
+	// FIXME: also would be nice to specify individual showArgs/hideArgs mixed into
+	// each animation individually.
+	// FIXME: also would be nice to have events from the animations exposed/bridged
+
+	/*=====
+	_showArgs: null,
+	_showAnim: null,
+
+	_hideArgs: null,
+	_hideAnim: null,
+
+	_isShowing: false,
+	_isHiding: false,
+	=====*/
+
+	constructor: function(args){
+		var _t = this;
+
+		lang.mixin(_t, args);
+		_t.node = args.node;
+		_t._showArgs = lang.mixin({}, args);
+		_t._showArgs.node = _t.node;
+		_t._showArgs.duration = _t.showDuration;
+		_t.showAnim = _t.showFunc(_t._showArgs);
+
+		_t._hideArgs = lang.mixin({}, args);
+		_t._hideArgs.node = _t.node;
+		_t._hideArgs.duration = _t.hideDuration;
+		_t.hideAnim = _t.hideFunc(_t._hideArgs);
+
+		connectUtil.connect(_t.showAnim, "beforeBegin", lang.hitch(_t.hideAnim, "stop", true));
+		connectUtil.connect(_t.hideAnim, "beforeBegin", lang.hitch(_t.showAnim, "stop", true));
+	},
+
+	show: function(delay){
+		// summary: Toggle the node to showing
+		// delay: Integer?
+		//		Ammount of time to stall playing the show animation
+		return this.showAnim.play(delay || 0);
+	},
+
+	hide: function(delay){
+		// summary: Toggle the node to hidden
+		// delay: Integer?
+		//		Ammount of time to stall playing the hide animation
+		return this.hideAnim.play(delay || 0);
+	}
+});
+
+});
diff --git a/js/dojo-1.7.2/dojo/fx/easing.js b/js/dojo-1.7.2/dojo/fx/easing.js
new file mode 100644
index 0000000..d77f15f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/fx/easing.js
@@ -0,0 +1,285 @@
+//>>built
+define("dojo/fx/easing", ["../_base/lang"], function(lang) {
+// module:
+//		dojo/fx/easing
+// summary:
+//		This module defines standard easing functions that are useful for animations.
+
+var easingFuncs = /*===== dojo.fx.easing= =====*/ {
+	// summary:
+	//		Collection of easing functions to use beyond the default
+	//		`dojo._defaultEasing` function.
+	//
+	// description:
+	//
+	//		Easing functions are used to manipulate the iteration through
+	//		an `dojo.Animation`s _Line. _Line being the properties of an Animation,
+	//		and the easing function progresses through that Line determing
+	//		how quickly (or slowly) it should go. Or more accurately: modify
+	//		the value of the _Line based on the percentage of animation completed.
+	//
+	//		All functions follow a simple naming convention of "ease type" + "when".
+	//		If the name of the function ends in Out, the easing described appears
+	//		towards the end of the animation. "In" means during the beginning,
+	//		and InOut means both ranges of the Animation will applied, both
+	//		beginning and end.
+	//
+	//		One does not call the easing function directly, it must be passed to
+	//		the `easing` property of an animation.
+	//
+	//	example:
+	//	|	dojo.require("dojo.fx.easing");
+	//	|	var anim = dojo.fadeOut({
+	//	|		node: 'node',
+	//	|		duration: 2000,
+	//	|		//	note there is no ()
+	//	|		easing: dojo.fx.easing.quadIn
+	//	|	}).play();
+	//
+
+	linear: function(/* Decimal? */n){
+		// summary: A linear easing function
+		return n;
+	},
+
+	quadIn: function(/* Decimal? */n){
+		return Math.pow(n, 2);
+	},
+
+	quadOut: function(/* Decimal? */n){
+		return n * (n - 2) * -1;
+	},
+
+	quadInOut: function(/* Decimal? */n){
+		n = n * 2;
+		if(n < 1){ return Math.pow(n, 2) / 2; }
+		return -1 * ((--n) * (n - 2) - 1) / 2;
+	},
+
+	cubicIn: function(/* Decimal? */n){
+		return Math.pow(n, 3);
+	},
+
+	cubicOut: function(/* Decimal? */n){
+		return Math.pow(n - 1, 3) + 1;
+	},
+
+	cubicInOut: function(/* Decimal? */n){
+		n = n * 2;
+		if(n < 1){ return Math.pow(n, 3) / 2; }
+		n -= 2;
+		return (Math.pow(n, 3) + 2) / 2;
+	},
+
+	quartIn: function(/* Decimal? */n){
+		return Math.pow(n, 4);
+	},
+
+	quartOut: function(/* Decimal? */n){
+		return -1 * (Math.pow(n - 1, 4) - 1);
+	},
+
+	quartInOut: function(/* Decimal? */n){
+		n = n * 2;
+		if(n < 1){ return Math.pow(n, 4) / 2; }
+		n -= 2;
+		return -1 / 2 * (Math.pow(n, 4) - 2);
+	},
+
+	quintIn: function(/* Decimal? */n){
+		return Math.pow(n, 5);
+	},
+
+	quintOut: function(/* Decimal? */n){
+		return Math.pow(n - 1, 5) + 1;
+	},
+
+	quintInOut: function(/* Decimal? */n){
+		n = n * 2;
+		if(n < 1){ return Math.pow(n, 5) / 2; }
+		n -= 2;
+		return (Math.pow(n, 5) + 2) / 2;
+	},
+
+	sineIn: function(/* Decimal? */n){
+		return -1 * Math.cos(n * (Math.PI / 2)) + 1;
+	},
+
+	sineOut: function(/* Decimal? */n){
+		return Math.sin(n * (Math.PI / 2));
+	},
+
+	sineInOut: function(/* Decimal? */n){
+		return -1 * (Math.cos(Math.PI * n) - 1) / 2;
+	},
+
+	expoIn: function(/* Decimal? */n){
+		return (n == 0) ? 0 : Math.pow(2, 10 * (n - 1));
+	},
+
+	expoOut: function(/* Decimal? */n){
+		return (n == 1) ? 1 : (-1 * Math.pow(2, -10 * n) + 1);
+	},
+
+	expoInOut: function(/* Decimal? */n){
+		if(n == 0){ return 0; }
+		if(n == 1){ return 1; }
+		n = n * 2;
+		if(n < 1){ return Math.pow(2, 10 * (n - 1)) / 2; }
+		--n;
+		return (-1 * Math.pow(2, -10 * n) + 2) / 2;
+	},
+
+	circIn: function(/* Decimal? */n){
+		return -1 * (Math.sqrt(1 - Math.pow(n, 2)) - 1);
+	},
+
+	circOut: function(/* Decimal? */n){
+		n = n - 1;
+		return Math.sqrt(1 - Math.pow(n, 2));
+	},
+
+	circInOut: function(/* Decimal? */n){
+		n = n * 2;
+		if(n < 1){ return -1 / 2 * (Math.sqrt(1 - Math.pow(n, 2)) - 1); }
+		n -= 2;
+		return 1 / 2 * (Math.sqrt(1 - Math.pow(n, 2)) + 1);
+	},
+
+	backIn: function(/* Decimal? */n){
+		// summary:
+		//		An easing function that starts away from the target,
+		//		and quickly accelerates towards the end value.
+		//
+		//		Use caution when the easing will cause values to become
+		//		negative as some properties cannot be set to negative values.
+		var s = 1.70158;
+		return Math.pow(n, 2) * ((s + 1) * n - s);
+	},
+
+	backOut: function(/* Decimal? */n){
+		// summary:
+		//		An easing function that pops past the range briefly, and slowly comes back.
+		//
+		// description:
+		//		An easing function that pops past the range briefly, and slowly comes back.
+		//
+		//		Use caution when the easing will cause values to become negative as some
+		//		properties cannot be set to negative values.
+
+		n = n - 1;
+		var s = 1.70158;
+		return Math.pow(n, 2) * ((s + 1) * n + s) + 1;
+	},
+
+	backInOut: function(/* Decimal? */n){
+		// summary:
+		//		An easing function combining the effects of `backIn` and `backOut`
+		//
+		// description:
+		//		An easing function combining the effects of `backIn` and `backOut`.
+		//		Use caution when the easing will cause values to become negative
+		//		as some properties cannot be set to negative values.
+		var s = 1.70158 * 1.525;
+		n = n * 2;
+		if(n < 1){ return (Math.pow(n, 2) * ((s + 1) * n - s)) / 2; }
+		n-=2;
+		return (Math.pow(n, 2) * ((s + 1) * n + s) + 2) / 2;
+	},
+
+	elasticIn: function(/* Decimal? */n){
+		// summary:
+		//		An easing function the elastically snaps from the start value
+		//
+		// description:
+		//		An easing function the elastically snaps from the start value
+		//
+		//		Use caution when the elasticity will cause values to become negative
+		//		as some properties cannot be set to negative values.
+		if(n == 0 || n == 1){ return n; }
+		var p = .3;
+		var s = p / 4;
+		n = n - 1;
+		return -1 * Math.pow(2, 10 * n) * Math.sin((n - s) * (2 * Math.PI) / p);
+	},
+
+	elasticOut: function(/* Decimal? */n){
+		// summary:
+		//		An easing function that elasticly snaps around the target value,
+		//		near the end of the Animation
+		//
+		// description:
+		//		An easing function that elasticly snaps around the target value,
+		//		near the end of the Animation
+		//
+		//		Use caution when the elasticity will cause values to become
+		//		negative as some properties cannot be set to negative values.
+		if(n==0 || n == 1){ return n; }
+		var p = .3;
+		var s = p / 4;
+		return Math.pow(2, -10 * n) * Math.sin((n - s) * (2 * Math.PI) / p) + 1;
+	},
+
+	elasticInOut: function(/* Decimal? */n){
+		// summary:
+		//		An easing function that elasticly snaps around the value, near
+		//		the beginning and end of the Animation.
+		//
+		// description:
+		//		An easing function that elasticly snaps around the value, near
+		//		the beginning and end of the Animation.
+		//
+		//		Use caution when the elasticity will cause values to become
+		//		negative as some properties cannot be set to negative values.
+		if(n == 0) return 0;
+		n = n * 2;
+		if(n == 2) return 1;
+		var p = .3 * 1.5;
+		var s = p / 4;
+		if(n < 1){
+			n -= 1;
+			return -.5 * (Math.pow(2, 10 * n) * Math.sin((n - s) * (2 * Math.PI) / p));
+		}
+		n -= 1;
+		return .5 * (Math.pow(2, -10 * n) * Math.sin((n - s) * (2 * Math.PI) / p)) + 1;
+	},
+
+	bounceIn: function(/* Decimal? */n){
+		// summary:
+		//		An easing function that 'bounces' near the beginning of an Animation
+		return (1 - easingFuncs.bounceOut(1 - n)); // Decimal
+	},
+
+	bounceOut: function(/* Decimal? */n){
+		// summary:
+		//		An easing function that 'bounces' near the end of an Animation
+		var s = 7.5625;
+		var p = 2.75;
+		var l;
+		if(n < (1 / p)){
+			l = s * Math.pow(n, 2);
+		}else if(n < (2 / p)){
+			n -= (1.5 / p);
+			l = s * Math.pow(n, 2) + .75;
+		}else if(n < (2.5 / p)){
+			n -= (2.25 / p);
+			l = s * Math.pow(n, 2) + .9375;
+		}else{
+			n -= (2.625 / p);
+			l = s * Math.pow(n, 2) + .984375;
+		}
+		return l;
+	},
+
+	bounceInOut: function(/* Decimal? */n){
+		// summary:
+		//		An easing function that 'bounces' at the beginning and end of the Animation
+		if(n < 0.5){ return easingFuncs.bounceIn(n * 2) / 2; }
+		return (easingFuncs.bounceOut(n * 2 - 1) / 2) + 0.5; // Decimal
+	}
+};
+
+lang.setObject("dojo.fx.easing", easingFuncs);
+
+return easingFuncs;
+});
diff --git a/js/dojo-1.7.2/dojo/gears.js b/js/dojo-1.7.2/dojo/gears.js
new file mode 100644
index 0000000..4298601
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/gears.js
@@ -0,0 +1,62 @@
+//>>built
+define("dojo/gears", ["./_base/kernel", "./_base/lang", "./_base/sniff"],
+	function(dojo, lang, has) {
+	// module:
+	//		dojo/gears
+	// summary:
+	//		TODOC
+
+lang.getObject("gears", true, dojo);
+
+dojo.gears._gearsObject = function(){
+	// summary:
+	//		factory method to get a Google Gears plugin instance to
+	//		expose in the browser runtime environment, if present
+	var factory;
+
+	var gearsObj = lang.getObject("google.gears");
+	if(gearsObj){ return gearsObj; } // already defined elsewhere
+
+	if(typeof GearsFactory != "undefined"){ // Firefox
+		factory = new GearsFactory();
+	}else{
+		if(has("ie")){
+			// IE
+			try{
+				factory = new ActiveXObject("Gears.Factory");
+			}catch(e){
+				// ok to squelch; there's no gears factory.  move on.
+			}
+		}else if(navigator.mimeTypes["application/x-googlegears"]){
+			// Safari?
+			factory = document.createElement("object");
+			factory.setAttribute("type", "application/x-googlegears");
+			factory.setAttribute("width", 0);
+			factory.setAttribute("height", 0);
+			factory.style.display = "none";
+			document.documentElement.appendChild(factory);
+		}
+	}
+
+	// still nothing?
+	if(!factory){ return null; }
+
+	// define the global objects now; don't overwrite them though if they
+	// were somehow set internally by the Gears plugin, which is on their
+	// dev roadmap for the future
+	lang.setObject("google.gears.factory", factory);
+	return lang.getObject("google.gears");
+};
+
+/*=====
+dojo.gears.available = {
+	// summary: True if client is using Google Gears
+};
+=====*/
+// see if we have Google Gears installed, and if
+// so, make it available in the runtime environment
+// and in the Google standard 'google.gears' global object
+dojo.gears.available = (!!dojo.gears._gearsObject())||0;
+
+return dojo.gears;
+});
diff --git a/js/dojo-1.7.2/dojo/has.js b/js/dojo-1.7.2/dojo/has.js
new file mode 100644
index 0000000..5899f04
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/has.js
@@ -0,0 +1,179 @@
+//>>built
+define("dojo/has", ["require"], function(require) {
+	// module:
+	//		dojo/has
+	// summary:
+	//		Defines the has.js API and several feature tests used by dojo.
+	// description:
+	//		This module defines the has API as described by the project has.js with the following additional features:
+	//
+	//			* the has test cache is exposed at has.cache.
+	//			* the method has.add includes a forth parameter that controls whether or not existing tests are replaced
+	//			* the loader's has cache may be optionally copied into this module's has cahce.
+	//
+	//		This module adopted from https://github.com/phiggins42/has.js; thanks has.js team!
+
+	// try to pull the has implementation from the loader; both the dojo loader and bdLoad provide one
+	// WARNING: if a foreign loader defines require.has to be something other than the has.js API, then this implementation fail
+	var has = require.has || function(){};
+	if(!1){
+		// notice the condition is written so that if 1 is transformed to 1 during a build
+		// the conditional will be (!1 && typeof has=="function") which is statically false and the closure
+		// compiler will discard the block.
+		var
+			isBrowser =
+				// the most fundamental decision: are we in the browser?
+				typeof window != "undefined" &&
+				typeof location != "undefined" &&
+				typeof document != "undefined" &&
+				window.location == location && window.document == document,
+
+			// has API variables
+			global = this,
+			doc = isBrowser && document,
+			element = doc && doc.createElement("DiV"),
+			cache = {};
+
+		has = /*===== dojo.has= =====*/ function(name){
+			//	summary:
+			//		Return the current value of the named feature.
+			//
+			//	name: String|Integer
+			//		The name (if a string) or identifier (if an integer) of the feature to test.
+			//
+			//	description:
+			//		Returns the value of the feature named by name. The feature must have been
+			//		previously added to the cache by has.add.
+
+			return typeof cache[name] == "function" ? (cache[name] = cache[name](global, doc, element)) : cache[name]; // Boolean
+		};
+
+		has.cache = cache;
+
+		has.add = /*====== dojo.has.add= ======*/ function(name, test, now, force){
+			// summary:
+			//	 Register a new feature test for some named feature.
+			//
+			// name: String|Integer
+			//	 The name (if a string) or identifier (if an integer) of the feature to test.
+			//
+			// test: Function
+			//	 A test function to register. If a function, queued for testing until actually
+			//	 needed. The test function should return a boolean indicating
+			//	 the presence of a feature or bug.
+			//
+			// now: Boolean?
+			//	 Optional. Omit if `test` is not a function. Provides a way to immediately
+			//	 run the test and cache the result.
+			//
+			// force: Boolean?
+			//	 Optional. If the test already exists and force is truthy, then the existing
+			//	 test will be replaced; otherwise, add does not replace an existing test (that
+			//	 is, by default, the first test advice wins).
+			//
+			// example:
+			//			A redundant test, testFn with immediate execution:
+			//	|				has.add("javascript", function(){ return true; }, true);
+			//
+			// example:
+			//			Again with the redundantness. You can do this in your tests, but we should
+			//			not be doing this in any internal has.js tests
+			//	|				has.add("javascript", true);
+			//
+			// example:
+			//			Three things are passed to the testFunction. `global`, `document`, and a generic element
+			//			from which to work your test should the need arise.
+			//	|				has.add("bug-byid", function(g, d, el){
+			//	|						// g	== global, typically window, yadda yadda
+			//	|						// d	== document object
+			//	|						// el == the generic element. a `has` element.
+			//	|						return false; // fake test, byid-when-form-has-name-matching-an-id is slightly longer
+			//	|				});
+
+			(typeof cache[name]=="undefined" || force) && (cache[name]= test);
+			return now && has(name);
+		};
+
+		// since we're operating under a loader that doesn't provide a has API, we must explicitly initialize
+		// has as it would have otherwise been initialized by the dojo loader; use has.add to the builder
+		// can optimize these away iff desired
+		true || has.add("host-browser", isBrowser);
+		true || has.add("dom", isBrowser);
+		true || has.add("dojo-dom-ready-api", 1);
+		true || has.add("dojo-sniff", 1);
+	}
+
+	if(1){
+		var agent = navigator.userAgent;
+		// Common application level tests
+		has.add("dom-addeventlistener", !!document.addEventListener);
+		has.add("touch", "ontouchstart" in document);
+		// I don't know if any of these tests are really correct, just a rough guess
+		has.add("device-width", screen.availWidth || innerWidth);
+		has.add("agent-ios", !!agent.match(/iPhone|iP[ao]d/));
+		has.add("agent-android", agent.indexOf("android") > 1);
+	}
+
+	has.clearElement = /*===== dojo.has.clearElement= ======*/ function(element) {
+		// summary:
+		//	 Deletes the contents of the element passed to test functions.
+		element.innerHTML= "";
+		return element;
+	};
+
+	has.normalize = /*===== dojo.has.normalize= ======*/ function(id, toAbsMid){
+		// summary:
+		//	 Resolves id into a module id based on possibly-nested tenary expression that branches on has feature test value(s).
+		//
+		// toAbsMid: Function
+		//	 Resolves a relative module id into an absolute module id
+		var
+			tokens = id.match(/[\?:]|[^:\?]*/g), i = 0,
+			get = function(skip){
+				var term = tokens[i++];
+				if(term == ":"){
+					// empty string module name, resolves to 0
+					return 0;
+				}else{
+					// postfixed with a ? means it is a feature to branch on, the term is the name of the feature
+					if(tokens[i++] == "?"){
+						if(!skip && has(term)){
+							// matched the feature, get the first value from the options
+							return get();
+						}else{
+							// did not match, get the second value, passing over the first
+							get(true);
+							return get(skip);
+						}
+					}
+					// a module
+					return term || 0;
+				}
+			};
+		id = get();
+		return id && toAbsMid(id);
+	};
+
+	has.load = /*===== dojo.has.load= ======*/ function(id, parentRequire, loaded){
+		// summary:
+		//	 Conditional loading of AMD modules based on a has feature test value.
+		//
+		// id: String
+		//	 Gives the resolved module id to load.
+		//
+		// parentRequire: Function
+		//	 The loader require function with respect to the module that contained the plugin resource in it's
+		//	 dependency list.
+		//
+		// loaded: Function
+		//	 Callback to loader that consumes result of plugin demand.
+
+		if(id){
+			parentRequire([id], loaded);
+		}else{
+			loaded();
+		}
+	};
+
+	return has;
+});
diff --git a/js/dojo-1.7.2/dojo/hash.js b/js/dojo-1.7.2/dojo/hash.js
new file mode 100644
index 0000000..00a6660
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/hash.js
@@ -0,0 +1,244 @@
+//>>built
+define("dojo/hash", ["./_base/kernel", "require", "./_base/connect", "./_base/lang", "./ready", "./_base/sniff"],
+	function(dojo, require, connect, lang, ready, has) {
+	// module:
+	//		dojo/hash
+	// summary:
+	//		TODOC
+
+
+//TODOC: where does this go?
+// summary:
+//		Methods for monitoring and updating the hash in the browser URL.
+//
+// example:
+//		dojo.subscribe("/dojo/hashchange", context, callback);
+//
+//		function callback (hashValue){
+//			// do something based on the hash value.
+//		}
+
+	dojo.hash = function(/* String? */ hash, /* Boolean? */ replace){
+		//	summary:
+		//		Gets or sets the hash string.
+		//	description:
+		//		Handles getting and setting of location.hash.
+		//		 - If no arguments are passed, acts as a getter.
+		//		 - If a string is passed, acts as a setter.
+		//	hash:
+		//		the hash is set - #string.
+		//	replace:
+		//		If true, updates the hash value in the current history
+		//		state instead of creating a new history state.
+		//	returns:
+		//		when used as a getter, returns the current hash string.
+		//		when used as a setter, returns the new hash string.
+
+		// getter
+		if(!arguments.length){
+			return _getHash();
+		}
+		// setter
+		if(hash.charAt(0) == "#"){
+			hash = hash.substring(1);
+		}
+		if(replace){
+			_replace(hash);
+		}else{
+			location.href = "#" + hash;
+		}
+		return hash; // String
+	};
+
+	// Global vars
+	var _recentHash, _ieUriMonitor, _connect,
+		_pollFrequency = dojo.config.hashPollFrequency || 100;
+
+	//Internal functions
+	function _getSegment(str, delimiter){
+		var i = str.indexOf(delimiter);
+		return (i >= 0) ? str.substring(i+1) : "";
+	}
+
+	function _getHash(){
+		return _getSegment(location.href, "#");
+	}
+
+	function _dispatchEvent(){
+		connect.publish("/dojo/hashchange", [_getHash()]);
+	}
+
+	function _pollLocation(){
+		if(_getHash() === _recentHash){
+			return;
+		}
+		_recentHash = _getHash();
+		_dispatchEvent();
+	}
+
+	function _replace(hash){
+		if(_ieUriMonitor){
+			if(_ieUriMonitor.isTransitioning()){
+				setTimeout(lang.hitch(null,_replace,hash), _pollFrequency);
+				return;
+			}
+			var href = _ieUriMonitor.iframe.location.href;
+			var index = href.indexOf('?');
+			// main frame will detect and update itself
+			_ieUriMonitor.iframe.location.replace(href.substring(0, index) + "?" + hash);
+			return;
+		}
+		location.replace("#"+hash);
+		!_connect && _pollLocation();
+	}
+
+	function IEUriMonitor(){
+		// summary:
+		//		Determine if the browser's URI has changed or if the user has pressed the
+		//		back or forward button. If so, call _dispatchEvent.
+		//
+		//	description:
+		//		IE doesn't add changes to the URI's hash into the history unless the hash
+		//		value corresponds to an actual named anchor in the document. To get around
+		//		this IE difference, we use a background IFrame to maintain a back-forward
+		//		history, by updating the IFrame's query string to correspond to the
+		//		value of the main browser location's hash value.
+		//
+		//		E.g. if the value of the browser window's location changes to
+		//
+		//		#action=someAction
+		//
+		//		... then we'd update the IFrame's source to:
+		//
+		//		?action=someAction
+		//
+		//		This design leads to a somewhat complex state machine, which is
+		//		described below:
+		//
+		//		s1: Stable state - neither the window's location has changed nor
+		//			has the IFrame's location. Note that this is the 99.9% case, so
+		//			we optimize for it.
+		//			Transitions: s1, s2, s3
+		//		s2: Window's location changed - when a user clicks a hyperlink or
+		//			code programmatically changes the window's URI.
+		//			Transitions: s4
+		//		s3: Iframe's location changed as a result of user pressing back or
+		//			forward - when the user presses back or forward, the location of
+		//			the background's iframe changes to the previous or next value in
+		//			its history.
+		//			Transitions: s1
+		//		s4: IEUriMonitor has programmatically changed the location of the
+		//			background iframe, but it's location hasn't yet changed. In this
+		//			case we do nothing because we need to wait for the iframe's
+		//			location to reflect its actual state.
+		//			Transitions: s4, s5
+		//		s5: IEUriMonitor has programmatically changed the location of the
+		//			background iframe, and the iframe's location has caught up with
+		//			reality. In this case we need to transition to s1.
+		//			Transitions: s1
+		//
+		//		The hashchange event is always dispatched on the transition back to s1.
+		//
+
+		// create and append iframe
+		var ifr = document.createElement("iframe"),
+			IFRAME_ID = "dojo-hash-iframe",
+			ifrSrc = dojo.config.dojoBlankHtmlUrl || require.toUrl("./resources/blank.html");
+
+		if(dojo.config.useXDomain && !dojo.config.dojoBlankHtmlUrl){
+			console.warn("dojo.hash: When using cross-domain Dojo builds,"
+				+ " please save dojo/resources/blank.html to your domain and set djConfig.dojoBlankHtmlUrl"
+				+ " to the path on your domain to blank.html");
+		}
+
+		ifr.id = IFRAME_ID;
+		ifr.src = ifrSrc + "?" + _getHash();
+		ifr.style.display = "none";
+		document.body.appendChild(ifr);
+
+		this.iframe = dojo.global[IFRAME_ID];
+		var recentIframeQuery, transitioning, expectedIFrameQuery, docTitle, ifrOffline,
+			iframeLoc = this.iframe.location;
+
+		function resetState(){
+			_recentHash = _getHash();
+			recentIframeQuery = ifrOffline ? _recentHash : _getSegment(iframeLoc.href, "?");
+			transitioning = false;
+			expectedIFrameQuery = null;
+		}
+
+		this.isTransitioning = function(){
+			return transitioning;
+		};
+
+		this.pollLocation = function(){
+			if(!ifrOffline) {
+				try{
+					//see if we can access the iframe's location without a permission denied error
+					var iframeSearch = _getSegment(iframeLoc.href, "?");
+					//good, the iframe is same origin (no thrown exception)
+					if(document.title != docTitle){ //sync title of main window with title of iframe.
+						docTitle = this.iframe.document.title = document.title;
+					}
+				}catch(e){
+					//permission denied - server cannot be reached.
+					ifrOffline = true;
+					console.error("dojo.hash: Error adding history entry. Server unreachable.");
+				}
+			}
+			var hash = _getHash();
+			if(transitioning && _recentHash === hash){
+				// we're in an iframe transition (s4 or s5)
+				if(ifrOffline || iframeSearch === expectedIFrameQuery){
+					// s5 (iframe caught up to main window or iframe offline), transition back to s1
+					resetState();
+					_dispatchEvent();
+				}else{
+					// s4 (waiting for iframe to catch up to main window)
+					setTimeout(lang.hitch(this,this.pollLocation),0);
+					return;
+				}
+			}else if(_recentHash === hash && (ifrOffline || recentIframeQuery === iframeSearch)){
+				// we're in stable state (s1, iframe query == main window hash), do nothing
+			}else{
+				// the user has initiated a URL change somehow.
+				// sync iframe query <-> main window hash
+				if(_recentHash !== hash){
+					// s2 (main window location changed), set iframe url and transition to s4
+					_recentHash = hash;
+					transitioning = true;
+					expectedIFrameQuery = hash;
+					ifr.src = ifrSrc + "?" + expectedIFrameQuery;
+					ifrOffline = false; //we're updating the iframe src - set offline to false so we can check again on next poll.
+					setTimeout(lang.hitch(this,this.pollLocation),0); //yielded transition to s4 while iframe reloads.
+					return;
+				}else if(!ifrOffline){
+					// s3 (iframe location changed via back/forward button), set main window url and transition to s1.
+					location.href = "#" + iframeLoc.search.substring(1);
+					resetState();
+					_dispatchEvent();
+				}
+			}
+			setTimeout(lang.hitch(this,this.pollLocation), _pollFrequency);
+		};
+		resetState(); // initialize state (transition to s1)
+		setTimeout(lang.hitch(this,this.pollLocation), _pollFrequency);
+	}
+	ready(function(){
+		if("onhashchange" in dojo.global && (!has("ie") || (has("ie") >= 8 && document.compatMode != "BackCompat"))){	//need this IE browser test because "onhashchange" exists in IE8 in IE7 mode
+			_connect = connect.connect(dojo.global,"onhashchange",_dispatchEvent);
+		}else{
+			if(document.addEventListener){ // Non-IE
+				_recentHash = _getHash();
+				setInterval(_pollLocation, _pollFrequency); //Poll the window location for changes
+			}else if(document.attachEvent){ // IE7-
+				//Use hidden iframe in versions of IE that don't have onhashchange event
+				_ieUriMonitor = new IEUriMonitor();
+			}
+			// else non-supported browser, do nothing.
+		}
+	});
+
+	return dojo.hash;
+
+});
diff --git a/js/dojo-1.7.2/dojo/html.js b/js/dojo-1.7.2/dojo/html.js
new file mode 100644
index 0000000..baa8b9e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/html.js
@@ -0,0 +1,343 @@
+//>>built
+define("dojo/html", ["./_base/kernel", "./_base/lang", "./_base/array", "./_base/declare", "./dom", "./dom-construct", "./parser"], function(dojo, lang, darray, declare, dom, domConstruct, parser) {
+	// module:
+	//		dojo/html
+	// summary:
+	//		TODOC
+
+	lang.getObject("html", true, dojo);
+
+	// the parser might be needed..
+
+	// idCounter is incremented with each instantiation to allow asignment of a unique id for tracking, logging purposes
+	var idCounter = 0;
+
+	dojo.html._secureForInnerHtml = function(/*String*/ cont){
+		// summary:
+		//		removes !DOCTYPE and title elements from the html string.
+		//
+		//		khtml is picky about dom faults, you can't attach a style or <title> node as child of body
+		//		must go into head, so we need to cut out those tags
+		//	cont:
+		//		An html string for insertion into the dom
+		//
+		return cont.replace(/(?:\s*<!DOCTYPE\s[^>]+>|<title[^>]*>[\s\S]*?<\/title>)/ig, ""); // String
+	};
+
+/*====
+	dojo.html._emptyNode = function(node){
+		// summary:
+		//		removes all child nodes from the given node
+		//	node: DOMNode
+		//		the parent element
+	};
+=====*/
+	dojo.html._emptyNode = domConstruct.empty;
+
+	dojo.html._setNodeContent = function(/* DomNode */ node, /* String|DomNode|NodeList */ cont){
+		// summary:
+		//		inserts the given content into the given node
+		//	node:
+		//		the parent element
+		//	content:
+		//		the content to be set on the parent element.
+		//		This can be an html string, a node reference or a NodeList, dojo.NodeList, Array or other enumerable list of nodes
+
+		// always empty
+		domConstruct.empty(node);
+
+		if(cont) {
+			if(typeof cont == "string") {
+				cont = domConstruct.toDom(cont, node.ownerDocument);
+			}
+			if(!cont.nodeType && lang.isArrayLike(cont)) {
+				// handle as enumerable, but it may shrink as we enumerate it
+				for(var startlen=cont.length, i=0; i<cont.length; i=startlen==cont.length ? i+1 : 0) {
+					domConstruct.place( cont[i], node, "last");
+				}
+			} else {
+				// pass nodes, documentFragments and unknowns through to dojo.place
+				domConstruct.place(cont, node, "last");
+			}
+		}
+
+		// return DomNode
+		return node;
+	};
+
+	// we wrap up the content-setting operation in a object
+	declare("dojo.html._ContentSetter", null,
+		{
+			// node: DomNode|String
+			//		An node which will be the parent element that we set content into
+			node: "",
+
+			// content: String|DomNode|DomNode[]
+			//		The content to be placed in the node. Can be an HTML string, a node reference, or a enumerable list of nodes
+			content: "",
+
+			// id: String?
+			//		Usually only used internally, and auto-generated with each instance
+			id: "",
+
+			// cleanContent: Boolean
+			//		Should the content be treated as a full html document,
+			//		and the real content stripped of <html>, <body> wrapper before injection
+			cleanContent: false,
+
+			// extractContent: Boolean
+			//		Should the content be treated as a full html document, and the real content stripped of <html>, <body> wrapper before injection
+			extractContent: false,
+
+			// parseContent: Boolean
+			//		Should the node by passed to the parser after the new content is set
+			parseContent: false,
+
+			// parserScope: String
+			//		Flag passed to parser.	Root for attribute names to search for.	  If scopeName is dojo,
+			//		will search for data-dojo-type (or dojoType).  For backwards compatibility
+			//		reasons defaults to dojo._scopeName (which is "dojo" except when
+			//		multi-version support is used, when it will be something like dojo16, dojo20, etc.)
+			parserScope: dojo._scopeName,
+
+			// startup: Boolean
+			//		Start the child widgets after parsing them.	  Only obeyed if parseContent is true.
+			startup: true,
+
+			// lifecyle methods
+			constructor: function(/* Object */params, /* String|DomNode */node){
+				//	summary:
+				//		Provides a configurable, extensible object to wrap the setting on content on a node
+				//		call the set() method to actually set the content..
+
+				// the original params are mixed directly into the instance "this"
+				lang.mixin(this, params || {});
+
+				// give precedence to params.node vs. the node argument
+				// and ensure its a node, not an id string
+				node = this.node = dom.byId( this.node || node );
+
+				if(!this.id){
+					this.id = [
+						"Setter",
+						(node) ? node.id || node.tagName : "",
+						idCounter++
+					].join("_");
+				}
+			},
+			set: function(/* String|DomNode|NodeList? */ cont, /* Object? */ params){
+				// summary:
+				//		front-end to the set-content sequence
+				//	cont:
+				//		An html string, node or enumerable list of nodes for insertion into the dom
+				//		If not provided, the object's content property will be used
+				if(undefined !== cont){
+					this.content = cont;
+				}
+				// in the re-use scenario, set needs to be able to mixin new configuration
+				if(params){
+					this._mixin(params);
+				}
+
+				this.onBegin();
+				this.setContent();
+				this.onEnd();
+
+				return this.node;
+			},
+			setContent: function(){
+				// summary:
+				//		sets the content on the node
+
+				var node = this.node;
+				if(!node) {
+					// can't proceed
+					throw new Error(this.declaredClass + ": setContent given no node");
+				}
+				try{
+					node = dojo.html._setNodeContent(node, this.content);
+				}catch(e){
+					// check if a domfault occurs when we are appending this.errorMessage
+					// like for instance if domNode is a UL and we try append a DIV
+
+					// FIXME: need to allow the user to provide a content error message string
+					var errMess = this.onContentError(e);
+					try{
+						node.innerHTML = errMess;
+					}catch(e){
+						console.error('Fatal ' + this.declaredClass + '.setContent could not change content due to '+e.message, e);
+					}
+				}
+				// always put back the node for the next method
+				this.node = node; // DomNode
+			},
+
+			empty: function() {
+				// summary
+				//	cleanly empty out existing content
+
+				// destroy any widgets from a previous run
+				// NOTE: if you dont want this you'll need to empty
+				// the parseResults array property yourself to avoid bad things happenning
+				if(this.parseResults && this.parseResults.length) {
+					darray.forEach(this.parseResults, function(w) {
+						if(w.destroy){
+							w.destroy();
+						}
+					});
+					delete this.parseResults;
+				}
+				// this is fast, but if you know its already empty or safe, you could
+				// override empty to skip this step
+				dojo.html._emptyNode(this.node);
+			},
+
+			onBegin: function(){
+				// summary
+				//		Called after instantiation, but before set();
+				//		It allows modification of any of the object properties
+				//		- including the node and content provided - before the set operation actually takes place
+				//		This default implementation checks for cleanContent and extractContent flags to
+				//		optionally pre-process html string content
+				var cont = this.content;
+
+				if(lang.isString(cont)){
+					if(this.cleanContent){
+						cont = dojo.html._secureForInnerHtml(cont);
+					}
+
+					if(this.extractContent){
+						var match = cont.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+						if(match){ cont = match[1]; }
+					}
+				}
+
+				// clean out the node and any cruft associated with it - like widgets
+				this.empty();
+
+				this.content = cont;
+				return this.node; /* DomNode */
+			},
+
+			onEnd: function(){
+				// summary
+				//		Called after set(), when the new content has been pushed into the node
+				//		It provides an opportunity for post-processing before handing back the node to the caller
+				//		This default implementation checks a parseContent flag to optionally run the dojo parser over the new content
+				if(this.parseContent){
+					// populates this.parseResults if you need those..
+					this._parse();
+				}
+				return this.node; /* DomNode */
+			},
+
+			tearDown: function(){
+				// summary
+				//		manually reset the Setter instance if its being re-used for example for another set()
+				// description
+				//		tearDown() is not called automatically.
+				//		In normal use, the Setter instance properties are simply allowed to fall out of scope
+				//		but the tearDown method can be called to explicitly reset this instance.
+				delete this.parseResults;
+				delete this.node;
+				delete this.content;
+			},
+
+			onContentError: function(err){
+				return "Error occured setting content: " + err;
+			},
+
+			_mixin: function(params){
+				// mix properties/methods into the instance
+				// TODO: the intention with tearDown is to put the Setter's state
+				// back to that of the original constructor (vs. deleting/resetting everything regardless of ctor params)
+				// so we could do something here to move the original properties aside for later restoration
+				var empty = {}, key;
+				for(key in params){
+					if(key in empty){ continue; }
+					// TODO: here's our opportunity to mask the properties we dont consider configurable/overridable
+					// .. but history shows we'll almost always guess wrong
+					this[key] = params[key];
+				}
+			},
+			_parse: function(){
+				// summary:
+				//		runs the dojo parser over the node contents, storing any results in this.parseResults
+				//		Any errors resulting from parsing are passed to _onError for handling
+
+				var rootNode = this.node;
+				try{
+					// store the results (widgets, whatever) for potential retrieval
+					var inherited = {};
+					darray.forEach(["dir", "lang", "textDir"], function(name){
+						if(this[name]){
+							inherited[name] = this[name];
+						}
+					}, this);
+					this.parseResults = parser.parse({
+						rootNode: rootNode,
+						noStart: !this.startup,
+						inherited: inherited,
+						scope: this.parserScope
+					});
+				}catch(e){
+					this._onError('Content', e, "Error parsing in _ContentSetter#"+this.id);
+				}
+			},
+
+			_onError: function(type, err, consoleText){
+				// summary:
+				//		shows user the string that is returned by on[type]Error
+				//		overide/implement on[type]Error and return your own string to customize
+				var errText = this['on' + type + 'Error'].call(this, err);
+				if(consoleText){
+					console.error(consoleText, err);
+				}else if(errText){ // a empty string won't change current content
+					dojo.html._setNodeContent(this.node, errText, true);
+				}
+			}
+	}); // end dojo.declare()
+
+	dojo.html.set = function(/* DomNode */ node, /* String|DomNode|NodeList */ cont, /* Object? */ params){
+			// summary:
+			//		inserts (replaces) the given content into the given node. dojo.place(cont, node, "only")
+			//		may be a better choice for simple HTML insertion.
+			// description:
+			//		Unless you need to use the params capabilities of this method, you should use
+			//		dojo.place(cont, node, "only"). dojo.place() has more robust support for injecting
+			//		an HTML string into the DOM, but it only handles inserting an HTML string as DOM
+			//		elements, or inserting a DOM node. dojo.place does not handle NodeList insertions
+			//		or the other capabilities as defined by the params object for this method.
+			//	node:
+			//		the parent element that will receive the content
+			//	cont:
+			//		the content to be set on the parent element.
+			//		This can be an html string, a node reference or a NodeList, dojo.NodeList, Array or other enumerable list of nodes
+			//	params:
+			//		Optional flags/properties to configure the content-setting. See dojo.html._ContentSetter
+			//	example:
+			//		A safe string/node/nodelist content replacement/injection with hooks for extension
+			//		Example Usage:
+			//		dojo.html.set(node, "some string");
+			//		dojo.html.set(node, contentNode, {options});
+			//		dojo.html.set(node, myNode.childNodes, {options});
+		if(undefined == cont){
+			console.warn("dojo.html.set: no cont argument provided, using empty string");
+			cont = "";
+		}
+		if(!params){
+			// simple and fast
+			return dojo.html._setNodeContent(node, cont, true);
+		}else{
+			// more options but slower
+			// note the arguments are reversed in order, to match the convention for instantiation via the parser
+			var op = new dojo.html._ContentSetter(lang.mixin(
+					params,
+					{ content: cont, node: node }
+			));
+			return op.set();
+		}
+	};
+
+	return dojo.html;
+});
diff --git a/js/dojo-1.7.2/dojo/i18n.js b/js/dojo-1.7.2/dojo/i18n.js
new file mode 100644
index 0000000..e205a3f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/i18n.js
@@ -0,0 +1,302 @@
+//>>built
+define("dojo/i18n", ["./_base/kernel", "require", "./has", "./_base/array", "./_base/config", "./_base/lang", "./_base/xhr"],
+	function(dojo, require, has, array, config, lang, xhr) {
+	// module:
+	//		dojo/i18n
+	// summary:
+	//		This module implements the !dojo/i18n plugin and the v1.6- i18n API
+	// description:
+	//		We choose to include our own plugin to leverage functionality already contained in dojo
+	//		and thereby reduce the size of the plugin compared to various loader implementations. Also, this
+	//		allows foreign AMD loaders to be used without their plugins.
+	var
+		thisModule= dojo.i18n=
+			// the dojo.i18n module
+			{},
+
+		nlsRe=
+			// regexp for reconstructing the master bundle name from parts of the regexp match
+			// nlsRe.exec("foo/bar/baz/nls/en-ca/foo") gives:
+			// ["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
+			// nlsRe.exec("foo/bar/baz/nls/foo") gives:
+			// ["foo/bar/baz/nls/foo", "foo/bar/baz/nls/", "/", "/", "foo", ""]
+			// so, if match[5] is blank, it means this is the top bundle definition.
+			// courtesy of http://requirejs.org
+			/(^.*(^|\/)nls)(\/|$)([^\/]*)\/?([^\/]*)/,
+
+		getAvailableLocales= function(
+			root,
+			locale,
+			bundlePath,
+			bundleName
+		){
+			// return a vector of module ids containing all available locales with respect to the target locale
+			// For example, assuming:
+			//	 * the root bundle indicates specific bundles for "fr" and "fr-ca",
+			//	 * bundlePath is "myPackage/nls"
+			//	 * bundleName is "myBundle"
+			// Then a locale argument of "fr-ca" would return
+			//	 ["myPackage/nls/myBundle", "myPackage/nls/fr/myBundle", "myPackage/nls/fr-ca/myBundle"]
+			// Notice that bundles are returned least-specific to most-specific, starting with the root.
+			//
+			// If root===false indicates we're working with a pre-AMD i18n bundle that doesn't tell about the available locales;
+			// therefore, assume everything is available and get 404 errors that indicate a particular localization is not available
+			//
+
+			for(var result= [bundlePath + bundleName], localeParts= locale.split("-"), current= "", i= 0; i<localeParts.length; i++){
+				current+= (current ? "-" : "") + localeParts[i];
+				if(!root || root[current]){
+					result.push(bundlePath + current + "/" + bundleName);
+				}
+			}
+			return result;
+		},
+
+		cache= {},
+
+		getL10nName= dojo.getL10nName = function(moduleName, bundleName, locale){
+			locale = locale ? locale.toLowerCase() : dojo.locale;
+			moduleName = "dojo/i18n!" + moduleName.replace(/\./g, "/");
+			bundleName = bundleName.replace(/\./g, "/");
+			return (/root/i.test(locale)) ?
+				(moduleName + "/nls/" + bundleName) :
+				(moduleName + "/nls/" + locale + "/" + bundleName);
+		},
+
+		doLoad = function(require, bundlePathAndName, bundlePath, bundleName, locale, load){
+			// get the root bundle which instructs which other bundles are required to construct the localized bundle
+			require([bundlePathAndName], function(root){
+				var
+					current= cache[bundlePathAndName + "/"]= lang.clone(root.root),
+					availableLocales= getAvailableLocales(!root._v1x && root, locale, bundlePath, bundleName);
+				require(availableLocales, function(){
+					for (var i= 1; i<availableLocales.length; i++){
+						cache[availableLocales[i]]= current= lang.mixin(lang.clone(current), arguments[i]);
+					}
+					// target may not have been resolve (e.g., maybe only "fr" exists when "fr-ca" was requested)
+					var target= bundlePathAndName + "/" + locale;
+					cache[target]= current;
+					load && load(lang.delegate(current));
+				});
+			});
+		},
+
+		normalize = function(id, toAbsMid){
+			// note: id may be relative
+			var match= nlsRe.exec(id),
+				bundlePath= match[1];
+			return /^\./.test(bundlePath) ? toAbsMid(bundlePath) + "/" +  id.substring(bundlePath.length) : id;
+		},
+
+		checkForLegacyModules = function(){},
+
+		load = function(id, require, load){
+			// note: id is always absolute
+			var
+				match= nlsRe.exec(id),
+				bundlePath= match[1] + "/",
+				bundleName= match[5] || match[4],
+				bundlePathAndName= bundlePath + bundleName,
+				localeSpecified = (match[5] && match[4]),
+				targetLocale=  localeSpecified || dojo.locale,
+				target= bundlePathAndName + "/" + targetLocale;
+
+			if(localeSpecified){
+				checkForLegacyModules(target);
+				if(cache[target]){
+					// a request for a specific local that has already been loaded; just return it
+					load(cache[target]);
+				}else{
+					// a request for a specific local that has not been loaded; load and return just that locale
+					doLoad(require, bundlePathAndName, bundlePath, bundleName, targetLocale, load);
+				}
+				return;
+			}// else a non-locale-specific request; therefore always load dojo.locale + config.extraLocale
+
+			// notice the subtle algorithm that loads targetLocal last, which is the only doLoad application that passes a value for the load callback
+			// this makes the sync loader follow a clean code path that loads extras first and then proceeds with tracing the current deps graph
+			var extra = config.extraLocale || [];
+			extra = lang.isArray(extra) ? extra : [extra];
+			extra.push(targetLocale);
+			var remaining = extra.length,
+				targetBundle;
+			array.forEach(extra, function(locale){
+				doLoad(require, bundlePathAndName, bundlePath, bundleName, locale, function(bundle){
+					if(locale == targetLocale){
+						targetBundle = bundle;
+					}
+					if(!--remaining){
+						load(targetBundle);
+					}
+				});
+			});
+		};
+
+	if(has("dojo-unit-tests")){
+		var unitTests = thisModule.unitTests = [];
+	}
+
+	true || has.add("dojo-v1x-i18n-Api",
+		// if true, define the v1.x i18n functions
+		1
+	);
+
+	if(1){
+		var
+			__evalError = {},
+
+			evalBundle=
+				// use the function ctor to keep the minifiers away and come close to global scope
+				// if bundle is an AMD bundle, then __amdResult will be defined; otherwise it's a pre-amd bundle and the bundle value is returned by eval
+				new Function("bundle, __evalError",
+					"var __amdResult, define = function(x){__amdResult= x;};" +
+					"return [(function(){" +
+								"try{eval(arguments[0]);}catch(e){}" +
+								"if(__amdResult)return 0;" +
+								"try{return eval('('+arguments[0]+')');}" +
+								"catch(e){__evalError.e = e; return __evalError;}" +
+							"})(arguments[0]) , __amdResult];"
+				),
+
+			fixup= function(url, preAmdResult, amdResult){
+				// nls/<locale>/<bundle-name> indicates not the root.
+				if(preAmdResult===__evalError){
+					console.error("failed to evaluate i18n bundle; url=" + url, __evalError.e);
+					return {};
+				}
+				return preAmdResult ? (/nls\/[^\/]+\/[^\/]+$/.test(url) ? preAmdResult : {root:preAmdResult, _v1x:1}) : amdResult;
+			},
+
+			syncRequire= function(deps, callback){
+				var results= [];
+				array.forEach(deps, function(mid){
+					var url= require.toUrl(mid + ".js");
+					if(cache[url]){
+						results.push(cache[url]);
+					}else{
+
+						try {
+							var bundle= require(mid);
+							if(bundle){
+								results.push(bundle);
+								return;
+							}
+						}catch(e){}
+
+						xhr.get({
+							url:url,
+							sync:true,
+							load:function(text){
+								var result = evalBundle(text, __evalError);
+								results.push(cache[url]= fixup(url, result[0], result[1]));
+							},
+							error:function(){
+								results.push(cache[url]= {});
+							}
+						});
+					}
+				});
+				callback && callback.apply(null, results);
+			},
+
+			normalizeLocale = thisModule.normalizeLocale= function(locale){
+				var result = locale ? locale.toLowerCase() : dojo.locale;
+				if(result == "root"){
+					result = "ROOT";
+				}
+				return result;
+			},
+
+			forEachLocale = function(locale, func){
+				// this function is equivalent to v1.6 dojo.i18n._searchLocalePath with down===true
+				var parts = locale.split("-");
+				while(parts.length){
+					if(func(parts.join("-"))){
+						return true;
+					}
+					parts.pop();
+				}
+				return func("ROOT");
+			};
+
+		checkForLegacyModules = function(target){
+			// legacy code may have already loaded [e.g] the raw bundle x/y/z at x.y.z; when true, push into the cache
+			for(var names = target.split("/"), object = dojo.global[names[0]], i = 1; object && i<names.length; object = object[names[i++]]){}
+			if(object){
+				cache[target] = object;
+			}
+		};
+
+		thisModule.getLocalization= function(moduleName, bundleName, locale){
+			var result,
+				l10nName= getL10nName(moduleName, bundleName, locale).substring(10);
+			load(l10nName, (1 && !require.isXdUrl(require.toUrl(l10nName + ".js")) ? syncRequire : require), function(result_){ result= result_; });
+			return result;
+		};
+
+		thisModule._preloadLocalizations = function(/*String*/bundlePrefix, /*Array*/localesGenerated){
+			//	summary:
+			//		Load built, flattened resource bundles, if available for all
+			//		locales used in the page. Only called by built layer files.
+			//
+			//  note: this function a direct copy of v1.6 function of same name
+
+			function preload(locale){
+				locale = normalizeLocale(locale);
+				forEachLocale(locale, function(loc){
+					for(var i=0; i<localesGenerated.length;i++){
+						if(localesGenerated[i] == loc){
+							syncRequire([bundlePrefix.replace(/\./g, "/")+"_"+loc]);
+							return true; // Boolean
+						}
+					}
+					return false; // Boolean
+				});
+			}
+			preload();
+			var extra = dojo.config.extraLocale||[];
+			for(var i=0; i<extra.length; i++){
+				preload(extra[i]);
+			}
+		};
+
+		if(has("dojo-unit-tests")){
+			unitTests.push(function(doh){
+				doh.register("tests.i18n.unit", function(t){
+					var check;
+
+					check = evalBundle("{prop:1}", __evalError);
+					t.is({prop:1}, check[0]); t.is(undefined, check[1]);
+
+					check = evalBundle("({prop:1})", __evalError);
+					t.is({prop:1}, check[0]); t.is(undefined, check[1]);
+
+					check = evalBundle("{'prop-x':1}", __evalError);
+					t.is({'prop-x':1}, check[0]); t.is(undefined, check[1]);
+
+					check = evalBundle("({'prop-x':1})", __evalError);
+					t.is({'prop-x':1}, check[0]); t.is(undefined, check[1]);
+
+					check = evalBundle("define({'prop-x':1})", __evalError);
+					t.is(0, check[0]); t.is({'prop-x':1}, check[1]);
+
+					check = evalBundle("define({'prop-x':1});", __evalError);
+					t.is(0, check[0]); t.is({'prop-x':1}, check[1]);
+
+					check = evalBundle("this is total nonsense and should throw an error", __evalError);
+					t.is(__evalError, check[0]); t.is(undefined, check[1]);
+					t.is({}, fixup("some/url", check[0], check[1]));
+				});
+			});
+		}
+	}
+
+	return lang.mixin(thisModule, {
+		dynamic:true,
+		normalize:normalize,
+		load:load,
+		cache:function(mid, value){
+			cache[mid] = value;
+		}
+	});
+});
diff --git a/js/dojo-1.7.2/dojo/io-query.js b/js/dojo-1.7.2/dojo/io-query.js
new file mode 100644
index 0000000..78b0068
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/io-query.js
@@ -0,0 +1,99 @@
+//>>built
+define("dojo/io-query", ["./_base/lang"], function(lang){
+	// module:
+	//		dojo/io-query
+	// summary:
+	//		This module defines query string processing functions.
+
+    var backstop = {};
+
+    function objectToQuery(/*Object*/ map){
+        // summary:
+        //		takes a name/value mapping object and returns a string representing
+        //		a URL-encoded version of that object.
+        // example:
+        //		this object:
+        //
+        //	|	{
+        //	|		blah: "blah",
+        //	|		multi: [
+        //	|			"thud",
+        //	|			"thonk"
+        //	|		]
+        //	|	};
+        //
+        // yields the following query string:
+        //
+        //	|	"blah=blah&multi=thud&multi=thonk"
+
+        // FIXME: need to implement encodeAscii!!
+        var enc = encodeURIComponent, pairs = [];
+        for(var name in map){
+            var value = map[name];
+            if(value != backstop[name]){
+                var assign = enc(name) + "=";
+                if(lang.isArray(value)){
+                    for(var i = 0, l = value.length; i < l; ++i){
+                        pairs.push(assign + enc(value[i]));
+                    }
+                }else{
+                    pairs.push(assign + enc(value));
+                }
+            }
+        }
+        return pairs.join("&"); // String
+    }
+
+    function queryToObject(/*String*/ str){
+        // summary:
+        //		Create an object representing a de-serialized query section of a
+        //		URL. Query keys with multiple values are returned in an array.
+        //
+        // example:
+        //		This string:
+        //
+        //	|		"foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&"
+        //
+        //		results in this object structure:
+        //
+        //	|		{
+        //	|			foo: [ "bar", "baz" ],
+        //	|			thinger: " spaces =blah",
+        //	|			zonk: "blarg"
+        //	|		}
+        //
+        //		Note that spaces and other urlencoded entities are correctly
+        //		handled.
+
+        // FIXME: should we grab the URL string if we're not passed one?
+        var dec = decodeURIComponent, qp = str.split("&"), ret = {}, name, val;
+        for(var i = 0, l = qp.length, item; i < l; ++i){
+            item = qp[i];
+            if(item.length){
+                var s = item.indexOf("=");
+                if(s < 0){
+                    name = dec(item);
+                    val = "";
+                }else{
+                    name = dec(item.slice(0, s));
+                    val  = dec(item.slice(s + 1));
+                }
+                if(typeof ret[name] == "string"){ // inline'd type check
+                    ret[name] = [ret[name]];
+                }
+
+                if(lang.isArray(ret[name])){
+                    ret[name].push(val);
+                }else{
+                    ret[name] = val;
+                }
+            }
+        }
+        return ret; // Object
+    }
+
+    return {
+        objectToQuery: objectToQuery,
+        queryToObject: queryToObject
+    };
+});
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/io/iframe.js b/js/dojo-1.7.2/dojo/io/iframe.js
new file mode 100644
index 0000000..055cd57
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/io/iframe.js
@@ -0,0 +1,377 @@
+//>>built
+define("dojo/io/iframe", ["../main", "require"], function(dojo, require) {
+	// module:
+	//		dojo/io/iframe
+	// summary:
+	//		TODOC
+
+dojo.getObject("io", true, dojo);
+
+/*=====
+dojo.declare("dojo.io.iframe.__ioArgs", dojo.__IoArgs, {
+	constructor: function(){
+		//	summary:
+		//		All the properties described in the dojo.__ioArgs type, apply
+		//		to this type. The following additional properties are allowed
+		//		for dojo.io.iframe.send():
+		//	method: String?
+		//		The HTTP method to use. "GET" or "POST" are the only supported
+		//		values.  It will try to read the value from the form node's
+		//		method, then try this argument. If neither one exists, then it
+		//		defaults to POST.
+		//	handleAs: String?
+		//		Specifies what format the result data should be given to the
+		//		load/handle callback. Valid values are: text, html, xml, json,
+		//		javascript. IMPORTANT: For all values EXCEPT html and xml, The
+		//		server response should be an HTML file with a textarea element.
+		//		The response data should be inside the textarea element. Using an
+		//		HTML document the only reliable, cross-browser way this
+		//		transport can know when the response has loaded. For the html
+		//		handleAs value, just return a normal HTML document.  NOTE: xml
+		//		is now supported with this transport (as of 1.1+); a known issue
+		//		is if the XML document in question is malformed, Internet Explorer
+		//		will throw an uncatchable error.
+		//	content: Object?
+		//		If "form" is one of the other args properties, then the content
+		//		object properties become hidden form form elements. For
+		//		instance, a content object of {name1 : "value1"} is converted
+		//		to a hidden form element with a name of "name1" and a value of
+		//		"value1". If there is not a "form" property, then the content
+		//		object is converted into a name=value&name=value string, by
+		//		using dojo.objectToQuery().
+		this.method = method;
+		this.handleAs = handleAs;
+		this.content = content;
+	}
+});
+=====*/
+
+dojo.io.iframe = {
+	// summary:
+	//		Sends an Ajax I/O call using and Iframe (for instance, to upload files)
+
+	create: function(/*String*/fname, /*String*/onloadstr, /*String?*/uri){
+		//	summary:
+		//		Creates a hidden iframe in the page. Used mostly for IO
+		//		transports.  You do not need to call this to start a
+		//		dojo.io.iframe request. Just call send().
+		//	fname: String
+		//		The name of the iframe. Used for the name attribute on the
+		//		iframe.
+		//	onloadstr: String
+		//		A string of JavaScript that will be executed when the content
+		//		in the iframe loads.
+		//	uri: String
+		//		The value of the src attribute on the iframe element. If a
+		//		value is not given, then dojo/resources/blank.html will be
+		//		used.
+		if(window[fname]){ return window[fname]; }
+		if(window.frames[fname]){ return window.frames[fname]; }
+		var turi = uri;
+		if(!turi){
+			if(dojo.config["useXDomain"] && !dojo.config["dojoBlankHtmlUrl"]){
+				console.warn("dojo.io.iframe.create: When using cross-domain Dojo builds,"
+					+ " please save dojo/resources/blank.html to your domain and set djConfig.dojoBlankHtmlUrl"
+					+ " to the path on your domain to blank.html");
+			}
+			turi = (dojo.config["dojoBlankHtmlUrl"]||require.toUrl("../resources/blank.html"));
+		}
+		var cframe = dojo.place(
+			'<iframe id="'+fname+'" name="'+fname+'" src="'+turi+'" onload="'+onloadstr+
+			'" style="position: absolute; left: 1px; top: 1px; height: 1px; width: 1px; visibility: hidden">',
+		dojo.body());
+
+		window[fname] = cframe;
+
+		return cframe;
+	},
+
+	setSrc: function(/*DOMNode*/iframe, /*String*/src, /*Boolean*/replace){
+		//summary:
+		//		Sets the URL that is loaded in an IFrame. The replace parameter
+		//		indicates whether location.replace() should be used when
+		//		changing the location of the iframe.
+		try{
+			if(!replace){
+				if(dojo.isWebKit){
+					iframe.location = src;
+				}else{
+					frames[iframe.name].location = src;
+				}
+			}else{
+				// Fun with DOM 0 incompatibilities!
+				var idoc;
+				if(dojo.isIE || dojo.isWebKit){
+					idoc = iframe.contentWindow.document;
+				}else{ //  if(d.isMozilla){
+					idoc = iframe.contentWindow;
+				}
+
+				//For Safari (at least 2.0.3) and Opera, if the iframe
+				//has just been created but it doesn't have content
+				//yet, then iframe.document may be null. In that case,
+				//use iframe.location and return.
+				if(!idoc){
+					iframe.location = src;
+				}else{
+					idoc.location.replace(src);
+				}
+			}
+		}catch(e){
+			console.log("dojo.io.iframe.setSrc: ", e);
+		}
+	},
+
+	doc: function(/*DOMNode*/iframeNode){
+		//summary: Returns the document object associated with the iframe DOM Node argument.
+		return iframeNode.contentDocument || // W3
+			(
+				(
+					(iframeNode.name) && (iframeNode.document) &&
+					(dojo.doc.getElementsByTagName("iframe")[iframeNode.name].contentWindow) &&
+					(dojo.doc.getElementsByTagName("iframe")[iframeNode.name].contentWindow.document)
+				)
+			) ||  // IE
+			(
+				(iframeNode.name)&&(dojo.doc.frames[iframeNode.name])&&
+				(dojo.doc.frames[iframeNode.name].document)
+			) || null;
+	},
+
+	send: function(/*dojo.io.iframe.__ioArgs*/args){
+		//summary:
+		//		Function that sends the request to the server.
+		//		This transport can only process one send() request at a time, so if send() is called
+		//multiple times, it will queue up the calls and only process one at a time.
+		if(!this["_frame"]){
+			this._frame = this.create(this._iframeName, dojo._scopeName + ".io.iframe._iframeOnload();");
+		}
+
+		//Set up the deferred.
+		var dfd = dojo._ioSetArgs(
+			args,
+			function(/*Deferred*/dfd){
+				//summary: canceller function for dojo._ioSetArgs call.
+				dfd.canceled = true;
+				dfd.ioArgs._callNext();
+			},
+			function(/*Deferred*/dfd){
+				//summary: okHandler function for dojo._ioSetArgs call.
+				var value = null;
+				try{
+					var ioArgs = dfd.ioArgs;
+					var dii = dojo.io.iframe;
+					var ifd = dii.doc(dii._frame);
+					var handleAs = ioArgs.handleAs;
+
+					//Assign correct value based on handleAs value.
+					value = ifd; //html
+					if(handleAs != "html"){
+						if(handleAs == "xml"){
+							//	FF, Saf 3+ and Opera all seem to be fine with ifd being xml.  We have to
+							//	do it manually for IE6-8.  Refs #6334.
+							if(dojo.isIE < 9 || (dojo.isIE && dojo.isQuirks)){
+								dojo.query("a", dii._frame.contentWindow.document.documentElement).orphan();
+								var xmlText=(dii._frame.contentWindow.document).documentElement.innerText;
+								xmlText=xmlText.replace(/>\s+</g, "><");
+								xmlText=dojo.trim(xmlText);
+								//Reusing some code in base dojo for handling XML content.  Simpler and keeps
+								//Core from duplicating the effort needed to locate the XML Parser on IE.
+								var fauxXhr = { responseText: xmlText };
+								value = dojo._contentHandlers["xml"](fauxXhr); // DOMDocument
+							}
+						}else{
+							value = ifd.getElementsByTagName("textarea")[0].value; //text
+							if(handleAs == "json"){
+								value = dojo.fromJson(value); //json
+							}else if(handleAs == "javascript"){
+								value = dojo.eval(value); //javascript
+							}
+						}
+					}
+				}catch(e){
+					value = e;
+				}finally{
+					ioArgs._callNext();
+				}
+				return value;
+			},
+			function(/*Error*/error, /*Deferred*/dfd){
+				//summary: errHandler function for dojo._ioSetArgs call.
+				dfd.ioArgs._hasError = true;
+				dfd.ioArgs._callNext();
+				return error;
+			}
+		);
+
+		//Set up a function that will fire the next iframe request. Make sure it only
+		//happens once per deferred.
+		dfd.ioArgs._callNext = function(){
+			if(!this["_calledNext"]){
+				this._calledNext = true;
+				dojo.io.iframe._currentDfd = null;
+				dojo.io.iframe._fireNextRequest();
+			}
+		};
+
+		this._dfdQueue.push(dfd);
+		this._fireNextRequest();
+
+		//Add it the IO watch queue, to get things like timeout support.
+		dojo._ioWatch(
+			dfd,
+			function(/*Deferred*/dfd){
+				//validCheck
+				return !dfd.ioArgs["_hasError"];
+			},
+			function(dfd){
+				//ioCheck
+				return (!!dfd.ioArgs["_finished"]);
+			},
+			function(dfd){
+				//resHandle
+				if(dfd.ioArgs._finished){
+					dfd.callback(dfd);
+				}else{
+					dfd.errback(new Error("Invalid dojo.io.iframe request state"));
+				}
+			}
+		);
+
+		return dfd;
+	},
+
+	_currentDfd: null,
+	_dfdQueue: [],
+	_iframeName: dojo._scopeName + "IoIframe",
+
+	_fireNextRequest: function(){
+		//summary: Internal method used to fire the next request in the bind queue.
+		try{
+			if((this._currentDfd)||(this._dfdQueue.length == 0)){ return; }
+			//Find next deferred, skip the canceled ones.
+			do{
+				var dfd = this._currentDfd = this._dfdQueue.shift();
+			} while(dfd && dfd.canceled && this._dfdQueue.length);
+
+			//If no more dfds, cancel.
+			if(!dfd || dfd.canceled){
+				this._currentDfd =  null;
+				return;
+			}
+
+			var ioArgs = dfd.ioArgs;
+			var args = ioArgs.args;
+
+			ioArgs._contentToClean = [];
+			var fn = dojo.byId(args["form"]);
+			var content = args["content"] || {};
+			if(fn){
+				if(content){
+					// if we have things in content, we need to add them to the form
+					// before submission
+					var pHandler = function(name, value) {
+						dojo.create("input", {type: "hidden", name: name, value: value}, fn);
+						ioArgs._contentToClean.push(name);
+					};
+					for(var x in content){
+						var val = content[x];
+						if(dojo.isArray(val) && val.length > 1){
+							var i;
+							for (i = 0; i < val.length; i++) {
+								pHandler(x,val[i]);
+							}
+						}else{
+							if(!fn[x]){
+								pHandler(x,val);
+							}else{
+								fn[x].value = val;
+							}
+						}
+					}
+				}
+				//IE requires going through getAttributeNode instead of just getAttribute in some form cases,
+				//so use it for all.  See #2844
+				var actnNode = fn.getAttributeNode("action");
+				var mthdNode = fn.getAttributeNode("method");
+				var trgtNode = fn.getAttributeNode("target");
+				if(args["url"]){
+					ioArgs._originalAction = actnNode ? actnNode.value : null;
+					if(actnNode){
+						actnNode.value = args.url;
+					}else{
+						fn.setAttribute("action",args.url);
+					}
+				}
+				if(!mthdNode || !mthdNode.value){
+					if(mthdNode){
+						mthdNode.value= (args["method"]) ? args["method"] : "post";
+					}else{
+						fn.setAttribute("method", (args["method"]) ? args["method"] : "post");
+					}
+				}
+				ioArgs._originalTarget = trgtNode ? trgtNode.value: null;
+				if(trgtNode){
+					trgtNode.value = this._iframeName;
+				}else{
+					fn.setAttribute("target", this._iframeName);
+				}
+				fn.target = this._iframeName;
+				dojo._ioNotifyStart(dfd);
+				fn.submit();
+			}else{
+				// otherwise we post a GET string by changing URL location for the
+				// iframe
+				var tmpUrl = args.url + (args.url.indexOf("?") > -1 ? "&" : "?") + ioArgs.query;
+				dojo._ioNotifyStart(dfd);
+				this.setSrc(this._frame, tmpUrl, true);
+			}
+		}catch(e){
+			dfd.errback(e);
+		}
+	},
+
+	_iframeOnload: function(){
+		var dfd = this._currentDfd;
+		if(!dfd){
+			this._fireNextRequest();
+			return;
+		}
+
+		var ioArgs = dfd.ioArgs;
+		var args = ioArgs.args;
+		var fNode = dojo.byId(args.form);
+
+		if(fNode){
+			// remove all the hidden content inputs
+			var toClean = ioArgs._contentToClean;
+			for(var i = 0; i < toClean.length; i++) {
+				var key = toClean[i];
+				//Need to cycle over all nodes since we may have added
+				//an array value which means that more than one node could
+				//have the same .name value.
+				for(var j = 0; j < fNode.childNodes.length; j++){
+					var chNode = fNode.childNodes[j];
+					if(chNode.name == key){
+						dojo.destroy(chNode);
+						break;
+					}
+				}
+			}
+
+			// restore original action + target
+			if(ioArgs["_originalAction"]){
+				fNode.setAttribute("action", ioArgs._originalAction);
+			}
+			if(ioArgs["_originalTarget"]){
+				fNode.setAttribute("target", ioArgs._originalTarget);
+				fNode.target = ioArgs._originalTarget;
+			}
+		}
+
+		ioArgs._finished = true;
+	}
+};
+
+return dojo.io.iframe;
+});
diff --git a/js/dojo-1.7.2/dojo/io/script.js b/js/dojo-1.7.2/dojo/io/script.js
new file mode 100644
index 0000000..59845f7
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/io/script.js
@@ -0,0 +1,257 @@
+//>>built
+define("dojo/io/script", ["../main"], function(dojo) {
+	// module:
+	//		dojo/io/script
+	// summary:
+	//		TODOC
+
+	dojo.getObject("io", true, dojo);
+
+/*=====
+dojo.declare("dojo.io.script.__ioArgs", dojo.__IoArgs, {
+	constructor: function(){
+		//	summary:
+		//		All the properties described in the dojo.__ioArgs type, apply to this
+		//		type as well, EXCEPT "handleAs". It is not applicable to
+		//		dojo.io.script.get() calls, since it is implied by the usage of
+		//		"jsonp" (response will be a JSONP call returning JSON)
+		//		or the response is pure JavaScript defined in
+		//		the body of the script that was attached.
+		//	callbackParamName: String
+		//		Deprecated as of Dojo 1.4 in favor of "jsonp", but still supported for
+		//		legacy code. See notes for jsonp property.
+		//	jsonp: String
+		//		The URL parameter name that indicates the JSONP callback string.
+		//		For instance, when using Yahoo JSONP calls it is normally,
+		//		jsonp: "callback". For AOL JSONP calls it is normally
+		//		jsonp: "c".
+		//	checkString: String
+		//		A string of JavaScript that when evaluated like so:
+		//		"typeof(" + checkString + ") != 'undefined'"
+		//		being true means that the script fetched has been loaded.
+		//		Do not use this if doing a JSONP type of call (use callbackParamName instead).
+		//	frameDoc: Document
+		//		The Document object for a child iframe. If this is passed in, the script
+		//		will be attached to that document. This can be helpful in some comet long-polling
+		//		scenarios with Firefox and Opera.
+		this.callbackParamName = callbackParamName;
+		this.jsonp = jsonp;
+		this.checkString = checkString;
+		this.frameDoc = frameDoc;
+	}
+});
+=====*/
+
+	var loadEvent = dojo.isIE ? "onreadystatechange" : "load",
+		readyRegExp = /complete|loaded/;
+
+	dojo.io.script = {
+		get: function(/*dojo.io.script.__ioArgs*/args){
+			//	summary:
+			//		sends a get request using a dynamically created script tag.
+			var dfd = this._makeScriptDeferred(args);
+			var ioArgs = dfd.ioArgs;
+			dojo._ioAddQueryToUrl(ioArgs);
+
+			dojo._ioNotifyStart(dfd);
+
+			if(this._canAttach(ioArgs)){
+				var node = this.attach(ioArgs.id, ioArgs.url, args.frameDoc);
+
+				//If not a jsonp callback or a polling checkString case, bind
+				//to load event on the script tag.
+				if(!ioArgs.jsonp && !ioArgs.args.checkString){
+					var handle = dojo.connect(node, loadEvent, function(evt){
+						if(evt.type == "load" || readyRegExp.test(node.readyState)){
+							dojo.disconnect(handle);
+							ioArgs.scriptLoaded = evt;
+						}
+					});
+				}
+			}
+
+			dojo._ioWatch(dfd, this._validCheck, this._ioCheck, this._resHandle);
+			return dfd;
+		},
+
+		attach: function(/*String*/id, /*String*/url, /*Document?*/frameDocument){
+			//	summary:
+			//		creates a new <script> tag pointing to the specified URL and
+			//		adds it to the document.
+			//	description:
+			//		Attaches the script element to the DOM.	 Use this method if you
+			//		just want to attach a script to the DOM and do not care when or
+			//		if it loads.
+			var doc = (frameDocument || dojo.doc);
+			var element = doc.createElement("script");
+			element.type = "text/javascript";
+			element.src = url;
+			element.id = id;
+			element.async = true;
+			element.charset = "utf-8";
+			return doc.getElementsByTagName("head")[0].appendChild(element);
+		},
+
+		remove: function(/*String*/id, /*Document?*/frameDocument){
+			//summary: removes the script element with the given id, from the given frameDocument.
+			//If no frameDocument is passed, the current document is used.
+			dojo.destroy(dojo.byId(id, frameDocument));
+
+			//Remove the jsonp callback on dojo.io.script, if it exists.
+			if(this["jsonp_" + id]){
+				delete this["jsonp_" + id];
+			}
+		},
+
+		_makeScriptDeferred: function(/*Object*/args){
+			//summary:
+			//		sets up a Deferred object for an IO request.
+			var dfd = dojo._ioSetArgs(args, this._deferredCancel, this._deferredOk, this._deferredError);
+
+			var ioArgs = dfd.ioArgs;
+			ioArgs.id = dojo._scopeName + "IoScript" + (this._counter++);
+			ioArgs.canDelete = false;
+
+			//Special setup for jsonp case
+			ioArgs.jsonp = args.callbackParamName || args.jsonp;
+			if(ioArgs.jsonp){
+				//Add the jsonp parameter.
+				ioArgs.query = ioArgs.query || "";
+				if(ioArgs.query.length > 0){
+					ioArgs.query += "&";
+				}
+				ioArgs.query += ioArgs.jsonp
+					+ "="
+					+ (args.frameDoc ? "parent." : "")
+					+ dojo._scopeName + ".io.script.jsonp_" + ioArgs.id + "._jsonpCallback";
+
+				ioArgs.frameDoc = args.frameDoc;
+
+				//Setup the Deferred to have the jsonp callback.
+				ioArgs.canDelete = true;
+				dfd._jsonpCallback = this._jsonpCallback;
+				this["jsonp_" + ioArgs.id] = dfd;
+			}
+			return dfd; // dojo.Deferred
+		},
+
+		_deferredCancel: function(/*Deferred*/dfd){
+			//summary: canceller function for dojo._ioSetArgs call.
+
+			//DO NOT use "this" and expect it to be dojo.io.script.
+			dfd.canceled = true;
+			if(dfd.ioArgs.canDelete){
+				dojo.io.script._addDeadScript(dfd.ioArgs);
+			}
+		},
+
+		_deferredOk: function(/*Deferred*/dfd){
+			//summary: okHandler function for dojo._ioSetArgs call.
+
+			//DO NOT use "this" and expect it to be dojo.io.script.
+			var ioArgs = dfd.ioArgs;
+
+			//Add script to list of things that can be removed.
+			if(ioArgs.canDelete){
+				dojo.io.script._addDeadScript(ioArgs);
+			}
+
+			//Favor JSONP responses, script load events then lastly ioArgs.
+			//The ioArgs are goofy, but cannot return the dfd since that stops
+			//the callback chain in Deferred. The return value is not that important
+			//in that case, probably a checkString case.
+			return ioArgs.json || ioArgs.scriptLoaded || ioArgs;
+		},
+
+		_deferredError: function(/*Error*/error, /*Deferred*/dfd){
+			//summary: errHandler function for dojo._ioSetArgs call.
+
+			if(dfd.ioArgs.canDelete){
+				//DO NOT use "this" and expect it to be dojo.io.script.
+				if(error.dojoType == "timeout"){
+					//For timeouts, remove the script element immediately to
+					//avoid a response from it coming back later and causing trouble.
+					dojo.io.script.remove(dfd.ioArgs.id, dfd.ioArgs.frameDoc);
+				}else{
+					dojo.io.script._addDeadScript(dfd.ioArgs);
+				}
+			}
+			console.log("dojo.io.script error", error);
+			return error;
+		},
+
+		_deadScripts: [],
+		_counter: 1,
+
+		_addDeadScript: function(/*Object*/ioArgs){
+			//summary: sets up an entry in the deadScripts array.
+			dojo.io.script._deadScripts.push({id: ioArgs.id, frameDoc: ioArgs.frameDoc});
+			//Being extra paranoid about leaks:
+			ioArgs.frameDoc = null;
+		},
+
+		_validCheck: function(/*Deferred*/dfd){
+			//summary: inflight check function to see if dfd is still valid.
+
+			//Do script cleanup here. We wait for one inflight pass
+			//to make sure we don't get any weird things by trying to remove a script
+			//tag that is part of the call chain (IE 6 has been known to
+			//crash in that case).
+			var _self = dojo.io.script;
+			var deadScripts = _self._deadScripts;
+			if(deadScripts && deadScripts.length > 0){
+				for(var i = 0; i < deadScripts.length; i++){
+					//Remove the script tag
+					_self.remove(deadScripts[i].id, deadScripts[i].frameDoc);
+					deadScripts[i].frameDoc = null;
+				}
+				dojo.io.script._deadScripts = [];
+			}
+
+			return true;
+		},
+
+		_ioCheck: function(/*Deferred*/dfd){
+			//summary: inflight check function to see if IO finished.
+			var ioArgs = dfd.ioArgs;
+			//Check for finished jsonp
+			if(ioArgs.json || (ioArgs.scriptLoaded && !ioArgs.args.checkString)){
+				return true;
+			}
+
+			//Check for finished "checkString" case.
+			var checkString = ioArgs.args.checkString;
+			return checkString && eval("typeof(" + checkString + ") != 'undefined'");
+
+
+		},
+
+		_resHandle: function(/*Deferred*/dfd){
+			//summary: inflight function to handle a completed response.
+			if(dojo.io.script._ioCheck(dfd)){
+				dfd.callback(dfd);
+			}else{
+				//This path should never happen since the only way we can get
+				//to _resHandle is if _ioCheck is true.
+				dfd.errback(new Error("inconceivable dojo.io.script._resHandle error"));
+			}
+		},
+
+		_canAttach: function(/*Object*/ioArgs){
+			//summary: A method that can be overridden by other modules
+			//to control when the script attachment occurs.
+			return true;
+		},
+
+		_jsonpCallback: function(/*JSON Object*/json){
+			//summary:
+			//		generic handler for jsonp callback. A pointer to this function
+			//		is used for all jsonp callbacks.  NOTE: the "this" in this
+			//		function will be the Deferred object that represents the script
+			//		request.
+			this.ioArgs.json = json;
+		}
+	};
+
+	return dojo.io.script;
+});
diff --git a/js/dojo-1.7.2/dojo/jaxer.js b/js/dojo-1.7.2/dojo/jaxer.js
new file mode 100644
index 0000000..97a7bb7
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/jaxer.js
@@ -0,0 +1,20 @@
+//>>built
+define("dojo/jaxer", ["./main"], function(dojo) {
+	// module:
+	//		dojo/jaxer
+	// summary:
+	//		TODOC
+
+
+if(typeof print == "function"){
+	console.debug = Jaxer.Log.debug;
+	console.warn = Jaxer.Log.warn;
+	console.error = Jaxer.Log.error;
+	console.info = Jaxer.Log.info;
+	console.log = Jaxer.Log.warn;
+}
+
+onserverload = dojo._loadInit;
+
+return dojo;
+});
diff --git a/js/dojo-1.7.2/dojo/json.js b/js/dojo-1.7.2/dojo/json.js
new file mode 100644
index 0000000..fc26c0a
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/json.js
@@ -0,0 +1,150 @@
+//>>built
+define("dojo/json", ["./has"], function(has){
+	"use strict";
+	var hasJSON = typeof JSON != "undefined";
+	has.add("json-parse", hasJSON); // all the parsers work fine
+		// Firefox 3.5/Gecko 1.9 fails to use replacer in stringify properly https://bugzilla.mozilla.org/show_bug.cgi?id=509184
+	has.add("json-stringify", hasJSON && JSON.stringify({a:0}, function(k,v){return v||1;}) == '{"a":1}'); 
+	if(has("json-stringify")){
+		return JSON;
+	}
+	else{
+		var escapeString = function(/*String*/str){
+			//summary:
+			//		Adds escape sequences for non-visual characters, double quote and
+			//		backslash and surrounds with double quotes to form a valid string
+			//		literal.
+			return ('"' + str.replace(/(["\\])/g, '\\$1') + '"').
+				replace(/[\f]/g, "\\f").replace(/[\b]/g, "\\b").replace(/[\n]/g, "\\n").
+				replace(/[\t]/g, "\\t").replace(/[\r]/g, "\\r"); // string
+		};
+		return {
+			parse: has("json-parse") ? JSON.parse : function(str, strict){
+				// summary:
+				// 		Parses a [JSON](http://json.org) string to return a JavaScript object.
+				// description:
+				//		This function follows [native JSON API](https://developer.mozilla.org/en/JSON)
+				// 		Throws for invalid JSON strings. This delegates to eval() if native JSON
+				// 		support is not available. By default this will evaluate any valid JS expression.
+				//		With the strict parameter set to true, the parser will ensure that only
+				//		valid JSON strings are parsed (otherwise throwing an error). Without the strict
+				// 		parameter, the content passed to this method must come
+				//		from a trusted source.
+				// str:
+				//		a string literal of a JSON item, for instance:
+				//			`'{ "foo": [ "bar", 1, { "baz": "thud" } ] }'`
+				//	strict: 
+				//		When set to true, this will ensure that only valid, secure JSON is ever parsed.
+				// 		Make sure this is set to true for untrusted content. Note that on browsers/engines
+				//		without native JSON support, setting this to true will run slower.
+				if(strict && !/^([\s\[\{]*(?:"(?:\\.|[^"])+"|-?\d[\d\.]*(?:[Ee][+-]?\d+)?|null|true|false|)[\s\]\}]*(?:,|:|$))+$/.test(str)){
+					throw new SyntaxError("Invalid characters in JSON");
+				}
+				return eval('(' + str + ')');
+			},
+			stringify: function(value, replacer, spacer){
+				//	summary:
+				//		Returns a [JSON](http://json.org) serialization of an object.
+				//	description:
+				//		Returns a [JSON](http://json.org) serialization of an object.
+				//		This function follows [native JSON API](https://developer.mozilla.org/en/JSON)
+				//		Note that this doesn't check for infinite recursion, so don't do that!
+				//	value:
+				//		A value to be serialized. 
+				//	replacer:
+				//		A replacer function that is called for each value and can return a replacement
+				//	spacer:
+				//		A spacer string to be used for pretty printing of JSON
+				//		
+				//	example:
+				//		simple serialization of a trivial object
+				//		|	define(["dojo/json"], function(JSON){
+				// 		|		var jsonStr = JSON.stringify({ howdy: "stranger!", isStrange: true });
+				//		|		doh.is('{"howdy":"stranger!","isStrange":true}', jsonStr);
+				var undef;
+				if(typeof replacer == "string"){
+					spacer = replacer;
+					replacer = null;
+				}
+				function stringify(it, indent, key){
+					if(replacer){
+						it = replacer(key, it);
+					}
+					var val, objtype = typeof it;
+					if(objtype == "number"){
+						return isFinite(it) ? it + "" : "null";
+					}
+					if(objtype == "boolean"){
+						return it + "";
+					}
+					if(it === null){
+						return "null";
+					}
+					if(typeof it == "string"){
+						return escapeString(it);
+					}
+					if(objtype == "function" || objtype == "undefined"){
+						return undef; // undefined
+					}
+					// short-circuit for objects that support "json" serialization
+					// if they return "self" then just pass-through...
+					if(typeof it.toJSON == "function"){
+						return stringify(it.toJSON(key), indent, key);
+					}
+					if(it instanceof Date){
+						return '"{FullYear}-{Month+}-{Date}T{Hours}:{Minutes}:{Seconds}Z"'.replace(/\{(\w+)(\+)?\}/g, function(t, prop, plus){
+							var num = it["getUTC" + prop]() + (plus ? 1 : 0);
+							return num < 10 ? "0" + num : num;
+						});
+					}
+					if(it.valueOf() !== it){
+						// primitive wrapper, try again unwrapped:
+						return stringify(it.valueOf(), indent, key);
+					}
+					var nextIndent= spacer ? (indent + spacer) : "";
+					/* we used to test for DOM nodes and throw, but FF serializes them as {}, so cross-browser consistency is probably not efficiently attainable */ 
+				
+					var sep = spacer ? " " : "";
+					var newLine = spacer ? "\n" : "";
+				
+					// array
+					if(it instanceof Array){
+						var itl = it.length, res = [];
+						for(key = 0; key < itl; key++){
+							var obj = it[key];
+							val = stringify(obj, nextIndent, key);
+							if(typeof val != "string"){
+								val = "null";
+							}
+							res.push(newLine + nextIndent + val);
+						}
+						return "[" + res.join(",") + newLine + indent + "]";
+					}
+					// generic object code path
+					var output = [];
+					for(key in it){
+						var keyStr;
+						if(typeof key == "number"){
+							keyStr = '"' + key + '"';
+						}else if(typeof key == "string"){
+							keyStr = escapeString(key);
+						}else{
+							// skip non-string or number keys
+							continue;
+						}
+						val = stringify(it[key], nextIndent, key);
+						if(typeof val != "string"){
+							// skip non-serializable values
+							continue;
+						}
+						// At this point, the most non-IE browsers don't get in this branch 
+						// (they have native JSON), so push is definitely the way to
+						output.push(newLine + nextIndent + keyStr + ":" + sep + val);
+					}
+					return "{" + output.join(",") + newLine + indent + "}"; // String
+				}
+				return stringify(value, "", "");
+			}
+		};
+	}
+});
diff --git a/js/dojo-1.7.2/dojo/keys.js b/js/dojo-1.7.2/dojo/keys.js
new file mode 100644
index 0000000..656193d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/keys.js
@@ -0,0 +1,81 @@
+//>>built
+define("dojo/keys", ["./_base/kernel", "./_base/sniff"], function(dojo, has) {
+	// module:
+	//		dojo/keys
+	// summary:
+	//		key constants
+// Constants
+
+// Public: client code should test
+// keyCode against these named constants, as the
+// actual codes can vary by browser.
+return dojo.keys = {
+	// summary:
+	//		Definitions for common key values
+	BACKSPACE: 8,
+	TAB: 9,
+	CLEAR: 12,
+	ENTER: 13,
+	SHIFT: 16,
+	CTRL: 17,
+	ALT: 18,
+	META: has("safari") ? 91 : 224,		// the apple key on macs
+	PAUSE: 19,
+	CAPS_LOCK: 20,
+	ESCAPE: 27,
+	SPACE: 32,
+	PAGE_UP: 33,
+	PAGE_DOWN: 34,
+	END: 35,
+	HOME: 36,
+	LEFT_ARROW: 37,
+	UP_ARROW: 38,
+	RIGHT_ARROW: 39,
+	DOWN_ARROW: 40,
+	INSERT: 45,
+	DELETE: 46,
+	HELP: 47,
+	LEFT_WINDOW: 91,
+	RIGHT_WINDOW: 92,
+	SELECT: 93,
+	NUMPAD_0: 96,
+	NUMPAD_1: 97,
+	NUMPAD_2: 98,
+	NUMPAD_3: 99,
+	NUMPAD_4: 100,
+	NUMPAD_5: 101,
+	NUMPAD_6: 102,
+	NUMPAD_7: 103,
+	NUMPAD_8: 104,
+	NUMPAD_9: 105,
+	NUMPAD_MULTIPLY: 106,
+	NUMPAD_PLUS: 107,
+	NUMPAD_ENTER: 108,
+	NUMPAD_MINUS: 109,
+	NUMPAD_PERIOD: 110,
+	NUMPAD_DIVIDE: 111,
+	F1: 112,
+	F2: 113,
+	F3: 114,
+	F4: 115,
+	F5: 116,
+	F6: 117,
+	F7: 118,
+	F8: 119,
+	F9: 120,
+	F10: 121,
+	F11: 122,
+	F12: 123,
+	F13: 124,
+	F14: 125,
+	F15: 126,
+	NUM_LOCK: 144,
+	SCROLL_LOCK: 145,
+	UP_DPAD: 175,
+	DOWN_DPAD: 176,
+	LEFT_DPAD: 177,
+	RIGHT_DPAD: 178,
+	// virtual key mapping
+	copyKey: has("mac") && !has("air") ? (has("safari") ? 91 : 224 ) : 17
+};
+});
diff --git a/js/dojo-1.7.2/dojo/loadInit.js b/js/dojo-1.7.2/dojo/loadInit.js
new file mode 100644
index 0000000..dfdac57
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/loadInit.js
@@ -0,0 +1,8 @@
+//>>built
+define("dojo/loadInit", ["./_base/loader"], function(loader){
+	return {
+		dynamic:0,
+		normalize:function(id){return id;},
+		load:loader.loadInit
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/main.js b/js/dojo-1.7.2/dojo/main.js
new file mode 100644
index 0000000..a55e78f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/main.js
@@ -0,0 +1,51 @@
+//>>built
+define("dojo/main", [
+	"./_base/kernel",
+	"./has",
+	"require",
+	"./_base/sniff",
+	"./_base/lang",
+	"./_base/array",
+	"./ready",
+	"./_base/declare",
+	"./_base/connect",
+	"./_base/Deferred",
+	"./_base/json",
+	"./_base/Color",
+	"./has!dojo-firebug?./_firebug/firebug",
+	"./_base/browser",
+	"./_base/loader"], function(dojo, has, require, sniff, lang, array, ready){
+	// module:
+	//		dojo/main
+	// summary:
+	//		This is the package main module for the dojo package; it loads dojo base appropriate for the execution environment.
+
+	// the preferred way to load the dojo firebug console is by setting has("dojo-firebug") true in dojoConfig
+	// the isDebug config switch is for backcompat and will work fine in sync loading mode; it works in
+	// async mode too, but there's no guarantee when the module is loaded; therefore, if you need a firebug
+	// console guarnanteed at a particular spot in an app, either set config.has["dojo-firebug"] true before
+	// loading dojo.js or explicitly include dojo/_firebug/firebug in a dependency list.
+	if(dojo.config.isDebug){
+		require(["./_firebug/firebug"]);
+	}
+
+	// dojoConfig.require is deprecated; use the loader configuration property deps
+	true || has.add("dojo-config-require", 1);
+	if(1){
+		var deps= dojo.config.require;
+		if(deps){
+			// dojo.config.require may be dot notation
+			deps= array.map(lang.isArray(deps) ? deps : [deps], function(item){ return item.replace(/\./g, "/"); });
+			if(dojo.isAsync){
+				require(deps);
+			}else{
+				// this is a bit janky; in 1.6- dojo is defined before these requires are applied; but in 1.7+
+				// dojo isn't defined until returning from this module; this is only a problem in sync mode
+				// since we're in sync mode, we know we've got our loader with its priority ready queue
+				ready(1, function(){require(deps);});
+			}
+		}
+	}
+
+	return dojo;
+});
diff --git a/js/dojo-1.7.2/dojo/mouse.js b/js/dojo-1.7.2/dojo/mouse.js
new file mode 100644
index 0000000..2731eed
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/mouse.js
@@ -0,0 +1,128 @@
+//>>built
+define("dojo/mouse", ["./_base/kernel", "./on", "./has", "./dom", "./_base/window"], function(dojo, on, has, dom, win){
+
+	/*=====
+	dojo.mouse = {
+	// summary:
+	//		This module provide mouse event handling utility functions and exports
+	//		mouseenter and mouseleave event emulation.
+	// enter: Synthetic Event
+	//		This is an extension event for the mouseenter that IE provides, emulating the
+	//		behavior on other browsers.
+	// leave: Synthetic Event
+	//		This is an extension event for the mouseleave that IE provides, emulating the
+	//		behavior on other browsers.
+	// isLeft: Function
+	//		Test an event object (from a mousedown event) to see if the left button was pressed.
+	// isMiddle: Function
+	//		Test an event object (from a mousedown event) to see if the middle button was pressed.
+	// isRight: Function
+	//		Test an event object (from a mousedown event) to see if the right button was pressed.
+	// example:
+	//		To use these events, you register a mouseenter like this:
+	//		|	define(["dojo/on", dojo/mouse"], function(on, mouse){
+	//		|		on(targetNode, mouse.enter, function(event){
+	//		|			dojo.addClass(targetNode, "highlighted");
+	//		|		});
+	//		|		on(targetNode, mouse.leave, function(event){
+	//		|			dojo.removeClass(targetNode, "highlighted");
+	//		|		});
+	};
+	======*/
+
+    has.add("dom-quirks", win.doc && win.doc.compatMode == "BackCompat");
+ 	has.add("events-mouseenter", win.doc && "onmouseenter" in win.doc.createElement("div"));
+
+	var mouseButtons;
+	if(has("dom-quirks") || !has("dom-addeventlistener")){
+		mouseButtons = {
+			LEFT:   1,
+			MIDDLE: 4,
+			RIGHT:  2,
+			// helper functions
+			isButton: function(e, button){ return e.button & button; },
+			isLeft:   function(e){ return e.button & 1; },
+			isMiddle: function(e){ return e.button & 4; },
+			isRight:  function(e){ return e.button & 2; }
+		};
+	}else{
+		mouseButtons = {
+			LEFT:   0,
+			MIDDLE: 1,
+			RIGHT:  2,
+			// helper functions
+			isButton: function(e, button){ return e.button == button; },
+			isLeft:   function(e){ return e.button == 0; },
+			isMiddle: function(e){ return e.button == 1; },
+			isRight:  function(e){ return e.button == 2; }
+		};
+	}
+	dojo.mouseButtons = mouseButtons;
+
+/*=====
+	dojo.mouseButtons = {
+		// LEFT: Number
+		//		Numeric value of the left mouse button for the platform.
+		LEFT:   0,
+		// MIDDLE: Number
+		//		Numeric value of the middle mouse button for the platform.
+		MIDDLE: 1,
+		// RIGHT: Number
+		//		Numeric value of the right mouse button for the platform.
+		RIGHT:  2,
+
+		isButton: function(e, button){
+			// summary:
+			//		Checks an event object for a pressed button
+			// e: Event
+			//		Event object to examine
+			// button: Number
+			//		The button value (example: dojo.mouseButton.LEFT)
+			return e.button == button; // Boolean
+		},
+		isLeft: function(e){
+			// summary:
+			//		Checks an event object for the pressed left button
+			// e: Event
+			//		Event object to examine
+			return e.button == 0; // Boolean
+		},
+		isMiddle: function(e){
+			// summary:
+			//		Checks an event object for the pressed middle button
+			// e: Event
+			//		Event object to examine
+			return e.button == 1; // Boolean
+		},
+		isRight: function(e){
+			// summary:
+			//		Checks an event object for the pressed right button
+			// e: Event
+			//		Event object to examine
+			return e.button == 2; // Boolean
+		}
+	};
+=====*/
+
+	function eventHandler(type, mustBubble){
+		// emulation of mouseenter/leave with mouseover/out using descendant checking
+		var handler = function(node, listener){
+			return on(node, type, function(evt){
+				if(!dom.isDescendant(evt.relatedTarget, mustBubble ? evt.target : node)){
+					return listener.call(this, evt);
+				}
+			});
+		};
+		if(!mustBubble){
+			handler.bubble = eventHandler(type, true);
+		}
+		return handler;
+	}
+	return {
+		enter: eventHandler("mouseover"),
+		leave: eventHandler("mouseout"),
+		isLeft: mouseButtons.isLeft,
+		isMiddle: mouseButtons.isMiddle,
+		isRight: mouseButtons.isRight
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/nls/ar/colors.js b/js/dojo-1.7.2/dojo/nls/ar/colors.js
new file mode 100644
index 0000000..afa4097
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/ar/colors.js
@@ -0,0 +1,159 @@
+//>>built
+define(
+"dojo/nls/ar/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "أزرق �اتح",
+antiquewhite: "أبيض عتيق",
+aqua: "أزرق مائي",
+aquamarine: "أزرق مائل للأخضر (زبرجد)",
+azure: "أزرق سماوي",
+beige: "بيج",
+bisque: "أص�ر برتقالي الى رمادي مص�ر",
+black: "أسود",
+blanchedalmond: "أخضر مائل للبياض",
+blue: "أزرق",
+blueviolet: "أزرق-بن�سجي",
+brown: "بني",
+burlywood: "خشبي",
+cadetblue: "أزرق ملون بالرمادي",
+chartreuse: "أخضر مائل للص�رة",
+chocolate: "بني غامق",
+coral: "مرجاني",
+cornflowerblue: "أزرق عنبري",
+cornsilk: "حريري",
+crimson: "قرمزي",
+cyan: "أزرق سماوي",
+darkblue: "أزرق داكن",
+darkcyan: "أزرق سماوي داكن",
+darkgoldenrod: "أص�ر ذهبي داكن",
+darkgray: "رمادي داكن",
+darkgreen: "أخضر داكن",
+darkgrey: "رمادي داكن", // same as darkgray
+darkkhaki: "كاكي داكن",
+darkmagenta: "قرمزي داكن",
+darkolivegreen: "أخضر زيتوني داكن",
+darkorange: "برتقالي داكن",
+darkorchid: "أرجواني داكن",
+darkred: "أحمر داكن",
+darksalmon: "�ضي داكن",
+darkseagreen: "أخضر مائل للأزرق داكن",
+darkslateblue: "أزرق اردوازي داكن",
+darkslategray: "رمادي اردوازي داكن",
+darkslategrey: "رمادي اردوازي داكن", // same as darkslategray
+darkturquoise: "تركواز داكن",
+darkviolet: "بن�سجي داكن",
+deeppink: "أحمر وردي غامق",
+deepskyblue: "أزرق سماوي غامق",
+dimgray: "رمادي شاحب",
+dimgrey: "رمادي شاحب", // same as dimgray
+dodgerblue: "أزرق عنبري",
+firebrick: "أص�ر زاهي",
+floralwhite: "أبيض زهري",
+forestgreen: "أخضر بلون أشجار الغابات",
+fuchsia: "�وشيا",
+gainsboro: "رمادي مائل للأزرق �اتح",
+ghostwhite: "أبيض ش�ا�",
+gold: "ذهبي",
+goldenrod: "أص�ر ذهبي",
+gray: "رمادي",
+green: "أخضر",
+greenyellow: "أخضر مائل للأص�ر",
+grey: "رمادي", // same as gray
+honeydew: "أبيض مائل للأخضر",
+hotpink: "أحمر وردي زاهي",
+indianred: "أحمر هندي",
+indigo: "نيلي",
+ivory: "عاجي",
+khaki: "كاكي",
+lavender: "أرجواني شاحب",
+lavenderblush: "أحمر أرجواني",
+lawngreen: "أخضر بلون العشب",
+lemonchiffon: "أص�ر ش�ا�",
+lightblue: "أزرق �اتح",
+lightcoral: "مرجاني �اتح",
+lightcyan: "سماوي �اتح",
+lightgoldenrodyellow: "أص�ر ذهبي �اتح",
+lightgray: "رمادي �اتح",
+lightgreen: "أخضر �اتح",
+lightgrey: "رمادي �اتح", // same as lightgray
+lightpink: "وردي �اتح",
+lightsalmon: "�ضي �اتح",
+lightseagreen: "أخضر مائل للأزرق �اتح",
+lightskyblue: "أزرق سماوي �اتح",
+lightslategray: "رمادي اردوازي �اتح",
+lightslategrey: "رمادي اردوازي �اتح", // same as lightslategray
+lightsteelblue: "أزرق معدني �اتح",
+lightyellow: "أص�ر �اتح",
+lime: "ليموني",
+limegreen: "أخضر ليموني",
+linen: "كتاني",
+magenta: "أحمر قرمزي",
+maroon: "أحمر داكن",
+mediumaquamarine: "أزرق مائل للأخضر (زبرجد) متوسط",
+mediumblue: "أزرق متوسط",
+mediumorchid: "أرجواني متوسط",
+mediumpurple: "قرمزي متوسط",
+mediumseagreen: "أخضر مائل للأزرق متوسط",
+mediumslateblue: "أزرق اردوازي متوسط",
+mediumspringgreen: "أخضر ربيعي متوسط",
+mediumturquoise: "تركواز متوسط",
+mediumvioletred: "أحمر-بن�سجي متوسط",
+midnightblue: "أزرق بحري",
+mintcream: "أص�ر شاحب مائل للأخضر الزرعي",
+mistyrose: "وردي",
+moccasin: "نحاسي أحمر",
+navajowhite: "أبيض ملاحي",
+navy: "أزرق داكن",
+oldlace: "برتقالي مائل للأص�ر شاحب",
+olive: "أخضر زيتوني داكن",
+olivedrab: "أسود �اتح",
+orange: "برتقالي",
+orangered: "أحمر مائل للبرتقالي",
+orchid: "أرجواني �اتح",
+palegoldenrod: "أص�ر ذهبي شاحب",
+palegreen: "أخضر شاحب",
+paleturquoise: "تركواز شاحب",
+palevioletred: "أحمر-بن�سجي شاحب",
+papayawhip: "خوخي �اتح",
+peachpuff: "خوخي مائل للأص�ر",
+peru: "بني جملي",
+pink: "وردي",
+plum: "أرجواني داكن",
+powderblue: "أزرق مائل للأص�ر",
+purple: "ارجواني",
+red: "أحمر",
+rosybrown: "بني وردي",
+royalblue: "أزرق ملكي",
+saddlebrown: "بني �اتح",
+salmon: "برتقالي وردي شاحب",
+sandybrown: "بني مائل للص�رة",
+seagreen: "أخضر مائل للأزرق",
+seashell: "أبيض مائل للأص�ر �اتح",
+sienna: "بني محروق",
+silver: "�ضي",
+skyblue: "أزرق سماوي",
+slateblue: "أزرق اردوازي",
+slategray: "رمادي اردوازي",
+slategrey: "رمادي اردوازي", // same as slategray
+snow: "أبيض ثلجي",
+springgreen: "أخضر ربيعي",
+steelblue: "أزرق معدني",
+tan: "خمري",
+teal: "بترولي",
+thistle: "ارجواني شاحب",
+tomato: "أحمر مائل للأص�ر",
+turquoise: "تركواز",
+violet: "بن�سجي",
+wheat: "أخضر قمحي",
+white: "أبيض",
+whitesmoke: "دخان أبيض",
+yellow: "أص�ر",
+yellowgreen: "أخضر مائل للأص�ر"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/az/colors.js b/js/dojo-1.7.2/dojo/nls/az/colors.js
new file mode 100644
index 0000000..0fd0628
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/az/colors.js
@@ -0,0 +1,154 @@
+//>>built
+define(
+"dojo/nls/az/colors", //begin v1.x content
+({
+	"lightsteelblue":"açıq metal mavi",
+	"orangered" :"narıncı qırmızı",
+	"midnightblue" :"gecÉ™ mavisi",
+	"cadetblue" :"dəniz mavisi" ,
+	"seashell" :"dəniz səthi",
+	"slategrey" :"boz şifer rəngi",
+	"coral" :"mərcan",
+	"darkturquoise" :"tünd firuzəyi",
+	"antiquewhite" :"antik aÄŸ",
+	"mediumspringgreen" :"orta bahar yaşılı",
+	"salmon" :"somon",
+	"darkgrey" :"tünd boz",
+	"ivory" :"fil diÅŸi",
+	"greenyellow" :"yaşıl-sarı",
+	"mistyrose" :"gül qurusu",
+	"lightsalmon" :"açıq somon",
+	"silver" :"gümüşü",
+	"dimgrey" :"açıq boz",
+	"orange" :"narıncı",
+	"white" :"aÄŸ",
+	"navajowhite" :"navajo ağı",
+	"royalblue" :"parlaq tünd mavi" ,
+	"deeppink" :"tünd çəhrayı",
+	"lime" :"lomon yaşılı",
+	"oldlace" :"köhnə krujeva",
+	"chartreuse" :"chartreuse",
+	"darkcyan" :"tünd firuzəyi",
+	"yellow" :"sarı",
+	"linen" :"kətan",
+	"olive" :"zeytun",
+	"gold" :"qızıl",
+	"lawngreen" :"çəmən yaşılı",
+	"lightyellow" :"açıq sarı",
+	"tan" :"günəş yanığı",
+	"darkviolet" :"tünd bənövşəyi",
+	"lightslategrey" :"tünd şifer bozu",
+	"grey" :"boz",
+	"darkkhaki" :"tünd haki",
+	"green" :"yaşıl",
+	"deepskyblue" :"tünd səma mavisi",
+	"aqua" :"dəniz mavisi",
+	"sienna" :"tünd qəhvəyi",
+	"mintcream" :"nanəli krem",
+	"rosybrown" :"çəhrayımsı qəhvəyi",
+	"mediumslateblue" :"orta şıfer bozu",
+	"magenta" :"magenta",
+	"lightseagreen" :"açıq dəniz yaşılı",
+	"cyan" :"firuzəyi",
+	"olivedrab" :"əsgər yaşılı",
+	"darkgoldenrod" :"tünd sarı",
+	"slateblue" :"ÅŸifer mavisi",
+	"mediumaquamarine" :"orta akvamarin",
+	"lavender" :"lavanta",
+	"mediumseagreen" :"orta dəniz yaşılı",
+	"maroon" :"tünd qırmızı",
+	"darkslategray" :"tünd şifer bozu",
+	"mediumturquoise" :"orta firuzəyi",
+	"ghostwhite" :"ala",
+	"darkblue" :"tünd mavi",
+	"mediumvioletred" :"orta bənövşəyi-qırmızı",
+	"brown" :"qəhvəyi",
+	"lightgray" :"açıq boz",
+	"sandybrown" :"qum rəngi",
+	"pink" :"çəhrayı",
+	"firebrick" :"yanmış kərpic rəngi",
+	"indigo" :"indigo",
+	"snow" :"qar",
+	"darkorchid" :"tünd orkide",
+	"turquoise" :"firuzəyi",
+	"chocolate" :"ÅŸokolad",
+	"springgreen" :"bahar yaşılı",
+	"moccasin" :"mokosen",
+	"navy" :"tünd göy",
+	"lemonchiffon" :"limon rəngi",
+	"teal" :"teal mavi",
+	"floralwhite" :"çiçək ağı",
+	"cornflowerblue" :"peyğəmbər çiçək mavisi",
+	"paleturquoise" :"solğun firuzəyi",
+	"purple" :"tünd qırmızı",
+	"gainsboro" :"gainsboro",
+	"plum" :"gavalı",
+	"red" :"qırmızı",
+	"blue" :"göy",
+	"forestgreen" :"tünd dəniz yaşılı",
+	"darkgreen" :"tünd yaşıl",
+	"honeydew" :"bal saqqızı",
+	"darkseagreen" :"tünd dəniz yaşılı",
+	"lightcoral" :"açıq mərcan",
+	"palevioletred" :"solğun bənövşəyi-qırmızı",
+	"mediumpurple" :"orta tünd qırmızı",
+	"saddlebrown" :"açıq qəhvəyi",
+	"darkmagenta" :"tünd magenta",
+	"thistle" :"dəvə tikanı",
+	"whitesmoke" :"aÄŸ duman",
+	"wheat" :"buğdayı",
+	"violet" :"bənövşəyi",
+	"lightskyblue" :"açıq səma mavisi" ,
+	"goldenrod" :"sapsarı",
+	"mediumblue" :"orta göy",
+	"skyblue" :"göy mavisi",
+	"crimson" :"crimson",
+	"darksalmon" :"tünd somon",
+	"darkred" :"tünd qırmızı",
+	"darkslategrey" :"tünd şifer bozu",
+	"peru" :"peru",
+	"lightgrey" :"açıq boz",
+	"lightgoldenrodyellow" :"açıq qızılı",
+	"blanchedalmond" :"solğun badamı",
+	"aliceblue" :"alice mavisi",
+	"bisque" :"biskvit",
+	"slategray" :"ÅŸifer bozu",
+	"palegoldenrod" :"açıq qızılı",
+	"darkorange" :"tünd narıncı",
+	"aquamarine" :"akvamarin",
+	"lightgreen" :"açıq yaşıl",
+	"burlywood" :"sarımsı qəhvə rəngi",
+	"dodgerblue" :"toz mavisi",
+	"darkgray" :"tünd boz",
+	"lightcyan" :"açıq firuzəyi",
+	"powderblue" :"pudra mavisi",
+	"blueviolet" :"mavi-bənövşəyi",
+	"orchid" :"orkide",
+	"dimgray" :"solÄŸun boz",
+	"beige" :"bej",
+	"fuchsia" :"fuÅŸya",
+	"lavenderblush" :"lavanta tünd qırmızısı",
+	"hotpink" :"tünd çəhrayı",
+	"steelblue" :"metal mavisi",
+	"tomato" :"pomidor",
+	"lightpink" :"açıq çəhrayı",
+	"limegreen" :"əhəng yaşılı",
+	"indianred" :"qızıldərili qırmızısı",
+	"papayawhip" :"papaya qamçısı",
+	"lightslategray" :"açıq şifer bozu",
+	"gray" :"boz",
+	"mediumorchid" :"orta orkide",
+	"cornsilk" :"qarğıdalı rəngi",
+	"black" :"qara",
+	"seagreen" :"dəniz yaşılı",
+	"darkslateblue" :"tünd şifer bozu",
+	"khaki" :"haki",
+	"lightblue" :"açıq mavi",
+	"palegreen" :"solğun yaşıl",
+	"azure" :"azur mavisi",
+	"peachpuff" :"açıq şaftalı",
+	"darkolivegreen" :"tünd zeytun yaşılı",
+	"yellowgreen" :"sarı-yaşıl"
+})
+//end v1.x content
+);
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/nls/ca/colors.js b/js/dojo-1.7.2/dojo/nls/ca/colors.js
new file mode 100644
index 0000000..d961327
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/ca/colors.js
@@ -0,0 +1,161 @@
+//>>built
+define(
+"dojo/nls/ca/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "blau cian clar",
+antiquewhite: "blanc antic",
+aqua: "aigua",
+aquamarine: "aiguamarina",
+azure: "atzur",
+beige: "beix",
+bisque: "crema",
+black: "negre",
+blanchedalmond: "ametlla pàl·lid",
+blue: "blau",
+blueviolet: "blau violeta",
+brown: "marró",
+burlywood: "marró arenós",
+cadetblue: "blau marí",
+chartreuse: "Llimona pàl·lid",
+chocolate: "xocolata",
+coral: "corall",
+cornflowerblue: "blau blauet",
+cornsilk: "cru",
+crimson: "carmesí",
+cyan: "cian",
+darkblue: "blau fosc",
+darkcyan: "cian fosc",
+darkgoldenrod: "ocre fosc",
+darkgray: "gris fosc",
+darkgreen: "verd fosc",
+darkgrey: "gris fosc", // same as darkgray
+darkkhaki: "caqui fosc",
+darkmagenta: "magenta fosc",
+darkolivegreen: "verd oliva fosc",
+darkorange: "taronja fosc",
+darkorchid: "orquídia fosc",
+darkred: "vermell fosc",
+darksalmon: "salmó fosc",
+darkseagreen: "verd marí fosc",
+darkslateblue: "blau pissarra fosc",
+darkslategray: "gris pissarra fosc",
+darkslategrey: "gris pissarra fosc", // same as darkslategray
+darkturquoise: "turquesa fosc",
+darkviolet: "violeta fosc",
+deeppink: "rosa profund",
+deepskyblue: "blau cel profund",
+dimgray: "gris fosc",
+dimgrey: "gris fosc", // same as dimgray
+dodgerblue: "blau Dodger",
+firebrick: "maó refractari",
+floralwhite: "blanc floral",
+forestgreen: "verd bosc",
+fuchsia: "fúcsia",
+gainsboro: "gainsboro",
+ghostwhite: "blanc fantasma",
+gold: "daurat",
+goldenrod: "ocre",
+gray: "gris",
+green: "verd",
+greenyellow: "verd grogós",
+grey: "gris", // same as gray
+honeydew: "rosada de mel",
+hotpink: "rosa fúcsia",
+indianred: "vermell indi",
+indigo: "índigo",
+ivory: "marbre",
+khaki: "caqui",
+lavender: "lavanda",
+lavenderblush: "lavanda vermellosa",
+lawngreen: "verd gespa",
+lemonchiffon: "groc brisa",
+lightblue: "blau clar",
+lightcoral: "corall clar",
+lightcyan: "cian clar",
+lightgoldenrodyellow: "groc ocre clar",
+lightgray: "gris clar",
+lightgreen: "verd clar",
+lightgrey: "gris clar", // same as lightgray
+lightpink: "rosa clar",
+lightsalmon: "salmó clar",
+lightseagreen: "verd marí clar",
+lightskyblue: "blau cel clar",
+lightslategray: "gris pissarra clar",
+lightslategrey: "gris pissarra clar", // same as lightslategray
+lightsteelblue: "blau acer clar",
+lightyellow: "groc clar",
+lime: "verd llimona",
+limegreen: "verd llimona verda",
+linen: "lli",
+magenta: "magenta",
+maroon: "marró vermellós",
+mediumaquamarine: "aiguamarina mitjana",
+mediumblue: "blau mitjà",
+mediumorchid: "orquídia mitjana",
+mediumpurple: "porpra mitjana",
+mediumseagreen: "verd marí mitjà",
+mediumslateblue: "blau pissarra mitjà",
+mediumspringgreen: "verd primavera mitjà",
+mediumturquoise: "turquesa mitjana",
+mediumvioletred: "vermell violeta mitjà",
+midnightblue: "blau mitjanit",
+mintcream: "menta pàl·lid",
+mistyrose: "rosa dens",
+moccasin: "mocassí",
+navajowhite: "blanc Navajo",
+navy: "blau marí",
+oldlace: "rosa cremós",
+olive: "oliva",
+olivedrab: "gris oliva",
+orange: "taronja",
+orangered: "taronja vermellós",
+orchid: "orquídia",
+palegoldenrod: "ocre pàl·lid",
+palegreen: "verd pàl·lid",
+paleturquoise: "turquesa pàl·lid",
+palevioletred: "vermell porpra pàl·lid",
+papayawhip: "préssec pastel",
+peachpuff: "préssec",
+peru: "Perú",
+pink: "rosa",
+plum: "pruna",
+powderblue: "blau grisós",
+purple: "porpra",
+red: "vermell",
+rosybrown: "marró rosat",
+royalblue: "blau marí intens",
+saddlebrown: "marró mitjà",
+salmon: "salmó",
+sandybrown: "marró arenós",
+seagreen: "verd marí",
+seashell: "petxina marina",
+sienna: "siena",
+silver: "argent",
+skyblue: "blau cel",
+slateblue: "blau pissarra",
+slategray: "gris pissarra",
+slategrey: "gris pissarra", // same as slategray
+snow: "neu",
+springgreen: "verd de primavera",
+steelblue: "blau acer",
+tan: "tan",
+teal: "verd blavós",
+thistle: "card",
+tomato: "tomàquet",
+transparent: "transparent",
+turquoise: "turquesa",
+violet: "violeta",
+wheat: "blat",
+white: "blanc",
+whitesmoke: "blanc fumat",
+yellow: "groc",
+yellowgreen: "verd grogós"
+})
+
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/colors.js b/js/dojo-1.7.2/dojo/nls/colors.js
new file mode 100644
index 0000000..b700278
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/colors.js
@@ -0,0 +1,192 @@
+//>>built
+define("dojo/nls/colors", { root:
+//begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "alice blue",
+antiquewhite: "antique white",
+aqua: "aqua",
+aquamarine: "aquamarine",
+azure: "azure",
+beige: "beige",
+bisque: "bisque",
+black: "black",
+blanchedalmond: "blanched almond",
+blue: "blue",
+blueviolet: "blue-violet",
+brown: "brown",
+burlywood: "burlywood",
+cadetblue: "cadet blue",
+chartreuse: "chartreuse",
+chocolate: "chocolate",
+coral: "coral",
+cornflowerblue: "cornflower blue",
+cornsilk: "cornsilk",
+crimson: "crimson",
+cyan: "cyan",
+darkblue: "dark blue",
+darkcyan: "dark cyan",
+darkgoldenrod: "dark goldenrod",
+darkgray: "dark gray",
+darkgreen: "dark green",
+darkgrey: "dark gray", // same as darkgray
+darkkhaki: "dark khaki",
+darkmagenta: "dark magenta",
+darkolivegreen: "dark olive green",
+darkorange: "dark orange",
+darkorchid: "dark orchid",
+darkred: "dark red",
+darksalmon: "dark salmon",
+darkseagreen: "dark sea green",
+darkslateblue: "dark slate blue",
+darkslategray: "dark slate gray",
+darkslategrey: "dark slate gray", // same as darkslategray
+darkturquoise: "dark turquoise",
+darkviolet: "dark violet",
+deeppink: "deep pink",
+deepskyblue: "deep sky blue",
+dimgray: "dim gray",
+dimgrey: "dim gray", // same as dimgray
+dodgerblue: "dodger blue",
+firebrick: "fire brick",
+floralwhite: "floral white",
+forestgreen: "forest green",
+fuchsia: "fuchsia",
+gainsboro: "gainsboro",
+ghostwhite: "ghost white",
+gold: "gold",
+goldenrod: "goldenrod",
+gray: "gray",
+green: "green",
+greenyellow: "green-yellow",
+grey: "gray", // same as gray
+honeydew: "honeydew",
+hotpink: "hot pink",
+indianred: "indian red",
+indigo: "indigo",
+ivory: "ivory",
+khaki: "khaki",
+lavender: "lavender",
+lavenderblush: "lavender blush",
+lawngreen: "lawn green",
+lemonchiffon: "lemon chiffon",
+lightblue: "light blue",
+lightcoral: "light coral",
+lightcyan: "light cyan",
+lightgoldenrodyellow: "light goldenrod yellow",
+lightgray: "light gray",
+lightgreen: "light green",
+lightgrey: "light gray", // same as lightgray
+lightpink: "light pink",
+lightsalmon: "light salmon",
+lightseagreen: "light sea green",
+lightskyblue: "light sky blue",
+lightslategray: "light slate gray",
+lightslategrey: "light slate gray", // same as lightslategray
+lightsteelblue: "light steel blue",
+lightyellow: "light yellow",
+lime: "lime",
+limegreen: "lime green",
+linen: "linen",
+magenta: "magenta",
+maroon: "maroon",
+mediumaquamarine: "medium aquamarine",
+mediumblue: "medium blue",
+mediumorchid: "medium orchid",
+mediumpurple: "medium purple",
+mediumseagreen: "medium sea green",
+mediumslateblue: "medium slate blue",
+mediumspringgreen: "medium spring green",
+mediumturquoise: "medium turquoise",
+mediumvioletred: "medium violet-red",
+midnightblue: "midnight blue",
+mintcream: "mint cream",
+mistyrose: "misty rose",
+moccasin: "moccasin",
+navajowhite: "navajo white",
+navy: "navy",
+oldlace: "old lace",
+olive: "olive",
+olivedrab: "olive drab",
+orange: "orange",
+orangered: "orange red",
+orchid: "orchid",
+palegoldenrod: "pale goldenrod",
+palegreen: "pale green",
+paleturquoise: "pale turquoise",
+palevioletred: "pale violet-red",
+papayawhip: "papaya whip",
+peachpuff: "peach puff",
+peru: "peru",
+pink: "pink",
+plum: "plum",
+powderblue: "powder blue",
+purple: "purple",
+red: "red",
+rosybrown: "rosy brown",
+royalblue: "royal blue",
+saddlebrown: "saddle brown",
+salmon: "salmon",
+sandybrown: "sandy brown",
+seagreen: "sea green",
+seashell: "seashell",
+sienna: "sienna",
+silver: "silver",
+skyblue: "sky blue",
+slateblue: "slate blue",
+slategray: "slate gray",
+slategrey: "slate gray", // same as slategray
+snow: "snow",
+springgreen: "spring green",
+steelblue: "steel blue",
+tan: "tan",
+teal: "teal",
+thistle: "thistle",
+tomato: "tomato",
+transparent: "transparent",
+turquoise: "turquoise",
+violet: "violet",
+wheat: "wheat",
+white: "white",
+whitesmoke: "white smoke",
+yellow: "yellow",
+yellowgreen: "yellow green"
+})
+//end v1.x content
+,
+"zh": true,
+"zh-tw": true,
+"tr": true,
+"th": true,
+"sv": true,
+"sl": true,
+"sk": true,
+"ru": true,
+"ro": true,
+"pt": true,
+"pt-pt": true,
+"pl": true,
+"nl": true,
+"nb": true,
+"ko": true,
+"kk": true,
+"ja": true,
+"it": true,
+"hu": true,
+"hr": true,
+"he": true,
+"fr": true,
+"fi": true,
+"es": true,
+"el": true,
+"de": true,
+"da": true,
+"cs": true,
+"ca": true,
+"az": true,
+"ar": true
+});
diff --git a/js/dojo-1.7.2/dojo/nls/cs/colors.js b/js/dojo-1.7.2/dojo/nls/cs/colors.js
new file mode 100644
index 0000000..d4da395
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/cs/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/cs/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "modravá",
+antiquewhite: "krémově bílá",
+aqua: "azurová",
+aquamarine: "akvamarínová",
+azure: "bledě azurová",
+beige: "bledě béžová",
+bisque: "bledě oranžová",
+black: "�erná",
+blanchedalmond: "mandlová",
+blue: "modrá",
+blueviolet: "modrofialová",
+brown: "�ervenohnědá",
+burlywood: "krémová",
+cadetblue: "šedomodrá",
+chartreuse: "chartreuska",
+chocolate: "hnědobéžová",
+coral: "korálová �ervená",
+cornflowerblue: "chrpově modrá",
+cornsilk: "režná",
+crimson: "karmínová",
+cyan: "azurová",
+darkblue: "tmavě modrá",
+darkcyan: "tmavě azurová",
+darkgoldenrod: "tmavě béžová",
+darkgray: "tmavě šedá",
+darkgreen: "tmavě zelená",
+darkgrey: "tmavě šedá", // same as darkgray
+darkkhaki: "pískově hnědá",
+darkmagenta: "tmavě purpurová",
+darkolivegreen: "tmavě olivová",
+darkorange: "tmavě oranžová",
+darkorchid: "tmavě orchidejová",
+darkred: "tmavě �ervená",
+darksalmon: "tmavě lososová",
+darkseagreen: "tmavá mořská zelená",
+darkslateblue: "tmavá břidlicová modrá",
+darkslategray: "tmavá břidlicová šedá",
+darkslategrey: "tmavá břidlicová šedá", // same as darkslategray
+darkturquoise: "tmavě tyrkysová",
+darkviolet: "tmavě fialová",
+deeppink: "sytě růžová",
+deepskyblue: "sytá nebeská modrá",
+dimgray: "kouřově šedá",
+dimgrey: "kouřově šedá", // same as dimgray
+dodgerblue: "jasně modrá",
+firebrick: "cihlová",
+floralwhite: "květinově bílá",
+forestgreen: "lesní zelená",
+fuchsia: "fuchsiová",
+gainsboro: "bledě šedá",
+ghostwhite: "modravě bílá",
+gold: "zlatá",
+goldenrod: "béžová",
+gray: "šedá",
+green: "zelená",
+greenyellow: "zelenožlutá",
+grey: "šedá", // same as gray
+honeydew: "nazelenalá",
+hotpink: "jasně růžová",
+indianred: "indiánská �ervená",
+indigo: "indigově modrá",
+ivory: "slonovinová",
+khaki: "písková",
+lavender: "levandulová",
+lavenderblush: "levandulová růžová",
+lawngreen: "jasně zelená",
+lemonchiffon: "světle citrónová",
+lightblue: "světle modrá",
+lightcoral: "světle korálová",
+lightcyan: "světle azurová",
+lightgoldenrodyellow: "světle žlutá",
+lightgray: "světle šedá",
+lightgreen: "světle zelená",
+lightgrey: "světle šedá", // same as lightgray
+lightpink: "světle růžová",
+lightsalmon: "světle lososová",
+lightseagreen: "světlá mořská zelená",
+lightskyblue: "světlá nebeská modrá",
+lightslategray: "světlá břidlicová šedá",
+lightslategrey: "světlá břidlicová šedá", // same as lightslategray
+lightsteelblue: "světlá ocelová modrá",
+lightyellow: "bledě žlutá",
+lime: "limetková",
+limegreen: "limetkově zelená",
+linen: "bledě šedobéžová",
+magenta: "purpurová",
+maroon: "kaštanová",
+mediumaquamarine: "střední akvamarínová",
+mediumblue: "středně modrá",
+mediumorchid: "středně orchidejová",
+mediumpurple: "středně nachová",
+mediumseagreen: "střední mořská zelená",
+mediumslateblue: "střední břidlicová modrá",
+mediumspringgreen: "střední jarní zelená",
+mediumturquoise: "středně tyrkysová",
+mediumvioletred: "středně fialovo�ervená",
+midnightblue: "temně modrá",
+mintcream: "mentolová",
+mistyrose: "růžovobílá",
+moccasin: "bledě krémová",
+navajowhite: "světle krémová",
+navy: "námořnická modrá",
+oldlace: "světle béžová",
+olive: "olivová",
+olivedrab: "khaki",
+orange: "oranžová",
+orangered: "oranžovo�ervená",
+orchid: "orchidejová",
+palegoldenrod: "bledě písková",
+palegreen: "bledě zelená",
+paleturquoise: "bledě tyrkysová",
+palevioletred: "bledě fialovo�ervená",
+papayawhip: "papájová",
+peachpuff: "broskvová",
+peru: "karamelová",
+pink: "růžová",
+plum: "švestková",
+powderblue: "bledě modrá",
+purple: "nachová",
+red: "�ervená",
+rosybrown: "růžovohnědá",
+royalblue: "královská modrá",
+saddlebrown: "hnědá",
+salmon: "lososová",
+sandybrown: "oranžovohnědá",
+seagreen: "mořská zelená",
+seashell: "lasturová",
+sienna: "siena",
+silver: "stříbrná",
+skyblue: "nebeská modrá",
+slateblue: "břidlicová modrá",
+slategray: "břidlicová šedá",
+slategrey: "břidlicová šedá", // same as slategray
+snow: "sněhobílá",
+springgreen: "jarní zelená",
+steelblue: "ocelová modrá",
+tan: "šedobéžová",
+teal: "šedozelená",
+thistle: "bodláková",
+tomato: "tomatová",
+transparent: "průhledná",
+turquoise: "tyrkysová",
+violet: "fialová",
+wheat: "zlatohnědá",
+white: "bílá",
+whitesmoke: "kouřově bílá",
+yellow: "žlutá",
+yellowgreen: "žlutozelená"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/da/colors.js b/js/dojo-1.7.2/dojo/nls/da/colors.js
new file mode 100644
index 0000000..71aa646
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/da/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/da/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "babyblå",
+antiquewhite: "antikhvid",
+aqua: "akvablå",
+aquamarine: "akvamarin",
+azure: "azurblå",
+beige: "beige",
+bisque: "gulgrå",
+black: "sort",
+blanchedalmond: "blanceret mandel",
+blue: "blå",
+blueviolet: "blåviolet",
+brown: "brun",
+burlywood: "tobak",
+cadetblue: "kadetblå",
+chartreuse: "chartreuse",
+chocolate: "rust",
+coral: "koralrød",
+cornflowerblue: "kornblomstblå",
+cornsilk: "majs",
+crimson: "blodrød",
+cyan: "cyan",
+darkblue: "mørkeblå",
+darkcyan: "mørk cyan",
+darkgoldenrod: "mørk gyldenris",
+darkgray: "mørkegrå",
+darkgreen: "mørkegrøn",
+darkgrey: "mørkegrå", // same as darkgray
+darkkhaki: "mørk khaki",
+darkmagenta: "mørk magenta",
+darkolivegreen: "mørk olivengrøn",
+darkorange: "mørk orange",
+darkorchid: "mørk orkide",
+darkred: "mørkerød",
+darksalmon: "mørk laksefarvet",
+darkseagreen: "mørk havgrøn",
+darkslateblue: "mørk skiferblå",
+darkslategray: "mørk skifergrå",
+darkslategrey: "mørk skifergrå", // same as darkslategray
+darkturquoise: "mørk turkis",
+darkviolet: "mørkelilla",
+deeppink: "dyb pink",
+deepskyblue: "dyb himmelblå",
+dimgray: "svag grå",
+dimgrey: "svag grå", // same as dimgray
+dodgerblue: "dodgerblå",
+firebrick: "chamottesten",
+floralwhite: "blomsterhvid",
+forestgreen: "skovgrøn",
+fuchsia: "lyslilla",
+gainsboro: "gainsboro",
+ghostwhite: "spøgelseshvid",
+gold: "guld",
+goldenrod: "gyldenris",
+gray: "grå",
+green: "grøn",
+greenyellow: "grøngul",
+grey: "grå", // same as gray
+honeydew: "honningdug",
+hotpink: "mørk rosa",
+indianred: "lys rødbrun",
+indigo: "indigo",
+ivory: "elfenben",
+khaki: "khaki",
+lavender: "lysviolet",
+lavenderblush: "lavendelrød",
+lawngreen: "græsgrøn",
+lemonchiffon: "citronfromage",
+lightblue: "lyseblå",
+lightcoral: "lys koralrød",
+lightcyan: "lys cyan",
+lightgoldenrodyellow: "lys gyldenrisgul",
+lightgray: "lysegrå",
+lightgreen: "lysegrøn",
+lightgrey: "lysegrå", // same as lightgray
+lightpink: "lys pink",
+lightsalmon: "lys laksefarvet",
+lightseagreen: "lys havgrøn",
+lightskyblue: "lys himmelblå",
+lightslategray: "lys skifergrå",
+lightslategrey: "lys skifergrå", // same as lightslategray
+lightsteelblue: "lys stålblå",
+lightyellow: "lysegul",
+lime: "lime",
+limegreen: "limegrøn",
+linen: "lærred",
+magenta: "magenta",
+maroon: "rødbrun",
+mediumaquamarine: "mellem akvamarin",
+mediumblue: "mellemblå",
+mediumorchid: "mellem orkide",
+mediumpurple: "mellemlilla",
+mediumseagreen: "mellemhavgrøn",
+mediumslateblue: "mellemskiferblå",
+mediumspringgreen: "mellemforårsgrøn",
+mediumturquoise: "mellemturkis",
+mediumvioletred: "mellemviolet",
+midnightblue: "midnatsblå",
+mintcream: "pebermyntecreme",
+mistyrose: "blegrosa",
+moccasin: "fruesko",
+navajowhite: "navajo-hvid",
+navy: "marineblå",
+oldlace: "kniplingshvid",
+olive: "olivengrøn",
+olivedrab: "brungrøn",
+orange: "orange",
+orangered: "orangerød",
+orchid: "orkide",
+palegoldenrod: "bleg gyldenris",
+palegreen: "bleggrøn",
+paleturquoise: "bleg turkis",
+palevioletred: "blegviolet",
+papayawhip: "papaya",
+peachpuff: "fersken",
+peru: "peru",
+pink: "pink",
+plum: "blomme",
+powderblue: "pudderblå",
+purple: "lilla",
+red: "rød",
+rosybrown: "rosabrun",
+royalblue: "kongeblå",
+saddlebrown: "saddelbrun",
+salmon: "laksefarvet",
+sandybrown: "sandbrun",
+seagreen: "havgrøn",
+seashell: "muslingeskal",
+sienna: "sienna",
+silver: "sølv",
+skyblue: "himmelblå",
+slateblue: "skiferblå",
+slategray: "skifergrå",
+slategrey: "skifergrå", // same as slategray
+snow: "sne",
+springgreen: "forårsgrøn",
+steelblue: "metalblå",
+tan: "tan",
+teal: "blågrøn",
+thistle: "tidsel",
+tomato: "tomat",
+transparent: "transparent",
+turquoise: "turkis",
+violet: "lilla",
+wheat: "korngul",
+white: "hvid",
+whitesmoke: "hvid røg",
+yellow: "gul",
+yellowgreen: "gulgrøn"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/de/colors.js b/js/dojo-1.7.2/dojo/nls/de/colors.js
new file mode 100644
index 0000000..9ae35f8
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/de/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/de/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "Alice-blau",
+antiquewhite: "Antikweiß",
+aqua: "Wasserblau",
+aquamarine: "Aquamarin",
+azure: "Azur",
+beige: "Beige",
+bisque: "Bisquit",
+black: "Schwarz",
+blanchedalmond: "Mandelweiß",
+blue: "Blau",
+blueviolet: "Blauviolett",
+brown: "Braun",
+burlywood: "Burlywood",
+cadetblue: "Kadettenblau",
+chartreuse: "Helles Gelbgrün",
+chocolate: "Schokoladenbraun",
+coral: "Koralle",
+cornflowerblue: "Kornblumenblau",
+cornsilk: "Kornseide",
+crimson: "Karmesinrot",
+cyan: "Zyan",
+darkblue: "Dunkelblau",
+darkcyan: "Dunkelzyan",
+darkgoldenrod: "Dunkelgoldgelb",
+darkgray: "Dunkelgrau",
+darkgreen: "Dunkelgrün",
+darkgrey: "Dunkelgrau", // same as darkgray
+darkkhaki: "Dunkelkhaki",
+darkmagenta: "Dunkelmagenta",
+darkolivegreen: "Dunkelolivgrün",
+darkorange: "Dunkelorange",
+darkorchid: "Dunkelorchidee",
+darkred: "Dunkelrot",
+darksalmon: "Dunkellachs",
+darkseagreen: "Dunkles Meergrün",
+darkslateblue: "Dunkelschieferblau",
+darkslategray: "Dunkelschiefergrau",
+darkslategrey: "Dunkelschiefergrau", // same as darkslategray
+darkturquoise: "Dunkeltürkis",
+darkviolet: "Dunkelviolett",
+deeppink: "Tiefrosa",
+deepskyblue: "Dunkles Himmelblau",
+dimgray: "Blassgrau",
+dimgrey: "Blassgrau", // same as dimgray
+dodgerblue: "Dodger-blau",
+firebrick: "Schamottestein",
+floralwhite: "Blütenweiß",
+forestgreen: "Forstgrün",
+fuchsia: "Fuchsia",
+gainsboro: "Gainsboro",
+ghostwhite: "Geisterweiß",
+gold: "Gold",
+goldenrod: "Goldgelb",
+gray: "Grau",
+green: "Grün",
+greenyellow: "Grüngelb",
+grey: "Grau", // same as gray
+honeydew: "Honigtau",
+hotpink: "Knallrosa",
+indianred: "Indischrot",
+indigo: "Indigoblau",
+ivory: "Elfenbein",
+khaki: "Khaki",
+lavender: "Lavendelblau",
+lavenderblush: "Lavendelhauch",
+lawngreen: "Grasgrün",
+lemonchiffon: "Zitronenchiffon",
+lightblue: "Hellblau",
+lightcoral: "Hellkoralle",
+lightcyan: "Hellzyan",
+lightgoldenrodyellow: "Hellgoldgelb",
+lightgray: "Hellgrau",
+lightgreen: "Hellgrün",
+lightgrey: "Hellgrau", // same as lightgray
+lightpink: "Hellrosa",
+lightsalmon: "Helllachs",
+lightseagreen: "Helles Meergrün",
+lightskyblue: "Helles Himmelblau",
+lightslategray: "Helles Schiefergrau",
+lightslategrey: "Helles Schiefergrau", // same as lightslategray
+lightsteelblue: "Helles Stahlblau",
+lightyellow: "Hellgelb",
+lime: "Limone",
+limegreen: "Limonengrün",
+linen: "Leinen",
+magenta: "Magenta",
+maroon: "Kastanienbraun",
+mediumaquamarine: "Mittelaquamarin",
+mediumblue: "Mittelblau",
+mediumorchid: "Mittelorchidee",
+mediumpurple: "Mittelpurpur",
+mediumseagreen: "Mittelmeeresgrün",
+mediumslateblue: "Mittelschieferblau ",
+mediumspringgreen: "Mittelfrühlingsgrün",
+mediumturquoise: "Mitteltürkis ",
+mediumvioletred: "Mittelviolettrot ",
+midnightblue: "Mitternachtblau",
+mintcream: "Mintcreme",
+mistyrose: "Blassrose",
+moccasin: "Mokassin",
+navajowhite: "Navajo-weiß",
+navy: "Marineblau",
+oldlace: "Alte Spitze",
+olive: "Oliv",
+olivedrab: "Olivgrau",
+orange: "Orange",
+orangered: "Orangerot",
+orchid: "Orchidee",
+palegoldenrod: "Blassgoldgelb",
+palegreen: "Blassgrün",
+paleturquoise: "Blasstürkis",
+palevioletred: "Blassviolettrot ",
+papayawhip: "Papayacreme",
+peachpuff: "Pfirsich",
+peru: "Peru",
+pink: "Rosa",
+plum: "Pflaume",
+powderblue: "Pulverblau",
+purple: "Purpurrot",
+red: "Rot",
+rosybrown: "Rosigbraun",
+royalblue: "Königsblau",
+saddlebrown: "Sattelbraun",
+salmon: "Lachs",
+sandybrown: "Sandbraun",
+seagreen: "Meeresgrün",
+seashell: "Muschelweiß",
+sienna: "Sienna",
+silver: "Silbergrau",
+skyblue: "Himmelblau",
+slateblue: "Schieferblau",
+slategray: "Schiefergrau",
+slategrey: "Schiefergrau", // same as slategray
+snow: "Schneeweiß",
+springgreen: "Frühlingsgrün",
+steelblue: "Stahlblau",
+tan: "Hautfarben",
+teal: "Smaragdgrün",
+thistle: "Distel",
+tomato: "Tomatenrot",
+transparent: "Transparent",
+turquoise: "Türkis",
+violet: "Violett",
+wheat: "Weizen",
+white: "Weiß",
+whitesmoke: "Rauchweiß",
+yellow: "Gelb",
+yellowgreen: "Gelbgrün"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/el/colors.js b/js/dojo-1.7.2/dojo/nls/el/colors.js
new file mode 100644
index 0000000..df4b887
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/el/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/el/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "σιέλ",
+antiquewhite: "ξεθω�ιασμένο λευκό",
+aqua: "γαλάζιο",
+aquamarine: "γαλαζοπ�άσινο",
+azure: "μπλε του ου�ανο�",
+beige: "μπεζ",
+bisque: "σκο��ο κ�εμ",
+black: "μα��ο",
+blanchedalmond: "ζαχα�ί",
+blue: "μπλε",
+blueviolet: "βιολετί",
+brown: "καφέ",
+burlywood: "καφέ του ξ�λου",
+cadetblue: "μπλε του στ�ατο�",
+chartreuse: "φωτεινό κιτ�ινοπ�άσινο",
+chocolate: "σοκολατί",
+coral: "κο�αλί",
+cornflowerblue: "μεσαίο μπλε",
+cornsilk: "ασημί του καλαμποκιο�",
+crimson: "βαθ� κόκκινο",
+cyan: "κυανό",
+darkblue: "σκο��ο μπλε",
+darkcyan: "σκο��ο κυανό",
+darkgoldenrod: "σκο��ο χ�υσοκίτ�ινο",
+darkgray: "σκο��ο γκ�ι",
+darkgreen: "σκο��ο π�άσινο",
+darkgrey: "σκο��ο γκ�ι", // same as darkgray
+darkkhaki: "σκο��ο χακί",
+darkmagenta: "σκο��ο ματζέντα",
+darkolivegreen: "σκο��ο π�άσινο λαδί",
+darkorange: "σκο��ο πο�τοκαλί",
+darkorchid: "σκο��α ο�χιδέα",
+darkred: "σκο��ο κόκκινο",
+darksalmon: "σκο��ο σομόν",
+darkseagreen: "σκο��ο π�άσινο της θάλασσας",
+darkslateblue: "σκο��ο μεταλλικό μπλε",
+darkslategray: "σκο��ο μεταλλικό γκ�ι",
+darkslategrey: "σκο��ο μεταλλικό γκ�ι", // same as darkslategray
+darkturquoise: "σκο��ο τυ�κουάζ",
+darkviolet: "σκο��ο βιολετί",
+deeppink: "βαθ� �οζ",
+deepskyblue: "βαθ� μπλε το ου�ανο�",
+dimgray: "αχνό γκ�ι",
+dimgrey: "αχνό γκ�ι", // same as dimgray
+dodgerblue: "σκο��ο ελεκτ�ίκ",
+firebrick: "κε�αμιδί",
+floralwhite: "λευκό των ανθών",
+forestgreen: "π�άσινο του δάσους",
+fuchsia: "φο�ξια",
+gainsboro: "γκ�ι σιέλ",
+ghostwhite: "άσπ�ο",
+gold: "χ�υσαφί",
+goldenrod: "χ�υσοκίτ�ινο",
+gray: "γκ�ι",
+green: "π�άσινο",
+greenyellow: "π�ασινοκίτ�ινο",
+grey: "γκ�ι", // same as gray
+honeydew: "μελί",
+hotpink: "έντονο �οζ",
+indianred: "ινδικό κόκκινο",
+indigo: "λουλακί",
+ivory: "ιβουά�",
+khaki: "χακί",
+lavender: "λίλα",
+lavenderblush: "μωβ λεβάντας",
+lawngreen: "σκο��ο π�άσινο",
+lemonchiffon: "λεμονί",
+lightblue: "ανοιχτό μπλε",
+lightcoral: "ανοιχτό κο�αλί",
+lightcyan: "ανοιχτό κυανό",
+lightgoldenrodyellow: "ανοιχτό χ�υσοκίτ�ινο",
+lightgray: "ανοιχτό γκ�ι",
+lightgreen: "ανοιχτό π�άσινο",
+lightgrey: "ανοιχτό γκ�ι", // same as lightgray
+lightpink: "ανοιχτό �οζ",
+lightsalmon: "ανοιχτό σομόν",
+lightseagreen: "ανοιχτό π�άσινο της θάλασσας",
+lightskyblue: "ανοιχτό μπλε το ου�ανο�",
+lightslategray: "ανοιχτό μεταλλικό γκ�ι",
+lightslategrey: "ανοιχτό μεταλλικό γκ�ι", // same as lightslategray
+lightsteelblue: "ανοιχτό μπλε ατσαλιο�",
+lightyellow: "ανοιχτό κίτ�ινο",
+lime: "λαχανί",
+limegreen: "π�άσινο λαχανί",
+linen: "σπαγγί",
+magenta: "ματζέντα",
+maroon: "βυσσινί",
+mediumaquamarine: "μεσαίο γαλαζοπ�άσινο",
+mediumblue: "μεσαίο μπλε",
+mediumorchid: "μεσαία ο�χιδέα",
+mediumpurple: "μεσαίο μωβ",
+mediumseagreen: "μεσαίο π�άσινο της θάλασσας",
+mediumslateblue: "μεσαίο μεταλλικό μπλε",
+mediumspringgreen: "μεσαίο π�άσινο της άνοιξης",
+mediumturquoise: "μεσαίο τυ�κουάζ",
+mediumvioletred: "μεσαίο κόκκινο βιολετί",
+midnightblue: "πολ� σκο��ο μπλε",
+mintcream: "βε�αμάν",
+mistyrose: "τ�ιανταφυλλί",
+moccasin: "μόκα",
+navajowhite: "άσπ�ο �αβάχο",
+navy: "μπλε του ναυτικο�",
+oldlace: "εκ�ο�",
+olive: "π�άσινο λαδί",
+olivedrab: "λαδί",
+orange: "πο�τοκαλί",
+orangered: "πο�τοκαλοκόκκινο",
+orchid: "ο�χιδέα",
+palegoldenrod: "αχνό χ�υσοκίτ�ινο",
+palegreen: "αχνό π�άσινο",
+paleturquoise: "αχνό τυ�κουάζ",
+palevioletred: "αχνό κόκκινο βιολετί",
+papayawhip: "αχνό �οζ",
+peachpuff: "�οδακινί",
+peru: "πε�ο�",
+pink: "�οζ",
+plum: "δαμασκηνί",
+powderblue: "αχνό μπλε",
+purple: "μωβ",
+red: "κόκκινο",
+rosybrown: "καστανό",
+royalblue: "έντονο μπλε",
+saddlebrown: "βαθ� καφέ",
+salmon: "σομόν",
+sandybrown: "μπεζ της άμμου",
+seagreen: "π�άσινο της θάλασσας",
+seashell: "κοχ�λι",
+sienna: "καφεκίτ�ινο",
+silver: "ασημί",
+skyblue: "μπλε του ου�ανο�",
+slateblue: "μεταλλικό μπλε",
+slategray: "μεταλλικό γκ�ι",
+slategrey: "μεταλλικό γκ�ι", // same as slategray
+snow: "χιονί",
+springgreen: "π�άσινο της άνοιξης",
+steelblue: "μπλε ατσαλιο�",
+tan: "ώχ�α",
+teal: "πετ�όλ",
+thistle: "μωβ βιολετί",
+tomato: "κόκκινο της ντομάτας",
+transparent: "διαφανές",
+turquoise: "τυ�κουάζ",
+violet: "βιολετί",
+wheat: "στα�ένιο",
+white: "λευκό",
+whitesmoke: "λευκός καπνός",
+yellow: "κίτ�ινο",
+yellowgreen: "κιτ�ινοπ�άσινο"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/es/colors.js b/js/dojo-1.7.2/dojo/nls/es/colors.js
new file mode 100644
index 0000000..1345111
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/es/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/es/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "blanco azulado",
+antiquewhite: "blanco antiguo",
+aqua: "aguamarina",
+aquamarine: "aguamarina 2",
+azure: "blanco cielo",
+beige: "beige",
+bisque: "miel",
+black: "negro",
+blanchedalmond: "almendra pálido",
+blue: "azul",
+blueviolet: "azul violáceo",
+brown: "marrón",
+burlywood: "madera",
+cadetblue: "azul cadete",
+chartreuse: "verde pálido 2",
+chocolate: "chocolate",
+coral: "coral",
+cornflowerblue: "azul aciano",
+cornsilk: "crudo",
+crimson: "carmesí",
+cyan: "cian",
+darkblue: "azul oscuro",
+darkcyan: "cian oscuro",
+darkgoldenrod: "ocre oscuro",
+darkgray: "gris oscuro",
+darkgreen: "verde oscuro",
+darkgrey: "gris oscuro", // same as darkgray
+darkkhaki: "caqui oscuro",
+darkmagenta: "magenta oscuro",
+darkolivegreen: "verde oliva oscuro",
+darkorange: "naranja oscuro",
+darkorchid: "orquídea oscuro",
+darkred: "rojo oscuro",
+darksalmon: "salmón oscuro",
+darkseagreen: "verde mar oscuro",
+darkslateblue: "azul pizarra oscuro",
+darkslategray: "gris pizarra oscuro",
+darkslategrey: "gris pizarra oscuro", // same as darkslategray
+darkturquoise: "turquesa oscuro",
+darkviolet: "violeta oscuro",
+deeppink: "rosa fuerte",
+deepskyblue: "azul cielo fuerte",
+dimgray: "gris marengo",
+dimgrey: "gris marengo", // same as dimgray
+dodgerblue: "azul fuerte",
+firebrick: "teja",
+floralwhite: "blanco manteca",
+forestgreen: "verde pino",
+fuchsia: "fucsia",
+gainsboro: "azul gainsboro",
+ghostwhite: "blanco ligero",
+gold: "oro",
+goldenrod: "ocre",
+gray: "gris",
+green: "verde",
+greenyellow: "amarillo verdoso",
+grey: "gris", // same as gray
+honeydew: "flor de rocío",
+hotpink: "rosa oscuro",
+indianred: "rojo teja",
+indigo: "añil",
+ivory: "marfil",
+khaki: "caqui",
+lavender: "lavanda",
+lavenderblush: "lavanda rosácea",
+lawngreen: "verde césped",
+lemonchiffon: "amarillo pastel",
+lightblue: "azul claro",
+lightcoral: "coral claro",
+lightcyan: "cian claro",
+lightgoldenrodyellow: "ocre claro",
+lightgray: "gris claro",
+lightgreen: "verde claro",
+lightgrey: "gris claro", // same as lightgray
+lightpink: "rosa claro",
+lightsalmon: "salmón claro",
+lightseagreen: "verde mar claro",
+lightskyblue: "azul cielo claro",
+lightslategray: "gris pizarra claro",
+lightslategrey: "gris pizarra claro", // same as lightslategray
+lightsteelblue: "azul acero claro",
+lightyellow: "amarillo claro",
+lime: "lima",
+limegreen: "lima limón",
+linen: "blanco arena",
+magenta: "magenta",
+maroon: "granate",
+mediumaquamarine: "aguamarina medio",
+mediumblue: "azul medio",
+mediumorchid: "orquídea medio",
+mediumpurple: "púrpura medio",
+mediumseagreen: "verde mar medio",
+mediumslateblue: "azul pizarra medio",
+mediumspringgreen: "verde primavera medio",
+mediumturquoise: "turquesa medio",
+mediumvioletred: "rojo violáceo medio",
+midnightblue: "azul medianoche",
+mintcream: "crema menta",
+mistyrose: "rosa difuminado",
+moccasin: "arena",
+navajowhite: "blanco navajo",
+navy: "azul marino",
+oldlace: "encaje antiguo",
+olive: "verde oliva",
+olivedrab: "verde oliva pardusco",
+orange: "naranja",
+orangered: "rojo anaranjado",
+orchid: "orquídea",
+palegoldenrod: "ocre pálido",
+palegreen: "verde pálido",
+paleturquoise: "turquesa pálido",
+palevioletred: "rojo violáceo pálido",
+papayawhip: "papaya claro",
+peachpuff: "melocotón",
+peru: "perú",
+pink: "rosa",
+plum: "ciruela",
+powderblue: "azul suave",
+purple: "púrpura",
+red: "rojo",
+rosybrown: "marrón rosáceo",
+royalblue: "azul real",
+saddlebrown: "cuero",
+salmon: "salmón",
+sandybrown: "marrón arcilla",
+seagreen: "verde mar",
+seashell: "blanco marfil",
+sienna: "siena",
+silver: "plateado",
+skyblue: "azul cielo",
+slateblue: "azul pizarra",
+slategray: "gris pizarra",
+slategrey: "gris pizarra", // same as slategray
+snow: "nieve",
+springgreen: "verde fuerte",
+steelblue: "azul acero",
+tan: "canela",
+teal: "verde azulado",
+thistle: "cardo",
+tomato: "tomate",
+transparent: "transparente",
+turquoise: "turquesa",
+violet: "violeta",
+wheat: "trigo",
+white: "blanco",
+whitesmoke: "blanco ahumado",
+yellow: "amarillo",
+yellowgreen: "verde amarillento"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/fi/colors.js b/js/dojo-1.7.2/dojo/nls/fi/colors.js
new file mode 100644
index 0000000..f76e8a1
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/fi/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/fi/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "vaaleanharmaansininen",
+antiquewhite: "antiikinvalkoinen",
+aqua: "sinivihreä",
+aquamarine: "vedenvihreä",
+azure: "taivaansininen",
+beige: "vaaleanruskea",
+bisque: "vaaleanruskea",
+black: "musta",
+blanchedalmond: "kuorittu manteli",
+blue: "sininen",
+blueviolet: "sinivioletti",
+brown: "ruskea",
+burlywood: "puunruskea",
+cadetblue: "meren vihreä",
+chartreuse: "kellanvihreä",
+chocolate: "suklaanruskea",
+coral: "koralli",
+cornflowerblue: "syvänsininen",
+cornsilk: "maissinkeltainen",
+crimson: "karmiininpunainen",
+cyan: "syaani",
+darkblue: "tummansininen",
+darkcyan: "tumma turkoosi",
+darkgoldenrod: "tumma kultapiisku",
+darkgray: "tummanharmaa",
+darkgreen: "tummanvihreä",
+darkgrey: "tummanharmaa", // same as darkgray
+darkkhaki: "tumma khaki",
+darkmagenta: "tumma magenta",
+darkolivegreen: "tummanoliivinvihreä",
+darkorange: "tummanoranssi",
+darkorchid: "tumma orkidea",
+darkred: "tummanpunainen",
+darksalmon: "tumma lohenpunainen",
+darkseagreen: "tumma merenvihreä",
+darkslateblue: "tumma siniharmaa",
+darkslategray: "tummanharmaa",
+darkslategrey: "tummanharmaa", // same as darkslategray
+darkturquoise: "tumma turkoosi",
+darkviolet: "tummanvioletti",
+deeppink: "syvä vaaleanpunainen",
+deepskyblue: "tumma taivaansininen",
+dimgray: "himmeänharmaa",
+dimgrey: "himmeänharmaa", // same as dimgray
+dodgerblue: "Dodger-sininen",
+firebrick: "poltetun tiilen punainen",
+floralwhite: "kukanvalkoinen",
+forestgreen: "metsänvihreä",
+fuchsia: "purppura",
+gainsboro: "gainsboro",
+ghostwhite: "lakananvalkoinen",
+gold: "kulta",
+goldenrod: "kullanruskea",
+gray: "harmaa",
+green: "vihreä",
+greenyellow: "vihreänkeltainen",
+grey: "harmaa", // same as gray
+honeydew: "hunajameloninvihreä",
+hotpink: "pinkki",
+indianred: "kirkkaanpunainen",
+indigo: "indigo",
+ivory: "norsunluu",
+khaki: "khaki",
+lavender: "laventeli",
+lavenderblush: "laventelinpunainen",
+lawngreen: "ruohonvihreä",
+lemonchiffon: "sitruunankeltainen",
+lightblue: "vaaleansininen",
+lightcoral: "vaalea koralli",
+lightcyan: "vaalea syaani",
+lightgoldenrodyellow: "vaalea kultapiiskunkeltainen",
+lightgray: "vaaleanharmaa",
+lightgreen: "vaaleanvihreä",
+lightgrey: "vaaleanharmaa", // same as lightgray
+lightpink: "vaaleanpunainen",
+lightsalmon: "vaalea lohenpunainen",
+lightseagreen: "vaalea merenvihreä",
+lightskyblue: "vaalea taivaansininen",
+lightslategray: "vaaleanharmaa",
+lightslategrey: "vaaleanharmaa", // same as lightslategray
+lightsteelblue: "vaalea teräksensininen",
+lightyellow: "vaaleankeltainen",
+lime: "vaaleanvihreä",
+limegreen: "limetinvihreä",
+linen: "pellavanvaalea",
+magenta: "magenta",
+maroon: "kastanjanruskea",
+mediumaquamarine: "keskivaalea vedenvihreä",
+mediumblue: "keskisininen",
+mediumorchid: "keskivaalea orkidea",
+mediumpurple: "keskivaalea violetti",
+mediumseagreen: "keskivaalea merenvihreä",
+mediumslateblue: "keskivaalea siniharmaa",
+mediumspringgreen: "keskivaalea keväänvihreä",
+mediumturquoise: "keskivaalea turkoosi",
+mediumvioletred: "keskivaalea lila",
+midnightblue: "yönsininen",
+mintcream: "minttukreemi",
+mistyrose: "utuinen ruusu",
+moccasin: "nahanruskea",
+navajowhite: "navajonvalkoinen",
+navy: "laivastonsininen",
+oldlace: "vanha pitsi",
+olive: "oliivinvihreä",
+olivedrab: "oliivinruskea",
+orange: "oranssi",
+orangered: "oranssinpunainen",
+orchid: "orkidea",
+palegoldenrod: "haalea kultapiisku",
+palegreen: "haalea vihreä",
+paleturquoise: "haalea turkoosi",
+palevioletred: "haalea lila",
+papayawhip: "papaijavaahto",
+peachpuff: "persikka",
+peru: "peru",
+pink: "vaaleanpunainen",
+plum: "luumunpunainen",
+powderblue: "harmaansininen",
+purple: "violetti",
+red: "punainen",
+rosybrown: "punertavanruskea",
+royalblue: "syvänsininen",
+saddlebrown: "satulanruskea",
+salmon: "lohenpunainen",
+sandybrown: "hiekanruskea",
+seagreen: "merenvihreä",
+seashell: "simpukankuori",
+sienna: "siena",
+silver: "hopea",
+skyblue: "taivaansininen",
+slateblue: "savensininen",
+slategray: "savenharmaa",
+slategrey: "savenharmaa", // same as slategray
+snow: "lumivalkoinen",
+springgreen: "keväänvihreä",
+steelblue: "teräksensininen",
+tan: "kellanruskea",
+teal: "sinivihreä",
+thistle: "ohdake",
+tomato: "tomaatinpunainen",
+transparent: "läpinäkyvä",
+turquoise: "turkoosi",
+violet: "violetti",
+wheat: "vehnänkeltainen",
+white: "valkoinen",
+whitesmoke: "savunvalkea",
+yellow: "keltainen",
+yellowgreen: "kellanvihreä"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/fr/colors.js b/js/dojo-1.7.2/dojo/nls/fr/colors.js
new file mode 100644
index 0000000..4dfa61f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/fr/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/fr/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "bleu gris",
+antiquewhite: "blanc antique",
+aqua: "bleu-vert",
+aquamarine: "aigue-marine",
+azure: "bleu azur",
+beige: "beige",
+bisque: "beige rosé",
+black: "noir",
+blanchedalmond: "coquille d'oeuf",
+blue: "bleu",
+blueviolet: "bleu-violet",
+brown: "brun",
+burlywood: "bois précieux",
+cadetblue: "bleu pétrole",
+chartreuse: "vert vif",
+chocolate: "chocolat",
+coral: "corail",
+cornflowerblue: "bleuet",
+cornsilk: "vanille",
+crimson: "cramoisi",
+cyan: "cyan",
+darkblue: "bleu foncé",
+darkcyan: "cyan foncé",
+darkgoldenrod: "jaune paille foncé",
+darkgray: "gris foncé",
+darkgreen: "vert foncé",
+darkgrey: "gris foncé", // same as darkgray
+darkkhaki: "kaki foncé",
+darkmagenta: "magenta foncé",
+darkolivegreen: "olive foncé",
+darkorange: "orange foncé",
+darkorchid: "lilas foncé",
+darkred: "rouge foncé",
+darksalmon: "saumon foncé",
+darkseagreen: "vert d'eau foncé",
+darkslateblue: "bleu ardoise foncé",
+darkslategray: "gris ardoise foncé",
+darkslategrey: "gris ardoise foncé", // same as darkslategray
+darkturquoise: "turquoise foncé",
+darkviolet: "violet foncé",
+deeppink: "rose soutenu",
+deepskyblue: "bleu ciel soutenu",
+dimgray: "gris soutenu",
+dimgrey: "gris soutenu", // same as dimgray
+dodgerblue: "bleu France",
+firebrick: "rouge brique",
+floralwhite: "lys",
+forestgreen: "vert sapin",
+fuchsia: "fuchsia",
+gainsboro: "gris souris",
+ghostwhite: "blanc laiteux",
+gold: "or",
+goldenrod: "jaune paille",
+gray: "gris",
+green: "vert",
+greenyellow: "vert-jaune",
+grey: "gris", // same as gray
+honeydew: "opalin",
+hotpink: "rose intense",
+indianred: "rose indien",
+indigo: "indigo",
+ivory: "ivoire",
+khaki: "kaki",
+lavender: "lavande",
+lavenderblush: "lavandin",
+lawngreen: "vert prairie",
+lemonchiffon: "mousse de citron",
+lightblue: "bleu clair",
+lightcoral: "corail clair",
+lightcyan: "cyan clair",
+lightgoldenrodyellow: "jaune paille clair",
+lightgray: "gris clair",
+lightgreen: "vert clair",
+lightgrey: "gris clair", // same as lightgray
+lightpink: "rose clair",
+lightsalmon: "saumon clair",
+lightseagreen: "vert d'eau clair",
+lightskyblue: "bleu ciel clair",
+lightslategray: "gris ardoise clair",
+lightslategrey: "gris ardoise clair", // same as lightslategray
+lightsteelblue: "bleu acier clair",
+lightyellow: "jaune clair",
+lime: "vert citron",
+limegreen: "citron vert",
+linen: "écru",
+magenta: "magenta",
+maroon: "marron",
+mediumaquamarine: "aigue-marine moyen",
+mediumblue: "bleu moyen",
+mediumorchid: "lilas moyen",
+mediumpurple: "pourpre moyen",
+mediumseagreen: "vert d'eau moyen",
+mediumslateblue: "bleu ardoise moyen",
+mediumspringgreen: "vert printemps moyen",
+mediumturquoise: "turquoise moyen",
+mediumvioletred: "rouge violacé moyen",
+midnightblue: "bleu nuit",
+mintcream: "crème de menthe",
+mistyrose: "rose pâle",
+moccasin: "chamois",
+navajowhite: "chair",
+navy: "bleu marine",
+oldlace: "blanc cassé",
+olive: "olive",
+olivedrab: "brun verdâtre",
+orange: "orange",
+orangered: "rouge orangé",
+orchid: "lilas",
+palegoldenrod: "jaune paille pâle",
+palegreen: "vert pâle",
+paleturquoise: "turquoise pâle",
+palevioletred: "rouge violacé pâle",
+papayawhip: "crème de papaye",
+peachpuff: "pêche",
+peru: "caramel",
+pink: "rose",
+plum: "prune",
+powderblue: "bleu de smalt",
+purple: "pourpre",
+red: "rouge",
+rosybrown: "vieux rose",
+royalblue: "bleu roi",
+saddlebrown: "brun cuir",
+salmon: "saumon",
+sandybrown: "sable",
+seagreen: "vert d'eau",
+seashell: "coquillage",
+sienna: "terre de sienne",
+silver: "argent",
+skyblue: "bleu ciel",
+slateblue: "bleu ardoise",
+slategray: "gris ardoise",
+slategrey: "gris ardoise", // same as slategray
+snow: "neige",
+springgreen: "vert printemps",
+steelblue: "bleu acier",
+tan: "grège",
+teal: "sarcelle",
+thistle: "chardon",
+tomato: "tomate",
+transparent: "transparent",
+turquoise: "turquoise",
+violet: "violet",
+wheat: "blé",
+white: "blanc",
+whitesmoke: "blanc cendré",
+yellow: "jaune",
+yellowgreen: "vert jaunâtre"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/he/colors.js b/js/dojo-1.7.2/dojo/nls/he/colors.js
new file mode 100644
index 0000000..53dae1f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/he/colors.js
@@ -0,0 +1,159 @@
+//>>built
+define(
+"dojo/nls/he/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "כחול פלדה",
+antiquewhite: "לבן עתיק",
+aqua: "�קווה",
+aquamarine: "�קוומ�רין",
+azure: "תכלת עז",
+beige: "בז'",
+bisque: "לבן שקד",
+black: "שחור",
+blanchedalmond: "שקד",
+blue: "כחול",
+blueviolet: "כחול-סגול",
+brown: "חו�",
+burlywood: "חו� דהוי",
+cadetblue: "כחול י�",
+chartreuse: "ירוק-צהוב",
+chocolate: "שוקולד",
+coral: "�למוג",
+cornflowerblue: "כחול דרדר",
+cornsilk: "צהבהב",
+crimson: "�רגמן",
+cyan: "טורקיז",
+darkblue: "כחול כהה",
+darkcyan: "טורקיז כהה",
+darkgoldenrod: "זהוב כהה",
+darkgray: "�פור כהה",
+darkgreen: "ירוק כהה",
+darkgrey: "�פור כהה", // same as darkgray
+darkkhaki: "ח�קי כהה",
+darkmagenta: "בורדו כהה",
+darkolivegreen: "ירוק זית כהה",
+darkorange: "כתו� כהה",
+darkorchid: "סחלב כהה",
+darkred: "�דו� כהה",
+darksalmon: "סלמון כהה",
+darkseagreen: "ירוק י� כהה",
+darkslateblue: "כחול צפחה כהה",
+darkslategray: "�פור צפחה כהה",
+darkslategrey: "�פור צפחה כהה", // same as darkslategray
+darkturquoise: "טורקיז כהה",
+darkviolet: "סגול כהה",
+deeppink: "ורוד עמוק",
+deepskyblue: "כחול שמיי� עמוק",
+dimgray: "�פור עמו�",
+dimgrey: "�פור עמו�", // same as dimgray
+dodgerblue: "כחול",
+firebrick: "לבנה שרופה",
+floralwhite: "לבן פרחוני",
+forestgreen: "ירוק יער",
+fuchsia: "ורוד בהיר",
+gainsboro: "גיינסבורו",
+ghostwhite: "לבן רפ�י�",
+gold: "זהב",
+goldenrod: "זהוב",
+gray: "�פור",
+green: "ירוק",
+greenyellow: "ירוק-צהוב",
+grey: "�פור", // same as gray
+honeydew: "ירקרק",
+hotpink: "ורוד לוהט",
+indianred: "�דו� דהוי",
+indigo: "�ינדיגו",
+ivory: "שנהב",
+khaki: "ח�קי",
+lavender: "לבנדר",
+lavenderblush: "סומק לבנדר",
+lawngreen: "ירוק דש�",
+lemonchiffon: "ירוק לימון",
+lightblue: "תכלת",
+lightcoral: "�למוג בהיר",
+lightcyan: "טורקיז בהיר",
+lightgoldenrodyellow: "צהוב בהיר",
+lightgray: "�פור בהיר",
+lightgreen: "ירוק בהיר",
+lightgrey: "�פור בהיר", // same as lightgray
+lightpink: "ורוד בהיר",
+lightsalmon: "סלמון בהיר",
+lightseagreen: "ירוק י� בהיר",
+lightskyblue: "כחול שמיי� בהיר",
+lightslategray: "�פור צפחה בהיר",
+lightslategrey: "�פור צפחה בהיר", // same as lightslategray
+lightsteelblue: "כחול פלדה בהיר",
+lightyellow: "צהוב בהיר",
+lime: "לימון",
+limegreen: "ירוק לימוני",
+linen: "פשתן",
+magenta: "בורדו",
+maroon: "חו� �דמד�",
+mediumaquamarine: "כחול בינוני",
+mediumblue: "תכלת בינוני",
+mediumorchid: "סחלב בינוני",
+mediumpurple: "סגול בינוני",
+mediumseagreen: "ירוק י� בינוני",
+mediumslateblue: "כחול צפחה בינוני",
+mediumspringgreen: "ירוק �ביב בינוני",
+mediumturquoise: "טורקיז בינוני",
+mediumvioletred: "סגול-�דו� בינוני",
+midnightblue: "כחול כהה",
+mintcream: "קר� מנטה",
+mistyrose: "ורוד מעורפל",
+moccasin: "מוקסין",
+navajowhite: "לבן נוו�חו",
+navy: "כחול כהה",
+oldlace: "תחרה עתיקה",
+olive: "זית",
+olivedrab: "זית עמו�",
+orange: "כתו�",
+orangered: "כתו� �דו�",
+orchid: "סחלב",
+palegoldenrod: "זהוב בהיר",
+palegreen: "ירוק בהיר",
+paleturquoise: "טורקיז בהיר",
+palevioletred: "סגול-�דו� בהיר",
+papayawhip: "פפ�יה",
+peachpuff: "קציפת �פרסק",
+peru: "פרו",
+pink: "ורוד",
+plum: "שזיף",
+powderblue: "כחול חיוור",
+purple: "סגול",
+red: "�דו�",
+rosybrown: "חו� ורדרד",
+royalblue: "כחול מלכותי",
+saddlebrown: "חו� דהוי",
+salmon: "סלמון",
+sandybrown: "חו� חולי",
+seagreen: "ירוק י�",
+seashell: "צדף",
+sienna: "סיינה",
+silver: "כסף",
+skyblue: "כחול שמיי�",
+slateblue: "כחול צפחה",
+slategray: "�פור צפחה",
+slategrey: "�פור צפחה", // same as slategray
+snow: "שלג",
+springgreen: "ירוק �ביב",
+steelblue: "כחול פלדה",
+tan: "חו� �דמד�",
+teal: "כחול-ירוק כהה",
+thistle: "דרדר",
+tomato: "עגבניה",
+turquoise: "טורקיז",
+violet: "סגול",
+wheat: "חיוט",
+white: "לבן",
+whitesmoke: "עשן לבן",
+yellow: "צהוב",
+yellowgreen: "ירוק צהוב"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/hr/colors.js b/js/dojo-1.7.2/dojo/nls/hr/colors.js
new file mode 100644
index 0000000..2994251
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/hr/colors.js
@@ -0,0 +1,157 @@
+//>>built
+define(
+"dojo/nls/hr/colors", ({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "alice plava",
+antiquewhite: "antique bijela",
+aqua: "aqua",
+aquamarine: "akvamarin",
+azure: "azurna",
+beige: "bež",
+bisque: "svjetlo smeđe ruži�asta",
+black: "crna",
+blanchedalmond: "slonova�a",
+blue: "plava",
+blueviolet: "plavo ljubi�asta",
+brown: "smeđa",
+burlywood: "pješ�ano smeđa",
+cadetblue: "plavo siva",
+chartreuse: "chartreuse",
+chocolate: "�okoladna",
+coral: "koraljna",
+cornflowerblue: "razli�ak plava",
+cornsilk: "cornsilk",
+crimson: "rumena",
+cyan: "cijan",
+darkblue: "tamno plava",
+darkcyan: "tamno cijan",
+darkgoldenrod: "tamno zlatno žuta",
+darkgray: "tamno siva",
+darkgreen: "tamno zelena",
+darkgrey: "tamno siva", // same as darkgray
+darkkhaki: "tamno sivo smeđa",
+darkmagenta: "tamno grimizna",
+darkolivegreen: "tamno maslinasto zelena",
+darkorange: "tamno naran�asta",
+darkorchid: "tamno ruži�asta",
+darkred: "tamno crvena",
+darksalmon: "tamno žuto ruži�asta",
+darkseagreen: "tamno plavo zelena",
+darkslateblue: "tamno sivo plava",
+darkslategray: "tamno plavo siva",
+darkslategrey: "tamno plavo siva", // same as darkslategray
+darkturquoise: "tamno tirkizna",
+darkviolet: "tamno ljubi�asta",
+deeppink: "intenzivno ruži�asta",
+deepskyblue: "intenzivno nebesko plava",
+dimgray: "mutno siva",
+dimgrey: "mutno siva", // same as dimgray
+dodgerblue: "dodger plava",
+firebrick: "žarko crvena",
+floralwhite: "cvjetno bijela",
+forestgreen: "tamno zelena",
+fuchsia: "fuksija",
+gainsboro: "gainsboro",
+ghostwhite: "sivo bijela",
+gold: "zlatna",
+goldenrod: "zlatno žuta",
+gray: "siva",
+green: "zelena",
+greenyellow: "zeleno-žuta",
+grey: "siva", // same as gray
+honeydew: "honeydew",
+hotpink: "žarko ruži�asta",
+indianred: "indijski crveno",
+indigo: "indigo",
+ivory: "slonova�a",
+khaki: "sivo smeđa",
+lavender: "lavanda",
+lavenderblush: "lavanda",
+lawngreen: "livadno zelena",
+lemonchiffon: "nježno žuta",
+lightblue: "svjetlo plava",
+lightcoral: "svjetlo koraljna",
+lightcyan: "svjetlo cijan",
+lightgoldenrodyellow: "svjetlo zlatno žuta",
+lightgray: "svjetlo siva",
+lightgreen: "svjetlo zelena",
+lightgrey: "svjetlo siva", // same as lightgray
+lightpink: "svjetlo ruži�asta",
+lightsalmon: "svjetlo žuto ruži�asta",
+lightseagreen: "svjetlo plavo zelena",
+lightskyblue: "svjetlo nebesko plava",
+lightslategray: "svjetlo plavo siva",
+lightslategrey: "svjetlo plavo siva", // same as lightslategray
+lightsteelblue: "svjetlo �eli�no plava",
+lightyellow: "svjetlo žuta",
+lime: "limeta",
+limegreen: "limeta zelena",
+linen: "platno",
+magenta: "grimizna",
+maroon: "kestenjasta",
+mediumaquamarine: "srednje akvamarin",
+mediumblue: "srednje plava",
+mediumorchid: "srednje ruži�asta",
+mediumpurple: "srednje purpurna",
+mediumseagreen: "srednje plavo zelena",
+mediumslateblue: "srednje sivo plava",
+mediumspringgreen: "srednje proljetno zelena",
+mediumturquoise: "srednje tirkizna",
+mediumvioletred: "srednje ljubi�asto-crvena",
+midnightblue: "ponoćno plava",
+mintcream: "blijedo zelena",
+mistyrose: "mutno ruži�asta",
+moccasin: "moccasin",
+navajowhite: "krem bijela",
+navy: "mornarsko plava",
+oldlace: "old lace",
+olive: "maslinasta",
+olivedrab: "maslinasta",
+orange: "naran�asta",
+orangered: "naran�asto crvena",
+orchid: "ruži�asta",
+palegoldenrod: "blijedo zlatno žuta",
+palegreen: "svjetlo zelena",
+paleturquoise: "blijedo tirkizna",
+palevioletred: "blijedo ljubi�asto crvena",
+papayawhip: "blijedo naran�asta",
+peachpuff: "breskva",
+peru: "peru",
+pink: "ruži�asta",
+plum: "Å¡ljiva",
+powderblue: "blijedo plava",
+purple: "purpurna",
+red: "crvena",
+rosybrown: "ruži�asto smeđa",
+royalblue: "kraljevski plava",
+saddlebrown: "srednje smeđa",
+salmon: "ruži�asta",
+sandybrown: "pješ�ano smeđa",
+seagreen: "plavo zelena",
+seashell: "nježno ruži�asta",
+sienna: "sjena",
+silver: "srebrna",
+skyblue: "nebesko plava",
+slateblue: "sivo plava",
+slategray: "plavo siva",
+slategrey: "plavo siva", // same as slategray
+snow: "snijeg",
+springgreen: "proljetno zeleno",
+steelblue: "�eli�no plava",
+tan: "ten",
+teal: "teal",
+thistle: "�i�ak",
+tomato: "raj�ica",
+transparent: "prozirno",
+turquoise: "tirkizna",
+violet: "ljubi�asta",
+wheat: "pšenica",
+white: "bijela",
+whitesmoke: "bijeli dim",
+yellow: "žuta",
+yellowgreen: "žuto zelena"
+})
+);
diff --git a/js/dojo-1.7.2/dojo/nls/hu/colors.js b/js/dojo-1.7.2/dojo/nls/hu/colors.js
new file mode 100644
index 0000000..6762402
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/hu/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/hu/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "Alice kék",
+antiquewhite: "antik fehér",
+aqua: "vízszín",
+aquamarine: "akvamarin",
+azure: "azúrkék",
+beige: "bézs",
+bisque: "porcelán",
+black: "fekete",
+blanchedalmond: "hámozott mandula",
+blue: "kék",
+blueviolet: "ibolyakék",
+brown: "barna",
+burlywood: "nyersfa",
+cadetblue: "kadétkék",
+chartreuse: "chartreuse",
+chocolate: "csokoládé",
+coral: "korall",
+cornflowerblue: "búzavirágkék",
+cornsilk: "kukoricahaj",
+crimson: "karmazsinvörös",
+cyan: "ciánkék",
+darkblue: "sötétkék",
+darkcyan: "sötét ciánkék",
+darkgoldenrod: "sötét aranyvessző",
+darkgray: "sötétszürke",
+darkgreen: "sötétzöld",
+darkgrey: "sötétszürke", // same as darkgray
+darkkhaki: "sötét khakiszín",
+darkmagenta: "sötétbíbor",
+darkolivegreen: "sötét olajzöld",
+darkorange: "sötét narancssárga",
+darkorchid: "sötét orchidea",
+darkred: "sötétvörös",
+darksalmon: "sötét lazacszín",
+darkseagreen: "sötét tengerzöld",
+darkslateblue: "sötét palakék",
+darkslategray: "sötét palaszürke",
+darkslategrey: "sötét palaszürke", // same as darkslategray
+darkturquoise: "sötét türkizkék",
+darkviolet: "sötét ibolyaszín",
+deeppink: "sötétrózsaszín",
+deepskyblue: "sötét égszínkék",
+dimgray: "halványszürke",
+dimgrey: "halványszürke", // same as dimgray
+dodgerblue: "dodger kék",
+firebrick: "téglavörös",
+floralwhite: "virágfehér",
+forestgreen: "erdőzöld",
+fuchsia: "fukszia",
+gainsboro: "gainsboro",
+ghostwhite: "szellemfehér",
+gold: "arany",
+goldenrod: "aranyvessző",
+gray: "szürke",
+green: "zöld",
+greenyellow: "zöldessárga",
+grey: "szürke", // same as gray
+honeydew: "mézharmat",
+hotpink: "meleg rózsaszín",
+indianred: "indiánvörös",
+indigo: "indigó",
+ivory: "elefántcsont",
+khaki: "khakiszín",
+lavender: "levendula",
+lavenderblush: "pirosas levendula",
+lawngreen: "fűzöld",
+lemonchiffon: "sárga műselyem",
+lightblue: "világoskék",
+lightcoral: "világos korall",
+lightcyan: "világos ciánkék",
+lightgoldenrodyellow: "világos aranyvessző sárga",
+lightgray: "világosszürke",
+lightgreen: "világoszöld",
+lightgrey: "világosszürke", // same as lightgray
+lightpink: "világos rózsaszín",
+lightsalmon: "világos lazacszín",
+lightseagreen: "világos tengerzöld",
+lightskyblue: "világos égszínkék",
+lightslategray: "világos palaszürke",
+lightslategrey: "világos palaszürke", // same as lightslategray
+lightsteelblue: "világos acélkék",
+lightyellow: "világossárga",
+lime: "lime",
+limegreen: "limezöld",
+linen: "vászonfehér",
+magenta: "bíbor",
+maroon: "gesztenyebarna",
+mediumaquamarine: "közepes akvamarin",
+mediumblue: "közepes kék",
+mediumorchid: "közepes orchidea",
+mediumpurple: "közepes lila",
+mediumseagreen: "közepes tengerzöld",
+mediumslateblue: "közepes palakék",
+mediumspringgreen: "közepes tavaszzöld",
+mediumturquoise: "közepes türkizkék",
+mediumvioletred: "közepes ibolyavörös",
+midnightblue: "éjkék",
+mintcream: "mentaszósz",
+mistyrose: "halvány rózsaszín",
+moccasin: "mokkaszín",
+navajowhite: "navajo fehér",
+navy: "tengerészkék",
+oldlace: "régi csipke",
+olive: "olajzöld",
+olivedrab: "olajzöld drapp",
+orange: "narancssárga",
+orangered: "narancsvörös",
+orchid: "orchidea",
+palegoldenrod: "halvány aranyvessző",
+palegreen: "halványzöld",
+paleturquoise: "halvány türkizkék",
+palevioletred: "halvány ibolyavörös",
+papayawhip: "papayahab",
+peachpuff: "barackszín",
+peru: "peru",
+pink: "rózsaszín",
+plum: "szilvakék",
+powderblue: "púderkék",
+purple: "lila",
+red: "vörös",
+rosybrown: "barnásrózsaszín",
+royalblue: "királykék",
+saddlebrown: "nyeregbarna",
+salmon: "lazacszín",
+sandybrown: "homokbarna",
+seagreen: "tengerzöld",
+seashell: "kagyló",
+sienna: "vörösesbarna",
+silver: "ezüst",
+skyblue: "égszínkék",
+slateblue: "palakék",
+slategray: "palaszürke",
+slategrey: "palaszürke", // same as slategray
+snow: "hó",
+springgreen: "tavaszzöld",
+steelblue: "acélkék",
+tan: "rozsdabarna",
+teal: "pávakék",
+thistle: "bogáncs",
+tomato: "paradicsom",
+transparent: "átlátszó",
+turquoise: "türkizkék",
+violet: "ibolyaszín",
+wheat: "búza",
+white: "fehér",
+whitesmoke: "fehér füst",
+yellow: "sárga",
+yellowgreen: "sárgászöld"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/it/colors.js b/js/dojo-1.7.2/dojo/nls/it/colors.js
new file mode 100644
index 0000000..bb4fd11
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/it/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/it/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "blu alice",
+antiquewhite: "bianco antico",
+aqua: "acqua",
+aquamarine: "acquamarina",
+azure: "azzurro ghiaccio",
+beige: "beige",
+bisque: "incarnato",
+black: "nero",
+blanchedalmond: "mandorla chiaro",
+blue: "blu",
+blueviolet: "blu violetto",
+brown: "marrone",
+burlywood: "tabacco",
+cadetblue: "verde acqua",
+chartreuse: "verde brillante",
+chocolate: "cioccolato",
+coral: "corallo",
+cornflowerblue: "blu fiordaliso",
+cornsilk: "crema",
+crimson: "cremisi",
+cyan: "ciano",
+darkblue: "blu scuro",
+darkcyan: "ciano scuro",
+darkgoldenrod: "ocra scuro",
+darkgray: "grigio scuro",
+darkgreen: "verde scuro",
+darkgrey: "grigio scuro", // same as darkgray
+darkkhaki: "kaki scuro",
+darkmagenta: "magenta scuro",
+darkolivegreen: "verde oliva scuro",
+darkorange: "arancione scuro",
+darkorchid: "orchidea scuro",
+darkred: "rosso scuro",
+darksalmon: "salmone scuro",
+darkseagreen: "verde mare scuro",
+darkslateblue: "blu ardesia scuro",
+darkslategray: "grigio ardesia scuro",
+darkslategrey: "grigio ardesia scuro", // same as darkslategray
+darkturquoise: "turchese scuro",
+darkviolet: "viola scuro",
+deeppink: "ciclamino",
+deepskyblue: "azzurro cielo scuro",
+dimgray: "grigio 80%",
+dimgrey: "grigio 80%", // same as dimgray
+dodgerblue: "blu d'oriente",
+firebrick: "rosso mattone",
+floralwhite: "bianco giglio",
+forestgreen: "verde foresta",
+fuchsia: "fucsia",
+gainsboro: "grigio 10%",
+ghostwhite: "bianco gesso",
+gold: "oro",
+goldenrod: "ocra gialla",
+gray: "grigio",
+green: "verde",
+greenyellow: "giallo verde",
+grey: "grigio", // same as gray
+honeydew: "bianco germoglio",
+hotpink: "rosa acceso",
+indianred: "terra indiana",
+indigo: "indaco",
+ivory: "avorio",
+khaki: "kaki",
+lavender: "lavanda",
+lavenderblush: "bianco rosato",
+lawngreen: "verde prato",
+lemonchiffon: "caffelatte chiaro",
+lightblue: "azzurro",
+lightcoral: "rosa corallo",
+lightcyan: "ciano chiaro",
+lightgoldenrodyellow: "giallo tenue",
+lightgray: "grigio chiaro",
+lightgreen: "verde chiaro",
+lightgrey: "grigio chiaro", // same as lightgray
+lightpink: "rosa chiaro",
+lightsalmon: "salmone chiaro",
+lightseagreen: "verde mare chiaro",
+lightskyblue: "azzurro cielo chiaro",
+lightslategray: "grigio ardesia chiaro",
+lightslategrey: "grigio ardesia chiaro", // same as lightslategray
+lightsteelblue: "blu acciao chiaro",
+lightyellow: "giallo chiaro",
+lime: "verde fluorescente",
+limegreen: "verde lime",
+linen: "lino",
+magenta: "magenta",
+maroon: "scarlatto",
+mediumaquamarine: "acquamarina medio",
+mediumblue: "blu medio",
+mediumorchid: "orchidea medio",
+mediumpurple: "porpora medio",
+mediumseagreen: "verde mare medio",
+mediumslateblue: "blu ardesia medio",
+mediumspringgreen: "verde primavera medio",
+mediumturquoise: "turchese medio",
+mediumvioletred: "vinaccia",
+midnightblue: "blu melanzana scuro",
+mintcream: "bianco nuvola",
+mistyrose: "rosa pallido",
+moccasin: "mocassino",
+navajowhite: "pesca chiaro",
+navy: "blu notte",
+oldlace: "mandorla",
+olive: "verde oliva",
+olivedrab: "marrone oliva",
+orange: "arancione",
+orangered: "vermiglio",
+orchid: "orchidea",
+palegoldenrod: "giallo zolfo chiaro",
+palegreen: "verde pallido",
+paleturquoise: "turchese pallido",
+palevioletred: "vinaccia chiaro",
+papayawhip: "cipria",
+peachpuff: "pesca",
+peru: "marrone terra bruciata",
+pink: "rosa",
+plum: "prugna",
+powderblue: "azzurro polvere",
+purple: "porpora",
+red: "rosso",
+rosybrown: "marrone rosato",
+royalblue: "blu reale",
+saddlebrown: "cacao",
+salmon: "salmone",
+sandybrown: "marrone sabbia",
+seagreen: "verde mare",
+seashell: "sabbia rosa",
+sienna: "cuoio",
+silver: "grigio 25%",
+skyblue: "azzurro cielo",
+slateblue: "blu ardesia",
+slategray: "grigio ardesia",
+slategrey: "grigio ardesia", // same as slategray
+snow: "neve",
+springgreen: "verde primavera",
+steelblue: "blu acciao",
+tan: "grigio bruno",
+teal: "verde turchese",
+thistle: "rosa cenere",
+tomato: "pomodoro",
+transparent: "trasparente",
+turquoise: "turchese",
+violet: "viola",
+wheat: "sabbia",
+white: "bianco",
+whitesmoke: "bianco fumo",
+yellow: "giallo",
+yellowgreen: "giallo verde"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/ja/colors.js b/js/dojo-1.7.2/dojo/nls/ja/colors.js
new file mode 100644
index 0000000..fd2ac7d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/ja/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/ja/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "アリス・ブルー",
+antiquewhite: "アンティーク・ホワイト",
+aqua: "アクア",
+aquamarine: "碧緑",
+azure: "薄�空色",
+beige: "ベージュ",
+bisque: "ビスク",
+black: "é»’",
+blanchedalmond: "皮��アーモンド",
+blue: "�",
+blueviolet: "�紫",
+brown: "茶",
+burlywood: "�ーリーウッド",
+cadetblue: "��ん��",
+chartreuse: "淡黄緑",
+chocolate: "�ョコレート",
+coral: "�瑚",
+cornflowerblue: "コーンフラワー・ブルー",
+cornsilk: "コーンシルク",
+crimson: "深紅",
+cyan: "シアン・ブルー",
+darkblue: "ダーク・ブルー",
+darkcyan: "ダーク・シアン・ブルー",
+darkgoldenrod: "ダーク・ゴールデン・ロッド",
+darkgray: "ダーク・グレイ",
+darkgreen: "ダーク・グリーン",
+darkgrey: "ダーク・グレイ", // same as darkgray
+darkkhaki: "ダーク・カーキー",
+darkmagenta: "ダーク・マジェンタ",
+darkolivegreen: "ダーク・オリーブ・グリーン",
+darkorange: "ダーク・オレンジ",
+darkorchid: "ダーク・オーキッド",
+darkred: "ダーク・レッド",
+darksalmon: "ダーク・サーモン",
+darkseagreen: "ダーク・シー・グリーン",
+darkslateblue: "ダーク・スレート・ブルー",
+darkslategray: "ダーク・スレート・グレイ",
+darkslategrey: "ダーク・スレート・グレイ", // same as darkslategray
+darkturquoise: "ダーク・ターコイズ",
+darkviolet: "ダーク・�イオレット",
+deeppink: "濃�ピンク",
+deepskyblue: "濃�空色",
+dimgray: "��ん�グレイ",
+dimgrey: "��ん�グレイ", // same as dimgray
+dodgerblue: "ドッジャー・ブルー",
+firebrick: "赤煉瓦色",
+floralwhite: "フローラル・ホワイト",
+forestgreen: "フォレスト・グリーン",
+fuchsia: "紫紅色",
+gainsboro: "ゲインズボーロ",
+ghostwhite: "ゴースト・ホワイト",
+gold: "金",
+goldenrod: "ゴールデン・ロッド",
+gray: "グレイ",
+green: "ç·‘",
+greenyellow: "緑黄色",
+grey: "グレイ", // same as gray
+honeydew: "�ニーデュー",
+hotpink: "ホット・ピンク",
+indianred: "インディアン・レッド",
+indigo: "�色",
+ivory: "アイボリー",
+khaki: "カーキー",
+lavender: "ラベンダー",
+lavenderblush: "ラベンダー・ブラッシ",
+lawngreen: "ローン・グリーン",
+lemonchiffon: "レモン・シフォン",
+lightblue: "ライト・ブルー",
+lightcoral: "ライト・コーラル",
+lightcyan: "ライト・シアン",
+lightgoldenrodyellow: "ライト・ゴールデン・ロッド・イエロー",
+lightgray: "ライト・グレイ",
+lightgreen: "ライト・グリーン",
+lightgrey: "ライト・グレイ", // same as lightgray
+lightpink: "ライト・ピンク",
+lightsalmon: "ライト・サーモン",
+lightseagreen: "ライト・シー・グリーン",
+lightskyblue: "ライト・スカイ・ブルー",
+lightslategray: "ライト・スレート・グレイ",
+lightslategrey: "ライト・スレート・グレイ", // same as lightslategray
+lightsteelblue: "ライト・ス�ール・ブルー",
+lightyellow: "ライト・イエロー",
+lime: "ライム",
+limegreen: "ライム・グリーン",
+linen: "亜麻色",
+magenta: "赤紫",
+maroon: "��茶",
+mediumaquamarine: "ミディアム・アクアマリーン",
+mediumblue: "ミディアム・ブルー",
+mediumorchid: "ミディアム・オーキッド",
+mediumpurple: "ミディアム・パープル",
+mediumseagreen: "ミディアム・シー・グリーン",
+mediumslateblue: "ミディアム・スレート・ブルー",
+mediumspringgreen: "ミディアム・スプリング・グリーン",
+mediumturquoise: "ミディアム・ターコイズ",
+mediumvioletred: "ミディアム・�イオレット・レッド",
+midnightblue: "ミッドナイト・ブルー",
+mintcream: "ミント・クリーム",
+mistyrose: "ミスティ・ローズ",
+moccasin: "モカシン",
+navajowhite: "ナ�ホ・ホワイト",
+navy: "濃紺",
+oldlace: "オールド・レイス",
+olive: "オリーブ",
+olivedrab: "濃黄緑",
+orange: "オレンジ",
+orangered: "オレンジ・レッド",
+orchid: "è–„ç´«",
+palegoldenrod: "ペイル・ゴールデン・ロッド",
+palegreen: "ペイル・グリーン",
+paleturquoise: "ペイル・ターコイズ",
+palevioletred: "ペイル・�イオレット・レッド",
+papayawhip: "パパイア・ホイップ",
+peachpuff: "ピー�・パフ",
+peru: "ペルー",
+pink: "ピンク",
+plum: "深紫",
+powderblue: "淡�",
+purple: "ç´«",
+red: "赤",
+rosybrown: "ロージー・ブラウン",
+royalblue: "藤色",
+saddlebrown: "サドル・ブラウン",
+salmon: "サーモン",
+sandybrown: "砂�色",
+seagreen: "シー・グリーン",
+seashell: "シーシェル",
+sienna: "黄�色",
+silver: "銀",
+skyblue: "スカイ・ブルー",
+slateblue: "スレート・ブルー",
+slategray: "スレート・グレイ",
+slategrey: "スレート・グレイ", // same as slategray
+snow: "雪色",
+springgreen: "スプリング・グリーン",
+steelblue: "鋼色",
+tan: "茶�色",
+teal: "ティール",
+thistle: "シスル",
+tomato: "トマト色",
+transparent: "�明",
+turquoise: "ターコイズ",
+violet: "��れ色",
+wheat: "�麦色",
+white: "白",
+whitesmoke: "ホワイト・スモーク",
+yellow: "黄",
+yellowgreen: "黄緑"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/kk/colors.js b/js/dojo-1.7.2/dojo/nls/kk/colors.js
new file mode 100644
index 0000000..7e8759c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/kk/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/kk/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "бозғылт көк",
+antiquewhite: "ақ антик",
+aqua: "�у тү�і",
+aquamarine: "жа�ылдау-көк",
+azure: "көкшіл",
+beige: "�арғыш",
+bisque: "би�квит",
+black: "қара",
+blanchedalmond: "ағартылған бадам",
+blue: "көк",
+blueviolet: "көк-ақшыл көк",
+brown: "қоңыр",
+burlywood: "ағаш тамыры",
+cadetblue: "кадет көк",
+chartreuse: "жа�ылдау-�ары",
+chocolate: "шоколад",
+coral: "коралл",
+cornflowerblue: "көктікен көк",
+cornsilk: "жібек",
+crimson: "таңқұрай",
+cyan: "циан",
+darkblue: "күңгірт көк",
+darkcyan: "күңгірт циан",
+darkgoldenrod: "қара алтын",
+darkgray: "қою �ұры",
+darkgreen: "қою жа�ыл",
+darkgrey: "қою �ұры", // same as darkgray
+darkkhaki: "қою хаки",
+darkmagenta: "қою күлгін",
+darkolivegreen: "қою қоңырлау жа�ыл",
+darkorange: "қою қызғылт �ары",
+darkorchid: "күңгірт ор�ель",
+darkred: "күңгірт қызыл",
+darksalmon: "қою �арылау қызғылт",
+darkseagreen: "қою теңіз толқыны",
+darkslateblue: "күңгірт грифель көк",
+darkslategray: "күңгірт көкшіл �ұры",
+darkslategrey: "күңгірт көкшіл �ұры", // same as darkslategray
+darkturquoise: "күңгірт көгілдір",
+darkviolet: "күңгірт күлгін",
+deeppink: "қою қызғылт",
+deepskyblue: "қою а�пан көк",
+dimgray: "күңгірт �ұры",
+dimgrey: "күңгірт �ұры", // same as dimgray
+dodgerblue: "көк доджер",
+firebrick: "қызыл кірпіш",
+floralwhite: "гүлді ақ",
+forestgreen: "шөпті жа�ыл",
+fuchsia: "фук�и�",
+gainsboro: "gainsboro",
+ghostwhite: "еле�ті ақ",
+gold: "�ары тү�ті",
+goldenrod: "алтын",
+gray: "�ұры",
+green: "жа�ыл",
+greenyellow: "жа�ыл-�ары",
+grey: "�ұры", // same as gray
+honeydew: "балдай",
+hotpink: "ашық қызғылт",
+indianred: "үнділік қызыл",
+indigo: "индиго",
+ivory: "піл �үйег",
+khaki: "хаки",
+lavender: "бозғылт ақшыл көк",
+lavenderblush: "күңгірт ақшыл қызыл",
+lawngreen: "көгал жа�ыл",
+lemonchiffon: "лимон шиффон",
+lightblue: "ақшыл көк",
+lightcoral: "ашық коралл",
+lightcyan: "ашық көгілдір",
+lightgoldenrodyellow: "ашық �ары тү�ті �ары",
+lightgray: "ашық �ұры",
+lightgreen: "ақшыл жа�ыл",
+lightgrey: "ашық �ұры", // same as lightgray
+lightpink: "ақшыл қызғылт",
+lightsalmon: "ашық �арғыш қызғылт",
+lightseagreen: "ашық теңіз толқыны",
+lightskyblue: "ашық а�пан көк",
+lightslategray: "ашық көкшіл �ұры",
+lightslategrey: "ашық көкшіл �ұры", // same as lightslategray
+lightsteelblue: "ашық �ұрғылт көк",
+lightyellow: "ашық �ары",
+lime: "әк",
+limegreen: "әк жа�ыл",
+linen: "зығыр",
+magenta: "фук�ин",
+maroon: "�арғылт",
+mediumaquamarine: "орташа жа�ылдау көк",
+mediumblue: "орташа көк",
+mediumorchid: "орташа ақшыл",
+mediumpurple: "орташа күлгін",
+mediumseagreen: "орташа теңіз толқыны",
+mediumslateblue: "орташа көкшіл �ұры",
+mediumspringgreen: "орташа ашық жа�ыл",
+mediumturquoise: "орташа көгілдір",
+mediumvioletred: "орташа ақшыл көк-қызыл",
+midnightblue: "түн орта�ы көк",
+mintcream: "жалбыз майы",
+mistyrose: "көме�кі қызғылт",
+moccasin: "мока�ин",
+navajowhite: "навахо ақ",
+navy: "қара-көк",
+oldlace: "е�кі бау",
+olive: "зәйтүнді",
+olivedrab: "жа�ылдау �ары",
+orange: "қызғылт �ары",
+orangered: "қызғылт �ары қызыл",
+orchid: "орхиде�",
+palegoldenrod: "бозғылт алтын",
+palegreen: "бозғылт жа�ыл",
+paleturquoise: "бозғылт көгілдір",
+palevioletred: "бозғылт ақшыл көк-қызыл",
+papayawhip: "папай� қамшы�ы",
+peachpuff: "шабдалы",
+peru: "перу",
+pink: "қызғылт",
+plum: "алхоры",
+powderblue: "жа�ылдау көк",
+purple: "күлгін",
+red: "қызыл",
+rosybrown: "қызғылт қоңыр",
+royalblue: "патша көк",
+saddlebrown: "тоқым қоңыр",
+salmon: "�омон",
+sandybrown: "құмды қоңыр",
+seagreen: "теңіз толқыны",
+seashell: "теңіз қабыршағы",
+sienna: "�иенна",
+silver: "күмі� тү�те�",
+skyblue: "а�пан көк",
+slateblue: "грифель көк",
+slategray: "көкшіл �ұры",
+slategrey: "көкшіл �ұры", // same as slategray
+snow: "қар",
+springgreen: "көктем жа�ыл",
+steelblue: "көкшіл �ұрғылт",
+tan: "�арғыш қоңыр",
+teal: "шүрегей",
+thistle: "артишок",
+tomato: "қызанақ",
+transparent: "мөлдір",
+turquoise: "көгілдір",
+violet: "күлгін",
+wheat: "бидай",
+white: "ақ",
+whitesmoke: "ақ түтін",
+yellow: "�ары",
+yellowgreen: "�арғыш жа�ыл"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/ko/colors.js b/js/dojo-1.7.2/dojo/nls/ko/colors.js
new file mode 100644
index 0000000..eab125c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/ko/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/ko/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "앨리스 블루(alice blue)",
+antiquewhite: "앤틱 화�트(antique white)",
+aqua: "ì•„ì¿ ì•„(aqua)",
+aquamarine: "아쿠아마린(aquamarine)",
+azure: "애쥬어(azure)",
+beige: "베�지(beige)",
+bisque: "비스�(bisque)",
+black: "블랙(black)",
+blanchedalmond: "블랜치 아몬드(blanched almond)",
+blue: "블루(blue)",
+blueviolet: "블루 바�올렛(blue-violet)",
+brown: "브�운(brown)",
+burlywood: "벌리우드(burlywood)",
+cadetblue: "카뎃 블루(cadet blue)",
+chartreuse: "샤르트뢰즈(chartreuse)",
+chocolate: "초콜렛(chocolate)",
+coral: "코랄(coral)",
+cornflowerblue: "콘플�워 블루(cornflower blue)",
+cornsilk: "콘실�(cornsilk)",
+crimson: "�림슨(crimson)",
+cyan: "시안(cyan)",
+darkblue: "다� 블루(dark blue)",
+darkcyan: "다� 시안(dark cyan)",
+darkgoldenrod: "다� 골든로드(dark goldenrod)",
+darkgray: "다� 그레�(dark gray)",
+darkgreen: "다� 그린(dark green)",
+darkgrey: "다� 그레�(dark gray)", // same as darkgray
+darkkhaki: "다� 카키(dark khaki)",
+darkmagenta: "다� 마젠타(dark magenta)",
+darkolivegreen: "다� 올리브 그린(dark olive green)",
+darkorange: "다� 오렌지(dark orange)",
+darkorchid: "다� 오키드(dark orchid)",
+darkred: "다� 레드(dark red)",
+darksalmon: "다� �몬(dark salmon)",
+darkseagreen: "다� 씨 그린(dark sea green)",
+darkslateblue: "다� 슬레�트 블루(dark slate blue)",
+darkslategray: "다� 슬레�트 그레�(dark slate gray)",
+darkslategrey: "다� 슬레�트 그레�(dark slate gray)", // same as darkslategray
+darkturquoise: "다� 터콰즈(dark turquoise)",
+darkviolet: "다� 바�올렛(dark violet)",
+deeppink: "딥 핑�(deep pink)",
+deepskyblue: "딥 스카� 블루(deep sky blue)",
+dimgray: "딤 그레�(dim gray)",
+dimgrey: "딤 그레�(dim gray)", // same as dimgray
+dodgerblue: "다저 블루(dodger blue)",
+firebrick: "파�어 브릭(fire brick)",
+floralwhite: "플로랄 화�트(floral white)",
+forestgreen: "�레스트 그린(forest green)",
+fuchsia: "후�샤(fuchsia)",
+gainsboro: "게�스브로(gainsboro)",
+ghostwhite: "고스트 화�트(ghost white)",
+gold: "골드(gold)",
+goldenrod: "골든로드(goldenrod)",
+gray: "그레�(gray)",
+green: "그린(green)",
+greenyellow: "그린 �로우(green-yellow)",
+grey: "그레�(gray)", // same as gray
+honeydew: "허니듀(honeydew)",
+hotpink: "핫 핑�(hot pink)",
+indianred: "�디안 레드(indian red)",
+indigo: "�디고(indigo)",
+ivory: "아�보리(ivory)",
+khaki: "카키(khaki)",
+lavender: "�벤�(lavender)",
+lavenderblush: "�벤� 블러쉬(lavender blush)",
+lawngreen: "론 그린(lawn green)",
+lemonchiffon: "레몬 쉬�(lemon chiffon)",
+lightblue: "��트 블루(light blue)",
+lightcoral: "��트 코랄(light coral)",
+lightcyan: "��트 시안(light cyan)",
+lightgoldenrodyellow: "��트 골든로드 �로우(light goldenrod yellow)",
+lightgray: "��트 그레�(light gray)",
+lightgreen: "��트 그린(light green)",
+lightgrey: "��트 그레�(light gray)", // same as lightgray
+lightpink: "��트 핑�(light pink)",
+lightsalmon: "��트 �몬(light salmon)",
+lightseagreen: "��트 씨 그린(light sea green)",
+lightskyblue: "��트 스카� 블루(light sky blue)",
+lightslategray: "��트 슬레�트 그레�(light slate gray)",
+lightslategrey: "��트 슬레�트 그레�(light slate gray)", // same as lightslategray
+lightsteelblue: "��트 스틸 블루(light steel blue)",
+lightyellow: "��트 �로우(light yellow)",
+lime: "�임(lime)",
+limegreen: "�임 그린(lime green)",
+linen: "리넨(linen)",
+magenta: "마젠타(magenta)",
+maroon: "마룬(maroon)",
+mediumaquamarine: "미디엄 아쿠아마린(medium aquamarine)",
+mediumblue: "미디엄 블루(medium blue)",
+mediumorchid: "미디엄 오키드(medium orchid)",
+mediumpurple: "미디엄 �플(medium purple)",
+mediumseagreen: "미디엄 씨 그린(medium sea green)",
+mediumslateblue: "미디엄 슬레�트 블루(medium slate blue)",
+mediumspringgreen: "미디엄 스프� 그린(medium spring green)",
+mediumturquoise: "미디엄 터콰즈(medium turquoise)",
+mediumvioletred: "미디엄 바�올렛 레드(medium violet-red)",
+midnightblue: "미드나잇 블루(midnight blue)",
+mintcream: "민트 �림(mint cream)",
+mistyrose: "미스티 로즈(misty rose)",
+moccasin: "모카신(moccasin)",
+navajowhite: "나바호 화�트(navajo white)",
+navy: "네�비(navy)",
+oldlace: "올드 레�스(old lace)",
+olive: "올리브(olive)",
+olivedrab: "올리브 드랩(olive drab)",
+orange: "오렌지(orange)",
+orangered: "오렌지 레드(orange red)",
+orchid: "오키드(orchid)",
+palegoldenrod: "페� 골든로드(pale goldenrod)",
+palegreen: "페� 그린(pale green)",
+paleturquoise: "페� 터콰즈(pale turquoise)",
+palevioletred: "페� 바�올렛 레드(pale violet-red)",
+papayawhip: "파파야 휩(papaya whip)",
+peachpuff: "피치 �프(peach puff)",
+peru: "페루(peru)",
+pink: "핑�(pink)",
+plum: "플럼(plum)",
+powderblue: "파우� 블루(powder blue)",
+purple: "�플(purple)",
+red: "레드(red)",
+rosybrown: "로지 브�운(rosy brown)",
+royalblue: "로얄 블루(royal blue)",
+saddlebrown: "새들 브�운(saddle brown)",
+salmon: "�몬(salmon)",
+sandybrown: "샌디 브�운(sandy brown)",
+seagreen: "씨 그린(sea green)",
+seashell: "씨쉘(seashell)",
+sienna: "시�나(sienna)",
+silver: "실버(silver)",
+skyblue: "스카� 블루(sky blue)",
+slateblue: "슬레�트 블루(slate blue)",
+slategray: "슬레�트 그레�(slate gray)",
+slategrey: "슬레�트 그레�(slate gray)", // same as slategray
+snow: "스노우(snow)",
+springgreen: "스프� 그린(spring green)",
+steelblue: "스틸 블루(steel blue)",
+tan: "탠(tan)",
+teal: "틸(teal)",
+thistle: "시슬(thistle)",
+tomato: "토마토(tomato)",
+transparent: "투명(transparent)",
+turquoise: "터콰즈(turquoise)",
+violet: "바�올렛(violet)",
+wheat: "휘트(wheat)",
+white: "화�트(white)",
+whitesmoke: "화�트 스모�(white smoke)",
+yellow: "�로우(yellow)",
+yellowgreen: "�로우 그린(yellow green)"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/nb/colors.js b/js/dojo-1.7.2/dojo/nls/nb/colors.js
new file mode 100644
index 0000000..55ce8f7
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/nb/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/nb/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "blåhvit",
+antiquewhite: "antikk hvit",
+aqua: "akva",
+aquamarine: "akvamarin",
+azure: "asur",
+beige: "beige",
+bisque: "gulrosa",
+black: "svart",
+blanchedalmond: "lys mandel",
+blue: "blå",
+blueviolet: "blåfiolett",
+brown: "brun",
+burlywood: "matt mellombrun",
+cadetblue: "mørk grønnblå",
+chartreuse: "løvgrønn",
+chocolate: "sjokolade",
+coral: "korall",
+cornflowerblue: "kornblå",
+cornsilk: "cornsilk",
+crimson: "karmosinrødt",
+cyan: "cyan",
+darkblue: "mørk blå",
+darkcyan: "mørk cyan",
+darkgoldenrod: "mørk gyldenris",
+darkgray: "mørk grå",
+darkgreen: "mørk grønn",
+darkgrey: "mørk grå", // same as darkgray
+darkkhaki: "mørk khaki",
+darkmagenta: "mørk magenta",
+darkolivegreen: "mørk olivengrønn",
+darkorange: "mørk oransje",
+darkorchid: "mørk orkide",
+darkred: "mørk rød",
+darksalmon: "mørk lakserosa",
+darkseagreen: "mørk sjøgrønn",
+darkslateblue: "mørk skiferblå",
+darkslategray: "mørk skifergrå",
+darkslategrey: "mørk skifergrå", // same as darkslategray
+darkturquoise: "mørk turkis",
+darkviolet: "mørk fiolett",
+deeppink: "dyp rosa",
+deepskyblue: "dyp himmelblå",
+dimgray: "mørk mørkegrå",
+dimgrey: "mørk mørkegrå", // same as dimgray
+dodgerblue: "lys havblå",
+firebrick: "mursteinsrød",
+floralwhite: "blomsterhvit",
+forestgreen: "skoggrønn",
+fuchsia: "fuksia",
+gainsboro: "lys lys grå",
+ghostwhite: "egghvit",
+gold: "gull",
+goldenrod: "gyldenris",
+gray: "grå",
+green: "grønn",
+greenyellow: "gulgrønn",
+grey: "grå", // same as gray
+honeydew: "grønnhvit",
+hotpink: "halvmørk rosa",
+indianred: "rustrød",
+indigo: "indigo",
+ivory: "elfenbenshvit",
+khaki: "khaki",
+lavender: "lavendel",
+lavenderblush: "lillahvit",
+lawngreen: "plengrønn",
+lemonchiffon: "ferskenfarget",
+lightblue: "lys blå",
+lightcoral: "lys korall",
+lightcyan: "lys cyan",
+lightgoldenrodyellow: "lys gyldenrisgul",
+lightgray: "lys grå",
+lightgreen: "lys grønn",
+lightgrey: "lys grå", // same as lightgray
+lightpink: "lys rosa",
+lightsalmon: "lys lakserosa",
+lightseagreen: "lys sjøgrønn",
+lightskyblue: "lys himmelblå",
+lightslategray: "lys skifergrå",
+lightslategrey: "lys skifergrå", // same as lightslategray
+lightsteelblue: "lys stålblå",
+lightyellow: "lys gul",
+lime: "lime",
+limegreen: "limegrønn",
+linen: "lin",
+magenta: "magenta",
+maroon: "rødbrun",
+mediumaquamarine: "middels akvamarin",
+mediumblue: "mellomblå",
+mediumorchid: "middels orkide",
+mediumpurple: "middels purpur",
+mediumseagreen: "middels sjøgrønn",
+mediumslateblue: "middels skiferblå",
+mediumspringgreen: "middels vårgrønn",
+mediumturquoise: "middels turkis",
+mediumvioletred: "middels fiolettrød",
+midnightblue: "midnattsblå",
+mintcream: "mintkrem",
+mistyrose: "lys rosenrød",
+moccasin: "lys gulbrun",
+navajowhite: "gulbrun",
+navy: "marineblå",
+oldlace: "kniplingshvit",
+olive: "oliven",
+olivedrab: "middels olivengrønn",
+orange: "oransje",
+orangered: "rødoransje",
+orchid: "orkide",
+palegoldenrod: "svak gyldenris",
+palegreen: "svak grønn",
+paleturquoise: "svak turkis",
+palevioletred: "svak fiolettrød",
+papayawhip: "lys papaya",
+peachpuff: "brunrosa",
+peru: "lys nøttebrun",
+pink: "rosa",
+plum: "plommefarget",
+powderblue: "lys grønnblå",
+purple: "purpur",
+red: "rød",
+rosybrown: "brunlilla",
+royalblue: "kongeblå",
+saddlebrown: "mørk nøttebrun",
+salmon: "lakserosa",
+sandybrown: "sandbrun",
+seagreen: "sjøgrønn",
+seashell: "skjellhvit",
+sienna: "nøttebrun",
+silver: "sølvfarget",
+skyblue: "himmelblå",
+slateblue: "skiferblå",
+slategray: "skifergrå",
+slategrey: "skifergrå", // same as slategray
+snow: "snøhvit",
+springgreen: "vårgrønn",
+steelblue: "stålblå",
+tan: "matt mellombrun",
+teal: "mørk grønnblå",
+thistle: "lys grålilla",
+tomato: "tomatrød",
+transparent: "gjennomsiktig",
+turquoise: "turkis",
+violet: "fiolett",
+wheat: "varm sienna",
+white: "hvit",
+whitesmoke: "røykhvit",
+yellow: "gul",
+yellowgreen: "gulgrønn"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/nl/colors.js b/js/dojo-1.7.2/dojo/nls/nl/colors.js
new file mode 100644
index 0000000..959d1a7
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/nl/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/nl/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "lichtblauw",
+antiquewhite: "antiekwit",
+aqua: "aqua",
+aquamarine: "aquamarijn",
+azure: "azuur",
+beige: "beige",
+bisque: "oranjegeel",
+black: "zwart",
+blanchedalmond: "amandel",
+blue: "blauw",
+blueviolet: "violet",
+brown: "bruin",
+burlywood: "lichtbruin",
+cadetblue: "donkerstaalblauw",
+chartreuse: "groengeel",
+chocolate: "chocoladebruin",
+coral: "koraalrood",
+cornflowerblue: "korenbloemblauw",
+cornsilk: "maïsgeel",
+crimson: "karmozijnrood",
+cyan: "cyaan",
+darkblue: "donkerblauw",
+darkcyan: "donkercyaan",
+darkgoldenrod: "donkergoud",
+darkgray: "donkergrijs",
+darkgreen: "donkergroen",
+darkgrey: "donkergrijs", // same as darkgray
+darkkhaki: "donkerkaki",
+darkmagenta: "donkermagenta",
+darkolivegreen: "donkerolijfgroen",
+darkorange: "donkeroranje",
+darkorchid: "donkerorchidee",
+darkred: "donkerrood",
+darksalmon: "donkerzalm",
+darkseagreen: "donkerzeegroen",
+darkslateblue: "donkergrijsblauw",
+darkslategray: "donkerblauwgrijs",
+darkslategrey: "donkerblauwgrijs", // same as darkslategray
+darkturquoise: "donkerturquoise",
+darkviolet: "donkerviolet",
+deeppink: "donkerroze",
+deepskyblue: "diephemelblauw",
+dimgray: "dofgrijs",
+dimgrey: "dofgrijs", // same as dimgray
+dodgerblue: "helderblauw",
+firebrick: "vuursteenrood",
+floralwhite: "rozewit",
+forestgreen: "bosgroen",
+fuchsia: "fuchsia",
+gainsboro: "lichtblauwgrijs",
+ghostwhite: "spierwit",
+gold: "goud",
+goldenrod: "goudbruin",
+gray: "grijs",
+green: "groen",
+greenyellow: "groengeel",
+grey: "grijs", // same as gray
+honeydew: "meloen",
+hotpink: "acaciaroze",
+indianred: "indisch rood",
+indigo: "indigo",
+ivory: "ivoorwit",
+khaki: "kaki",
+lavender: "lavendelblauw",
+lavenderblush: "lavendelblos",
+lawngreen: "grasgroen",
+lemonchiffon: "citroengeel",
+lightblue: "lichtblauw",
+lightcoral: "lichtkoraal",
+lightcyan: "lichtcyaan",
+lightgoldenrodyellow: "lichtgoudgeel",
+lightgray: "lichtgrijs",
+lightgreen: "lichtgroen",
+lightgrey: "lichtgrijs", // same as lightgray
+lightpink: "lichtroze",
+lightsalmon: "lichtzalm",
+lightseagreen: "lichtzeegroen",
+lightskyblue: "lichthemelsblauw",
+lightslategray: "lichtblauwgrijs",
+lightslategrey: "lichtblauwgrijs", // same as lightslategray
+lightsteelblue: "lichtstaalblauw",
+lightyellow: "lichtgeel",
+lime: "limoen",
+limegreen: "limoengroen",
+linen: "linnen",
+magenta: "magenta",
+maroon: "kastanjebruin",
+mediumaquamarine: "midaquamarijn",
+mediumblue: "midblauw",
+mediumorchid: "midorchidee",
+mediumpurple: "midpurper",
+mediumseagreen: "midzeegroen",
+mediumslateblue: "midgrijsblauw",
+mediumspringgreen: "midlentegroen",
+mediumturquoise: "midturquoise",
+mediumvioletred: "midvioletrood",
+midnightblue: "nachtblauw",
+mintcream: "mintroomgeel",
+mistyrose: "matroze",
+moccasin: "moccasin",
+navajowhite: "navajowit",
+navy: "marineblauw",
+oldlace: "kant",
+olive: "olijfgroen",
+olivedrab: "grijsbruin",
+orange: "oranje",
+orangered: "oranjerood",
+orchid: "orchidee",
+palegoldenrod: "bleekgeel",
+palegreen: "bleekgroen",
+paleturquoise: "bleekturquoise",
+palevioletred: "bleekvioletrood",
+papayawhip: "papajaroze",
+peachpuff: "perzikroze",
+peru: "bruin",
+pink: "roze",
+plum: "pruim",
+powderblue: "lichtblauw-wit",
+purple: "purper",
+red: "rood",
+rosybrown: "roodbruin",
+royalblue: "koningsblauw",
+saddlebrown: "leerbruin",
+salmon: "zalm",
+sandybrown: "zandbruin",
+seagreen: "zeegroen",
+seashell: "schelp",
+sienna: "sienna",
+silver: "zilvergrijs",
+skyblue: "hemelsblauw",
+slateblue: "leiblauw",
+slategray: "leigrijs",
+slategrey: "leigrijs", // same as slategray
+snow: "sneeuwwit",
+springgreen: "lentegroen",
+steelblue: "staalblauw",
+tan: "geelbruin",
+teal: "grijsblauw",
+thistle: "distel",
+tomato: "tomaat",
+transparent: "transparant",
+turquoise: "turquoise",
+violet: "violet",
+wheat: "tarwebruin",
+white: "wit",
+whitesmoke: "rookwit",
+yellow: "geel",
+yellowgreen: "geelgroen"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/pl/colors.js b/js/dojo-1.7.2/dojo/nls/pl/colors.js
new file mode 100644
index 0000000..8675cc4
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/pl/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/pl/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "bladoniebieski",
+antiquewhite: "biel antyczna",
+aqua: "morski",
+aquamarine: "akwamaryna",
+azure: "lazurowy",
+beige: "beżowy",
+bisque: "biszkoptowy",
+black: "czarny",
+blanchedalmond: "migdałowy",
+blue: "niebieski",
+blueviolet: "błękitnofiołkowy",
+brown: "brÄ…zowy",
+burlywood: "kolor drewna",
+cadetblue: "niebieskoszary",
+chartreuse: "żółtooliwkowy",
+chocolate: "czekoladowy",
+coral: "koralowy",
+cornflowerblue: "chabrowy",
+cornsilk: "kukurydziany",
+crimson: "karmazynowy",
+cyan: "niebieskozielony",
+darkblue: "ciemnoniebieski",
+darkcyan: "ciemnoniebieskozielony",
+darkgoldenrod: "ciemne stare złoto",
+darkgray: "ciemnoszary",
+darkgreen: "ciemnozielony",
+darkgrey: "ciemnoszary", // same as darkgray
+darkkhaki: "ciemny khaki",
+darkmagenta: "ciemnoamarantowy",
+darkolivegreen: "ciemnooliwkowy",
+darkorange: "ciemnopomarańczowy",
+darkorchid: "ciemna orchidea",
+darkred: "ciemnoczerwony",
+darksalmon: "ciemnołososiowy",
+darkseagreen: "ciemna zieleń morska",
+darkslateblue: "ciemny gołębi",
+darkslategray: "ciemny mysi",
+darkslategrey: "ciemny mysi", // same as darkslategray
+darkturquoise: "mlecznoturkusowy",
+darkviolet: "ciemnofiołkowy",
+deeppink: "głęboki różowy",
+deepskyblue: "intensywny błękit nieba",
+dimgray: "przyciemniony szary",
+dimgrey: "przyciemniony szary", // same as dimgray
+dodgerblue: "błękit Dodgers",
+firebrick: "ceglasty",
+floralwhite: "kwiatowa biel",
+forestgreen: "leśna zieleń",
+fuchsia: "fuksjowy",
+gainsboro: "bladoszary",
+ghostwhite: "bladobiały",
+gold: "złoty",
+goldenrod: "stare złoto",
+gray: "szary",
+green: "zielony",
+greenyellow: "zielonożółty",
+grey: "szary", // same as gray
+honeydew: "miodowy",
+hotpink: "odblaskoworóżowy",
+indianred: "kasztanowy",
+indigo: "indygo",
+ivory: "kość słoniowa",
+khaki: "khaki",
+lavender: "lawendowy",
+lavenderblush: "lawendowocielisty",
+lawngreen: "trawiasty",
+lemonchiffon: "cytrynowy",
+lightblue: "jasnoniebieski",
+lightcoral: "jasnokoralowy",
+lightcyan: "jasnoniebieskozielony",
+lightgoldenrodyellow: "jasnożółte stare złoto",
+lightgray: "jasnoszary",
+lightgreen: "jasnozielony",
+lightgrey: "jasnoszary", // same as lightgray
+lightpink: "jasnoróżowy",
+lightsalmon: "jasnołososiowy",
+lightseagreen: "jasna zieleń morska",
+lightskyblue: "jasny błękit nieba",
+lightslategray: "jasny mysi",
+lightslategrey: "jasny mysi", // same as lightslategray
+lightsteelblue: "jasnostalowoniebieski",
+lightyellow: "jasnożółty",
+lime: "limonkowy",
+limegreen: "zielony limonkowy",
+linen: "lniany",
+magenta: "amarantowy",
+maroon: "kasztanowy",
+mediumaquamarine: "średnia akwamaryna",
+mediumblue: "ciemnochabrowy",
+mediumorchid: "średnia orchidea",
+mediumpurple: "średni fioletowy",
+mediumseagreen: "średnia zieleń morska",
+mediumslateblue: "średni gołębi",
+mediumspringgreen: "średnia wiosenna zieleń",
+mediumturquoise: "średni turkusowy",
+mediumvioletred: "średni fiołkowowoczerwony",
+midnightblue: "granatowoczarny",
+mintcream: "jasnomiętowy",
+mistyrose: "bladoróżany",
+moccasin: "mokasynowy",
+navajowhite: "piaskowy",
+navy: "granatowy",
+oldlace: "bladopomarańczowy",
+olive: "oliwkowy",
+olivedrab: "oliwkowa zieleń",
+orange: "pomarańczowy",
+orangered: "pomarańczowoczerwony",
+orchid: "orchidea",
+palegoldenrod: "blade stare złoto",
+palegreen: "bladozielony",
+paleturquoise: "bladoturkusowy",
+palevioletred: "blady fiołkowoczerwony",
+papayawhip: "papaja",
+peachpuff: "brzoskwiniowy",
+peru: "jasnobrÄ…zowy",
+pink: "różowy",
+plum: "śliwkowy",
+powderblue: "jasnobladobłękitny",
+purple: "fioletowy",
+red: "czerwony",
+rosybrown: "różowobrązowy",
+royalblue: "królewski błękit",
+saddlebrown: "brąz skórzany",
+salmon: "Å‚ososiowy",
+sandybrown: "piaskowy brÄ…z",
+seagreen: "zieleń morska",
+seashell: "matowoliliowy",
+sienna: "siena",
+silver: "srebrny",
+skyblue: "błękit nieba",
+slateblue: "gołębi",
+slategray: "mysi",
+slategrey: "mysi", // same as slategray
+snow: "śnieżny",
+springgreen: "wiosenna zieleń",
+steelblue: "stalowoniebieski",
+tan: "śniady",
+teal: "zielonomodry",
+thistle: "bladofioletowy",
+tomato: "pomidorowy",
+transparent: "przezroczysty",
+turquoise: "turkusowy",
+violet: "fiołkowy",
+wheat: "pszeniczny",
+white: "biały",
+whitesmoke: "przydymiony biały",
+yellow: "żółty",
+yellowgreen: "żółtozielony"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/pt-pt/colors.js b/js/dojo-1.7.2/dojo/nls/pt-pt/colors.js
new file mode 100644
index 0000000..ab9799e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/pt-pt/colors.js
@@ -0,0 +1,159 @@
+//>>built
+define(
+"dojo/nls/pt-pt/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "azul alice",
+antiquewhite: "branco antigo",
+aqua: "verde-água",
+aquamarine: "verde-azulado",
+azure: "azul-celeste",
+beige: "bege",
+bisque: "rosa-velho",
+black: "preto",
+blanchedalmond: "amêndoa claro",
+blue: "azul",
+blueviolet: "azul violeta",
+brown: "castanho",
+burlywood: "castanho pinho",
+cadetblue: "azul cadete",
+chartreuse: "amarelo esverdeado",
+chocolate: "chocolate",
+coral: "coral",
+cornflowerblue: "azul-violáceo",
+cornsilk: "branco seda",
+crimson: "carmesim",
+cyan: "ciano",
+darkblue: "azul escuro",
+darkcyan: "ciano escuro",
+darkgoldenrod: "ouro velho escuro",
+darkgray: "cinzento escuro",
+darkgreen: "verde escuro",
+darkgrey: "cinzento escuro", // same as darkgray
+darkkhaki: "caqui escuro",
+darkmagenta: "magenta escuro",
+darkolivegreen: "verde-azeitona escuro",
+darkorange: "laranja escuro",
+darkorchid: "orquídea escuro",
+darkred: "vermelho escuro",
+darksalmon: "salmão escuro",
+darkseagreen: "verde marinho escuro",
+darkslateblue: "azul ardósia escuro",
+darkslategray: "cinzento ardósia escuro",
+darkslategrey: "cinzento ardósia escuro", // same as darkslategray
+darkturquoise: "turquesa escuro",
+darkviolet: "violeta escuro",
+deeppink: "rosa profundo",
+deepskyblue: "azul céu profundo",
+dimgray: "cinzento esbatido",
+dimgrey: "cinzento esbatido", // same as dimgray
+dodgerblue: "azul furtivo",
+firebrick: "tijolo fogo",
+floralwhite: "branco floral",
+forestgreen: "verde floresta",
+fuchsia: "fúcsia",
+gainsboro: "cinzento azulado claro",
+ghostwhite: "branco sombreado",
+gold: "dourado",
+goldenrod: "ouro velho",
+gray: "cinzento",
+green: "verde",
+greenyellow: "amarelo esverdeado",
+grey: "cinzento", // same as gray
+honeydew: "mel",
+hotpink: "rosa forte",
+indianred: "almagre",
+indigo: "índigo",
+ivory: "marfim",
+khaki: "caqui",
+lavender: "alfazema",
+lavenderblush: "alfazema rosado",
+lawngreen: "verde relva",
+lemonchiffon: "limão chiffon",
+lightblue: "azul claro",
+lightcoral: "coral claro",
+lightcyan: "ciano claro",
+lightgoldenrodyellow: "ouro velho amarelado claro",
+lightgray: "cinzento claro",
+lightgreen: "verde claro",
+lightgrey: "cinzento claro", // same as lightgray
+lightpink: "rosa claro",
+lightsalmon: "salmão claro",
+lightseagreen: "verde marinho claro",
+lightskyblue: "azul céu claro",
+lightslategray: "cinzento ardósia claro",
+lightslategrey: "cinzento ardósia claro", // same as lightslategray
+lightsteelblue: "azul-aço claro",
+lightyellow: "amarelo claro",
+lime: "lima",
+limegreen: "verde-lima",
+linen: "linho",
+magenta: "magenta",
+maroon: "bordeaux",
+mediumaquamarine: "verde-azulado médio",
+mediumblue: "azul médio",
+mediumorchid: "orquídea médio",
+mediumpurple: "roxo médio",
+mediumseagreen: "verde marinho médio",
+mediumslateblue: "azul ardósia médio",
+mediumspringgreen: "verde primavera médio",
+mediumturquoise: "turquesa médio",
+mediumvioletred: "violeta avermelhado médio",
+midnightblue: "azul meia-noite",
+mintcream: "creme de menta",
+mistyrose: "rosa pálido",
+moccasin: "mocassim",
+navajowhite: "branco navajo",
+navy: "azul marinho",
+oldlace: "renda antiga",
+olive: "azeitona",
+olivedrab: "azeitona claro",
+orange: "laranja",
+orangered: "vermelho alaranjado",
+orchid: "orquídea",
+palegoldenrod: "ouro velho pálido",
+palegreen: "verde pálido",
+paleturquoise: "turquesa pálido",
+palevioletred: "violeta avermelhado pálido",
+papayawhip: "creme de papaia",
+peachpuff: "pêssego",
+peru: "peru",
+pink: "rosa",
+plum: "cor-de-ameixa",
+powderblue: "azul de esmalte",
+purple: "roxo",
+red: "vermelho",
+rosybrown: "castanho rosado",
+royalblue: "azul real",
+saddlebrown: "castanho sela",
+salmon: "salmão",
+sandybrown: "castanho areia",
+seagreen: "verde marinho",
+seashell: "concha",
+sienna: "castanho-avermelhado",
+silver: "prateado",
+skyblue: "azul céu",
+slateblue: "azul ardósia",
+slategray: "cinzento ardósia",
+slategrey: "cinzento ardósia", // same as slategray
+snow: "branco-neve",
+springgreen: "verde primavera",
+steelblue: "azul-aço",
+tan: "castanho claro",
+teal: "verde-azulado",
+thistle: "cardo",
+tomato: "vermelho tomate",
+turquoise: "turquesa",
+violet: "violeta",
+wheat: "trigo",
+white: "branco",
+whitesmoke: "fumo branco",
+yellow: "amarelo",
+yellowgreen: "verde amarelado"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/pt/colors.js b/js/dojo-1.7.2/dojo/nls/pt/colors.js
new file mode 100644
index 0000000..b3a5338
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/pt/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/pt/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "azul alice",
+antiquewhite: "branco antigo",
+aqua: "aqua",
+aquamarine: "água marinha",
+azure: "azul celeste",
+beige: "bege",
+bisque: "bisque",
+black: "preto",
+blanchedalmond: "amêndoa pelada",
+blue: "azul",
+blueviolet: "azul violeta",
+brown: "marrom",
+burlywood: "burlywood",
+cadetblue: "azul cadet",
+chartreuse: "chartreuse",
+chocolate: "chocolate",
+coral: "coral",
+cornflowerblue: "azul centaurea",
+cornsilk: "cornsilk",
+crimson: "carmesim",
+cyan: "ciano",
+darkblue: "azul escuro",
+darkcyan: "ciano escuro",
+darkgoldenrod: "goldenrod escuro",
+darkgray: "cinza escuro",
+darkgreen: "verde escuro",
+darkgrey: "cinza escuro", // same as darkgray
+darkkhaki: "cáqui escuro",
+darkmagenta: "magenta escuro",
+darkolivegreen: "verde oliva escuro",
+darkorange: "laranja escuro",
+darkorchid: "orquídea escuro",
+darkred: "vermelho escuro",
+darksalmon: "salmão escuro",
+darkseagreen: "verde marinho escuro",
+darkslateblue: "azul ardósia escuro",
+darkslategray: "cinza ardósia escuro",
+darkslategrey: "cinza ardósia escuro", // same as darkslategray
+darkturquoise: "turquesa escuro",
+darkviolet: "violeta escuro",
+deeppink: "rosa profundo",
+deepskyblue: "azul céu intenso",
+dimgray: "cinza turvo",
+dimgrey: "cinza turvo", // same as dimgray
+dodgerblue: "azul dodger",
+firebrick: "firebrick",
+floralwhite: "branco floral",
+forestgreen: "verde floresta",
+fuchsia: "fúcsia",
+gainsboro: "gainsboro",
+ghostwhite: "branco ghost",
+gold: "dourado",
+goldenrod: "goldenrod",
+gray: "cinza",
+green: "verde",
+greenyellow: "amarelo esverdeado",
+grey: "cinza", // same as gray
+honeydew: "honeydew",
+hotpink: "rosa quente",
+indianred: "vermelho indiano",
+indigo: "índigo",
+ivory: "marfim",
+khaki: "cáqui",
+lavender: "lavanda",
+lavenderblush: "lavanda avermelhada",
+lawngreen: "verde grama",
+lemonchiffon: "limão chiffon",
+lightblue: "azul claro",
+lightcoral: "coral claro",
+lightcyan: "ciano claro",
+lightgoldenrodyellow: "amarelo goldenrod claro",
+lightgray: "cinza claro",
+lightgreen: "verde claro",
+lightgrey: "cinza claro", // same as lightgray
+lightpink: "rosa claro",
+lightsalmon: "salmão claro",
+lightseagreen: "verde marinho claro",
+lightskyblue: "azul céu claro",
+lightslategray: "cinza ardósia claro",
+lightslategrey: "cinza ardósia claro", // same as lightslategray
+lightsteelblue: "azul aço claro",
+lightyellow: "amarelo claro",
+lime: "lima",
+limegreen: "verde lima",
+linen: "linho",
+magenta: "magenta",
+maroon: "castanho",
+mediumaquamarine: "água marinha médio",
+mediumblue: "azul médio",
+mediumorchid: "orquídea médio",
+mediumpurple: "roxo médio",
+mediumseagreen: "verde marinho médio",
+mediumslateblue: "azul ardósia médio",
+mediumspringgreen: "verde primavera médio",
+mediumturquoise: "turquesa médio",
+mediumvioletred: "vermelho violeta médio",
+midnightblue: "azul meia-noite",
+mintcream: "creme de menta",
+mistyrose: "rosa enevoado",
+moccasin: "moccasin",
+navajowhite: "branco navajo",
+navy: "marinho",
+oldlace: "cadarço velho",
+olive: "oliva",
+olivedrab: "verde oliva",
+orange: "laranja",
+orangered: "vermelho alaranjado",
+orchid: "orquídea",
+palegoldenrod: "goldenrod esbranquiçado",
+palegreen: "verde esbranquiçado",
+paleturquoise: "turquesa esbranquiçado",
+palevioletred: "vermelho violeta esbranquiçado",
+papayawhip: "creme de papaya",
+peachpuff: "peach puff",
+peru: "peru",
+pink: "rosa",
+plum: "ameixa",
+powderblue: "azul talco",
+purple: "roxo",
+red: "vermelho",
+rosybrown: "marrom rosado",
+royalblue: "azul royal",
+saddlebrown: "marrom saddle",
+salmon: "salmão",
+sandybrown: "marrom cor de areia",
+seagreen: "verde marinho",
+seashell: "seashell",
+sienna: "sienna",
+silver: "prateado",
+skyblue: "azul céu",
+slateblue: "azul ardósia",
+slategray: "cinza ardósia",
+slategrey: "cinza ardósia", // same as slategray
+snow: "branco neve",
+springgreen: "verde primavera",
+steelblue: "azul aço",
+tan: "tan",
+teal: "azul esverdeado",
+thistle: "thistle",
+tomato: "tomate",
+transparent: "transparente",
+turquoise: "turquesa",
+violet: "violeta",
+wheat: "trigo",
+white: "branco",
+whitesmoke: "fumaça branca",
+yellow: "amarelo",
+yellowgreen: "verde amarelado"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/ro/colors.js b/js/dojo-1.7.2/dojo/nls/ro/colors.js
new file mode 100644
index 0000000..e2bbf75
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/ro/colors.js
@@ -0,0 +1,161 @@
+//>>built
+define(
+"dojo/nls/ro/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "alice blue",
+antiquewhite: "antique white",
+aqua: "aqua",
+aquamarine: "aquamarine",
+azure: "azuriu",
+beige: "bej",
+bisque: "bisque",
+black: "negru",
+blanchedalmond: "blanched almond",
+blue: "albastru",
+blueviolet: "albastru-violet",
+brown: "maro",
+burlywood: "burlywood",
+cadetblue: "cadet blue",
+chartreuse: "chartreuse",
+chocolate: "ciocolată",
+coral: "coral",
+cornflowerblue: "cornflower blue",
+cornsilk: "cornsilk",
+crimson: "crimson",
+cyan: "cyan",
+darkblue: "albastru închis",
+darkcyan: "cyan închis",
+darkgoldenrod: "goldenrod închis",
+darkgray: "cenuşiu închis",
+darkgreen: "verde închis",
+darkgrey: "gri închis", // same as darkgray
+darkkhaki: "kaki închis",
+darkmagenta: "magenta închis",
+darkolivegreen: "verde oliv închis",
+darkorange: "portocaliu închis",
+darkorchid: "dark orchid",
+darkred: "roşu închis",
+darksalmon: "dark salmon",
+darkseagreen: "dark sea green",
+darkslateblue: "dark slate blue",
+darkslategray: "dark slate gray",
+darkslategrey: "dark slate gray", // same as darkslategray
+darkturquoise: "dark turquoise",
+darkviolet: "violet închis",
+deeppink: "roz închis",
+deepskyblue: "deep sky blue",
+dimgray: "dim gray",
+dimgrey: "dim gray", // same as dimgray
+dodgerblue: "dodger blue",
+firebrick: "fire brick",
+floralwhite: "floral white",
+forestgreen: "verde pădure",
+fuchsia: "fuchsia",
+gainsboro: "gainsboro",
+ghostwhite: "ghost white",
+gold: "auriu",
+goldenrod: "goldenrod",
+gray: "cenuÅŸiu",
+green: "verde",
+greenyellow: "verde-galben",
+grey: "gri", // same as gray
+honeydew: "honeydew",
+hotpink: "roz aprins",
+indianred: "roÅŸu indian",
+indigo: "indigo",
+ivory: "ivoriu",
+khaki: "kaki",
+lavender: "levănţică",
+lavenderblush: "lavender blush",
+lawngreen: "lawn green",
+lemonchiffon: "lemon chiffon",
+lightblue: "albastru deschis",
+lightcoral: "coral deschis",
+lightcyan: "cyan deschis",
+lightgoldenrodyellow: "light goldenrod yellow",
+lightgray: "gri deschis",
+lightgreen: "verde deschis",
+lightgrey: "gri deschis", // same as lightgray
+lightpink: "roz deschis",
+lightsalmon: "somon deschis",
+lightseagreen: "verde marin deschis",
+lightskyblue: "albastru cer deschis",
+lightslategray: "light slate gray",
+lightslategrey: "light slate gray", // same as lightslategray
+lightsteelblue: "light steel blue",
+lightyellow: "galben deschis",
+lime: "lime",
+limegreen: "verde lime",
+linen: "linen",
+magenta: "magenta",
+maroon: "maroon",
+mediumaquamarine: "medium aquamarine",
+mediumblue: "medium blue",
+mediumorchid: "medium orchid",
+mediumpurple: "medium purple",
+mediumseagreen: "medium sea green",
+mediumslateblue: "medium slate blue",
+mediumspringgreen: "medium spring green",
+mediumturquoise: "medium turquoise",
+mediumvioletred: "medium violet-red",
+midnightblue: "midnight blue",
+mintcream: "mint cream",
+mistyrose: "trandafiriu obscur",
+moccasin: "moccasin",
+navajowhite: "navajo white",
+navy: "navy",
+oldlace: "old lace",
+olive: "oliv",
+olivedrab: "maron-gălbui oliv",
+orange: "portocaliu",
+orangered: "roÅŸu portocaliu",
+orchid: "orhidee",
+palegoldenrod: "solidago pal",
+palegreen: "verde pal",
+paleturquoise: "turquoise pal",
+palevioletred: "roÅŸu violet pal",
+papayawhip: "papaya whip",
+peachpuff: "puf de piersică",
+peru: "peru",
+pink: "roz",
+plum: "prună",
+powderblue: "albastru pudră",
+purple: "purpură",
+red: "roÅŸu",
+rosybrown: "maro trandafiriu",
+royalblue: "albastru regal",
+saddlebrown: "maro de ÅŸa",
+salmon: "somon",
+sandybrown: "maro nisipiu",
+seagreen: "verde marin",
+seashell: "cochilie",
+sienna: "sienna",
+silver: "argintiu",
+skyblue: "albastru de cer",
+slateblue: "albastru ardezie",
+slategray: "gri ardezie",
+slategrey: "gri ardezie", // same as slategray
+snow: "zăpadă",
+springgreen: "verde de primăvară",
+steelblue: "albastru metalic",
+tan: "tan",
+teal: "lişiţă",
+thistle: "ciulin",
+tomato: "roÅŸie",
+transparent: "transparent",
+turquoise: "turquoise",
+violet: "violet",
+wheat: "grâu",
+white: "alb",
+whitesmoke: "fum alb",
+yellow: "galben",
+yellowgreen: "verde galben"
+})
+
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/ru/colors.js b/js/dojo-1.7.2/dojo/nls/ru/colors.js
new file mode 100644
index 0000000..65f1024
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/ru/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/ru/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "�еро-голубой",
+antiquewhite: "белый антик",
+aqua: "зеленовато-голубой",
+aquamarine: "аквамарин",
+azure: "лазурный",
+beige: "бежевый",
+bisque: "би�квитный",
+black: "черный",
+blanchedalmond: "�ветло-миндальный",
+blue: "�иний",
+blueviolet: "�ине-фиолетовый",
+brown: "коричневый",
+burlywood: "�ветло-коричневый",
+cadetblue: "�еро-�иний",
+chartreuse: "желто-�алатный",
+chocolate: "шоколадный",
+coral: "коралловый",
+cornflowerblue: "фиолетово-�иний",
+cornsilk: "шелковый оттенок",
+crimson: "малиновый",
+cyan: "циан",
+darkblue: "темно-�иний",
+darkcyan: "темный циан",
+darkgoldenrod: "темно-золоти�тый",
+darkgray: "темно-�ерый",
+darkgreen: "темно-зеленый",
+darkgrey: "темно-�ерый", // same as darkgray
+darkkhaki: "темный хаки",
+darkmagenta: "темно-пурпурный",
+darkolivegreen: "темно-оливковый",
+darkorange: "темно-оранжевый",
+darkorchid: "темный ор�ель",
+darkred: "темно-кра�ный",
+darksalmon: "темно-ло�о�евый",
+darkseagreen: "темный мор�кой волны",
+darkslateblue: "темный грифельно-�иний",
+darkslategray: "темный грифельно-�ерый",
+darkslategrey: "темный грифельно-�ерый", // same as darkslategray
+darkturquoise: "темный бирюзовый",
+darkviolet: "темно-фиолетовый",
+deeppink: "темно-розовый",
+deepskyblue: "темный небе�но-голубой",
+dimgray: "ту�кло-�ерый",
+dimgrey: "ту�кло-�ерый", // same as dimgray
+dodgerblue: "бледно-�иний",
+firebrick: "кирпичный",
+floralwhite: "цветочно-белый",
+forestgreen: "зеленый ле�ной",
+fuchsia: "фук�ин",
+gainsboro: "бледно-�ерый",
+ghostwhite: "призрачно-белый",
+gold: "золотой",
+goldenrod: "золоти�тый",
+gray: "�ерый",
+green: "зеленый",
+greenyellow: "зелено-желтый",
+grey: "�ерый", // same as gray
+honeydew: "медовый",
+hotpink: "кра�но-розовый",
+indianred: "индий�кий кра�ный",
+indigo: "индиго",
+ivory: "�лоновой ко�ти",
+khaki: "хаки",
+lavender: "бледно-лиловый",
+lavenderblush: "розовато-лиловый",
+lawngreen: "зелена� лужайка",
+lemonchiffon: "бледно-лимонный",
+lightblue: "�ветло-�иний",
+lightcoral: "�ветло-коралловый",
+lightcyan: "�ветлый циан",
+lightgoldenrodyellow: "�ветло-золоти�тый",
+lightgray: "�ветло-�ерый",
+lightgreen: "�ветло-зеленый",
+lightgrey: "�ветло-�ерый", // same as lightgray
+lightpink: "�ветло-розовый",
+lightsalmon: "�ветло-ло�о�евый",
+lightseagreen: "�ветлый мор�кой волны",
+lightskyblue: "�ветлый небе�но-голубой",
+lightslategray: "�ветлый грифельно-�ерый",
+lightslategrey: "�ветлый грифельно-�ерый", // same as lightslategray
+lightsteelblue: "�ветлый �тальной",
+lightyellow: "�ветло-желтый",
+lime: "лайм",
+limegreen: "зеленый лайм",
+linen: "хлопковый",
+magenta: "пурпурный",
+maroon: "темно-бордовый",
+mediumaquamarine: "нейтральный аквамарин",
+mediumblue: "нейтральный �иний",
+mediumorchid: "нейтральный ор�ель",
+mediumpurple: "нейтральный фиолетовый",
+mediumseagreen: "нейтральный мор�кой волны",
+mediumslateblue: "нейтральный грифельно-�иний",
+mediumspringgreen: "нейтральный ве�енне-зеленый",
+mediumturquoise: "нейтральный бирюзовый",
+mediumvioletred: "нейтральный фиолетово-кра�ный",
+midnightblue: "полуночно-�иний",
+mintcream: "м�тно-кремовый",
+mistyrose: "блекло-розовый",
+moccasin: "мока�ин",
+navajowhite: "белый навахо",
+navy: "темно-�иний",
+oldlace: "матово-белый",
+olive: "оливковый",
+olivedrab: "желтовато-�ерый",
+orange: "оранжевый",
+orangered: "оранжево-кра�ный",
+orchid: "ор�ель",
+palegoldenrod: "бледно-золоти�тый",
+palegreen: "бледно-зеленый",
+paleturquoise: "бледно-бирюзовый",
+palevioletred: "бледный фиолетово-кра�ный",
+papayawhip: "черенок папайи",
+peachpuff: "пер�иковый",
+peru: "перу",
+pink: "розовый",
+plum: "�ливовый",
+powderblue: "пороховой",
+purple: "фиолетовый",
+red: "кра�ный",
+rosybrown: "розово-коричневый",
+royalblue: "королев�кий голубой",
+saddlebrown: "кожано-коричневый",
+salmon: "ло�о�евый",
+sandybrown: "коричнево-пе�чаный",
+seagreen: "мор�кой волны",
+seashell: "мор�ка� раковина",
+sienna: "охра",
+silver: "�еребри�тый",
+skyblue: "небе�но-голубой",
+slateblue: "грифельно-�иний",
+slategray: "грифельно-�ерый",
+slategrey: "грифельно-�ерый", // same as slategray
+snow: "бело�нежный",
+springgreen: "ве�енний зеленый",
+steelblue: "�тальной",
+tan: "рыжевато-коричневый",
+teal: "чирок",
+thistle: "чертополох",
+tomato: "помидор",
+transparent: "прозрачный",
+turquoise: "бирюзовый",
+violet: "фиолетовый",
+wheat: "пшеница",
+white: "белый",
+whitesmoke: "дымчато-белый",
+yellow: "желтый",
+yellowgreen: "желто-зеленый"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/sk/colors.js b/js/dojo-1.7.2/dojo/nls/sk/colors.js
new file mode 100644
index 0000000..f958bfb
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/sk/colors.js
@@ -0,0 +1,161 @@
+//>>built
+define(
+"dojo/nls/sk/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "modrá alice",
+antiquewhite: "antická biela",
+aqua: "svetlá zelenomodrá",
+aquamarine: "akvamarínová",
+azure: "azúrová",
+beige: "béžová",
+bisque: "biskvitová",
+black: "�ierna",
+blanchedalmond: "lúpané mandle",
+blue: "modrá",
+blueviolet: "modrofialová",
+brown: "hnedá",
+burlywood: "pieskovo hnedá",
+cadetblue: "sivomodrá",
+chartreuse: "kartúza",
+chocolate: "�okoládovo hnedá",
+coral: "koralová",
+cornflowerblue: "nevädzovo modrá",
+cornsilk: "hodvábna žltá",
+crimson: "karmínová",
+cyan: "zelenomodrá",
+darkblue: "tmavomodrá",
+darkcyan: "tmavozelenomodrá",
+darkgoldenrod: "zlatobyľová tmavá",
+darkgray: "tmavosivá",
+darkgreen: "tmavozelená",
+darkgrey: "tmavosivá", // same as darkgray
+darkkhaki: "žltohnedá tmavá",
+darkmagenta: "tmavopurpurová",
+darkolivegreen: "olivovozelená tmavá",
+darkorange: "tmavooranžová",
+darkorchid: "orchideovo ružová tmavá",
+darkred: "tmavo�ervená",
+darksalmon: "lososovo ružová tmavá",
+darkseagreen: "morská zelená tmavá",
+darkslateblue: "bridlicová modrá tmavá",
+darkslategray: "bridlicová sivá tmavá",
+darkslategrey: "bridlicová sivá tmavá", // same as darkslategray
+darkturquoise: "tyrkysová tmavá",
+darkviolet: "tmavofialová",
+deeppink: "hlboká ružová",
+deepskyblue: "hlboká blankytná modrá",
+dimgray: "sivá matná",
+dimgrey: "sivá matná", // same as dimgray
+dodgerblue: "modrá dodger",
+firebrick: "pálená tehla",
+floralwhite: "kvetinová biela",
+forestgreen: "lesná zelená",
+fuchsia: "purpurová",
+gainsboro: "sivomodrá svetlá",
+ghostwhite: "biely tieň",
+gold: "zlatá",
+goldenrod: "zlatobyľ",
+gray: "sivá",
+green: "zelená",
+greenyellow: "žltozelená",
+grey: "sivá", // same as gray
+honeydew: "ambrózia",
+hotpink: "teplá ružová",
+indianred: "indická �ervená",
+indigo: "fialovo modrá",
+ivory: "slonovinová",
+khaki: "khaki",
+lavender: "levanduľová",
+lavenderblush: "levanduľový rumenec",
+lawngreen: "zelená tráva",
+lemonchiffon: "citrónový šifón",
+lightblue: "svetlomodrá",
+lightcoral: "koralová svetlá",
+lightcyan: "zelenomodrá svetlá",
+lightgoldenrodyellow: "zlatobyľová svetlá",
+lightgray: "svetlosivá",
+lightgreen: "svetlozelená",
+lightgrey: "svetlosivá", // same as lightgray
+lightpink: "svetloružová",
+lightsalmon: "lososovo ružová svetlá",
+lightseagreen: "morská zelená svetlá",
+lightskyblue: "blankytná modrá svetlá",
+lightslategray: "bridlicová sivá svetlá",
+lightslategrey: "bridlicová sivá svetlá", // same as lightslategray
+lightsteelblue: "oceľovo modrá svetlá",
+lightyellow: "svetložltá",
+lime: "lipová",
+limegreen: "lipová zelená",
+linen: "ľan",
+magenta: "purpurová",
+maroon: "gaštanovo hnedá",
+mediumaquamarine: "akvamarínová stredná",
+mediumblue: "stredne modrá",
+mediumorchid: "orchideovo ružová stredná",
+mediumpurple: "purpurová stredná",
+mediumseagreen: "morská zelená stredná",
+mediumslateblue: "bridlicová modrá stredná",
+mediumspringgreen: "jarná zelená stredná",
+mediumturquoise: "tyrkysová stredná",
+mediumvioletred: "fialovo�ervená stredná",
+midnightblue: "no�ná modrá",
+mintcream: "mätová krémová",
+mistyrose: "zahmlená ruža",
+moccasin: "�rievi�níková",
+navajowhite: "navajská biela",
+navy: "vojenská zelená",
+oldlace: "stará �ipka",
+olive: "olivovo zelená",
+olivedrab: "olivovo zelená fádna",
+orange: "oranžová",
+orangered: "oranžovo �ervená",
+orchid: "orchideovo ružová",
+palegoldenrod: "bledá zlatobyľová",
+palegreen: "bledozelená",
+paleturquoise: "bledo tyrkysová",
+palevioletred: "bledá fialovo �ervená",
+papayawhip: "papájový krém",
+peachpuff: "broskyňová pena",
+peru: "peru",
+pink: "ružová",
+plum: "slivková",
+powderblue: "prášková modrá",
+purple: "purpurová",
+red: "�ervená",
+rosybrown: "ružovo hnedá",
+royalblue: "kráľovská modrá",
+saddlebrown: "sedlová hnedá",
+salmon: "lososovo ružová",
+sandybrown: "pieskovo hnedá",
+seagreen: "morská zelená",
+seashell: "lastúrová",
+sienna: "sienská",
+silver: "strieborná",
+skyblue: "blankytná modrá",
+slateblue: "bridlicová modrá",
+slategray: "bridlicová sivá",
+slategrey: "bridlicová sivá", // same as slategray
+snow: "snehobiela",
+springgreen: "jarná zelená",
+steelblue: "oceľovo modrá",
+tan: "žltohnedá",
+teal: "tyrkysová",
+thistle: "bodliaková fialová",
+tomato: "paradajková �ervená",
+transparent: "priesvitná",
+turquoise: "tyrkysová",
+violet: "fialová",
+wheat: "pšeni�ná",
+white: "biela",
+whitesmoke: "biely dym",
+yellow: "žltá",
+yellowgreen: "žltozelená"
+})
+
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/sl/colors.js b/js/dojo-1.7.2/dojo/nls/sl/colors.js
new file mode 100644
index 0000000..d8c0d30
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/sl/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/sl/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "alice blue modra",
+antiquewhite: "anti�no bela",
+aqua: "akva",
+aquamarine: "akvamarin",
+azure: "azurno modra",
+beige: "bež",
+bisque: "porcelanasta",
+black: "�rna",
+blanchedalmond: "obledelo mandljeva",
+blue: "modra",
+blueviolet: "modro vijoli�na",
+brown: "rjava",
+burlywood: "peš�eno sivo-rjava",
+cadetblue: "kadetsko modra",
+chartreuse: "chartreuse",
+chocolate: "�okoladna",
+coral: "koralna",
+cornflowerblue: "plavi�asto modra",
+cornsilk: "koruzna",
+crimson: "karminasta",
+cyan: "cijan",
+darkblue: "temno modra",
+darkcyan: "temno cijan",
+darkgoldenrod: "temna zlata rozga",
+darkgray: "temno siva",
+darkgreen: "temno zelena",
+darkgrey: "temno siva", // same as darkgray
+darkkhaki: "temno kaki",
+darkmagenta: "temna magenta",
+darkolivegreen: "temna olivno zelena",
+darkorange: "temno oranžna",
+darkorchid: "temno orhidejasta",
+darkred: "temno rde�a",
+darksalmon: "temno lososova",
+darkseagreen: "temno morsko zelena",
+darkslateblue: "temno skrilasto modra",
+darkslategray: "temno skrilasto siva",
+darkslategrey: "temno skrilasto siva", // same as darkslategray
+darkturquoise: "temno turkizna",
+darkviolet: "temno vijoli�na",
+deeppink: "temno rožnata",
+deepskyblue: "temno nebeško modra",
+dimgray: "pepelnato siva",
+dimgrey: "pepelnato siva", // same as dimgray
+dodgerblue: "dodgersko modra",
+firebrick: "ope�nata",
+floralwhite: "cvetno bela",
+forestgreen: "gozdno zelena",
+fuchsia: "fuksija",
+gainsboro: "gainsboro",
+ghostwhite: "sen�nato bela",
+gold: "zlata",
+goldenrod: "zlata rozga",
+gray: "siva",
+green: "zelena",
+greenyellow: "zeleno-rumena",
+grey: "siva", // same as gray
+honeydew: "medena rosa",
+hotpink: "kri�e�e rožnata",
+indianred: "indijansko rde�a",
+indigo: "indigo",
+ivory: "slonokoš�ena",
+khaki: "kaki",
+lavender: "sivka",
+lavenderblush: "rožnato sivka",
+lawngreen: "travniško zelena",
+lemonchiffon: "limonast Å¡ifon",
+lightblue: "svetlo modra",
+lightcoral: "svetlo koralna",
+lightcyan: "svetlo cijan",
+lightgoldenrodyellow: "svetlo rumena zlata rozga",
+lightgray: "svetlo siva",
+lightgreen: "svetlo zelena",
+lightgrey: "svetlo siva", // same as lightgray
+lightpink: "svetlo rožnata",
+lightsalmon: "svetlo lososova",
+lightseagreen: "svetlo morsko zelena",
+lightskyblue: "svetlo nebeško modra",
+lightslategray: "svetlo skrilasto siva",
+lightslategrey: "svetlo skrilasto siva", // same as lightslategray
+lightsteelblue: "svetlo kovinsko modra",
+lightyellow: "svetlo rumena",
+lime: "limetasta",
+limegreen: "apneno zelena",
+linen: "lanena",
+magenta: "magenta",
+maroon: "kostanjeva",
+mediumaquamarine: "srednji akvamarin",
+mediumblue: "srednje modra",
+mediumorchid: "srednje orhidejasta",
+mediumpurple: "srednje Å¡krlatna",
+mediumseagreen: "srednje morsko zelena",
+mediumslateblue: "srednje skrilasto modra",
+mediumspringgreen: "srednje pomladno zelena",
+mediumturquoise: "srednje turkizna",
+mediumvioletred: "srednje vijoli�no rde�a",
+midnightblue: "polno�no modra",
+mintcream: "metina krema",
+mistyrose: "megleno rožnata",
+moccasin: "mokasinasta",
+navajowhite: "navajo bela",
+navy: "mornarska",
+oldlace: "stara �ipka",
+olive: "olivna",
+olivedrab: "umazano olivna",
+orange: "oranžna",
+orangered: "oranžno-rde�a",
+orchid: "orhidejasta",
+palegoldenrod: "bleda zlata rozga",
+palegreen: "bledo zelena",
+paleturquoise: "bledo turkizna",
+palevioletred: "bledo vijoli�no-rde�a",
+papayawhip: "papaja",
+peachpuff: "breskova",
+peru: "perujska",
+pink: "rožnata",
+plum: "slivova",
+powderblue: "kobaltovo modra",
+purple: "Å¡krlatna",
+red: "rde�a",
+rosybrown: "rožnato rjava",
+royalblue: "kraljevsko modra",
+saddlebrown: "sedlasto rjava",
+salmon: "lososova",
+sandybrown: "peš�eno rjava",
+seagreen: "morsko zelena",
+seashell: "morska lupina",
+sienna: "sienna",
+silver: "srebrna",
+skyblue: "nebeško modra",
+slateblue: "skrilasto modra",
+slategray: "skrilasto siva",
+slategrey: "skrilasto siva", // same as slategray
+snow: "snežena",
+springgreen: "pomladno zelena",
+steelblue: "kovinsko modra",
+tan: "rumeno-rjava",
+teal: "modrozelena",
+thistle: "osatna",
+tomato: "paradižnikova",
+transparent: "prosojno",
+turquoise: "turkizna",
+violet: "vijoli�na",
+wheat: "pšeni�na",
+white: "bela",
+whitesmoke: "megleno bela",
+yellow: "rumena",
+yellowgreen: "rumeno-zelena"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/sv/colors.js b/js/dojo-1.7.2/dojo/nls/sv/colors.js
new file mode 100644
index 0000000..06e23be
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/sv/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/sv/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "aliceblå",
+antiquewhite: "antikvitt",
+aqua: "akvamarin",
+aquamarine: "akvamarin",
+azure: "azurblått",
+beige: "beige",
+bisque: "biskvi",
+black: "svart",
+blanchedalmond: "skållad mandel",
+blue: "blått",
+blueviolet: "blåviolett",
+brown: "brunt",
+burlywood: "träfärgat",
+cadetblue: "kadettblått",
+chartreuse: "chartreuse",
+chocolate: "choklad",
+coral: "korall",
+cornflowerblue: "kornblått",
+cornsilk: "gulvitt",
+crimson: "karmosinrött",
+cyan: "cyan",
+darkblue: "mörkblått",
+darkcyan: "mörkt cyan",
+darkgoldenrod: "mörkt gullris",
+darkgray: "mörkgrått",
+darkgreen: "mörkgrönt",
+darkgrey: "mörkgrått", // same as darkgray
+darkkhaki: "mörkt kaki",
+darkmagenta: "mörk magenta",
+darkolivegreen: "mörkt olivgrönt",
+darkorange: "mörkorange",
+darkorchid: "mörkt orkidé",
+darkred: "mörkrött",
+darksalmon: "mörkt laxfärgat",
+darkseagreen: "mörkt havsgrönt",
+darkslateblue: "mörkt skifferblått",
+darkslategray: "mörkt skiffergrått",
+darkslategrey: "mörkt skiffergrått", // same as darkslategray
+darkturquoise: "mörkturkost",
+darkviolet: "mörkviolett",
+deeppink: "djuprosa",
+deepskyblue: "mörkt himmelsblått",
+dimgray: "smutsgrått",
+dimgrey: "smutsgrått", // same as dimgray
+dodgerblue: "dodgerblått",
+firebrick: "tegelstensrött",
+floralwhite: "blomvitt",
+forestgreen: "skogsgrönt",
+fuchsia: "fuchsia",
+gainsboro: "gainsboro",
+ghostwhite: "spökvitt",
+gold: "guld",
+goldenrod: "gullris",
+gray: "grått",
+green: "grönt",
+greenyellow: "gröngult",
+grey: "grått", // same as gray
+honeydew: "honungsdagg",
+hotpink: "varmrosa",
+indianred: "indianrött",
+indigo: "indigo",
+ivory: "elfenbensvitt",
+khaki: "kaki",
+lavender: "lavendel",
+lavenderblush: "lavendelskimrande",
+lawngreen: "gräsmattegrönt",
+lemonchiffon: "citronchiffong",
+lightblue: "ljusblått",
+lightcoral: "ljuskorall",
+lightcyan: "ljust cyan",
+lightgoldenrodyellow: "ljust gullrisgult",
+lightgray: "ljusgrått",
+lightgreen: "ljusgrönt",
+lightgrey: "ljusgrått", // same as lightgray
+lightpink: "ljusrosa",
+lightsalmon: "ljust laxfärgat",
+lightseagreen: "ljust havsgrönt",
+lightskyblue: "ljust himmelsblått",
+lightslategray: "ljust skiffergrått",
+lightslategrey: "ljust skiffergrått", // same as lightslategray
+lightsteelblue: "ljust stålblått",
+lightyellow: "ljusgult",
+lime: "lime",
+limegreen: "limegrönt",
+linen: "linne",
+magenta: "magenta",
+maroon: "rödbrunt",
+mediumaquamarine: "mellanakvamarin",
+mediumblue: "mellanblått",
+mediumorchid: "mellanorkidé",
+mediumpurple: "mellanlila",
+mediumseagreen: "mellanhavsgrönt",
+mediumslateblue: "mellanskifferblått",
+mediumspringgreen: "mellanvårgrönt",
+mediumturquoise: "mellanturkost",
+mediumvioletred: "mellanviolettrött",
+midnightblue: "midnattsblått",
+mintcream: "mintgrädde",
+mistyrose: "dunkelrosa",
+moccasin: "mockasin",
+navajowhite: "navajovitt",
+navy: "marinblått",
+oldlace: "spetsvitt",
+olive: "olivfärgat",
+olivedrab: "olivsmutsgult",
+orange: "orange",
+orangered: "orangerött",
+orchid: "orkidé",
+palegoldenrod: "blekt gullris",
+palegreen: "blekgrönt",
+paleturquoise: "blekturkost",
+palevioletred: "blekviolettrött",
+papayawhip: "papayaröra",
+peachpuff: "persika",
+peru: "peru",
+pink: "rosa",
+plum: "plommon",
+powderblue: "pulverblått",
+purple: "lila",
+red: "rött",
+rosybrown: "rosenbrunt",
+royalblue: "kungligt blått",
+saddlebrown: "sadelbrunt",
+salmon: "laxfärgat",
+sandybrown: "sandbrunt",
+seagreen: "havsgrönt",
+seashell: "snäckskal",
+sienna: "sienna",
+silver: "silver",
+skyblue: "himmelsblått",
+slateblue: "skifferblått",
+slategray: "skiffergrått",
+slategrey: "skiffergrått", // same as slategray
+snow: "snö",
+springgreen: "vårgrönt",
+steelblue: "stålblått",
+tan: "mellanbrunt",
+teal: "blågrönt",
+thistle: "tistel",
+tomato: "tomatrött",
+transparent: "transparent",
+turquoise: "turkost",
+violet: "violett",
+wheat: "vete",
+white: "vitt",
+whitesmoke: "vit rök",
+yellow: "gult",
+yellowgreen: "gulgrönt"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/th/colors.js b/js/dojo-1.7.2/dojo/nls/th/colors.js
new file mode 100644
index 0000000..9d36b68
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/th/colors.js
@@ -0,0 +1,161 @@
+//>>built
+define(
+"dojo/nls/th/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "alice blue",
+antiquewhite: "antique white",
+aqua: "ฟ้าน้ำทะเล",
+aquamarine: "aquamarine",
+azure: "น้ำเงินฟ้า",
+beige: "น้ำตาลเบจ",
+bisque: "bisque",
+black: "ดำ",
+blanchedalmond: "blanched almond",
+blue: "น้ำเงิน",
+blueviolet: "น้ำเงินม่วง",
+brown: "น้ำตาล",
+burlywood: "burlywood",
+cadetblue: "cadet blue",
+chartreuse: "chartreuse",
+chocolate: "ช็อ�โ��ลต",
+coral: "coral",
+cornflowerblue: "cornflower blue",
+cornsilk: "cornsilk",
+crimson: "�ดงเลือดหมู",
+cyan: "เขียว��มน้ำเงิน",
+darkblue: "น้ำเงินเข้ม",
+darkcyan: "เขียว��มน้ำเงินเข้ม",
+darkgoldenrod: "dark goldenrod",
+darkgray: "เทาเข้ม",
+darkgreen: "เขียวเข้ม",
+darkgrey: "เทาเข้ม", // same as darkgray
+darkkhaki: "dark khaki",
+darkmagenta: "�ดง��มม่วงเข้ม",
+darkolivegreen: "เขียวโอลีฟเข้ม",
+darkorange: "ส้มเข้ม",
+darkorchid: "dark orchid",
+darkred: "�ดงเข้ม",
+darksalmon: "dark salmon",
+darkseagreen: "dark sea green",
+darkslateblue: "dark slate blue",
+darkslategray: "dark slate gray",
+darkslategrey: "dark slate gray", // same as darkslategray
+darkturquoise: "dark turquoise",
+darkviolet: "ม่วงเข้ม",
+deeppink: "ชมพูเข้ม",
+deepskyblue: "deep sky blue",
+dimgray: "dim gray",
+dimgrey: "dim gray", // same as dimgray
+dodgerblue: "dodger blue",
+firebrick: "สีอิ�",
+floralwhite: "floral white",
+forestgreen: "forest green",
+fuchsia: "fuchsia",
+gainsboro: "gainsboro",
+ghostwhite: "ghost white",
+gold: "ทอง",
+goldenrod: "goldenrod",
+gray: "เทา",
+green: "เขียว",
+greenyellow: "เขียว��มเหลือง",
+grey: "เทา", // same as gray
+honeydew: "honeydew",
+hotpink: "hot pink",
+indianred: "indian red",
+indigo: "indigo",
+ivory: "งาช้าง",
+khaki: "khaki",
+lavender: "ม่วงลาเวนเดอร์",
+lavenderblush: "lavender blush",
+lawngreen: "lawn green",
+lemonchiffon: "lemon chiffon",
+lightblue: "น้ำเงินอ่อน",
+lightcoral: "light coral",
+lightcyan: "เขียว��มน้ำเงินอ่อน",
+lightgoldenrodyellow: "light goldenrod yellow",
+lightgray: "เทาอ่อน",
+lightgreen: "เขียวอ่อน",
+lightgrey: "เทาอ่อน", // same as lightgray
+lightpink: "ชมพูอ่อน",
+lightsalmon: "light salmon",
+lightseagreen: "light sea green",
+lightskyblue: "ฟ้าอ่อน",
+lightslategray: "light slate gray",
+lightslategrey: "light slate gray", // same as lightslategray
+lightsteelblue: "light steel blue",
+lightyellow: "เหลืองอ่อน",
+lime: "เหลืองมะนาว",
+limegreen: "เขียวมะนาว",
+linen: "linen",
+magenta: "�ดง��มม่วง",
+maroon: "น้ำตาล�ดง",
+mediumaquamarine: "medium aquamarine",
+mediumblue: "medium blue",
+mediumorchid: "medium orchid",
+mediumpurple: "medium purple",
+mediumseagreen: "medium sea green",
+mediumslateblue: "medium slate blue",
+mediumspringgreen: "medium spring green",
+mediumturquoise: "medium turquoise",
+mediumvioletred: "medium violet-red",
+midnightblue: "midnight blue",
+mintcream: "mint cream",
+mistyrose: "misty rose",
+moccasin: "ม็อคค่า",
+navajowhite: "navajo white",
+navy: "น้ำเงินเข้ม",
+oldlace: "old lace",
+olive: "โอลีฟ",
+olivedrab: "olive drab",
+orange: "ส้ม",
+orangered: "ส้ม��ม�ดง",
+orchid: "orchid",
+palegoldenrod: "pale goldenrod",
+palegreen: "pale green",
+paleturquoise: "pale turquoise",
+palevioletred: "pale violet-red",
+papayawhip: "papaya whip",
+peachpuff: "peach puff",
+peru: "peru",
+pink: "ชมพู",
+plum: "plum",
+powderblue: "powder blue",
+purple: "ม่วง",
+red: "�ดง",
+rosybrown: "rosy brown",
+royalblue: "royal blue",
+saddlebrown: "saddle brown",
+salmon: "salmon",
+sandybrown: "sandy brown",
+seagreen: "sea green",
+seashell: "seashell",
+sienna: "sienna",
+silver: "เงิน",
+skyblue: "sky blue",
+slateblue: "slate blue",
+slategray: "slate gray",
+slategrey: "slate gray", // same as slategray
+snow: "snow",
+springgreen: "spring green",
+steelblue: "steel blue",
+tan: "tan",
+teal: "teal",
+thistle: "thistle",
+tomato: "tomato",
+transparent: "สีใส",
+turquoise: "turquoise",
+violet: "ม่วง",
+wheat: "wheat",
+white: "ขาว",
+whitesmoke: "ขาวควัน",
+yellow: "เหลือง",
+yellowgreen: "เหลือง��มเขียว"
+})
+
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/tr/colors.js b/js/dojo-1.7.2/dojo/nls/tr/colors.js
new file mode 100644
index 0000000..f5df7dd
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/tr/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/tr/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "alice mavisi",
+antiquewhite: "antik beyaz",
+aqua: "deniz mavisi",
+aquamarine: "akuamarin",
+azure: "azur mavisi",
+beige: "bej",
+bisque: "bisküvi",
+black: "siyah",
+blanchedalmond: "soluk badem",
+blue: "mavi",
+blueviolet: "mavi-mor",
+brown: "kahverengi",
+burlywood: "sarımsı kahverengi",
+cadetblue: "denizci mavisi",
+chartreuse: "chartreuse",
+chocolate: "çikolata",
+coral: "mercan",
+cornflowerblue: "peygamber çiçeği mavisi",
+cornsilk: "mısır rengi",
+crimson: "crimson",
+cyan: "camgöbeği",
+darkblue: "koyu mavi",
+darkcyan: "koyu camgöbeği",
+darkgoldenrod: "koyu sarı",
+darkgray: "koyu gri",
+darkgreen: "koyu yeÅŸil",
+darkgrey: "koyu gri", // same as darkgray
+darkkhaki: "koyu haki",
+darkmagenta: "koyu mor",
+darkolivegreen: "koyu zeytin yeÅŸili",
+darkorange: "koyu turuncu",
+darkorchid: "koyu orkide",
+darkred: "koyu kırmızı",
+darksalmon: "koyu somon",
+darkseagreen: "koyu deniz yeÅŸili",
+darkslateblue: "koyu arduvaz mavisi",
+darkslategray: "koyu arduvaz grisi",
+darkslategrey: "koyu arduvaz grisi", // same as darkslategray
+darkturquoise: "koyu turkuaz",
+darkviolet: "koyu eflatun",
+deeppink: "koyu pembe",
+deepskyblue: "koyu gök mavisi",
+dimgray: "soluk gri",
+dimgrey: "soluk gri", // same as dimgray
+dodgerblue: "toz mavisi",
+firebrick: "canlı kiremit",
+floralwhite: "çiçek beyazı",
+forestgreen: "koyu deniz yeÅŸili",
+fuchsia: "fuÅŸya",
+gainsboro: "gainsboro",
+ghostwhite: "silik beyaz",
+gold: "altın",
+goldenrod: "sarısabır",
+gray: "gri",
+green: "yeÅŸil",
+greenyellow: "yeşil-sarı",
+grey: "gri", // same as gray
+honeydew: "çam sakızı",
+hotpink: "sıcak pembe",
+indianred: "kızılderili kırmızısı",
+indigo: "çivit mavisi",
+ivory: "fildiÅŸi",
+khaki: "haki",
+lavender: "lavanta",
+lavenderblush: "lavanta pembesi",
+lawngreen: "çimen yeşili",
+lemonchiffon: "limoni",
+lightblue: "açık mavi",
+lightcoral: "açık mercan",
+lightcyan: "açık camgöbeği",
+lightgoldenrodyellow: "açık sarısabır",
+lightgray: "açık gri",
+lightgreen: "açık yeşil",
+lightgrey: "açık gri", // same as lightgray
+lightpink: "açık pembe",
+lightsalmon: "açık somon",
+lightseagreen: "açık deniz yeşili",
+lightskyblue: "açık gök mavisi",
+lightslategray: "açık arduvaz grisi",
+lightslategrey: "açık arduvaz grisi", // same as lightslategray
+lightsteelblue: "açık metalik mavi",
+lightyellow: "açık sarı",
+lime: "limon yeÅŸili",
+limegreen: "küf yeşili",
+linen: "keten",
+magenta: "macenta",
+maroon: "kestane",
+mediumaquamarine: "orta akuamarin",
+mediumblue: "orta mavi",
+mediumorchid: "orta orkide",
+mediumpurple: "orta mor",
+mediumseagreen: "orta deniz yeÅŸili",
+mediumslateblue: "orta arduvaz mavisi",
+mediumspringgreen: "orta bahar yeÅŸili",
+mediumturquoise: "orta turkuaz",
+mediumvioletred: "orta menekşe kırmızısı",
+midnightblue: "gece mavisi",
+mintcream: "naneli krem",
+mistyrose: "gülkurusu",
+moccasin: "mokosen",
+navajowhite: "navajo beyazı",
+navy: "lacivert",
+oldlace: "eski dantel",
+olive: "zeytin",
+olivedrab: "asker yeÅŸili",
+orange: "turuncu",
+orangered: "turuncu kırmızı",
+orchid: "orkide",
+palegoldenrod: "soluk sarısabır",
+palegreen: "soluk yeÅŸil",
+paleturquoise: "soluk turkuaz",
+palevioletred: "soluk menekşe kırmızısı",
+papayawhip: "papaya sapı",
+peachpuff: "açık şeftali",
+peru: "peru",
+pink: "pembe",
+plum: "erik",
+powderblue: "pudra mavisi",
+purple: "mor",
+red: "kırmızı",
+rosybrown: "pembemsi kahverengi",
+royalblue: "parlak koyu mavi",
+saddlebrown: "açık kahve",
+salmon: "somon",
+sandybrown: "kum rengi",
+seagreen: "deniz yeÅŸili",
+seashell: "deniz kabuÄŸu",
+sienna: "koyu kahve",
+silver: "gümüş",
+skyblue: "gök mavisi",
+slateblue: "arduvaz mavisi",
+slategray: "arduvaz grisi",
+slategrey: "arduvaz grisi", // same as slategray
+snow: "kar",
+springgreen: "bahar yeÅŸili",
+steelblue: "metalik mavi",
+tan: "güneş yanığı",
+teal: "Teal mavi",
+thistle: "devedikeni",
+tomato: "domates",
+transparent: "saydam",
+turquoise: "turkuaz",
+violet: "eflatun",
+wheat: "buÄŸday",
+white: "beyaz",
+whitesmoke: "beyaz duman",
+yellow: "sarı",
+yellowgreen: "sarı yeşil"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/zh-tw/colors.js b/js/dojo-1.7.2/dojo/nls/zh-tw/colors.js
new file mode 100644
index 0000000..a91b2ec
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/zh-tw/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/zh-tw/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "愛麗絲�",
+antiquewhite: "米白色",
+aqua: "水色",
+aquamarine: "碧綠色",
+azure: "天�色",
+beige: "�棕色",
+bisque: "橘黃色",
+black: "黑色",
+blanchedalmond: "��白",
+blue: "�色",
+blueviolet: "�紫色",
+brown: "�色",
+burlywood: "實木色",
+cadetblue: "���",
+chartreuse: "淡黃綠色",
+chocolate: "巧克力色",
+coral: "�瑚紅",
+cornflowerblue: "矢車��",
+cornsilk: "玉米黃",
+crimson: "暗深紅色",
+cyan: "�色",
+darkblue: "暗�色",
+darkcyan: "暗�色",
+darkgoldenrod: "暗金�色",
+darkgray: "暗�色",
+darkgreen: "暗綠色",
+darkgrey: "暗�色", // same as darkgray
+darkkhaki: "暗�其色",
+darkmagenta: "暗紫紅色",
+darkolivegreen: "暗橄欖綠",
+darkorange: "暗橙色",
+darkorchid: "暗蘭花色",
+darkred: "暗紅色",
+darksalmon: "æš—é®­ç´…",
+darkseagreen: "暗海綠色",
+darkslateblue: "暗岩�色",
+darkslategray: "暗岩�色",
+darkslategrey: "暗岩�色", // same as darkslategray
+darkturquoise: "暗�石綠",
+darkviolet: "暗紫羅蘭色",
+deeppink: "深粉紅色",
+deepskyblue: "深天�色",
+dimgray: "��色",
+dimgrey: "��色", // same as dimgray
+dodgerblue: "�奇�",
+firebrick: "紅磚色",
+floralwhite: "花�白",
+forestgreen: "森綠色",
+fuchsia: "海棠紅",
+gainsboro: "石��",
+ghostwhite: "幽�色",
+gold: "金色",
+goldenrod: "金�色",
+gray: "�色",
+green: "綠色",
+greenyellow: "綠黃色",
+grey: "�色", // same as gray
+honeydew: "密瓜色",
+hotpink: "暖粉紅色",
+indianred: "�度紅",
+indigo: "��色",
+ivory: "象牙色",
+khaki: "�其色",
+lavender: "薰衣�紫",
+lavenderblush: "薰衣�紫紅",
+lawngreen: "�綠色",
+lemonchiffon: "奶油黃",
+lightblue: "淡�色",
+lightcoral: "淡�瑚紅",
+lightcyan: "淡�色",
+lightgoldenrodyellow: "淡金�黃",
+lightgray: "淡�色",
+lightgreen: "淡綠色",
+lightgrey: "淡�色", // same as lightgray
+lightpink: "淡粉紅色",
+lightsalmon: "æ·¡é®­ç´…",
+lightseagreen: "淡海綠色",
+lightskyblue: "淡天�色",
+lightslategray: "淡岩�色",
+lightslategrey: "淡岩�色", // same as lightslategray
+lightsteelblue: "淡��色",
+lightyellow: "淡黃色",
+lime: "檸檬色",
+limegreen: "檸檬綠",
+linen: "亞麻色",
+magenta: "紫紅色",
+maroon: "栗色",
+mediumaquamarine: "中碧綠色",
+mediumblue: "中�色",
+mediumorchid: "中蘭紫色",
+mediumpurple: "中紫色",
+mediumseagreen: "中海綠色",
+mediumslateblue: "中岩�色",
+mediumspringgreen: "中春綠色",
+mediumturquoise: "中�石綠",
+mediumvioletred: "中紫羅蘭紅",
+midnightblue: "�夜�",
+mintcream: "薄�乳白色",
+mistyrose: "霧玫瑰色",
+moccasin: "鹿皮黃色",
+navajowhite: "�地安黃色",
+navy: "海��",
+oldlace: "舊蕾絲色",
+olive: "橄欖色",
+olivedrab: "橄欖綠",
+orange: "橙色",
+orangered: "橙紅色",
+orchid: "蘭花色",
+palegoldenrod: "�金�色",
+palegreen: "�綠色",
+paleturquoise: "��石綠",
+palevioletred: "�紫羅蘭紅",
+papayawhip: "番木瓜色",
+peachpuff: "粉撲桃色",
+peru: "祕魯色",
+pink: "粉紅色",
+plum: "�紫色",
+powderblue: "粉�色",
+purple: "紫色",
+red: "紅色",
+rosybrown: "玫瑰�",
+royalblue: "��色",
+saddlebrown: "��色",
+salmon: "鮭紅色",
+sandybrown: "沙�色",
+seagreen: "海綠色",
+seashell: "海�色",
+sienna: "黃土赭色",
+silver: "銀色",
+skyblue: "天�色",
+slateblue: "岩�色",
+slategray: "岩�色",
+slategrey: "岩�色", // same as slategray
+snow: "雪白色",
+springgreen: "春綠色",
+steelblue: "��色",
+tan: "皮�色",
+teal: "深�綠色",
+thistle: "薊色",
+tomato: "蕃茄紅",
+transparent: "�明",
+turquoise: "�石綠",
+violet: "紫羅蘭色",
+wheat: "�麥色",
+white: "白色",
+whitesmoke: "白煙色",
+yellow: "黃色",
+yellowgreen: "黃綠色"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/nls/zh/colors.js b/js/dojo-1.7.2/dojo/nls/zh/colors.js
new file mode 100644
index 0000000..c098d58
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/nls/zh/colors.js
@@ -0,0 +1,160 @@
+//>>built
+define(
+"dojo/nls/zh/colors", //begin v1.x content
+({
+// local representation of all CSS3 named colors, companion to dojo.colors.  To be used where descriptive information
+// is required for each color, such as a palette widget, and not for specifying color programatically.
+
+//Note: due to the SVG 1.0 spec additions, some of these are alternate spellings for the same color e.g. gray vs. gray.
+//TODO: should we be using unique rgb values as keys instead and avoid these duplicates, or rely on the caller to do the reverse mapping?
+aliceblue: "艾莉斯�",
+antiquewhite: "�董白",
+aqua: "水绿色",
+aquamarine: "碧绿色",
+azure: "浅天�",
+beige: "米色",
+bisque: "乳黄色",
+black: "黑色",
+blanchedalmond: "��白",
+blue: "�色",
+blueviolet: "�紫色",
+brown: "�色",
+burlywood: "原木色",
+cadetblue: "军队�",
+chartreuse: "浅黄绿色",
+chocolate: "巧克力色",
+coral: "�瑚红",
+cornflowerblue: "��色",
+cornsilk: "玉米黄",
+crimson: "绯红色",
+cyan: "�色",
+darkblue: "深�色",
+darkcyan: "深�色",
+darkgoldenrod: "深金黄色",
+darkgray: "深�色",
+darkgreen: "深绿色",
+darkgrey: "深�色", // same as darkgray
+darkkhaki: "深�色",
+darkmagenta: "深洋红色",
+darkolivegreen: "深橄榄绿色",
+darkorange: "深橙色",
+darkorchid: "暗兰花紫",
+darkred: "深红色",
+darksalmon: "深橙红",
+darkseagreen: "深海绿色",
+darkslateblue: "深石��",
+darkslategray: "深石��",
+darkslategrey: "深石��", // same as darkslategray
+darkturquoise: "深�绿色",
+darkviolet: "深紫罗兰",
+deeppink: "深粉色",
+deepskyblue: "深天�色",
+dimgray: "暗�色",
+dimgrey: "暗�色", // same as dimgray
+dodgerblue: "��",
+firebrick: "砖红色",
+floralwhite: "花白",
+forestgreen: "森林绿",
+fuchsia: "紫红色",
+gainsboro: "亮�色",
+ghostwhite: "�白",
+gold: "金黄色",
+goldenrod: "鲜黄",
+gray: "�色",
+green: "绿色",
+greenyellow: "绿黄色",
+grey: "�色", // same as gray
+honeydew: "蜜色",
+hotpink: "暗粉",
+indianred: "�度红",
+indigo: "��色",
+ivory: "象牙色",
+khaki: "黄�色",
+lavender: "淡紫色",
+lavenderblush: "淡紫红色",
+lawngreen: "�绿色",
+lemonchiffon: "柠檬色",
+lightblue: "淡�色",
+lightcoral: "浅�瑚红",
+lightcyan: "浅�色",
+lightgoldenrodyellow: "浅金黄色",
+lightgray: "浅�色",
+lightgreen: "浅绿色",
+lightgrey: "浅�色", // same as lightgray
+lightpink: "浅粉色",
+lightsalmon: "浅橙红色",
+lightseagreen: "浅海绿色",
+lightskyblue: "浅天�色",
+lightslategray: "浅石��",
+lightslategrey: "浅石��", // same as lightslategray
+lightsteelblue: "浅钢�色",
+lightyellow: "浅黄色",
+lime: "酸橙色",
+limegreen: "暗黄绿色",
+linen: "亚麻布色",
+magenta: "洋红色",
+maroon: "�紫红色",
+mediumaquamarine: "淡碧绿色",
+mediumblue: "淡�色",
+mediumorchid: "淡兰花紫",
+mediumpurple: "淡紫色",
+mediumseagreen: "淡海绿色",
+mediumslateblue: "淡��色",
+mediumspringgreen: "淡�绿色",
+mediumturquoise: "淡�绿色",
+mediumvioletred: "æ·¡ç´«ç½—å…°",
+midnightblue: "�黑色",
+mintcream: "薄�乳白",
+mistyrose: "粉红玫瑰",
+moccasin: "鹿皮黄",
+navajowhite: "�地安黄",
+navy: "��色",
+oldlace: "旧布黄",
+olive: "橄榄色",
+olivedrab: "暗橄榄色",
+orange: "橙色",
+orangered: "桔红色",
+orchid: "兰花紫",
+palegoldenrod: "浅金黄色",
+palegreen: "淡绿色",
+paleturquoise: "淡�绿色",
+palevioletred: "æµ…ç´«ç½—å…°",
+papayawhip: "粉木瓜橙",
+peachpuff: "粉桃红",
+peru: "秘�棕",
+pink: "粉红色",
+plum: "梅红色",
+powderblue: "粉�色",
+purple: "紫色",
+red: "红色",
+rosybrown: "玫瑰�色",
+royalblue: "亮�色",
+saddlebrown: "�具�色",
+salmon: "橙红色",
+sandybrown: "浅�色",
+seagreen: "海绿色",
+seashell: "�壳白",
+sienna: "赭色",
+silver: "银白色",
+skyblue: "天�色",
+slateblue: "石��",
+slategray: "石��",
+slategrey: "石��", // same as slategray
+snow: "雪白",
+springgreen: "浅�绿色",
+steelblue: "钢�色",
+tan: "茶色",
+teal: "�色",
+thistle: "蓟色",
+tomato: "番茄色",
+transparent: "�明的",
+turquoise: "�绿色",
+violet: "紫罗兰色",
+wheat: "淡黄色",
+white: "白色",
+whitesmoke: "烟白色",
+yellow: "黄色",
+yellowgreen: "黄绿色"
+})
+//end v1.x content
+);
diff --git a/js/dojo-1.7.2/dojo/number.js b/js/dojo-1.7.2/dojo/number.js
new file mode 100644
index 0000000..b19b042
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/number.js
@@ -0,0 +1,577 @@
+//>>built
+define("dojo/number", ["./_base/kernel", "./_base/lang", "./i18n", "./i18n!./cldr/nls/number", "./string", "./regexp"],
+	function(dojo, lang, i18n, nlsNumber, dstring, dregexp) {
+
+	// module:
+	//		dojo/number
+	// summary:
+	//		TODOC
+
+lang.getObject("number", true, dojo);
+
+/*=====
+dojo.number = {
+	// summary: localized formatting and parsing routines for Number
+}
+
+dojo.number.__FormatOptions = function(){
+	//	pattern: String?
+	//		override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
+	//		with this string.  Default value is based on locale.  Overriding this property will defeat
+	//		localization.  Literal characters in patterns are not supported.
+	//	type: String?
+	//		choose a format type based on the locale from the following:
+	//		decimal, scientific (not yet supported), percent, currency. decimal by default.
+	//	places: Number?
+	//		fixed number of decimal places to show.  This overrides any
+	//		information in the provided pattern.
+	//	round: Number?
+	//		5 rounds to nearest .5; 0 rounds to nearest whole (default). -1
+	//		means do not round.
+	//	locale: String?
+	//		override the locale used to determine formatting rules
+	//	fractional: Boolean?
+	//		If false, show no decimal places, overriding places and pattern settings.
+	this.pattern = pattern;
+	this.type = type;
+	this.places = places;
+	this.round = round;
+	this.locale = locale;
+	this.fractional = fractional;
+}
+=====*/
+
+dojo.number.format = function(/*Number*/value, /*dojo.number.__FormatOptions?*/options){
+	// summary:
+	//		Format a Number as a String, using locale-specific settings
+	// description:
+	//		Create a string from a Number using a known localized pattern.
+	//		Formatting patterns appropriate to the locale are chosen from the
+	//		[Common Locale Data Repository](http://unicode.org/cldr) as well as the appropriate symbols and
+	//		delimiters.
+	//		If value is Infinity, -Infinity, or is not a valid JavaScript number, return null.
+	// value:
+	//		the number to be formatted
+
+	options = lang.mixin({}, options || {});
+	var locale = i18n.normalizeLocale(options.locale),
+		bundle = i18n.getLocalization("dojo.cldr", "number", locale);
+	options.customs = bundle;
+	var pattern = options.pattern || bundle[(options.type || "decimal") + "Format"];
+	if(isNaN(value) || Math.abs(value) == Infinity){ return null; } // null
+	return dojo.number._applyPattern(value, pattern, options); // String
+};
+
+//dojo.number._numberPatternRE = /(?:[#0]*,?)*[#0](?:\.0*#*)?/; // not precise, but good enough
+dojo.number._numberPatternRE = /[#0,]*[#0](?:\.0*#*)?/; // not precise, but good enough
+
+dojo.number._applyPattern = function(/*Number*/value, /*String*/pattern, /*dojo.number.__FormatOptions?*/options){
+	// summary:
+	//		Apply pattern to format value as a string using options. Gives no
+	//		consideration to local customs.
+	// value:
+	//		the number to be formatted.
+	// pattern:
+	//		a pattern string as described by
+	//		[unicode.org TR35](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
+	// options: dojo.number.__FormatOptions?
+	//		_applyPattern is usually called via `dojo.number.format()` which
+	//		populates an extra property in the options parameter, "customs".
+	//		The customs object specifies group and decimal parameters if set.
+
+	//TODO: support escapes
+	options = options || {};
+	var group = options.customs.group,
+		decimal = options.customs.decimal,
+		patternList = pattern.split(';'),
+		positivePattern = patternList[0];
+	pattern = patternList[(value < 0) ? 1 : 0] || ("-" + positivePattern);
+
+	//TODO: only test against unescaped
+	if(pattern.indexOf('%') != -1){
+		value *= 100;
+	}else if(pattern.indexOf('\u2030') != -1){
+		value *= 1000; // per mille
+	}else if(pattern.indexOf('\u00a4') != -1){
+		group = options.customs.currencyGroup || group;//mixins instead?
+		decimal = options.customs.currencyDecimal || decimal;// Should these be mixins instead?
+		pattern = pattern.replace(/\u00a4{1,3}/, function(match){
+			var prop = ["symbol", "currency", "displayName"][match.length-1];
+			return options[prop] || options.currency || "";
+		});
+	}else if(pattern.indexOf('E') != -1){
+		throw new Error("exponential notation not supported");
+	}
+
+	//TODO: support @ sig figs?
+	var numberPatternRE = dojo.number._numberPatternRE;
+	var numberPattern = positivePattern.match(numberPatternRE);
+	if(!numberPattern){
+		throw new Error("unable to find a number expression in pattern: "+pattern);
+	}
+	if(options.fractional === false){ options.places = 0; }
+	return pattern.replace(numberPatternRE,
+		dojo.number._formatAbsolute(value, numberPattern[0], {decimal: decimal, group: group, places: options.places, round: options.round}));
+};
+
+dojo.number.round = function(/*Number*/value, /*Number?*/places, /*Number?*/increment){
+	//	summary:
+	//		Rounds to the nearest value with the given number of decimal places, away from zero
+	//	description:
+	//		Rounds to the nearest value with the given number of decimal places, away from zero if equal.
+	//		Similar to Number.toFixed(), but compensates for browser quirks. Rounding can be done by
+	//		fractional increments also, such as the nearest quarter.
+	//		NOTE: Subject to floating point errors.  See dojox.math.round for experimental workaround.
+	//	value:
+	//		The number to round
+	//	places:
+	//		The number of decimal places where rounding takes place.  Defaults to 0 for whole rounding.
+	//		Must be non-negative.
+	//	increment:
+	//		Rounds next place to nearest value of increment/10.  10 by default.
+	//	example:
+	//		>>> dojo.number.round(-0.5)
+	//		-1
+	//		>>> dojo.number.round(162.295, 2)
+	//		162.29  // note floating point error.  Should be 162.3
+	//		>>> dojo.number.round(10.71, 0, 2.5)
+	//		10.75
+	var factor = 10 / (increment || 10);
+	return (factor * +value).toFixed(places) / factor; // Number
+};
+
+if((0.9).toFixed() == 0){
+	// (isIE) toFixed() bug workaround: Rounding fails on IE when most significant digit
+	// is just after the rounding place and is >=5
+	var round = dojo.number.round;
+	dojo.number.round = function(v, p, m){
+		var d = Math.pow(10, -p || 0), a = Math.abs(v);
+		if(!v || a >= d || a * Math.pow(10, p + 1) < 5){
+			d = 0;
+		}
+		return round(v, p, m) + (v > 0 ? d : -d);
+	};
+}
+
+/*=====
+dojo.number.__FormatAbsoluteOptions = function(){
+	//	decimal: String?
+	//		the decimal separator
+	//	group: String?
+	//		the group separator
+	//	places: Number?|String?
+	//		number of decimal places.  the range "n,m" will format to m places.
+	//	round: Number?
+	//		5 rounds to nearest .5; 0 rounds to nearest whole (default). -1
+	//		means don't round.
+	this.decimal = decimal;
+	this.group = group;
+	this.places = places;
+	this.round = round;
+}
+=====*/
+
+dojo.number._formatAbsolute = function(/*Number*/value, /*String*/pattern, /*dojo.number.__FormatAbsoluteOptions?*/options){
+	// summary:
+	//		Apply numeric pattern to absolute value using options. Gives no
+	//		consideration to local customs.
+	// value:
+	//		the number to be formatted, ignores sign
+	// pattern:
+	//		the number portion of a pattern (e.g. `#,##0.00`)
+	options = options || {};
+	if(options.places === true){options.places=0;}
+	if(options.places === Infinity){options.places=6;} // avoid a loop; pick a limit
+
+	var patternParts = pattern.split("."),
+		comma = typeof options.places == "string" && options.places.indexOf(","),
+		maxPlaces = options.places;
+	if(comma){
+		maxPlaces = options.places.substring(comma + 1);
+	}else if(!(maxPlaces >= 0)){
+		maxPlaces = (patternParts[1] || []).length;
+	}
+	if(!(options.round < 0)){
+		value = dojo.number.round(value, maxPlaces, options.round);
+	}
+
+	var valueParts = String(Math.abs(value)).split("."),
+		fractional = valueParts[1] || "";
+	if(patternParts[1] || options.places){
+		if(comma){
+			options.places = options.places.substring(0, comma);
+		}
+		// Pad fractional with trailing zeros
+		var pad = options.places !== undefined ? options.places : (patternParts[1] && patternParts[1].lastIndexOf("0") + 1);
+		if(pad > fractional.length){
+			valueParts[1] = dstring.pad(fractional, pad, '0', true);
+		}
+
+		// Truncate fractional
+		if(maxPlaces < fractional.length){
+			valueParts[1] = fractional.substr(0, maxPlaces);
+		}
+	}else{
+		if(valueParts[1]){ valueParts.pop(); }
+	}
+
+	// Pad whole with leading zeros
+	var patternDigits = patternParts[0].replace(',', '');
+	pad = patternDigits.indexOf("0");
+	if(pad != -1){
+		pad = patternDigits.length - pad;
+		if(pad > valueParts[0].length){
+			valueParts[0] = dstring.pad(valueParts[0], pad);
+		}
+
+		// Truncate whole
+		if(patternDigits.indexOf("#") == -1){
+			valueParts[0] = valueParts[0].substr(valueParts[0].length - pad);
+		}
+	}
+
+	// Add group separators
+	var index = patternParts[0].lastIndexOf(','),
+		groupSize, groupSize2;
+	if(index != -1){
+		groupSize = patternParts[0].length - index - 1;
+		var remainder = patternParts[0].substr(0, index);
+		index = remainder.lastIndexOf(',');
+		if(index != -1){
+			groupSize2 = remainder.length - index - 1;
+		}
+	}
+	var pieces = [];
+	for(var whole = valueParts[0]; whole;){
+		var off = whole.length - groupSize;
+		pieces.push((off > 0) ? whole.substr(off) : whole);
+		whole = (off > 0) ? whole.slice(0, off) : "";
+		if(groupSize2){
+			groupSize = groupSize2;
+			delete groupSize2;
+		}
+	}
+	valueParts[0] = pieces.reverse().join(options.group || ",");
+
+	return valueParts.join(options.decimal || ".");
+};
+
+/*=====
+dojo.number.__RegexpOptions = function(){
+	//	pattern: String?
+	//		override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
+	//		with this string.  Default value is based on locale.  Overriding this property will defeat
+	//		localization.
+	//	type: String?
+	//		choose a format type based on the locale from the following:
+	//		decimal, scientific (not yet supported), percent, currency. decimal by default.
+	//	locale: String?
+	//		override the locale used to determine formatting rules
+	//	strict: Boolean?
+	//		strict parsing, false by default.  Strict parsing requires input as produced by the format() method.
+	//		Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators
+	//	places: Number|String?
+	//		number of decimal places to accept: Infinity, a positive number, or
+	//		a range "n,m".  Defined by pattern or Infinity if pattern not provided.
+	this.pattern = pattern;
+	this.type = type;
+	this.locale = locale;
+	this.strict = strict;
+	this.places = places;
+}
+=====*/
+dojo.number.regexp = function(/*dojo.number.__RegexpOptions?*/options){
+	//	summary:
+	//		Builds the regular needed to parse a number
+	//	description:
+	//		Returns regular expression with positive and negative match, group
+	//		and decimal separators
+	return dojo.number._parseInfo(options).regexp; // String
+};
+
+dojo.number._parseInfo = function(/*Object?*/options){
+	options = options || {};
+	var locale = i18n.normalizeLocale(options.locale),
+		bundle = i18n.getLocalization("dojo.cldr", "number", locale),
+		pattern = options.pattern || bundle[(options.type || "decimal") + "Format"],
+//TODO: memoize?
+		group = bundle.group,
+		decimal = bundle.decimal,
+		factor = 1;
+
+	if(pattern.indexOf('%') != -1){
+		factor /= 100;
+	}else if(pattern.indexOf('\u2030') != -1){
+		factor /= 1000; // per mille
+	}else{
+		var isCurrency = pattern.indexOf('\u00a4') != -1;
+		if(isCurrency){
+			group = bundle.currencyGroup || group;
+			decimal = bundle.currencyDecimal || decimal;
+		}
+	}
+
+	//TODO: handle quoted escapes
+	var patternList = pattern.split(';');
+	if(patternList.length == 1){
+		patternList.push("-" + patternList[0]);
+	}
+
+	var re = dregexp.buildGroupRE(patternList, function(pattern){
+		pattern = "(?:"+dregexp.escapeString(pattern, '.')+")";
+		return pattern.replace(dojo.number._numberPatternRE, function(format){
+			var flags = {
+				signed: false,
+				separator: options.strict ? group : [group,""],
+				fractional: options.fractional,
+				decimal: decimal,
+				exponent: false
+				},
+
+				parts = format.split('.'),
+				places = options.places;
+
+			// special condition for percent (factor != 1)
+			// allow decimal places even if not specified in pattern
+			if(parts.length == 1 && factor != 1){
+			    parts[1] = "###";
+			}
+			if(parts.length == 1 || places === 0){
+				flags.fractional = false;
+			}else{
+				if(places === undefined){ places = options.pattern ? parts[1].lastIndexOf('0') + 1 : Infinity; }
+				if(places && options.fractional == undefined){flags.fractional = true;} // required fractional, unless otherwise specified
+				if(!options.places && (places < parts[1].length)){ places += "," + parts[1].length; }
+				flags.places = places;
+			}
+			var groups = parts[0].split(',');
+			if(groups.length > 1){
+				flags.groupSize = groups.pop().length;
+				if(groups.length > 1){
+					flags.groupSize2 = groups.pop().length;
+				}
+			}
+			return "("+dojo.number._realNumberRegexp(flags)+")";
+		});
+	}, true);
+
+	if(isCurrency){
+		// substitute the currency symbol for the placeholder in the pattern
+		re = re.replace(/([\s\xa0]*)(\u00a4{1,3})([\s\xa0]*)/g, function(match, before, target, after){
+			var prop = ["symbol", "currency", "displayName"][target.length-1],
+				symbol = dregexp.escapeString(options[prop] || options.currency || "");
+			before = before ? "[\\s\\xa0]" : "";
+			after = after ? "[\\s\\xa0]" : "";
+			if(!options.strict){
+				if(before){before += "*";}
+				if(after){after += "*";}
+				return "(?:"+before+symbol+after+")?";
+			}
+			return before+symbol+after;
+		});
+	}
+
+//TODO: substitute localized sign/percent/permille/etc.?
+
+	// normalize whitespace and return
+	return {regexp: re.replace(/[\xa0 ]/g, "[\\s\\xa0]"), group: group, decimal: decimal, factor: factor}; // Object
+};
+
+/*=====
+dojo.number.__ParseOptions = function(){
+	//	pattern: String?
+	//		override [formatting pattern](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
+	//		with this string.  Default value is based on locale.  Overriding this property will defeat
+	//		localization.  Literal characters in patterns are not supported.
+	//	type: String?
+	//		choose a format type based on the locale from the following:
+	//		decimal, scientific (not yet supported), percent, currency. decimal by default.
+	//	locale: String?
+	//		override the locale used to determine formatting rules
+	//	strict: Boolean?
+	//		strict parsing, false by default.  Strict parsing requires input as produced by the format() method.
+	//		Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators
+	//	fractional: Boolean?|Array?
+	//		Whether to include the fractional portion, where the number of decimal places are implied by pattern
+	//		or explicit 'places' parameter.  The value [true,false] makes the fractional portion optional.
+	this.pattern = pattern;
+	this.type = type;
+	this.locale = locale;
+	this.strict = strict;
+	this.fractional = fractional;
+}
+=====*/
+dojo.number.parse = function(/*String*/expression, /*dojo.number.__ParseOptions?*/options){
+	// summary:
+	//		Convert a properly formatted string to a primitive Number, using
+	//		locale-specific settings.
+	// description:
+	//		Create a Number from a string using a known localized pattern.
+	//		Formatting patterns are chosen appropriate to the locale
+	//		and follow the syntax described by
+	//		[unicode.org TR35](http://www.unicode.org/reports/tr35/#Number_Format_Patterns)
+    	//		Note that literal characters in patterns are not supported.
+	// expression:
+	//		A string representation of a Number
+	var info = dojo.number._parseInfo(options),
+		results = (new RegExp("^"+info.regexp+"$")).exec(expression);
+	if(!results){
+		return NaN; //NaN
+	}
+	var absoluteMatch = results[1]; // match for the positive expression
+	if(!results[1]){
+		if(!results[2]){
+			return NaN; //NaN
+		}
+		// matched the negative pattern
+		absoluteMatch =results[2];
+		info.factor *= -1;
+	}
+
+	// Transform it to something Javascript can parse as a number.  Normalize
+	// decimal point and strip out group separators or alternate forms of whitespace
+	absoluteMatch = absoluteMatch.
+		replace(new RegExp("["+info.group + "\\s\\xa0"+"]", "g"), "").
+		replace(info.decimal, ".");
+	// Adjust for negative sign, percent, etc. as necessary
+	return absoluteMatch * info.factor; //Number
+};
+
+/*=====
+dojo.number.__RealNumberRegexpFlags = function(){
+	//	places: Number?
+	//		The integer number of decimal places or a range given as "n,m".  If
+	//		not given, the decimal part is optional and the number of places is
+	//		unlimited.
+	//	decimal: String?
+	//		A string for the character used as the decimal point.  Default
+	//		is ".".
+	//	fractional: Boolean?|Array?
+	//		Whether decimal places are used.  Can be true, false, or [true,
+	//		false].  Default is [true, false] which means optional.
+	//	exponent: Boolean?|Array?
+	//		Express in exponential notation.  Can be true, false, or [true,
+	//		false]. Default is [true, false], (i.e. will match if the
+	//		exponential part is present are not).
+	//	eSigned: Boolean?|Array?
+	//		The leading plus-or-minus sign on the exponent.  Can be true,
+	//		false, or [true, false].  Default is [true, false], (i.e. will
+	//		match if it is signed or unsigned).  flags in regexp.integer can be
+	//		applied.
+	this.places = places;
+	this.decimal = decimal;
+	this.fractional = fractional;
+	this.exponent = exponent;
+	this.eSigned = eSigned;
+}
+=====*/
+
+dojo.number._realNumberRegexp = function(/*dojo.number.__RealNumberRegexpFlags?*/flags){
+	// summary:
+	//		Builds a regular expression to match a real number in exponential
+	//		notation
+
+	// assign default values to missing parameters
+	flags = flags || {};
+	//TODO: use mixin instead?
+	if(!("places" in flags)){ flags.places = Infinity; }
+	if(typeof flags.decimal != "string"){ flags.decimal = "."; }
+	if(!("fractional" in flags) || /^0/.test(flags.places)){ flags.fractional = [true, false]; }
+	if(!("exponent" in flags)){ flags.exponent = [true, false]; }
+	if(!("eSigned" in flags)){ flags.eSigned = [true, false]; }
+
+	var integerRE = dojo.number._integerRegexp(flags),
+		decimalRE = dregexp.buildGroupRE(flags.fractional,
+		function(q){
+			var re = "";
+			if(q && (flags.places!==0)){
+				re = "\\" + flags.decimal;
+				if(flags.places == Infinity){
+					re = "(?:" + re + "\\d+)?";
+				}else{
+					re += "\\d{" + flags.places + "}";
+				}
+			}
+			return re;
+		},
+		true
+	);
+
+	var exponentRE = dregexp.buildGroupRE(flags.exponent,
+		function(q){
+			if(q){ return "([eE]" + dojo.number._integerRegexp({ signed: flags.eSigned}) + ")"; }
+			return "";
+		}
+	);
+
+	var realRE = integerRE + decimalRE;
+	// allow for decimals without integers, e.g. .25
+	if(decimalRE){realRE = "(?:(?:"+ realRE + ")|(?:" + decimalRE + "))";}
+	return realRE + exponentRE; // String
+};
+
+/*=====
+dojo.number.__IntegerRegexpFlags = function(){
+	//	signed: Boolean?
+	//		The leading plus-or-minus sign. Can be true, false, or `[true,false]`.
+	//		Default is `[true, false]`, (i.e. will match if it is signed
+	//		or unsigned).
+	//	separator: String?
+	//		The character used as the thousands separator. Default is no
+	//		separator. For more than one symbol use an array, e.g. `[",", ""]`,
+	//		makes ',' optional.
+	//	groupSize: Number?
+	//		group size between separators
+	//	groupSize2: Number?
+	//		second grouping, where separators 2..n have a different interval than the first separator (for India)
+	this.signed = signed;
+	this.separator = separator;
+	this.groupSize = groupSize;
+	this.groupSize2 = groupSize2;
+}
+=====*/
+
+dojo.number._integerRegexp = function(/*dojo.number.__IntegerRegexpFlags?*/flags){
+	// summary:
+	//		Builds a regular expression that matches an integer
+
+	// assign default values to missing parameters
+	flags = flags || {};
+	if(!("signed" in flags)){ flags.signed = [true, false]; }
+	if(!("separator" in flags)){
+		flags.separator = "";
+	}else if(!("groupSize" in flags)){
+		flags.groupSize = 3;
+	}
+
+	var signRE = dregexp.buildGroupRE(flags.signed,
+		function(q){ return q ? "[-+]" : ""; },
+		true
+	);
+
+	var numberRE = dregexp.buildGroupRE(flags.separator,
+		function(sep){
+			if(!sep){
+				return "(?:\\d+)";
+			}
+
+			sep = dregexp.escapeString(sep);
+			if(sep == " "){ sep = "\\s"; }
+			else if(sep == "\xa0"){ sep = "\\s\\xa0"; }
+
+			var grp = flags.groupSize, grp2 = flags.groupSize2;
+			//TODO: should we continue to enforce that numbers with separators begin with 1-9?  See #6933
+			if(grp2){
+				var grp2RE = "(?:0|[1-9]\\d{0," + (grp2-1) + "}(?:[" + sep + "]\\d{" + grp2 + "})*[" + sep + "]\\d{" + grp + "})";
+				return ((grp-grp2) > 0) ? "(?:" + grp2RE + "|(?:0|[1-9]\\d{0," + (grp-1) + "}))" : grp2RE;
+			}
+			return "(?:0|[1-9]\\d{0," + (grp-1) + "}(?:[" + sep + "]\\d{" + grp + "})*)";
+		},
+		true
+	);
+
+	return signRE + numberRE; // String
+};
+
+return dojo.number;
+});
diff --git a/js/dojo-1.7.2/dojo/on.js b/js/dojo-1.7.2/dojo/on.js
new file mode 100644
index 0000000..8bdfe82
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/on.js
@@ -0,0 +1,475 @@
+//>>built
+define("dojo/on", ["./has!dom-addeventlistener?:./aspect", "./_base/kernel", "./has"], function(aspect, dojo, has){
+	// summary:
+	//		The export of this module is a function that provides core event listening functionality. With this function
+	//		you can provide a target, event type, and listener to be notified of
+	//		future matching events that are fired.
+	// target: Element|Object
+	//		This is the target object or DOM element that to receive events from
+	// type: String|Function
+	// 		This is the name of the event to listen for or an extension event type.
+	// listener: Function
+	// 		This is the function that should be called when the event fires.
+	// returns: Object
+	// 		An object with a remove() method that can be used to stop listening for this
+	// 		event.
+	// description:
+	// 		To listen for "click" events on a button node, we can do:
+	// 		|	define(["dojo/on"], function(listen){
+	// 		|		on(button, "click", clickHandler);
+	//		|		...
+	//  	Evented JavaScript objects can also have their own events.
+	// 		|	var obj = new Evented;
+	//		|	on(obj, "foo", fooHandler);
+	//		And then we could publish a "foo" event:
+	//		|	on.emit(obj, "foo", {key: "value"});
+	//		We can use extension events as well. For example, you could listen for a tap gesture:
+	// 		|	define(["dojo/on", "dojo/gesture/tap", function(listen, tap){
+	// 		|		on(button, tap, tapHandler);
+	//		|		...
+	//		which would trigger fooHandler. Note that for a simple object this is equivalent to calling:
+	//		|	obj.onfoo({key:"value"});
+	//		If you use on.emit on a DOM node, it will use native event dispatching when possible.
+
+ 	"use strict";
+	if(1){ // check to make sure we are in a browser, this module should work anywhere
+		var major = window.ScriptEngineMajorVersion;
+		has.add("jscript", major && (major() + ScriptEngineMinorVersion() / 10));
+		has.add("event-orientationchange", has("touch") && !has("android")); // TODO: how do we detect this?
+	}
+	var on = function(target, type, listener, dontFix){
+		if(target.on){ 
+			// delegate to the target's on() method, so it can handle it's own listening if it wants
+			return target.on(type, listener);
+		}
+		// delegate to main listener code
+		return on.parse(target, type, listener, addListener, dontFix, this);
+	};
+	on.pausable =  function(target, type, listener, dontFix){
+		// summary:
+		//		This function acts the same as on(), but with pausable functionality. The
+		// 		returned signal object has pause() and resume() functions. Calling the
+		//		pause() method will cause the listener to not be called for future events. Calling the
+		//		resume() method will cause the listener to again be called for future events.
+		var paused;
+		var signal = on(target, type, function(){
+			if(!paused){
+				return listener.apply(this, arguments);
+			}
+		}, dontFix);
+		signal.pause = function(){
+			paused = true;
+		};
+		signal.resume = function(){
+			paused = false;
+		};
+		return signal;
+	};
+	on.once = function(target, type, listener, dontFix){
+		// summary:
+		//		This function acts the same as on(), but will only call the listener once. The 
+		// 		listener will be called for the first
+		//		event that takes place and then listener will automatically be removed.
+		var signal = on(target, type, function(){
+			// remove this listener
+			signal.remove();
+			// proceed to call the listener
+			return listener.apply(this, arguments);
+		});
+		return signal;
+	};
+	on.parse = function(target, type, listener, addListener, dontFix, matchesTarget){
+		if(type.call){
+			// event handler function
+			// on(node, dojo.touch.press, touchListener);
+			return type.call(matchesTarget, target, listener);
+		}
+
+		if(type.indexOf(",") > -1){
+			// we allow comma delimited event names, so you can register for multiple events at once
+			var events = type.split(/\s*,\s*/);
+			var handles = [];
+			var i = 0;
+			var eventName;
+			while(eventName = events[i++]){
+				handles.push(addListener(target, eventName, listener, dontFix, matchesTarget));
+			}
+			handles.remove = function(){
+				for(var i = 0; i < handles.length; i++){
+					handles[i].remove();
+				}
+			};
+			return handles;
+		}
+		return addListener(target, type, listener, dontFix, matchesTarget)
+	};
+	var touchEvents = /^touch/;
+	function addListener(target, type, listener, dontFix, matchesTarget){		
+		// event delegation:
+		var selector = type.match(/(.*):(.*)/);
+		// if we have a selector:event, the last one is interpreted as an event, and we use event delegation
+		if(selector){
+			type = selector[2];
+			selector = selector[1];
+			// create the extension event for selectors and directly call it
+			return on.selector(selector, type).call(matchesTarget, target, listener);
+		}
+		// test to see if it a touch event right now, so we don't have to do it every time it fires
+		if(has("touch")){
+			if(touchEvents.test(type)){
+				// touch event, fix it
+				listener = fixTouchListener(listener);
+			}
+			if(!has("event-orientationchange") && (type == "orientationchange")){
+				//"orientationchange" not supported <= Android 2.1, 
+				//but works through "resize" on window
+				type = "resize"; 
+				target = window;
+				listener = fixTouchListener(listener);
+			} 
+		}
+		// normal path, the target is |this|
+		if(target.addEventListener){
+			// the target has addEventListener, which should be used if available (might or might not be a node, non-nodes can implement this method as well)
+			// check for capture conversions
+			var capture = type in captures;
+			target.addEventListener(capture ? captures[type] : type, listener, capture);
+			// create and return the signal
+			return {
+				remove: function(){
+					target.removeEventListener(type, listener, capture);
+				}
+			};
+		}
+		type = "on" + type;
+		if(fixAttach && target.attachEvent){
+			return fixAttach(target, type, listener);
+		}
+	 	throw new Error("Target must be an event emitter");
+	}
+
+	on.selector = function(selector, eventType, children){
+		// summary:
+		//		Creates a new extension event with event delegation. This is based on
+		// 		the provided event type (can be extension event) that
+		// 		only calls the listener when the CSS selector matches the target of the event.
+		//	selector:
+		//		The CSS selector to use for filter events and determine the |this| of the event listener.
+		//	eventType:
+		//		The event to listen for
+		// children:
+		//		Indicates if children elements of the selector should be allowed. This defaults to 
+		// 		true (except in the case of normally non-bubbling events like mouse.enter, in which case it defaults to false).
+		//	example:
+		//		define(["dojo/on", "dojo/mouse"], function(listen, mouse){
+		//			on(node, on.selector(".my-class", mouse.enter), handlerForMyHover);
+		return function(target, listener){
+			var matchesTarget = this;
+			var bubble = eventType.bubble;
+			if(bubble){
+				// the event type doesn't naturally bubble, but has a bubbling form, use that
+				eventType = bubble;
+			}else if(children !== false){
+				// for normal bubbling events we default to allowing children of the selector
+				children = true;
+			}
+			return on(target, eventType, function(event){
+				var eventTarget = event.target;
+				// see if we have a valid matchesTarget or default to dojo.query
+				matchesTarget = matchesTarget && matchesTarget.matches ? matchesTarget : dojo.query;
+				// there is a selector, so make sure it matches
+				while(!matchesTarget.matches(eventTarget, selector, target)){
+					if(eventTarget == target || !children || !(eventTarget = eventTarget.parentNode)){ // intentional assignment
+						return;
+					}
+				}
+				return listener.call(eventTarget, event);
+			});
+		};
+	};
+
+	function syntheticPreventDefault(){
+		this.cancelable = false;
+	}
+	function syntheticStopPropagation(){
+		this.bubbles = false;
+	}
+	var slice = [].slice,
+		syntheticDispatch = on.emit = function(target, type, event){
+		// summary:
+		//		Fires an event on the target object.
+		//	target:
+		//		The target object to fire the event on. This can be a DOM element or a plain 
+		// 		JS object. If the target is a DOM element, native event emiting mechanisms
+		//		are used when possible.
+		//	type:
+		//		The event type name. You can emulate standard native events like "click" and 
+		// 		"mouseover" or create custom events like "open" or "finish".
+		//	event:
+		//		An object that provides the properties for the event. See https://developer.mozilla.org/en/DOM/event.initEvent 
+		// 		for some of the properties. These properties are copied to the event object.
+		//		Of particular importance are the cancelable and bubbles properties. The
+		//		cancelable property indicates whether or not the event has a default action
+		// 		that can be cancelled. The event is cancelled by calling preventDefault() on
+		// 		the event object. The bubbles property indicates whether or not the
+		//		event will bubble up the DOM tree. If bubbles is true, the event will be called
+		//		on the target and then each parent successively until the top of the tree
+		//		is reached or stopPropagation() is called. Both bubbles and cancelable 
+		// 		default to false.
+		//	returns:
+		//		If the event is cancelable and the event is not cancelled,
+		// 		emit will return true. If the event is cancelable and the event is cancelled,
+		// 		emit will return false.
+		//	details:
+		//		Note that this is designed to emit events for listeners registered through
+		//		dojo/on. It should actually work with any event listener except those
+		// 		added through IE's attachEvent (IE8 and below's non-W3C event emiting
+		// 		doesn't support custom event types). It should work with all events registered
+		// 		through dojo/on. Also note that the emit method does do any default
+		// 		action, it only returns a value to indicate if the default action should take
+		// 		place. For example, emiting a keypress event would not cause a character
+		// 		to appear in a textbox.
+		//	example:
+		//		To fire our own click event
+		//	|	on.emit(dojo.byId("button"), "click", {
+		//	|		cancelable: true,
+		//	|		bubbles: true,
+		//	|		screenX: 33,
+		//	|		screenY: 44
+		//	|	});
+		//		We can also fire our own custom events:
+		//	|	on.emit(dojo.byId("slider"), "slide", {
+		//	|		cancelable: true,
+		//	|		bubbles: true,
+		//	|		direction: "left-to-right"
+		//	|	});
+		var args = slice.call(arguments, 2);
+		var method = "on" + type;
+		if("parentNode" in target){
+			// node (or node-like), create event controller methods
+			var newEvent = args[0] = {};
+			for(var i in event){
+				newEvent[i] = event[i];
+			}
+			newEvent.preventDefault = syntheticPreventDefault;
+			newEvent.stopPropagation = syntheticStopPropagation;
+			newEvent.target = target;
+			newEvent.type = type;
+			event = newEvent;
+		}
+		do{
+			// call any node which has a handler (note that ideally we would try/catch to simulate normal event propagation but that causes too much pain for debugging)
+			target[method] && target[method].apply(target, args);
+			// and then continue up the parent node chain if it is still bubbling (if started as bubbles and stopPropagation hasn't been called)
+		}while(event && event.bubbles && (target = target.parentNode));
+		return event && event.cancelable && event; // if it is still true (was cancelable and was cancelled), return the event to indicate default action should happen
+	};
+	var captures = {}; 
+	if(has("dom-addeventlistener")){
+		// normalize focusin and focusout
+		captures = {
+			focusin: "focus",
+			focusout: "blur"
+		};
+		if(has("opera")){
+			captures.keydown = "keypress"; // this one needs to be transformed because Opera doesn't support repeating keys on keydown (and keypress works because it incorrectly fires on all keydown events)
+		}
+
+		// emiter that works with native event handling
+		on.emit = function(target, type, event){
+			if(target.dispatchEvent && document.createEvent){
+				// use the native event emiting mechanism if it is available on the target object
+				// create a generic event				
+				// we could create branch into the different types of event constructors, but 
+				// that would be a lot of extra code, with little benefit that I can see, seems 
+				// best to use the generic constructor and copy properties over, making it 
+				// easy to have events look like the ones created with specific initializers
+				var nativeEvent = document.createEvent("HTMLEvents");
+				nativeEvent.initEvent(type, !!event.bubbles, !!event.cancelable);
+				// and copy all our properties over
+				for(var i in event){
+					var value = event[i];
+					if(!(i in nativeEvent)){
+						nativeEvent[i] = event[i];
+					}
+				}
+				return target.dispatchEvent(nativeEvent) && nativeEvent;
+			}
+			return syntheticDispatch.apply(on, arguments); // emit for a non-node
+		};
+	}else{
+		// no addEventListener, basically old IE event normalization
+		on._fixEvent = function(evt, sender){
+			// summary:
+			//		normalizes properties on the event object including event
+			//		bubbling methods, keystroke normalization, and x/y positions
+			// evt:
+			//		native event object
+			// sender:
+			//		node to treat as "currentTarget"
+			if(!evt){
+				var w = sender && (sender.ownerDocument || sender.document || sender).parentWindow || window;
+				evt = w.event;
+			}
+			if(!evt){return(evt);}
+			if(!evt.target){ // check to see if it has been fixed yet
+				evt.target = evt.srcElement;
+				evt.currentTarget = (sender || evt.srcElement);
+				if(evt.type == "mouseover"){
+					evt.relatedTarget = evt.fromElement;
+				}
+				if(evt.type == "mouseout"){
+					evt.relatedTarget = evt.toElement;
+				}
+				if(!evt.stopPropagation){
+					evt.stopPropagation = stopPropagation;
+					evt.preventDefault = preventDefault;
+				}
+				switch(evt.type){
+					case "keypress":
+						var c = ("charCode" in evt ? evt.charCode : evt.keyCode);
+						if (c==10){
+							// CTRL-ENTER is CTRL-ASCII(10) on IE, but CTRL-ENTER on Mozilla
+							c=0;
+							evt.keyCode = 13;
+						}else if(c==13||c==27){
+							c=0; // Mozilla considers ENTER and ESC non-printable
+						}else if(c==3){
+							c=99; // Mozilla maps CTRL-BREAK to CTRL-c
+						}
+						// Mozilla sets keyCode to 0 when there is a charCode
+						// but that stops the event on IE.
+						evt.charCode = c;
+						_setKeyChar(evt);
+						break;
+				}
+			}
+			return evt;
+		};
+		var IESignal = function(handle){
+			this.handle = handle;
+		};
+		IESignal.prototype.remove = function(){
+			delete _dojoIEListeners_[this.handle];
+		};
+		var fixListener = function(listener){
+			// this is a minimal function for closing on the previous listener with as few as variables as possible
+			return function(evt){
+				evt = on._fixEvent(evt, this);
+				return listener.call(this, evt);
+			}
+		}
+		var fixAttach = function(target, type, listener){
+			listener = fixListener(listener);
+			if(((target.ownerDocument ? target.ownerDocument.parentWindow : target.parentWindow || target.window || window) != top || 
+						has("jscript") < 5.8) && 
+					!has("config-_allow_leaks")){
+				// IE will leak memory on certain handlers in frames (IE8 and earlier) and in unattached DOM nodes for JScript 5.7 and below.
+				// Here we use global redirection to solve the memory leaks
+				if(typeof _dojoIEListeners_ == "undefined"){
+					_dojoIEListeners_ = [];
+				}
+				var emiter = target[type];
+				if(!emiter || !emiter.listeners){
+					var oldListener = emiter;
+					target[type] = emiter = Function('event', 'var callee = arguments.callee; for(var i = 0; i<callee.listeners.length; i++){var listener = _dojoIEListeners_[callee.listeners[i]]; if(listener){listener.call(this,event);}}');
+					emiter.listeners = [];
+					emiter.global = this;
+					if(oldListener){
+						emiter.listeners.push(_dojoIEListeners_.push(oldListener) - 1);
+					}
+				}
+				var handle;
+				emiter.listeners.push(handle = (emiter.global._dojoIEListeners_.push(listener) - 1));
+				return new IESignal(handle);
+			}
+			return aspect.after(target, type, listener, true);
+		};
+
+		var _setKeyChar = function(evt){
+			evt.keyChar = evt.charCode ? String.fromCharCode(evt.charCode) : '';
+			evt.charOrCode = evt.keyChar || evt.keyCode;
+		};
+		// Called in Event scope
+		var stopPropagation = function(){
+			this.cancelBubble = true;
+		};
+		var preventDefault = on._preventDefault = function(){
+			// Setting keyCode to 0 is the only way to prevent certain keypresses (namely
+			// ctrl-combinations that correspond to menu accelerator keys).
+			// Otoh, it prevents upstream listeners from getting this information
+			// Try to split the difference here by clobbering keyCode only for ctrl
+			// combinations. If you still need to access the key upstream, bubbledKeyCode is
+			// provided as a workaround.
+			this.bubbledKeyCode = this.keyCode;
+			if(this.ctrlKey){
+				try{
+					// squelch errors when keyCode is read-only
+					// (e.g. if keyCode is ctrl or shift)
+					this.keyCode = 0;
+				}catch(e){
+				}
+			}
+			this.returnValue = false;
+		};
+	}
+	if(has("touch")){ 
+		var Event = function (){};
+		var windowOrientation = window.orientation; 
+		var fixTouchListener = function(listener){ 
+			return function(originalEvent){ 
+				//Event normalization(for ontouchxxx and resize): 
+				//1.incorrect e.pageX|pageY in iOS 
+				//2.there are no "e.rotation", "e.scale" and "onorientationchange" in Andriod
+				//3.More TBD e.g. force | screenX | screenX | clientX | clientY | radiusX | radiusY
+
+				// see if it has already been corrected
+				var event = originalEvent.corrected;
+				if(!event){
+					var type = originalEvent.type;
+					try{
+						delete originalEvent.type; // on some JS engines (android), deleting properties make them mutable
+					}catch(e){} 
+					if(originalEvent.type){
+						// deleting properties doesn't work (older iOS), have to use delegation
+						Event.prototype = originalEvent;
+						var event = new Event;
+						// have to delegate methods to make them work
+						event.preventDefault = function(){
+							originalEvent.preventDefault();
+						};
+						event.stopPropagation = function(){
+							originalEvent.stopPropagation();
+						};
+					}else{
+						// deletion worked, use property as is
+						event = originalEvent;
+						event.type = type;
+					}
+					originalEvent.corrected = event;
+					if(type == 'resize'){
+						if(windowOrientation == window.orientation){ 
+							return null;//double tap causes an unexpected 'resize' in Andriod 
+						} 
+						windowOrientation = window.orientation;
+						event.type = "orientationchange"; 
+						return listener.call(this, event);
+					}
+					// We use the original event and augment, rather than doing an expensive mixin operation
+					if(!("rotation" in event)){ // test to see if it has rotation
+						event.rotation = 0; 
+						event.scale = 1;
+					}
+					//use event.changedTouches[0].pageX|pageY|screenX|screenY|clientX|clientY|target
+					var firstChangeTouch = event.changedTouches[0];
+					for(var i in firstChangeTouch){ // use for-in, we don't need to have dependency on dojo/_base/lang here
+						delete event[i]; // delete it first to make it mutable
+						event[i] = firstChangeTouch[i];
+					}
+				}
+				return listener.call(this, event); 
+			}; 
+		}; 
+	}
+	return on;
+});
diff --git a/js/dojo-1.7.2/dojo/package.json b/js/dojo-1.7.2/dojo/package.json
new file mode 100644
index 0000000..7618c4d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/package.json
@@ -0,0 +1,23 @@
+{
+	"name": "dojo",
+	"version":"1.7.2",
+	"directories": {
+		"lib": "."
+	},
+	"main": "main",
+	"description": "Dojo core is a powerful, lightweight library that makes common tasks quicker and easier. Animate elements, manipulate the DOM, and query with easy CSS syntax, all without sacrificing performance.",
+	"licenses": [
+		 {
+				 "type": "AFLv2.1",
+				 "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L43"
+		 },
+		 {
+				 "type": "BSD",
+				 "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L13"
+		 }
+	],
+	"bugs": "http://bugs.dojotoolkit.org/",
+	"keywords": ["JavaScript", "Dojo", "Toolkit"],
+	"homepage": "http://dojotoolkit.org/",
+	"dojoBuild": "dojo.profile.js"
+}
diff --git a/js/dojo-1.7.2/dojo/parser.js b/js/dojo-1.7.2/dojo/parser.js
new file mode 100644
index 0000000..657b4c1
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/parser.js
@@ -0,0 +1,595 @@
+//>>built
+define(
+	"dojo/parser", ["./_base/kernel", "./_base/lang", "./_base/array", "./_base/html", "./_base/window", "./_base/url",
+		"./_base/json", "./aspect", "./date/stamp", "./query", "./on", "./ready"],
+	function(dojo, dlang, darray, dhtml, dwindow, _Url, djson, aspect, dates, query, don){
+
+// module:
+//		dojo/parser
+// summary:
+//		The Dom/Widget parsing package
+
+new Date("X"); // workaround for #11279, new Date("") == NaN
+
+var features = {
+	// Feature detection for when node.attributes only lists the attributes specified in the markup
+	// rather than old IE/quirks behavior where it lists every default value too
+	"dom-attributes-explicit": document.createElement("div").attributes.length < 40
+};
+function has(feature){
+	return features[feature];
+}
+
+
+dojo.parser = new function(){
+	// summary:
+	//		The Dom/Widget parsing package
+
+	var _nameMap = {
+		// Map from widget name (ex: "dijit.form.Button") to structure mapping
+		// lowercase version of attribute names to the version in the widget ex:
+		//	{
+		//		label: "label",
+		//		onclick: "onClick"
+		//	}
+	};
+	function getNameMap(proto){
+		// summary:
+		//		Returns map from lowercase name to attribute name in class, ex: {onclick: "onClick"}
+		var map = {};
+		for(var name in proto){
+			if(name.charAt(0)=="_"){ continue; }	// skip internal properties
+			map[name.toLowerCase()] = name;
+		}
+		return map;
+	}
+	// Widgets like BorderContainer add properties to _Widget via dojo.extend().
+	// If BorderContainer is loaded after _Widget's parameter list has been cached,
+	// we need to refresh that parameter list (for _Widget and all widgets that extend _Widget).
+	aspect.after(dlang, "extend", function(){
+		_nameMap = {};
+	}, true);
+
+	// Map from widget name (ex: "dijit.form.Button") to constructor
+	var _ctorMap = {};
+
+	this._functionFromScript = function(script, attrData){
+		// summary:
+		//		Convert a <script type="dojo/method" args="a, b, c"> ... </script>
+		//		into a function
+		// script: DOMNode
+		//		The <script> DOMNode
+		// attrData: String
+		//		For HTML5 compliance, searches for attrData + "args" (typically
+		//		"data-dojo-args") instead of "args"
+		var preamble = "";
+		var suffix = "";
+		var argsStr = (script.getAttribute(attrData + "args") || script.getAttribute("args"));
+		if(argsStr){
+			darray.forEach(argsStr.split(/\s*,\s*/), function(part, idx){
+				preamble += "var "+part+" = arguments["+idx+"]; ";
+			});
+		}
+		var withStr = script.getAttribute("with");
+		if(withStr && withStr.length){
+			darray.forEach(withStr.split(/\s*,\s*/), function(part){
+				preamble += "with("+part+"){";
+				suffix += "}";
+			});
+		}
+		return new Function(preamble+script.innerHTML+suffix);
+	};
+
+	this.instantiate = /*====== dojo.parser.instantiate= ======*/function(nodes, mixin, args){
+		// summary:
+		//		Takes array of nodes, and turns them into class instances and
+		//		potentially calls a startup method to allow them to connect with
+		//		any children.
+		// nodes: Array
+		//		Array of nodes or objects like
+		//	|		{
+		//	|			type: "dijit.form.Button",
+		//	|			node: DOMNode,
+		//	|			scripts: [ ... ],	// array of <script type="dojo/..."> children of node
+		//	|			inherited: { ... }	// settings inherited from ancestors like dir, theme, etc.
+		//	|		}
+		// mixin: Object?
+		//		An object that will be mixed in with each node in the array.
+		//		Values in the mixin will override values in the node, if they
+		//		exist.
+		// args: Object?
+		//		An object used to hold kwArgs for instantiation.
+		//		See parse.args argument for details.
+
+		var thelist = [],
+		mixin = mixin||{};
+		args = args||{};
+
+		// Precompute names of special attributes we are looking for
+		// TODO: for 2.0 default to data-dojo- regardless of scopeName (or maybe scopeName won't exist in 2.0)
+		var dojoType = (args.scope || dojo._scopeName) + "Type",		// typically "dojoType"
+			attrData = "data-" + (args.scope || dojo._scopeName) + "-",// typically "data-dojo-"
+			dataDojoType = attrData + "type",						// typically "data-dojo-type"
+			dataDojoProps = attrData + "props",						// typically "data-dojo-props"
+			dataDojoAttachPoint = attrData + "attach-point",
+			dataDojoAttachEvent = attrData + "attach-event",
+			dataDojoId = attrData + "id";
+
+		// And make hash to quickly check if a given attribute is special, and to map the name to something friendly
+		var specialAttrs = {};
+		darray.forEach([dataDojoProps, dataDojoType, dojoType, dataDojoId, "jsId", dataDojoAttachPoint,
+				dataDojoAttachEvent, "dojoAttachPoint", "dojoAttachEvent", "class", "style"], function(name){
+			specialAttrs[name.toLowerCase()] = name.replace(args.scope, "dojo");
+		});
+
+		darray.forEach(nodes, function(obj){
+			if(!obj){ return; }
+
+			var node = obj.node || obj,
+				type = dojoType in mixin ? mixin[dojoType] : obj.node ? obj.type : (node.getAttribute(dataDojoType) || node.getAttribute(dojoType)),
+				ctor = _ctorMap[type] || (_ctorMap[type] = dlang.getObject(type)),
+				proto = ctor && ctor.prototype;
+			if(!ctor){
+				throw new Error("Could not load class '" + type);
+			}
+
+			// Setup hash to hold parameter settings for this widget.	Start with the parameter
+			// settings inherited from ancestors ("dir" and "lang").
+			// Inherited setting may later be overridden by explicit settings on node itself.
+			var params = {};
+
+			if(args.defaults){
+				// settings for the document itself (or whatever subtree is being parsed)
+				dlang.mixin(params, args.defaults);
+			}
+			if(obj.inherited){
+				// settings from dir=rtl or lang=... on a node above this node
+				dlang.mixin(params, obj.inherited);
+			}
+
+			// Get list of attributes explicitly listed in the markup
+			var attributes;
+			if(has("dom-attributes-explicit")){
+				// Standard path to get list of user specified attributes
+				attributes = node.attributes;
+			}else{
+				// Special path for IE, avoid (sometimes >100) bogus entries in node.attributes
+				var clone = /^input$|^img$/i.test(node.nodeName) ? node : node.cloneNode(false),
+					attrs = clone.outerHTML.replace(/=[^\s"']+|="[^"]*"|='[^']*'/g, "").replace(/^\s*<[a-zA-Z0-9]*/, "").replace(/>.*$/, "");
+
+				attributes = darray.map(attrs.split(/\s+/), function(name){
+					var lcName = name.toLowerCase();
+					return {
+						name: name,
+						// getAttribute() doesn't work for button.value, returns innerHTML of button.
+						// but getAttributeNode().value doesn't work for the form.encType or li.value
+						value: (node.nodeName == "LI" && name == "value") || lcName == "enctype" ?
+								node.getAttribute(lcName) : node.getAttributeNode(lcName).value,
+						specified: true
+					};
+				});
+			}
+
+			// Read in attributes and process them, including data-dojo-props, data-dojo-type,
+			// dojoAttachPoint, etc., as well as normal foo=bar attributes.
+			var i=0, item;
+			while(item = attributes[i++]){
+				if(!item || !item.specified){
+					continue;
+				}
+
+				var name = item.name,
+					lcName = name.toLowerCase(),
+					value = item.value;
+
+				if(lcName in specialAttrs){
+					switch(specialAttrs[lcName]){
+
+					// Data-dojo-props.   Save for later to make sure it overrides direct foo=bar settings
+					case "data-dojo-props":
+						var extra = value;
+						break;
+
+					// data-dojo-id or jsId. TODO: drop jsId in 2.0
+					case "data-dojo-id":
+					case "jsId":
+						var jsname = value;
+						break;
+
+					// For the benefit of _Templated
+					case "data-dojo-attach-point":
+					case "dojoAttachPoint":
+						params.dojoAttachPoint = value;
+						break;
+					case "data-dojo-attach-event":
+					case "dojoAttachEvent":
+						params.dojoAttachEvent = value;
+						break;
+
+					// Special parameter handling needed for IE
+					case "class":
+						params["class"] = node.className;
+						break;
+					case "style":
+						params["style"] = node.style && node.style.cssText;
+						break;
+					}
+				}else{
+					// Normal attribute, ex: value="123"
+
+					// Find attribute in widget corresponding to specified name.
+					// May involve case conversion, ex: onclick --> onClick
+					if(!(name in proto)){
+						var map = (_nameMap[type] || (_nameMap[type] = getNameMap(proto)));
+						name = map[lcName] || name;
+					}
+
+					// Set params[name] to value, doing type conversion
+					if(name in proto){
+						switch(typeof proto[name]){
+						case "string":
+							params[name] = value;
+							break;
+						case "number":
+							params[name] = value.length ? Number(value) : NaN;
+							break;
+						case "boolean":
+							// for checked/disabled value might be "" or "checked".	 interpret as true.
+							params[name] = value.toLowerCase() != "false";
+							break;
+						case "function":
+							if(value === "" || value.search(/[^\w\.]+/i) != -1){
+								// The user has specified some text for a function like "return x+5"
+								params[name] = new Function(value);
+							}else{
+								// The user has specified the name of a function like "myOnClick"
+								// or a single word function "return"
+								params[name] = dlang.getObject(value, false) || new Function(value);
+							}
+							break;
+						default:
+							var pVal = proto[name];
+							params[name] =
+								(pVal && "length" in pVal) ? (value ? value.split(/\s*,\s*/) : []) :	// array
+									(pVal instanceof Date) ?
+										(value == "" ? new Date("") :	// the NaN of dates
+										value == "now" ? new Date() :	// current date
+										dates.fromISOString(value)) :
+								(pVal instanceof dojo._Url) ? (dojo.baseUrl + value) :
+								djson.fromJson(value);
+						}
+					}else{
+						params[name] = value;
+					}
+				}
+			}
+
+			// Mix things found in data-dojo-props into the params, overriding any direct settings
+			if(extra){
+				try{
+					extra = djson.fromJson.call(args.propsThis, "{" + extra + "}");
+					dlang.mixin(params, extra);
+				}catch(e){
+					// give the user a pointer to their invalid parameters. FIXME: can we kill this in production?
+					throw new Error(e.toString() + " in data-dojo-props='" + extra + "'");
+				}
+			}
+
+			// Any parameters specified in "mixin" override everything else.
+			dlang.mixin(params, mixin);
+
+			var scripts = obj.node ? obj.scripts : (ctor && (ctor._noScript || proto._noScript) ? [] :
+						query("> script[type^='dojo/']", node));
+
+			// Process <script type="dojo/*"> script tags
+			// <script type="dojo/method" event="foo"> tags are added to params, and passed to
+			// the widget on instantiation.
+			// <script type="dojo/method"> tags (with no event) are executed after instantiation
+			// <script type="dojo/connect" data-dojo-event="foo"> tags are dojo.connected after instantiation
+			// <script type="dojo/watch" data-dojo-prop="foo"> tags are dojo.watch after instantiation
+			// <script type="dojo/on" data-dojo-event="foo"> tags are dojo.on after instantiation
+			// note: dojo/* script tags cannot exist in self closing widgets, like <input />
+			var connects = [],	// functions to connect after instantiation
+				calls = [],		// functions to call after instantiation
+				watch = [],  //functions to watch after instantiation
+				on = []; //functions to on after instantiation
+
+			if(scripts){
+				for(i=0; i<scripts.length; i++){
+					var script = scripts[i];
+					node.removeChild(script);
+					// FIXME: drop event="" support in 2.0. use data-dojo-event="" instead
+					var event = (script.getAttribute(attrData + "event") || script.getAttribute("event")),
+						prop = script.getAttribute(attrData + "prop"),
+						type = script.getAttribute("type"),
+						nf = this._functionFromScript(script, attrData);
+					if(event){
+						if(type == "dojo/connect"){
+							connects.push({event: event, func: nf});
+						}else if(type == "dojo/on"){
+							on.push({event: event, func: nf});
+						}else{
+							params[event] = nf;
+						}
+					}else if(type == "dojo/watch"){
+						watch.push({prop: prop, func: nf});
+					}else{
+						calls.push(nf);
+					}
+				}
+			}
+
+			// create the instance
+			var markupFactory = ctor.markupFactory || proto.markupFactory;
+			var instance = markupFactory ? markupFactory(params, node, ctor) : new ctor(params, node);
+			thelist.push(instance);
+
+			// map it to the JS namespace if that makes sense
+			if(jsname){
+				dlang.setObject(jsname, instance);
+			}
+
+			// process connections and startup functions
+			for(i=0; i<connects.length; i++){
+				aspect.after(instance, connects[i].event, dojo.hitch(instance, connects[i].func), true);
+			}
+			for(i=0; i<calls.length; i++){
+				calls[i].call(instance);
+			}
+			for(i=0; i<watch.length; i++){
+				instance.watch(watch[i].prop, watch[i].func);
+			}
+			for(i=0; i<on.length; i++){
+				don(instance, on[i].event, on[i].func);
+			}
+		}, this);
+
+		// Call startup on each top level instance if it makes sense (as for
+		// widgets).  Parent widgets will recursively call startup on their
+		// (non-top level) children
+		if(!mixin._started){
+			darray.forEach(thelist, function(instance){
+				if( !args.noStart && instance  &&
+					dlang.isFunction(instance.startup) &&
+					!instance._started
+				){
+					instance.startup();
+				}
+			});
+		}
+		return thelist;
+	};
+
+	this.parse = /*====== dojo.parser.parse= ======*/ function(rootNode, args){
+		// summary:
+		//		Scan the DOM for class instances, and instantiate them.
+		//
+		// description:
+		//		Search specified node (or root node) recursively for class instances,
+		//		and instantiate them. Searches for either data-dojo-type="Class" or
+		//		dojoType="Class" where "Class" is a a fully qualified class name,
+		//		like `dijit.form.Button`
+		//
+		//		Using `data-dojo-type`:
+		//		Attributes using can be mixed into the parameters used to instantiate the
+		//		Class by using a `data-dojo-props` attribute on the node being converted.
+		//		`data-dojo-props` should be a string attribute to be converted from JSON.
+		//
+		//		Using `dojoType`:
+		//		Attributes are read from the original domNode and converted to appropriate
+		//		types by looking up the Class prototype values. This is the default behavior
+		//		from Dojo 1.0 to Dojo 1.5. `dojoType` support is deprecated, and will
+		//		go away in Dojo 2.0.
+		//
+		// rootNode: DomNode?
+		//		A default starting root node from which to start the parsing. Can be
+		//		omitted, defaulting to the entire document. If omitted, the `args`
+		//		object can be passed in this place. If the `args` object has a
+		//		`rootNode` member, that is used.
+		//
+		// args: Object
+		//		a kwArgs object passed along to instantiate()
+		//
+		//			* noStart: Boolean?
+		//				when set will prevent the parser from calling .startup()
+		//				when locating the nodes.
+		//			* rootNode: DomNode?
+		//				identical to the function's `rootNode` argument, though
+		//				allowed to be passed in via this `args object.
+		//			* template: Boolean
+		//				If true, ignores ContentPane's stopParser flag and parses contents inside of
+		//				a ContentPane inside of a template.   This allows dojoAttachPoint on widgets/nodes
+		//				nested inside the ContentPane to work.
+		//			* inherited: Object
+		//				Hash possibly containing dir and lang settings to be applied to
+		//				parsed widgets, unless there's another setting on a sub-node that overrides
+		//			* scope: String
+		//				Root for attribute names to search for.   If scopeName is dojo,
+		//				will search for data-dojo-type (or dojoType).   For backwards compatibility
+		//				reasons defaults to dojo._scopeName (which is "dojo" except when
+		//				multi-version support is used, when it will be something like dojo16, dojo20, etc.)
+		//			* propsThis: Object
+		//				If specified, "this" referenced from data-dojo-props will refer to propsThis.
+		//				Intended for use from the widgets-in-template feature of `dijit._WidgetsInTemplateMixin`
+		//
+		// example:
+		//		Parse all widgets on a page:
+		//	|		dojo.parser.parse();
+		//
+		// example:
+		//		Parse all classes within the node with id="foo"
+		//	|		dojo.parser.parse(dojo.byId('foo'));
+		//
+		// example:
+		//		Parse all classes in a page, but do not call .startup() on any
+		//		child
+		//	|		dojo.parser.parse({ noStart: true })
+		//
+		// example:
+		//		Parse all classes in a node, but do not call .startup()
+		//	|		dojo.parser.parse(someNode, { noStart:true });
+		//	|		// or
+		//	|		dojo.parser.parse({ noStart:true, rootNode: someNode });
+
+		// determine the root node based on the passed arguments.
+		var root;
+		if(!args && rootNode && rootNode.rootNode){
+			args = rootNode;
+			root = args.rootNode;
+		}else{
+			root = rootNode;
+		}
+		root = root ? dhtml.byId(root) : dwindow.body();
+		args = args || {};
+
+		var dojoType = (args.scope || dojo._scopeName) + "Type",		// typically "dojoType"
+			attrData = "data-" + (args.scope || dojo._scopeName) + "-",	// typically "data-dojo-"
+			dataDojoType = attrData + "type",						// typically "data-dojo-type"
+			dataDojoTextDir = attrData + "textdir";					// typically "data-dojo-textdir"
+
+		// List of all nodes on page w/dojoType specified
+		var list = [];
+
+		// Info on DOMNode currently being processed
+		var node = root.firstChild;
+
+		// Info on parent of DOMNode currently being processed
+		//	- inherited: dir, lang, and textDir setting of parent, or inherited by parent
+		//	- parent: pointer to identical structure for my parent (or null if no parent)
+		//	- scripts: if specified, collects <script type="dojo/..."> type nodes from children
+		var inherited = args && args.inherited;
+		if(!inherited){
+			function findAncestorAttr(node, attr){
+				return (node.getAttribute && node.getAttribute(attr)) ||
+					(node !== dwindow.doc && node !== dwindow.doc.documentElement && node.parentNode ? findAncestorAttr(node.parentNode, attr) : null);
+			}
+			inherited = {
+				dir: findAncestorAttr(root, "dir"),
+				lang: findAncestorAttr(root, "lang"),
+				textDir: findAncestorAttr(root, dataDojoTextDir)
+			};
+			for(var key in inherited){
+				if(!inherited[key]){ delete inherited[key]; }
+			}
+		}
+		var parent = {
+			inherited: inherited
+		};
+
+		// For collecting <script type="dojo/..."> type nodes (when null, we don't need to collect)
+		var scripts;
+
+		// when true, only look for <script type="dojo/..."> tags, and don't recurse to children
+		var scriptsOnly;
+
+		function getEffective(parent){
+			// summary:
+			//		Get effective dir, lang, textDir settings for specified obj
+			//		(matching "parent" object structure above), and do caching.
+			//		Take care not to return null entries.
+			if(!parent.inherited){
+				parent.inherited = {};
+				var node = parent.node,
+					grandparent = getEffective(parent.parent);
+				var inherited  = {
+					dir: node.getAttribute("dir") || grandparent.dir,
+					lang: node.getAttribute("lang") || grandparent.lang,
+					textDir: node.getAttribute(dataDojoTextDir) || grandparent.textDir
+				};
+				for(var key in inherited){
+					if(inherited[key]){
+						parent.inherited[key] = inherited[key];
+					}
+				}
+			}
+			return parent.inherited;
+		}
+
+		// DFS on DOM tree, collecting nodes with data-dojo-type specified.
+		while(true){
+			if(!node){
+				// Finished this level, continue to parent's next sibling
+				if(!parent || !parent.node){
+					break;
+				}
+				node = parent.node.nextSibling;
+				scripts = parent.scripts;
+				scriptsOnly = false;
+				parent = parent.parent;
+				continue;
+			}
+
+			if(node.nodeType != 1){
+				// Text or comment node, skip to next sibling
+				node = node.nextSibling;
+				continue;
+			}
+
+			if(scripts && node.nodeName.toLowerCase() == "script"){
+				// Save <script type="dojo/..."> for parent, then continue to next sibling
+				type = node.getAttribute("type");
+				if(type && /^dojo\/\w/i.test(type)){
+					scripts.push(node);
+				}
+				node = node.nextSibling;
+				continue;
+			}
+			if(scriptsOnly){
+				node = node.nextSibling;
+				continue;
+			}
+
+			// Check for data-dojo-type attribute, fallback to backward compatible dojoType
+			var type = node.getAttribute(dataDojoType) || node.getAttribute(dojoType);
+
+			// Short circuit for leaf nodes containing nothing [but text]
+			var firstChild = node.firstChild;
+			if(!type && (!firstChild || (firstChild.nodeType == 3 && !firstChild.nextSibling))){
+				node = node.nextSibling;
+				continue;
+			}
+
+			// Setup data structure to save info on current node for when we return from processing descendant nodes
+			var current = {
+				node: node,
+				scripts: scripts,
+				parent: parent
+			};
+
+			// If dojoType/data-dojo-type specified, add to output array of nodes to instantiate
+			var ctor = type && (_ctorMap[type] || (_ctorMap[type] = dlang.getObject(type))), // note: won't find classes declared via dojo.Declaration
+				childScripts = ctor && !ctor.prototype._noScript ? [] : null; // <script> nodes that are parent's children
+			if(type){
+				list.push({
+					"type": type,
+					node: node,
+					scripts: childScripts,
+					inherited: getEffective(current) // dir & lang settings for current node, explicit or inherited
+				});
+			}
+
+			// Recurse, collecting <script type="dojo/..."> children, and also looking for
+			// descendant nodes with dojoType specified (unless the widget has the stopParser flag).
+			// When finished with children, go to my next sibling.
+			node = firstChild;
+			scripts = childScripts;
+			scriptsOnly = ctor && ctor.prototype.stopParser && !(args && args.template);
+			parent = current;
+
+		}
+
+		// go build the object instances
+		var mixin = args && args.template ? {template: true} : null;
+		return this.instantiate(list, mixin, args); // Array
+	};
+}();
+
+
+//Register the parser callback. It should be the first callback
+//after the a11y test.
+if(dojo.config.parseOnLoad){
+	dojo.ready(100, dojo.parser, "parse");
+}
+
+return dojo.parser;
+});
diff --git a/js/dojo-1.7.2/dojo/query.js b/js/dojo-1.7.2/dojo/query.js
new file mode 100644
index 0000000..9b55285
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/query.js
@@ -0,0 +1,714 @@
+//>>built
+define("dojo/query", ["./_base/kernel", "./has", "./dom", "./on", "./_base/array", "./_base/lang", "./selector/_loader", "./selector/_loader!default"],
+	function(dojo, has, dom, on, array, lang, loader, defaultEngine){
+"use strict";
+
+	has.add("array-extensible", function(){
+		// test to see if we can extend an array (not supported in old IE)
+		return lang.delegate([], {length: 1}).length == 1 && !has("bug-for-in-skips-shadowed");
+	});
+	
+	var ap = Array.prototype, aps = ap.slice, apc = ap.concat, forEach = array.forEach;
+
+	var tnl = function(/*Array*/ a, /*dojo.NodeList?*/ parent, /*Function?*/ NodeListCtor){
+		// summary:
+		//		decorate an array to make it look like a `dojo.NodeList`.
+		// a:
+		//		Array of nodes to decorate.
+		// parent:
+		//		An optional parent NodeList that generated the current
+		//		list of nodes. Used to call _stash() so the parent NodeList
+		//		can be accessed via end() later.
+		// NodeListCtor:
+		//		An optional constructor function to use for any
+		//		new NodeList calls. This allows a certain chain of
+		//		NodeList calls to use a different object than dojo.NodeList.
+		var nodeList = new (NodeListCtor || this._NodeListCtor || nl)(a);
+		return parent ? nodeList._stash(parent) : nodeList;
+	};
+
+	var loopBody = function(f, a, o){
+		a = [0].concat(aps.call(a, 0));
+		o = o || dojo.global;
+		return function(node){
+			a[0] = node;
+			return f.apply(o, a);
+		};
+	};
+
+	// adapters
+
+	var adaptAsForEach = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the forEach-type
+		//		actions. The initial object is returned from the specialized
+		//		function.
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			this.forEach(loopBody(f, arguments, o));
+			return this;	// Object
+		};
+	};
+
+	var adaptAsMap = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the map-type
+		//		actions. The return is a new array of values, as via `dojo.map`
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			return this.map(loopBody(f, arguments, o));
+		};
+	};
+
+	var adaptAsFilter = function(f, o){
+		// summary:
+		//		adapts a single node function to be used in the filter-type actions
+		// f: Function
+		//		a function to adapt
+		// o: Object?
+		//		an optional context for f
+		return function(){
+			return this.filter(loopBody(f, arguments, o));
+		};
+	};
+
+	var adaptWithCondition = function(f, g, o){
+		// summary:
+		//		adapts a single node function to be used in the map-type
+		//		actions, behaves like forEach() or map() depending on arguments
+		// f: Function
+		//		a function to adapt
+		// g: Function
+		//		a condition function, if true runs as map(), otherwise runs as forEach()
+		// o: Object?
+		//		an optional context for f and g
+		return function(){
+			var a = arguments, body = loopBody(f, a, o);
+			if(g.call(o || dojo.global, a)){
+				return this.map(body);	// self
+			}
+			this.forEach(body);
+			return this;	// self
+		};
+	};
+
+	var NodeList = function(array){
+		// summary:
+		//		dojo.NodeList is an of Array-like object which adds syntactic
+		//		sugar for chaining, common iteration operations, animation, and
+		//		node manipulation. NodeLists are most often returned as the
+		//		result of dojo.query() calls.
+		// description:
+		//		dojo.NodeList instances provide many utilities that reflect
+		//		core Dojo APIs for Array iteration and manipulation, DOM
+		//		manipulation, and event handling. Instead of needing to dig up
+		//		functions in the dojo.* namespace, NodeLists generally make the
+		//		full power of Dojo available for DOM manipulation tasks in a
+		//		simple, chainable way.
+		// example:
+		//		create a node list from a node
+		//		|	new dojo.NodeList(dojo.byId("foo"));
+		// example:
+		//		get a NodeList from a CSS query and iterate on it
+		//		|	var l = dojo.query(".thinger");
+		//		|	l.forEach(function(node, index, nodeList){
+		//		|		console.log(index, node.innerHTML);
+		//		|	});
+		// example:
+		//		use native and Dojo-provided array methods to manipulate a
+		//		NodeList without needing to use dojo.* functions explicitly:
+		//		|	var l = dojo.query(".thinger");
+		//		|	// since NodeLists are real arrays, they have a length
+		//		|	// property that is both readable and writable and
+		//		|	// push/pop/shift/unshift methods
+		//		|	console.log(l.length);
+		//		|	l.push(dojo.create("span"));
+		//		|
+		//		|	// dojo's normalized array methods work too:
+		//		|	console.log( l.indexOf(dojo.byId("foo")) );
+		//		|	// ...including the special "function as string" shorthand
+		//		|	console.log( l.every("item.nodeType == 1") );
+		//		|
+		//		|	// NodeLists can be [..] indexed, or you can use the at()
+		//		|	// function to get specific items wrapped in a new NodeList:
+		//		|	var node = l[3]; // the 4th element
+		//		|	var newList = l.at(1, 3); // the 2nd and 4th elements
+		// example:
+		//		the style functions you expect are all there too:
+		//		|	// style() as a getter...
+		//		|	var borders = dojo.query(".thinger").style("border");
+		//		|	// ...and as a setter:
+		//		|	dojo.query(".thinger").style("border", "1px solid black");
+		//		|	// class manipulation
+		//		|	dojo.query("li:nth-child(even)").addClass("even");
+		//		|	// even getting the coordinates of all the items
+		//		|	var coords = dojo.query(".thinger").coords();
+		// example:
+		//		DOM manipulation functions from the dojo.* namespace area also
+		//		available:
+		//		|	// remove all of the elements in the list from their
+		//		|	// parents (akin to "deleting" them from the document)
+		//		|	dojo.query(".thinger").orphan();
+		//		|	// place all elements in the list at the front of #foo
+		//		|	dojo.query(".thinger").place("foo", "first");
+		// example:
+		//		Event handling couldn't be easier. `dojo.connect` is mapped in,
+		//		and shortcut handlers are provided for most DOM events:
+		//		|	// like dojo.connect(), but with implicit scope
+		//		|	dojo.query("li").connect("onclick", console, "log");
+		//		|
+		//		|	// many common event handlers are already available directly:
+		//		|	dojo.query("li").onclick(console, "log");
+		//		|	var toggleHovered = dojo.hitch(dojo, "toggleClass", "hovered");
+		//		|	dojo.query("p")
+		//		|		.onmouseenter(toggleHovered)
+		//		|		.onmouseleave(toggleHovered);
+		// example:
+		//		chainability is a key advantage of NodeLists:
+		//		|	dojo.query(".thinger")
+		//		|		.onclick(function(e){ /* ... */ })
+		//		|		.at(1, 3, 8) // get a subset
+		//		|			.style("padding", "5px")
+		//		|			.forEach(console.log);
+		var isNew = this instanceof nl && has("array-extensible");
+		if(typeof array == "number"){
+			array = Array(array);
+		}
+		var nodeArray = (array && "length" in array) ? array : arguments;
+		if(isNew || !nodeArray.sort){
+			// make sure it's a real array before we pass it on to be wrapped 
+			var target = isNew ? this : [],
+				l = target.length = nodeArray.length;
+			for(var i = 0; i < l; i++){
+				target[i] = nodeArray[i];
+			}
+			if(isNew){
+				// called with new operator, this means we are going to use this instance and push
+				// the nodes on to it. This is usually much faster since the NodeList properties
+				//	don't need to be copied (unless the list of nodes is extremely large).
+				return target;
+			}
+			nodeArray = target;
+		}
+		// called without new operator, use a real array and copy prototype properties,
+		// this is slower and exists for back-compat. Should be removed in 2.0.
+		lang._mixin(nodeArray, nlp);
+		nodeArray._NodeListCtor = function(array){
+			// call without new operator to preserve back-compat behavior
+			return nl(array);
+		};
+		return nodeArray;
+	};
+	
+	var nl = NodeList, nlp = nl.prototype = 
+		has("array-extensible") ? [] : {};// extend an array if it is extensible
+
+	// expose adapters and the wrapper as private functions
+
+	nl._wrap = nlp._wrap = tnl;
+	nl._adaptAsMap = adaptAsMap;
+	nl._adaptAsForEach = adaptAsForEach;
+	nl._adaptAsFilter  = adaptAsFilter;
+	nl._adaptWithCondition = adaptWithCondition;
+
+	// mass assignment
+
+	// add array redirectors
+	forEach(["slice", "splice"], function(name){
+		var f = ap[name];
+		//Use a copy of the this array via this.slice() to allow .end() to work right in the splice case.
+		// CANNOT apply ._stash()/end() to splice since it currently modifies
+		// the existing this array -- it would break backward compatibility if we copy the array before
+		// the splice so that we can use .end(). So only doing the stash option to this._wrap for slice.
+		nlp[name] = function(){ return this._wrap(f.apply(this, arguments), name == "slice" ? this : null); };
+	});
+	// concat should be here but some browsers with native NodeList have problems with it
+
+	// add array.js redirectors
+	forEach(["indexOf", "lastIndexOf", "every", "some"], function(name){
+		var f = array[name];
+		nlp[name] = function(){ return f.apply(dojo, [this].concat(aps.call(arguments, 0))); };
+	});
+
+	/*===== var NodeList = dojo.NodeList; =====*/
+	lang.extend(NodeList, {
+		// copy the constructors
+		constructor: nl,
+		_NodeListCtor: nl,
+		toString: function(){
+			// Array.prototype.toString can't be applied to objects, so we use join
+			return this.join(",");
+		},
+		_stash: function(parent){
+			// summary:
+			//		private function to hold to a parent NodeList. end() to return the parent NodeList.
+			//
+			// example:
+			// How to make a `dojo.NodeList` method that only returns the third node in
+			// the dojo.NodeList but allows access to the original NodeList by using this._stash:
+			//	|	dojo.extend(dojo.NodeList, {
+			//	|		third: function(){
+			//	|			var newNodeList = dojo.NodeList(this[2]);
+			//	|			return newNodeList._stash(this);
+			//	|		}
+			//	|	});
+			//	|	// then see how _stash applies a sub-list, to be .end()'ed out of
+			//	|	dojo.query(".foo")
+			//	|		.third()
+			//	|			.addClass("thirdFoo")
+			//	|		.end()
+			//	|		// access to the orig .foo list
+			//	|		.removeClass("foo")
+			//	|
+			//
+			this._parent = parent;
+			return this; //dojo.NodeList
+		},
+
+		on: function(eventName, listener){
+			// summary:
+			//		Listen for events on the nodes in the NodeList. Basic usage is:
+			//		| query(".my-class").on("click", listener);
+			// 		This supports event delegation by using selectors as the first argument with the event names as
+			//		pseudo selectors. For example:
+			//		| dojo.query("#my-list").on("li:click", listener);
+			//		This will listen for click events within <li> elements that are inside the #my-list element.
+			//		Because on supports CSS selector syntax, we can use comma-delimited events as well:
+			//		| dojo.query("#my-list").on("li button:mouseover, li:click", listener);
+			var handles = this.map(function(node){
+				return on(node, eventName, listener); // TODO: apply to the NodeList so the same selector engine is used for matches
+			});
+			handles.remove = function(){
+				for(var i = 0; i < handles.length; i++){
+					handles[i].remove();
+				}
+			};
+			return handles;
+		},
+
+		end: function(){
+			// summary:
+			//		Ends use of the current `dojo.NodeList` by returning the previous dojo.NodeList
+			//		that generated the current dojo.NodeList.
+			// description:
+			//		Returns the `dojo.NodeList` that generated the current `dojo.NodeList`. If there
+			//		is no parent dojo.NodeList, an empty dojo.NodeList is returned.
+			// example:
+			//	|	dojo.query("a")
+			//	|		.filter(".disabled")
+			//	|			// operate on the anchors that only have a disabled class
+			//	|			.style("color", "grey")
+			//	|		.end()
+			//	|		// jump back to the list of anchors
+			//	|		.style(...)
+			//
+			if(this._parent){
+				return this._parent;
+			}else{
+				//Just return empty list.
+				return new this._NodeListCtor(0);
+			}
+		},
+
+		// http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array#Methods
+
+		// FIXME: handle return values for #3244
+		//		http://trac.dojotoolkit.org/ticket/3244
+
+		// FIXME:
+		//		need to wrap or implement:
+		//			join (perhaps w/ innerHTML/outerHTML overload for toString() of items?)
+		//			reduce
+		//			reduceRight
+
+		/*=====
+		slice: function(begin, end){
+			// summary:
+			//		Returns a new NodeList, maintaining this one in place
+			// description:
+			//		This method behaves exactly like the Array.slice method
+			//		with the caveat that it returns a dojo.NodeList and not a
+			//		raw Array. For more details, see Mozilla's (slice
+			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:slice]
+			// begin: Integer
+			//		Can be a positive or negative integer, with positive
+			//		integers noting the offset to begin at, and negative
+			//		integers denoting an offset from the end (i.e., to the left
+			//		of the end)
+			// end: Integer?
+			//		Optional parameter to describe what position relative to
+			//		the NodeList's zero index to end the slice at. Like begin,
+			//		can be positive or negative.
+			return this._wrap(a.slice.apply(this, arguments));
+		},
+
+		splice: function(index, howmany, item){
+			// summary:
+			//		Returns a new NodeList, manipulating this NodeList based on
+			//		the arguments passed, potentially splicing in new elements
+			//		at an offset, optionally deleting elements
+			// description:
+			//		This method behaves exactly like the Array.splice method
+			//		with the caveat that it returns a dojo.NodeList and not a
+			//		raw Array. For more details, see Mozilla's (splice
+			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:splice]
+			//		For backwards compatibility, calling .end() on the spliced NodeList
+			//		does not return the original NodeList -- splice alters the NodeList in place.
+			// index: Integer
+			//		begin can be a positive or negative integer, with positive
+			//		integers noting the offset to begin at, and negative
+			//		integers denoting an offset from the end (i.e., to the left
+			//		of the end)
+			// howmany: Integer?
+			//		Optional parameter to describe what position relative to
+			//		the NodeList's zero index to end the slice at. Like begin,
+			//		can be positive or negative.
+			// item: Object...?
+			//		Any number of optional parameters may be passed in to be
+			//		spliced into the NodeList
+			// returns:
+			//		dojo.NodeList
+			return this._wrap(a.splice.apply(this, arguments));
+		},
+
+		indexOf: function(value, fromIndex){
+			// summary:
+			//		see dojo.indexOf(). The primary difference is that the acted-on
+			//		array is implicitly this NodeList
+			// value: Object:
+			//		The value to search for.
+			// fromIndex: Integer?:
+			//		The location to start searching from. Optional. Defaults to 0.
+			// description:
+			//		For more details on the behavior of indexOf, see Mozilla's
+			//		(indexOf
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf]
+			// returns:
+			//		Positive Integer or 0 for a match, -1 of not found.
+			return d.indexOf(this, value, fromIndex); // Integer
+		},
+
+		lastIndexOf: function(value, fromIndex){
+			// summary:
+			//		see dojo.lastIndexOf(). The primary difference is that the
+			//		acted-on array is implicitly this NodeList
+			// description:
+			//		For more details on the behavior of lastIndexOf, see
+			//		Mozilla's (lastIndexOf
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf]
+			// value: Object
+			//		The value to search for.
+			// fromIndex: Integer?
+			//		The location to start searching from. Optional. Defaults to 0.
+			// returns:
+			//		Positive Integer or 0 for a match, -1 of not found.
+			return d.lastIndexOf(this, value, fromIndex); // Integer
+		},
+
+		every: function(callback, thisObject){
+			// summary:
+			//		see `dojo.every()` and the (Array.every
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every].
+			//		Takes the same structure of arguments and returns as
+			//		dojo.every() with the caveat that the passed array is
+			//		implicitly this NodeList
+			// callback: Function: the callback
+			// thisObject: Object?: the context
+			return d.every(this, callback, thisObject); // Boolean
+		},
+
+		some: function(callback, thisObject){
+			// summary:
+			//		Takes the same structure of arguments and returns as
+			//		`dojo.some()` with the caveat that the passed array is
+			//		implicitly this NodeList.  See `dojo.some()` and Mozilla's
+			//		(Array.some
+			//		documentation)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some].
+			// callback: Function: the callback
+			// thisObject: Object?: the context
+			return d.some(this, callback, thisObject); // Boolean
+		},
+		=====*/
+
+		concat: function(item){
+			// summary:
+			//		Returns a new NodeList comprised of items in this NodeList
+			//		as well as items passed in as parameters
+			// description:
+			//		This method behaves exactly like the Array.concat method
+			//		with the caveat that it returns a `dojo.NodeList` and not a
+			//		raw Array. For more details, see the (Array.concat
+			//		docs)[http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:concat]
+			// item: Object?
+			//		Any number of optional parameters may be passed in to be
+			//		spliced into the NodeList
+			// returns:
+			//		dojo.NodeList
+
+			//return this._wrap(apc.apply(this, arguments));
+			// the line above won't work for the native NodeList :-(
+
+			// implementation notes:
+			// 1) Native NodeList is not an array, and cannot be used directly
+			// in concat() --- the latter doesn't recognize it as an array, and
+			// does not inline it, but append as a single entity.
+			// 2) On some browsers (e.g., Safari) the "constructor" property is
+			// read-only and cannot be changed. So we have to test for both
+			// native NodeList and dojo.NodeList in this property to recognize
+			// the node list.
+
+			var t = lang.isArray(this) ? this : aps.call(this, 0),
+				m = array.map(arguments, function(a){
+					return a && !lang.isArray(a) &&
+						(typeof NodeList != "undefined" && a.constructor === NodeList || a.constructor === this._NodeListCtor) ?
+							aps.call(a, 0) : a;
+				});
+			return this._wrap(apc.apply(t, m), this);	// dojo.NodeList
+		},
+
+		map: function(/*Function*/ func, /*Function?*/ obj){
+			// summary:
+			//		see dojo.map(). The primary difference is that the acted-on
+			//		array is implicitly this NodeList and the return is a
+			//		dojo.NodeList (a subclass of Array)
+			///return d.map(this, func, obj, d.NodeList); // dojo.NodeList
+			return this._wrap(array.map(this, func, obj), this); // dojo.NodeList
+		},
+
+		forEach: function(callback, thisObj){
+			// summary:
+			//		see `dojo.forEach()`. The primary difference is that the acted-on
+			//		array is implicitly this NodeList. If you want the option to break out
+			//		of the forEach loop, use every() or some() instead.
+			forEach(this, callback, thisObj);
+			// non-standard return to allow easier chaining
+			return this; // dojo.NodeList
+		},
+		filter: function(/*String|Function*/ filter){
+			// summary:
+			//		"masks" the built-in javascript filter() method (supported
+			//		in Dojo via `dojo.filter`) to support passing a simple
+			//		string filter in addition to supporting filtering function
+			//		objects.
+			// filter:
+			//		If a string, a CSS rule like ".thinger" or "div > span".
+			// example:
+			//		"regular" JS filter syntax as exposed in dojo.filter:
+			//		|	dojo.query("*").filter(function(item){
+			//		|		// highlight every paragraph
+			//		|		return (item.nodeName == "p");
+			//		|	}).style("backgroundColor", "yellow");
+			// example:
+			//		the same filtering using a CSS selector
+			//		|	dojo.query("*").filter("p").styles("backgroundColor", "yellow");
+
+			var a = arguments, items = this, start = 0;
+			if(typeof filter == "string"){ // inline'd type check
+				items = query._filterResult(this, a[0]);
+				if(a.length == 1){
+					// if we only got a string query, pass back the filtered results
+					return items._stash(this); // dojo.NodeList
+				}
+				// if we got a callback, run it over the filtered items
+				start = 1;
+			}
+			return this._wrap(array.filter(items, a[start], a[start + 1]), this);	// dojo.NodeList
+		},
+		instantiate: function(/*String|Object*/ declaredClass, /*Object?*/ properties){
+			// summary:
+			//		Create a new instance of a specified class, using the
+			//		specified properties and each node in the nodeList as a
+			//		srcNodeRef.
+			// example:
+			//		Grabs all buttons in the page and converts them to diji.form.Buttons.
+			//	|	var buttons = dojo.query("button").instantiate("dijit.form.Button", {showLabel: true});
+			var c = lang.isFunction(declaredClass) ? declaredClass : lang.getObject(declaredClass);
+			properties = properties || {};
+			return this.forEach(function(node){
+				new c(properties, node);
+			});	// dojo.NodeList
+		},
+		at: function(/*===== index =====*/){
+			// summary:
+			//		Returns a new NodeList comprised of items in this NodeList
+			//		at the given index or indices.
+			//
+			// index: Integer...
+			//		One or more 0-based indices of items in the current
+			//		NodeList. A negative index will start at the end of the
+			//		list and go backwards.
+			//
+			// example:
+			//	Shorten the list to the first, second, and third elements
+			//	|	dojo.query("a").at(0, 1, 2).forEach(fn);
+			//
+			// example:
+			//	Retrieve the first and last elements of a unordered list:
+			//	|	dojo.query("ul > li").at(0, -1).forEach(cb);
+			//
+			// example:
+			//	Do something for the first element only, but end() out back to
+			//	the original list and continue chaining:
+			//	|	dojo.query("a").at(0).onclick(fn).end().forEach(function(n){
+			//	|		console.log(n); // all anchors on the page.
+			//	|	})
+			//
+			// returns:
+			//		dojo.NodeList
+			var t = new this._NodeListCtor(0);
+			forEach(arguments, function(i){
+				if(i < 0){ i = this.length + i; }
+				if(this[i]){ t.push(this[i]); }
+			}, this);
+			return t._stash(this); // dojo.NodeList
+		}
+	});
+
+
+/*===== 
+dojo.query = function(selector, context){
+	// summary:
+	//		This modules provides DOM querying functionality. The module export is a function
+	//		that can be used to query for DOM nodes by CSS selector and returns a dojo.NodeList
+	//		representing the matching nodes.
+	//
+	// selector: String
+	//		A CSS selector to search for.
+	// context: String|DomNode?
+	//		An optional context to limit the searching scope. Only nodes under `context` will be 
+	//		scanned. 
+	// 
+	//	example:
+	//		add an onclick handler to every submit button in the document
+	//		which causes the form to be sent via Ajax instead:
+	//	|	define(["dojo/query"], function(query){
+	// 	|	query("input[type='submit']").on("click", function(e){
+	//	|		dojo.stopEvent(e); // prevent sending the form
+	//	|		var btn = e.target;
+	//	|		dojo.xhrPost({
+	//	|			form: btn.form,
+	//	|			load: function(data){
+	//	|				// replace the form with the response
+	//	|				var div = dojo.doc.createElement("div");
+	//	|				dojo.place(div, btn.form, "after");
+	//	|				div.innerHTML = data;
+	//	|				dojo.style(btn.form, "display", "none");
+	//	|			}
+	//	|		});
+	//	|	}); 
+	//
+	// description:
+	//		dojo/query is responsible for loading the appropriate query engine and wrapping 
+	//		its results with a `dojo.NodeList`. You can use dojo/query with a specific selector engine
+	//		by using it as a plugin. For example, if you installed the sizzle package, you could
+	//		use it as the selector engine with:
+	//		|	define("dojo/query!sizzle", function(query){
+	//		|		query("div")...
+	//
+	//		The id after the ! can be a module id of the selector engine or one of the following values:
+	//		|	+ acme: This is the default engine used by Dojo base, and will ensure that the full
+	//		|	Acme engine is always loaded. 
+	//		|	
+	//		|	+ css2: If the browser has a native selector engine, this will be used, otherwise a
+	//		|	very minimal lightweight selector engine will be loaded that can do simple CSS2 selectors
+	//		|	(by #id, .class, tag, and [name=value] attributes, with standard child or descendant (>)
+	//		|	operators) and nothing more.
+	//		|
+	//		|	+ css2.1: If the browser has a native selector engine, this will be used, otherwise the
+	//		|	full Acme engine will be loaded. 
+	//		|	
+	//		|	+ css3: If the browser has a native selector engine with support for CSS3 pseudo
+	//		|	selectors (most modern browsers except IE8), this will be used, otherwise the
+	//		|	full Acme engine will be loaded.
+	//		|	
+	//		|	+ Or the module id of a selector engine can be used to explicitly choose the selector engine
+	//		
+	//		For example, if you are using CSS3 pseudo selectors in module, you can specify that
+	//		you will need support them with:
+	//		|	define("dojo/query!css3", function(query){
+	//		|		query('#t > h3:nth-child(odd)')...
+	//
+	//		You can also choose the selector engine/load configuration by setting the <FIXME:what is the configuration setting?>.
+	//		For example:
+	//		|	<script data-dojo-config="query-selector:'css3'" src="dojo.js"></script>
+	//		
+	return new dojo.NodeList(); // dojo.NodeList
+};
+=====*/
+
+function queryForEngine(engine, NodeList){
+	var query = function(/*String*/ query, /*String|DOMNode?*/ root){
+		//	summary:
+		//		Returns nodes which match the given CSS selector, searching the
+		//		entire document by default but optionally taking a node to scope
+		//		the search by. Returns an instance of dojo.NodeList.
+		if(typeof root == "string"){
+			root = dom.byId(root);
+			if(!root){
+				return new NodeList([]);
+			}
+		}
+		var results = typeof query == "string" ? engine(query, root) : query.orphan ? query : [query];
+		if(results.orphan){
+			// already wrapped
+			return results; 
+		}
+		return new NodeList(results);
+	};
+	query.matches = engine.match || function(node, selector, root){
+		// summary:
+		//		Test to see if a node matches a selector
+		return query.filter([node], selector, root).length > 0;
+	};
+	// the engine provides a filtering function, use it to for matching
+	query.filter = engine.filter || function(nodes, selector, root){
+		// summary:
+		//		Filters an array of nodes. Note that this does not guarantee to return a dojo.NodeList, just an array.
+		return query(selector, root).filter(function(node){
+			return array.indexOf(nodes, node) > -1;
+		});
+	};
+	if(typeof engine != "function"){
+		var search = engine.search;
+		engine = function(selector, root){
+			// Slick does it backwards (or everyone else does it backwards, probably the latter)
+			return search(root || document, selector);
+		};
+	}
+	return query;
+}
+var query = queryForEngine(defaultEngine, NodeList);
+// the query that is returned from this module is slightly different than dojo.query,
+// because dojo.query has to maintain backwards compatibility with returning a
+// true array which has performance problems. The query returned from the module
+// does not use true arrays, but rather inherits from Array, making it much faster to
+// instantiate.
+dojo.query = queryForEngine(defaultEngine, function(array){
+	// call it without the new operator to invoke the back-compat behavior that returns a true array
+	return NodeList(array);
+});
+
+query.load = /*===== dojo.query.load= ======*/ function(id, parentRequire, loaded, config){
+	// summary: can be used as AMD plugin to conditionally load new query engine
+	// example:
+	//	|	define(["dojo/query!custom"], function(qsa){ 
+	//	|		// loaded selector/custom.js as engine
+	//	|		qsa("#foobar").forEach(...);
+	//	|	});
+	loader.load(id, parentRequire, function(engine){
+		loaded(queryForEngine(engine, NodeList));
+	});
+};
+
+dojo._filterQueryResult = query._filterResult = function(nodes, selector, root){
+	return new NodeList(query.filter(nodes, selector, root));
+};
+dojo.NodeList = query.NodeList = NodeList;
+return query;
+});
diff --git a/js/dojo-1.7.2/dojo/ready.js b/js/dojo-1.7.2/dojo/ready.js
new file mode 100644
index 0000000..5e10389
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/ready.js
@@ -0,0 +1,139 @@
+//>>built
+define("dojo/ready", ["./_base/kernel", "./has", "require", "./domReady", "./_base/lang"], function(dojo, has, require, domReady, lang) {
+	// module:
+	//		dojo/ready
+	// summary:
+	//		This module defines the dojo.ready API.
+	//
+	// note:
+	//		This module should be unnecessary in dojo 2.0
+	var
+		// truthy if DOMContentLoaded or better (e.g., window.onload fired) has been achieved
+		isDomReady = 0,
+
+		// a function to call to cause onLoad to be called when all requested modules have been loaded
+		requestCompleteSignal,
+
+		// The queue of functions waiting to execute as soon as dojo.ready conditions satisfied
+		loadQ = [],
+
+		// prevent recursion in onLoad
+		onLoadRecursiveGuard = 0,
+
+		handleDomReady = function(){
+			isDomReady = 1;
+			dojo._postLoad = dojo.config.afterOnLoad = true;
+			if(loadQ.length){
+				requestCompleteSignal(onLoad);
+			}
+		},
+
+		// run the next function queued with dojo.ready
+		onLoad = function(){
+			if(isDomReady && !onLoadRecursiveGuard && loadQ.length){
+				//guard against recursions into this function
+				onLoadRecursiveGuard = 1;
+				var f = loadQ.shift();
+					try{
+						f();
+					}
+						// FIXME: signal the error via require.on
+					finally{
+						onLoadRecursiveGuard = 0;
+					}
+				onLoadRecursiveGuard = 0;
+				if(loadQ.length){
+					requestCompleteSignal(onLoad);
+				}
+			}
+		};
+
+	// define requireCompleteSignal; impl depends on loader
+	if(1){
+		require.on("idle", onLoad);
+		requestCompleteSignal = function(){
+			if(require.idle()){
+				onLoad();
+			} // else do nothing, onLoad will be called with the next idle signal
+		};
+	}else{
+		// RequireJS or similar
+		requestCompleteSignal = function(){
+			// the next function call will fail if you don't have a loader with require.ready
+			// in that case, either fix your loader, use dojo's loader, or don't call dojo.ready;
+			require.ready(onLoad);
+		};
+	}
+
+	var ready = dojo.ready = dojo.addOnLoad = function(priority, context, callback){
+		// summary: Add a function to execute on DOM content loaded and all requested modules have arrived and been evaluated.
+		// priority: Integer?
+		//		The order in which to exec this callback relative to other callbacks, defaults to 1000
+		// context: Object?|Function
+		//		The context in which to run execute callback, or a callback if not using context
+		// callback: Function?
+		//		The function to execute.
+		//
+		// example:
+		//	Simple DOM and Modules ready syntax
+		//	|	dojo.ready(function(){ alert("Dom ready!"); });
+		//
+		// example:
+		//	Using a priority
+		//	|	dojo.ready(2, function(){ alert("low priority ready!"); })
+		//
+		// example:
+		//	Using context
+		//	|	dojo.ready(foo, function(){
+		//	|		// in here, this == foo
+		//	|	})
+		//
+		// example:
+		//	Using dojo.hitch style args:
+		//	|	var foo = { dojoReady: function(){ console.warn(this, "dojo dom and modules ready."); } };
+		//	|	dojo.ready(foo, "dojoReady");
+
+		var hitchArgs = lang._toArray(arguments);
+		if(typeof priority != "number"){
+			callback = context;
+			context = priority;
+			priority = 1000;
+		}else{
+			hitchArgs.shift();
+		}
+		callback = callback ?
+			lang.hitch.apply(dojo, hitchArgs) :
+			function(){
+				context();
+			};
+		callback.priority = priority;
+		for(var i = 0; i < loadQ.length && priority >= loadQ[i].priority; i++){}
+		loadQ.splice(i, 0, callback);
+		requestCompleteSignal();
+	};
+
+	true || has.add("dojo-config-addOnLoad", 1);
+	if(1){
+		var dca = dojo.config.addOnLoad;
+		if(dca){
+			ready[(lang.isArray(dca) ? "apply" : "call")](dojo, dca);
+		}
+	}
+
+	if(1 && dojo.config.parseOnLoad && !dojo.isAsync){
+		ready(99, function(){
+			if(!dojo.parser){
+				dojo.deprecated("Add explicit require(['dojo/parser']);", "", "2.0");
+				require(["dojo/parser"]);
+			}
+		});
+	}
+
+	if(1){
+		domReady(handleDomReady);
+	}else{
+		handleDomReady();
+	}
+
+	return ready;
+});
diff --git a/js/dojo-1.7.2/dojo/regexp.js b/js/dojo-1.7.2/dojo/regexp.js
new file mode 100644
index 0000000..cceaa4a
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/regexp.js
@@ -0,0 +1,74 @@
+//>>built
+define("dojo/regexp", ["./_base/kernel", "./_base/lang"], function(dojo, lang) {
+	// module:
+	//		dojo/regexp
+	// summary:
+	//		TODOC
+
+lang.getObject("regexp", true, dojo);
+
+/*=====
+dojo.regexp = {
+	// summary: Regular expressions and Builder resources
+};
+=====*/
+
+dojo.regexp.escapeString = function(/*String*/str, /*String?*/except){
+	//	summary:
+	//		Adds escape sequences for special characters in regular expressions
+	// except:
+	//		a String with special characters to be left unescaped
+
+	return str.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, function(ch){
+		if(except && except.indexOf(ch) != -1){
+			return ch;
+		}
+		return "\\" + ch;
+	}); // String
+};
+
+dojo.regexp.buildGroupRE = function(/*Object|Array*/arr, /*Function*/re, /*Boolean?*/nonCapture){
+	//	summary:
+	//		Builds a regular expression that groups subexpressions
+	//	description:
+	//		A utility function used by some of the RE generators. The
+	//		subexpressions are constructed by the function, re, in the second
+	//		parameter.  re builds one subexpression for each elem in the array
+	//		a, in the first parameter. Returns a string for a regular
+	//		expression that groups all the subexpressions.
+	// arr:
+	//		A single value or an array of values.
+	// re:
+	//		A function. Takes one parameter and converts it to a regular
+	//		expression.
+	// nonCapture:
+	//		If true, uses non-capturing match, otherwise matches are retained
+	//		by regular expression. Defaults to false
+
+	// case 1: a is a single value.
+	if(!(arr instanceof Array)){
+		return re(arr); // String
+	}
+
+	// case 2: a is an array
+	var b = [];
+	for(var i = 0; i < arr.length; i++){
+		// convert each elem to a RE
+		b.push(re(arr[i]));
+	}
+
+	 // join the REs as alternatives in a RE group.
+	return dojo.regexp.group(b.join("|"), nonCapture); // String
+};
+
+dojo.regexp.group = function(/*String*/expression, /*Boolean?*/nonCapture){
+	// summary:
+	//		adds group match to expression
+	// nonCapture:
+	//		If true, uses non-capturing match, otherwise matches are retained
+	//		by regular expression.
+	return "(" + (nonCapture ? "?:":"") + expression + ")"; // String
+};
+
+return dojo.regexp;
+});
diff --git a/js/dojo-1.7.2/dojo/require.js b/js/dojo-1.7.2/dojo/require.js
new file mode 100644
index 0000000..f4a1682
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/require.js
@@ -0,0 +1,8 @@
+//>>built
+define("dojo/require", ["./_base/loader"], function(loader){
+	return {
+		dynamic:0,
+		normalize:function(id){return id;},
+		load:loader.require
+	};
+});
diff --git a/js/dojo-1.7.2/dojo/resources/LICENSE b/js/dojo-1.7.2/dojo/resources/LICENSE
new file mode 100644
index 0000000..eb28b7e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/LICENSE
@@ -0,0 +1,30 @@
+License Disclaimer:
+
+All contents of this directory are Copyright (c) the Dojo Foundation, with the
+following exceptions:
+-------------------------------------------------------------------------------
+
+dojo.css:
+	* parts Copyright (c) 2007, Yahoo! Inc. All rights reserved.
+	  Distributed under the terms of the BSD License
+
+The Program includes all or portions of the following software which was obtained under the terms and conditions of the BSD License.
+
+http://developer.yahoo.com/yui/license.html
+
+Copyright (c) 2007, Yahoo! Inc.
+ All rights reserved.
+ Redistribution and use of this software in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
+ * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the 
+documentation and/or other materials provided with the distribution.
+ * Neither the name of Yahoo! Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without 
+specific prior written permission of Yahoo! Inc. 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+ EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
diff --git a/js/dojo-1.7.2/dojo/resources/_modules.js b/js/dojo-1.7.2/dojo/resources/_modules.js
new file mode 100644
index 0000000..e093a58
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/_modules.js
@@ -0,0 +1,36 @@
+/*=====
+// Supplemental summaries for those hard-to-doc places your conventional doc parser can't reach.
+// Where possible, these summaries should appear inline in the code.
+//
+// this is "package level documentation"
+
+dojo.cldr = {
+	// summary: transformation of relevant pieces of the Unicode.org Common Locale Data Repository
+	// (see http://unicode.org/cldr) to JSON from the original XML with associated utility classes
+};
+
+dojo.data = {
+	// summary: A uniform data access layer
+};
+
+dojo.dnd = {
+	// summary: Drag and Drop resources
+};
+
+dojo.io = {
+	// summary: Additional I/O transports (Ajax)
+};
+
+dojo.rpc = {
+	// summary: Dojo remote-procedure-call resources
+};
+
+// "variables"
+
+dojo.baseUrl = {
+	// summary: The root relative path to dojo.js (as a string)
+	// example:
+	//	if(typeof dojo != "undefined"){ console.log(dojo.baseUrl); }
+};
+
+=====*/
diff --git a/js/dojo-1.7.2/dojo/resources/blank.gif b/js/dojo-1.7.2/dojo/resources/blank.gif
new file mode 100644
index 0000000..e565824
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/blank.gif
diff --git a/js/dojo-1.7.2/dojo/resources/blank.html b/js/dojo-1.7.2/dojo/resources/blank.html
new file mode 100644
index 0000000..40fe770
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/blank.html
@@ -0,0 +1 @@
+<html><head><script>isLoaded = true;</script></head><body></body></html>
diff --git a/js/dojo-1.7.2/dojo/resources/dnd.css b/js/dojo-1.7.2/dojo/resources/dnd.css
new file mode 100644
index 0000000..fb06118
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/dnd.css
@@ -0,0 +1,16 @@
+/* DnD avatar-specific settings */
+.dojoDndAvatar			{font-size: 75%; color: black;}
+.dojoDndAvatarHeader td	{padding-left: 20px; padding-right: 4px;  height: 16px;}
+.dojoDndAvatarHeader	{background: #ccc;}
+.dojoDndAvatarItem		{background: #eee;}
+.dojoDndMove .dojoDndAvatarHeader	{background-image: url(images/dndNoMove.png); background-repeat: no-repeat;}
+.dojoDndCopy .dojoDndAvatarHeader	{background-image: url(images/dndNoCopy.png); background-repeat: no-repeat;}
+.dojoDndMove .dojoDndAvatarCanDrop .dojoDndAvatarHeader	{background-image: url(images/dndMove.png); background-repeat: no-repeat;}
+.dojoDndCopy .dojoDndAvatarCanDrop .dojoDndAvatarHeader	{background-image: url(images/dndCopy.png); background-repeat: no-repeat;}
+
+.dojoDndHandle {cursor: move;}
+.dojoDndIgnore {cursor: default;}
+
+.dijit_a11y .dojoDndAvatar { font-size: 1em; font-weight:bold;}
+.dijit_a11y .dojoDndAvatarHeader td {padding-left:2px !important;}
+.dijit_a11y .dojoDndAvatarHeader td span {padding-right: 5px;}
diff --git a/js/dojo-1.7.2/dojo/resources/dojo.css b/js/dojo-1.7.2/dojo/resources/dojo.css
new file mode 100644
index 0000000..fdaa842
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/dojo.css
@@ -0,0 +1,196 @@
+/*
+	dojo.css
+	Baseline CSS file for general usage.
+
+	This file is intended to be a "quick and dirty" stylesheet you can use to give
+	a straight-up web page some basic styling without having to do the dirty work
+	yourself.  It includes a modified version of YUI's reset.css (we pulled some
+	of the list reset definitions, among other things), and then provides some very
+	basic style rules to be applied to general HTML elements.
+
+	This stylesheet is NOT intended to serve as the foundation for more complex things--
+	including the use of a TABLE for layout purposes.  The table definitions in this
+	file make the assumption that you will be using tables for thier declared purpose:
+	displaying tabular data.
+
+	If you are looking for a baseline stylesheet using tables for grid layout, you will
+	need to supply your own layout rules to override the ones in this stylesheet.
+	
+	Applications using Dojo will function correctly without including this
+	file, but it should provide sane defaults for many common things that page
+	authors often need to set up manually.
+
+	The Dojo Core uses this stylesheet to quickly style HTML-based tests and demos.  Feel
+	free to use it as you will.
+*/
+
+/*****************************************************************************************/
+
+/*
+	The below are borrowed from YUI's reset style sheets for pages and fonts.
+	We've verified w/ the YUI development team that these are entirely
+	copyright Yahoo, written entirely by Nate Koechley and Matt Sweeney without
+	external contributions.
+
+	Copyright (c) 2007, Yahoo! Inc. All rights reserved.
+	Code licensed under the BSD License:
+	http://developer.yahoo.net/yui/license.txt
+	version: 2.2.1
+*/
+
+body, div, dl, dt, dd, li, h1, h2, h3, h4, h5, h6, pre, form, fieldset, input, textarea, p, blockquote, th, td {
+	margin: 0;
+	padding: 0;
+}
+
+fieldset, img {
+	border: 0 none;
+}
+
+address, caption, cite, code, dfn, th, var {
+	font-style: normal; 
+	font-weight: normal;
+}
+
+caption, th {
+	text-align: left;
+}
+
+q:before, q:after {
+	content:"";
+}
+
+abbr, acronym {
+	border:0;
+}
+/* End YUI imported code. */
+
+/*****************************************************************************************/
+
+/* 
+	Begin Dojo additions.
+
+	Style definitions, based loosely on the Dijit Tundra theme.
+	Relative unit calculations based on "Compose to a Vertical Rhythm",
+	by Richard Rutter (http://24ways.org/2006/compose-to-a-vertical-rhythm)
+
+	If changing the font size, make sure you do it in both
+	percent and px (% for IE, px for everything else). 
+	% value based on default size of 16px (in most browsers).
+	So if you want the default size to be 14px, set the 
+	% to 87% (14 / 16 = 0.875).
+
+	Typical values:
+	10px: 62.5%
+	11px: 69% (68.75)
+	12px: 75%
+	13px: 81.25%
+	14px: 87.5%
+	16px: 100%
+
+	Default: 12px
+*/
+body { 
+	font: 12px Myriad,Helvetica,Tahoma,Arial,clean,sans-serif; 
+	*font-size: 75%;
+}
+
+/* Headings */
+h1 {
+	font-size: 1.5em; 
+	font-weight: normal;
+	line-height: 1em; 
+	margin-top: 1em;
+	margin-bottom:0;
+}
+
+h2 { 
+	font-size: 1.1667em; 
+	font-weight: bold; 
+	line-height: 1.286em; 
+	margin-top: 1.929em; 
+	margin-bottom:0.643em;
+}
+
+h3, h4, h5, h6 {
+	font-size: 1em; 
+	font-weight: bold; 
+	line-height: 1.5em; 
+	margin-top: 1.5em; 
+	margin-bottom: 0;
+}
+
+/* paragraphs, quotes and lists */
+p { 
+	font-size: 1em; 
+	margin-top: 1.5em; 
+	margin-bottom: 1.5em; 
+	line-height: 1.5em;
+}
+
+blockquote { 
+	font-size: 0.916em; 
+	margin-top: 3.272em; 
+	margin-bottom: 3.272em; 
+	line-height: 1.636em; 
+	padding: 1.636em; 
+	border-top: 1px solid #ccc; 
+	border-bottom: 1px solid #ccc;
+}
+
+ol li, ul li { 
+	font-size: 1em; 
+	line-height: 1.5em; 
+	margin: 0;
+}
+
+/* pre and code */
+pre, code { 
+	font-size:115%;
+	*font-size:100%;
+	font-family: Courier, "Courier New"; 
+	background-color: #efefef; 
+	border: 1px solid #ccc;
+}
+
+pre { 
+	border-width: 1px 0; 
+	padding: 1.5em;
+}
+
+/*
+	Tables
+
+	Note that these table definitions make the assumption that you are using tables
+	to display tabular data, and NOT using tables as layout mechanisms.  If you are
+	using tables for layout, you will probably want to override these rules with
+	more specific ones.
+
+	These definitions make tabular data look presentable, particularly when presented
+	inline with paragraphs.
+*/
+table {  font-size:100%; }
+
+.dojoTabular { 
+	border-collapse: collapse; 
+	border-spacing: 0; 
+	border: 1px solid #ccc; 
+	margin: 0 1.5em;
+}
+
+.dojoTabular th { 
+	text-align: center; 
+	font-weight: bold;
+}
+
+.dojoTabular thead,
+.dojoTabular tfoot { 
+	background-color: #efefef; 
+	border: 1px solid #ccc; 
+	border-width: 1px 0; 
+}
+
+.dojoTabular th,
+.dojoTabular td { 
+	padding: 0.25em 0.5em;
+}
diff --git a/js/dojo-1.7.2/dojo/resources/iframe_history.html b/js/dojo-1.7.2/dojo/resources/iframe_history.html
new file mode 100644
index 0000000..2c5acce
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/iframe_history.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+	<title></title>
+	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+	<script type="text/javascript">
+	// <!--
+	var noInit = false;
+		
+	function init(){
+		if(noInit){ return; }
+		var hasParentDojo = false;
+		try{
+			hasParentDojo = window.parent != window && window.parent["dojo"];
+		}catch(e){
+			alert("Initializing iframe_history.html failed. If you are using a cross-domain Dojo build,"
+				+ " please save iframe_history.html to your domain and set djConfig.dojoIframeHistoryUrl"
+				+ " to the path on your domain to iframe_history.html");
+			throw e;
+		}
+
+		if(hasParentDojo){
+			//Set the page title so IE history shows up with a somewhat correct name.
+			document.title = window.parent.document.title;
+			
+			//Notify parent that we are loaded.
+			var pdj = window.parent.dojo;
+			if(pdj["back"]){
+				pdj.back._iframeLoaded(null, window.location);
+			}
+		}
+
+	}
+	// -->
+	</script>
+</head>
+<body onload="try{ init(); }catch(e){ alert(e); }">
+	<h4>The Dojo Toolkit -- iframe_history.html</h4>
+
+	<p>This file is used in Dojo's back/fwd button management.</p>
+</body>
+</html>
diff --git a/js/dojo-1.7.2/dojo/resources/images/dndCopy.png b/js/dojo-1.7.2/dojo/resources/images/dndCopy.png
new file mode 100644
index 0000000..660ca4f
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/images/dndCopy.png
diff --git a/js/dojo-1.7.2/dojo/resources/images/dndMove.png b/js/dojo-1.7.2/dojo/resources/images/dndMove.png
new file mode 100644
index 0000000..74af29c
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/images/dndMove.png
diff --git a/js/dojo-1.7.2/dojo/resources/images/dndNoCopy.png b/js/dojo-1.7.2/dojo/resources/images/dndNoCopy.png
new file mode 100644
index 0000000..998c2f2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/images/dndNoCopy.png
diff --git a/js/dojo-1.7.2/dojo/resources/images/dndNoMove.png b/js/dojo-1.7.2/dojo/resources/images/dndNoMove.png
new file mode 100644
index 0000000..e909173
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/resources/images/dndNoMove.png
diff --git a/js/dojo-1.7.2/dojo/rpc/JsonService.js b/js/dojo-1.7.2/dojo/rpc/JsonService.js
new file mode 100644
index 0000000..496d48d
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/rpc/JsonService.js
@@ -0,0 +1,86 @@
+//>>built
+define("dojo/rpc/JsonService", ["../main", "./RpcService"], function(dojo) {
+	// module:
+	//		dojo/rpc/JsonService
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.rpc.JsonService", dojo.rpc.RpcService, {
+		bustCache: false,
+		contentType: "application/json-rpc",
+		lastSubmissionId: 0,
+
+		callRemote: function(method, params){
+			// summary:
+			// 		call an arbitrary remote method without requiring it to be
+			// 		predefined with SMD
+			//	method: string
+			//		the name of the remote method you want to call.
+			//	params: array
+			//		array of parameters to pass to method
+
+			var deferred = new dojo.Deferred();
+			this.bind(method, params, deferred);
+			return deferred;
+		},
+
+		bind: function(method, parameters, deferredRequestHandler, url){
+			//summary:
+			//		JSON-RPC bind method. Takes remote method, parameters,
+			//		deferred, and a url, calls createRequest to make a JSON-RPC
+			//		envelope and passes that off with bind.
+			//	method: string
+			//		The name of the method we are calling
+			//	parameters: array
+			//		The parameters we are passing off to the method
+			//	deferredRequestHandler: deferred
+			//		The Deferred object for this particular request
+
+			var def = dojo.rawXhrPost({
+				url: url||this.serviceUrl,
+				postData: this.createRequest(method, parameters),
+				contentType: this.contentType,
+				timeout: this.timeout,
+				handleAs: "json-comment-optional"
+			});
+			def.addCallbacks(this.resultCallback(deferredRequestHandler), this.errorCallback(deferredRequestHandler));
+		},
+
+		createRequest: function(method, params){
+			// summary:
+			//	create a JSON-RPC envelope for the request
+			//	method: string
+			//		The name of the method we are creating the requst for
+			//	params: array
+			//		The array of parameters for this request;
+
+			var req = { "params": params, "method": method, "id": ++this.lastSubmissionId };
+			return dojo.toJson(req);
+		},
+
+		parseResults: function(/*anything*/obj){
+			//summary:
+			//		parse the result envelope and pass the results back to
+			//		the callback function
+			//	obj: Object
+			//		Object containing envelope of data we recieve from the server
+
+			if(dojo.isObject(obj)){
+				if("result" in obj){
+					return obj.result;
+				}
+				if("Result" in obj){
+					return obj.Result;
+				}
+				if("ResultSet" in obj){
+					return obj.ResultSet;
+				}
+			}
+			return obj;
+		}
+	}
+);
+
+return dojo.rpc.JsonService;
+});
diff --git a/js/dojo-1.7.2/dojo/rpc/JsonpService.js b/js/dojo-1.7.2/dojo/rpc/JsonpService.js
new file mode 100644
index 0000000..de139ff
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/rpc/JsonpService.js
@@ -0,0 +1,68 @@
+//>>built
+define("dojo/rpc/JsonpService", ["../main", "./RpcService", "../io/script"], function(dojo) {
+	// module:
+	//		dojo/rpc/JsonpService
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.rpc.JsonpService", dojo.rpc.RpcService, {
+	// summary:
+	//	Generic JSONP service.  Minimally extends RpcService to allow
+	//	easy definition of nearly any JSONP style service. Example
+	//	SMD files exist in dojox.data
+
+	constructor: function(args, requiredArgs){
+		if(this.required) {
+			if(requiredArgs){
+				dojo.mixin(this.required, requiredArgs);
+			}
+
+			dojo.forEach(this.required, function(req){
+				if(req=="" || req==undefined){
+					throw new Error("Required Service Argument not found: "+req);
+				}
+			});
+		}
+	},
+
+	strictArgChecks: false,
+
+	bind: function(method, parameters, deferredRequestHandler, url){
+		//summary:
+		//              JSONP bind method. Takes remote method, parameters,
+		//              deferred, and a url, calls createRequest to make a JSON-RPC
+		//              envelope and passes that off with bind.
+		//      method: string
+		//              The name of the method we are calling
+		//      parameters: array
+		//              The parameters we are passing off to the method
+		//      deferredRequestHandler: deferred
+		//              The Deferred object for this particular request
+
+		var def = dojo.io.script.get({
+			url: url||this.serviceUrl,
+			callbackParamName: this.callbackParamName||"callback",
+			content: this.createRequest(parameters),
+			timeout: this.timeout,
+			handleAs: "json",
+			preventCache: true
+		});
+		def.addCallbacks(this.resultCallback(deferredRequestHandler), this.errorCallback(deferredRequestHandler));
+	},
+
+	createRequest: function(parameters){
+		// summary:
+		//      create a JSONP req
+		//      params: array
+		//              The array of parameters for this request;
+
+		var params = (dojo.isArrayLike(parameters) && parameters.length==1) ?
+				parameters[0] : {};
+		dojo.mixin(params,this.required);
+		return params;
+	}
+});
+
+return dojo.rpc.JsonpService;
+});
diff --git a/js/dojo-1.7.2/dojo/rpc/RpcService.js b/js/dojo-1.7.2/dojo/rpc/RpcService.js
new file mode 100644
index 0000000..5145108
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/rpc/RpcService.js
@@ -0,0 +1,176 @@
+//>>built
+define("dojo/rpc/RpcService", ["../main", "../_base/url"], function(dojo) {
+	// module:
+	//		dojo/rpc/RpcService
+	// summary:
+	//		TODOC
+
+
+dojo.declare("dojo.rpc.RpcService", null, {
+	constructor: function(args){
+		//summary:
+		//Take a string as a url to retrieve an smd or an object that is an smd or partial smd to use
+		//as a definition for the service
+		//
+		//	args: object
+		//		Takes a number of properties as kwArgs for defining the service.  It also
+		//		accepts a string.  When passed a string, it is treated as a url from
+		//		which it should synchronously retrieve an smd file.  Otherwise it is a kwArgs
+		//		object.  It accepts serviceUrl, to manually define a url for the rpc service
+		//		allowing the rpc system to be used without an smd definition. strictArgChecks
+		//		forces the system to verify that the # of arguments provided in a call
+		//		matches those defined in the smd.  smdString allows a developer to pass
+		//		a jsonString directly, which will be converted into an object or alternatively
+		//		smdObject is accepts an smdObject directly.
+		//
+		if(args){
+			//if the arg is a string, we assume it is a url to retrieve an smd definition from
+			if( (dojo.isString(args)) || (args instanceof dojo._Url)){
+				if (args instanceof dojo._Url){
+					var url = args + "";
+				}else{
+					url = args;
+				}
+				var def = dojo.xhrGet({
+					url: url,
+					handleAs: "json-comment-optional",
+					sync: true
+				});
+
+				def.addCallback(this, "processSmd");
+				def.addErrback(function() {
+					throw new Error("Unable to load SMD from " + args);
+				});
+
+			}else if(args.smdStr){
+				this.processSmd(dojo.eval("("+args.smdStr+")"));
+			}else{
+				// otherwise we assume it's an arguments object with the following
+				// (optional) properties:
+				//      - serviceUrl
+				//      - strictArgChecks
+				//      - smdStr
+				//      - smdObj
+
+				if(args.serviceUrl){
+					this.serviceUrl = args.serviceUrl;
+				}
+
+				this.timeout = args.timeout || 3000;
+
+				if("strictArgChecks" in args){
+					this.strictArgChecks = args.strictArgChecks;
+				}
+
+				this.processSmd(args);
+			}
+		}
+	},
+
+	strictArgChecks: true,
+	serviceUrl: "",
+
+	parseResults: function(obj){
+		// summary:
+		//		parse the results coming back from an rpc request.  this
+		//		base implementation, just returns the full object
+		//		subclasses should parse and only return the actual results
+		//	obj: Object
+		//		Object that is the return results from an rpc request
+		return obj;
+	},
+
+	errorCallback: function(/* dojo.Deferred */ deferredRequestHandler){
+		// summary:
+		//		create callback that calls the Deferres errback method
+		//	deferredRequestHandler: Deferred
+		//		The deferred object handling a request.
+		return function(data){
+			deferredRequestHandler.errback(data.message);
+		};
+	},
+
+	resultCallback: function(/* dojo.Deferred */ deferredRequestHandler){
+		// summary:
+		//		create callback that calls the Deferred's callback method
+		//	deferredRequestHandler: Deferred
+		//		The deferred object handling a request.
+
+		return dojo.hitch(this,
+			function(obj){
+				if(obj.error!=null){
+					var err;
+					if(typeof obj.error == 'object'){
+						err = new Error(obj.error.message);
+						err.code = obj.error.code;
+						err.error = obj.error.error;
+					}else{
+						err = new Error(obj.error);
+					}
+					err.id = obj.id;
+					err.errorObject = obj;
+					deferredRequestHandler.errback(err);
+				}else{
+					deferredRequestHandler.callback(this.parseResults(obj));
+				}
+			}
+		);
+	},
+
+	generateMethod: function(/*string*/ method, /*array*/ parameters, /*string*/ url){
+		// summary:
+		//		generate the local bind methods for the remote object
+		//	method: string
+		//		The name of the method we are generating
+		//	parameters: array
+		//		the array of parameters for this call.
+		//	url: string
+		//		the service url for this call
+
+		return dojo.hitch(this, function(){
+			var deferredRequestHandler = new dojo.Deferred();
+
+			// if params weren't specified, then we can assume it's varargs
+			if( (this.strictArgChecks) &&
+				(parameters != null) &&
+				(arguments.length != parameters.length)
+			){
+				// put error stuff here, no enough params
+				throw new Error("Invalid number of parameters for remote method.");
+			}else{
+				this.bind(method, dojo._toArray(arguments), deferredRequestHandler, url);
+			}
+
+			return deferredRequestHandler;
+		});
+	},
+
+	processSmd: function(object){
+		// summary:
+		//		callback method for reciept of a smd object.  Parse the smd
+		//		and generate functions based on the description
+		//	object:
+		//		smd object defining this service.
+
+		if(object.methods){
+			dojo.forEach(object.methods, function(m){
+				if(m && m.name){
+					this[m.name] = this.generateMethod(	m.name,
+										m.parameters,
+										m.url||m.serviceUrl||m.serviceURL);
+					if(!dojo.isFunction(this[m.name])){
+						throw new Error("RpcService: Failed to create" + m.name + "()");
+						/*console.log("RpcService: Failed to create", m.name, "()");*/
+					}
+				}
+			}, this);
+		}
+
+		this.serviceUrl = object.serviceUrl||object.serviceURL;
+		this.required = object.required;
+		this.smd = object;
+	}
+});
+
+return dojo.rpc.RpcService;
+});
diff --git a/js/dojo-1.7.2/dojo/selector/_loader.js b/js/dojo-1.7.2/dojo/selector/_loader.js
new file mode 100644
index 0000000..cc49cfc
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/selector/_loader.js
@@ -0,0 +1,46 @@
+//>>built
+define("dojo/selector/_loader", ["../has", "require"],
+		function(has, require){
+// summary:
+//		This module handles loading the appropriate selector engine for the given browser
+"use strict";
+var testDiv = document.createElement("div");
+has.add("dom-qsa2.1", !!testDiv.querySelectorAll);
+has.add("dom-qsa3", function(){
+			// test to see if we have a reasonable native selector engine available
+			try{
+				testDiv.innerHTML = "<p class='TEST'></p>"; // test kind of from sizzle
+				// Safari can't handle uppercase or unicode characters when
+				// in quirks mode, IE8 can't handle pseudos like :empty
+				return testDiv.querySelectorAll(".TEST:empty").length == 1;
+			}catch(e){}
+		});
+var fullEngine;
+var acme = "./acme", lite = "./lite";
+return {
+	load: function(id, parentRequire, loaded, config){
+		var req = require;
+		// here we implement the default logic for choosing a selector engine
+		id = id == "default" ? has("config-selectorEngine") || "css3" : id;
+		id = id == "css2" || id == "lite" ? lite :
+				id == "css2.1" ? has("dom-qsa2.1") ? lite : acme :
+				id == "css3" ? has("dom-qsa3") ? lite : acme :
+				id == "acme" ? acme : (req = parentRequire) && id;
+		if(id.charAt(id.length-1) == '?'){
+			id = id.substring(0,id.length - 1);
+			var optionalLoad = true;
+		}
+		// the query engine is optional, only load it if a native one is not available or existing one has not been loaded
+		if(optionalLoad && (has("dom-compliant-qsa") || fullEngine)){
+			return loaded(fullEngine);
+		}
+		// load the referenced selector engine
+		req([id], function(engine){
+			if(id != "./lite"){
+				fullEngine = engine;
+			}
+			loaded(engine);
+		});
+	}
+};
+});
diff --git a/js/dojo-1.7.2/dojo/selector/acme.js b/js/dojo-1.7.2/dojo/selector/acme.js
new file mode 100644
index 0000000..cc909f4
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/selector/acme.js
@@ -0,0 +1,1481 @@
+//>>built
+define("dojo/selector/acme", ["../_base/kernel", "../has", "../dom", "../_base/sniff", "../_base/array", "../_base/lang", "../_base/window"], function(dojo, has, dom){
+  //  module:
+  //    dojo/selector/acme
+  //  summary:
+  //    This module defines the Acme selector engine
+
+/*
+	acme architectural overview:
+
+		acme is a relatively full-featured CSS3 query library. It is
+		designed to take any valid CSS3 selector and return the nodes matching
+		the selector. To do this quickly, it processes queries in several
+		steps, applying caching where profitable.
+
+		The steps (roughly in reverse order of the way they appear in the code):
+			1.) check to see if we already have a "query dispatcher"
+				- if so, use that with the given parameterization. Skip to step 4.
+			2.) attempt to determine which branch to dispatch the query to:
+				- JS (optimized DOM iteration)
+				- native (FF3.1+, Safari 3.1+, IE 8+)
+			3.) tokenize and convert to executable "query dispatcher"
+				- this is where the lion's share of the complexity in the
+					system lies. In the DOM version, the query dispatcher is
+					assembled as a chain of "yes/no" test functions pertaining to
+					a section of a simple query statement (".blah:nth-child(odd)"
+					but not "div div", which is 2 simple statements). Individual
+					statement dispatchers are cached (to prevent re-definition)
+					as are entire dispatch chains (to make re-execution of the
+					same query fast)
+			4.) the resulting query dispatcher is called in the passed scope
+					(by default the top-level document)
+				- for DOM queries, this results in a recursive, top-down
+					evaluation of nodes based on each simple query section
+				- for native implementations, this may mean working around spec
+					bugs. So be it.
+			5.) matched nodes are pruned to ensure they are unique (if necessary)
+*/
+
+
+	////////////////////////////////////////////////////////////////////////
+	// Toolkit aliases
+	////////////////////////////////////////////////////////////////////////
+
+	// if you are extracting acme for use in your own system, you will
+	// need to provide these methods and properties. No other porting should be
+	// necessary, save for configuring the system to use a class other than
+	// dojo.NodeList as the return instance instantiator
+	var trim = 			dojo.trim;
+	var each = 			dojo.forEach;
+	// 					d.isIE; // float
+	// 					d.isSafari; // float
+	// 					d.isOpera; // float
+	// 					d.isWebKit; // float
+	// 					d.doc ; // document element
+
+	var getDoc = function(){ return dojo.doc; };
+	// NOTE(alex): the spec is idiotic. CSS queries should ALWAYS be case-sensitive, but nooooooo
+	var cssCaseBug = ((dojo.isWebKit||dojo.isMozilla) && ((getDoc().compatMode) == "BackCompat"));
+
+	////////////////////////////////////////////////////////////////////////
+	// Global utilities
+	////////////////////////////////////////////////////////////////////////
+
+
+	var specials = ">~+";
+
+	// global thunk to determine whether we should treat the current query as
+	// case sensitive or not. This switch is flipped by the query evaluator
+	// based on the document passed as the context to search.
+	var caseSensitive = false;
+
+	// how high?
+	var yesman = function(){ return true; };
+
+	////////////////////////////////////////////////////////////////////////
+	// Tokenizer
+	////////////////////////////////////////////////////////////////////////
+
+	var getQueryParts = function(query){
+		//	summary:
+		//		state machine for query tokenization
+		//	description:
+		//		instead of using a brittle and slow regex-based CSS parser,
+		//		acme implements an AST-style query representation. This
+		//		representation is only generated once per query. For example,
+		//		the same query run multiple times or under different root nodes
+		//		does not re-parse the selector expression but instead uses the
+		//		cached data structure. The state machine implemented here
+		//		terminates on the last " " (space) character and returns an
+		//		ordered array of query component structures (or "parts"). Each
+		//		part represents an operator or a simple CSS filtering
+		//		expression. The structure for parts is documented in the code
+		//		below.
+
+
+		// NOTE:
+		//		this code is designed to run fast and compress well. Sacrifices
+		//		to readability and maintainability have been made.  Your best
+		//		bet when hacking the tokenizer is to put The Donnas on *really*
+		//		loud (may we recommend their "Spend The Night" release?) and
+		//		just assume you're gonna make mistakes. Keep the unit tests
+		//		open and run them frequently. Knowing is half the battle ;-)
+		if(specials.indexOf(query.slice(-1)) >= 0){
+			// if we end with a ">", "+", or "~", that means we're implicitly
+			// searching all children, so make it explicit
+			query += " * "
+		}else{
+			// if you have not provided a terminator, one will be provided for
+			// you...
+			query += " ";
+		}
+
+		var ts = function(/*Integer*/ s, /*Integer*/ e){
+			// trim and slice.
+
+			// take an index to start a string slice from and an end position
+			// and return a trimmed copy of that sub-string
+			return trim(query.slice(s, e));
+		};
+
+		// the overall data graph of the full query, as represented by queryPart objects
+		var queryParts = [];
+
+
+		// state keeping vars
+		var inBrackets = -1, inParens = -1, inMatchFor = -1,
+			inPseudo = -1, inClass = -1, inId = -1, inTag = -1,
+			lc = "", cc = "", pStart;
+
+		// iteration vars
+		var x = 0, // index in the query
+			ql = query.length,
+			currentPart = null, // data structure representing the entire clause
+			_cp = null; // the current pseudo or attr matcher
+
+		// several temporary variables are assigned to this structure during a
+		// potential sub-expression match:
+		//		attr:
+		//			a string representing the current full attribute match in a
+		//			bracket expression
+		//		type:
+		//			if there's an operator in a bracket expression, this is
+		//			used to keep track of it
+		//		value:
+		//			the internals of parenthetical expression for a pseudo. for
+		//			:nth-child(2n+1), value might be "2n+1"
+
+		var endTag = function(){
+			// called when the tokenizer hits the end of a particular tag name.
+			// Re-sets state variables for tag matching and sets up the matcher
+			// to handle the next type of token (tag or operator).
+			if(inTag >= 0){
+				var tv = (inTag == x) ? null : ts(inTag, x); // .toLowerCase();
+				currentPart[ (specials.indexOf(tv) < 0) ? "tag" : "oper" ] = tv;
+				inTag = -1;
+			}
+		};
+
+		var endId = function(){
+			// called when the tokenizer might be at the end of an ID portion of a match
+			if(inId >= 0){
+				currentPart.id = ts(inId, x).replace(/\\/g, "");
+				inId = -1;
+			}
+		};
+
+		var endClass = function(){
+			// called when the tokenizer might be at the end of a class name
+			// match. CSS allows for multiple classes, so we augment the
+			// current item with another class in its list
+			if(inClass >= 0){
+				currentPart.classes.push(ts(inClass + 1, x).replace(/\\/g, ""));
+				inClass = -1;
+			}
+		};
+
+		var endAll = function(){
+			// at the end of a simple fragment, so wall off the matches
+			endId();
+			endTag();
+			endClass();
+		};
+
+		var endPart = function(){
+			endAll();
+			if(inPseudo >= 0){
+				currentPart.pseudos.push({ name: ts(inPseudo + 1, x) });
+			}
+			// hint to the selector engine to tell it whether or not it
+			// needs to do any iteration. Many simple selectors don't, and
+			// we can avoid significant construction-time work by advising
+			// the system to skip them
+			currentPart.loops = (
+					currentPart.pseudos.length ||
+					currentPart.attrs.length ||
+					currentPart.classes.length	);
+
+			currentPart.oquery = currentPart.query = ts(pStart, x); // save the full expression as a string
+
+
+			// otag/tag are hints to suggest to the system whether or not
+			// it's an operator or a tag. We save a copy of otag since the
+			// tag name is cast to upper-case in regular HTML matches. The
+			// system has a global switch to figure out if the current
+			// expression needs to be case sensitive or not and it will use
+			// otag or tag accordingly
+			currentPart.otag = currentPart.tag = (currentPart["oper"]) ? null : (currentPart.tag || "*");
+
+			if(currentPart.tag){
+				// if we're in a case-insensitive HTML doc, we likely want
+				// the toUpperCase when matching on element.tagName. If we
+				// do it here, we can skip the string op per node
+				// comparison
+				currentPart.tag = currentPart.tag.toUpperCase();
+			}
+
+			// add the part to the list
+			if(queryParts.length && (queryParts[queryParts.length-1].oper)){
+				// operators are always infix, so we remove them from the
+				// list and attach them to the next match. The evaluator is
+				// responsible for sorting out how to handle them.
+				currentPart.infixOper = queryParts.pop();
+				currentPart.query = currentPart.infixOper.query + " " + currentPart.query;
+				/*
+				console.debug(	"swapping out the infix",
+								currentPart.infixOper,
+								"and attaching it to",
+								currentPart);
+				*/
+			}
+			queryParts.push(currentPart);
+
+			currentPart = null;
+		};
+
+		// iterate over the query, character by character, building up a
+		// list of query part objects
+		for(; lc=cc, cc=query.charAt(x), x < ql; x++){
+			//		cc: the current character in the match
+			//		lc: the last character (if any)
+
+			// someone is trying to escape something, so don't try to match any
+			// fragments. We assume we're inside a literal.
+			if(lc == "\\"){ continue; }
+			if(!currentPart){ // a part was just ended or none has yet been created
+				// NOTE: I hate all this alloc, but it's shorter than writing tons of if's
+				pStart = x;
+				//	rules describe full CSS sub-expressions, like:
+				//		#someId
+				//		.className:first-child
+				//	but not:
+				//		thinger > div.howdy[type=thinger]
+				//	the indidual components of the previous query would be
+				//	split into 3 parts that would be represented a structure
+				//	like:
+				//		[
+				//			{
+				//				query: "thinger",
+				//				tag: "thinger",
+				//			},
+				//			{
+				//				query: "div.howdy[type=thinger]",
+				//				classes: ["howdy"],
+				//				infixOper: {
+				//					query: ">",
+				//					oper: ">",
+				//				}
+				//			},
+				//		]
+				currentPart = {
+					query: null, // the full text of the part's rule
+					pseudos: [], // CSS supports multiple pseud-class matches in a single rule
+					attrs: [],	// CSS supports multi-attribute match, so we need an array
+					classes: [], // class matches may be additive, e.g.: .thinger.blah.howdy
+					tag: null,	// only one tag...
+					oper: null, // ...or operator per component. Note that these wind up being exclusive.
+					id: null,	// the id component of a rule
+					getTag: function(){
+						return (caseSensitive) ? this.otag : this.tag;
+					}
+				};
+
+				// if we don't have a part, we assume we're going to start at
+				// the beginning of a match, which should be a tag name. This
+				// might fault a little later on, but we detect that and this
+				// iteration will still be fine.
+				inTag = x;
+			}
+
+			if(inBrackets >= 0){
+				// look for a the close first
+				if(cc == "]"){ // if we're in a [...] clause and we end, do assignment
+					if(!_cp.attr){
+						// no attribute match was previously begun, so we
+						// assume this is an attribute existence match in the
+						// form of [someAttributeName]
+						_cp.attr = ts(inBrackets+1, x);
+					}else{
+						// we had an attribute already, so we know that we're
+						// matching some sort of value, as in [attrName=howdy]
+						_cp.matchFor = ts((inMatchFor||inBrackets+1), x);
+					}
+					var cmf = _cp.matchFor;
+					if(cmf){
+						// try to strip quotes from the matchFor value. We want
+						// [attrName=howdy] to match the same
+						//	as [attrName = 'howdy' ]
+						if(	(cmf.charAt(0) == '"') || (cmf.charAt(0) == "'") ){
+							_cp.matchFor = cmf.slice(1, -1);
+						}
+					}
+					// end the attribute by adding it to the list of attributes.
+					currentPart.attrs.push(_cp);
+					_cp = null; // necessary?
+					inBrackets = inMatchFor = -1;
+				}else if(cc == "="){
+					// if the last char was an operator prefix, make sure we
+					// record it along with the "=" operator.
+					var addToCc = ("|~^$*".indexOf(lc) >=0 ) ? lc : "";
+					_cp.type = addToCc+cc;
+					_cp.attr = ts(inBrackets+1, x-addToCc.length);
+					inMatchFor = x+1;
+				}
+				// now look for other clause parts
+			}else if(inParens >= 0){
+				// if we're in a parenthetical expression, we need to figure
+				// out if it's attached to a pseudo-selector rule like
+				// :nth-child(1)
+				if(cc == ")"){
+					if(inPseudo >= 0){
+						_cp.value = ts(inParens+1, x);
+					}
+					inPseudo = inParens = -1;
+				}
+			}else if(cc == "#"){
+				// start of an ID match
+				endAll();
+				inId = x+1;
+			}else if(cc == "."){
+				// start of a class match
+				endAll();
+				inClass = x;
+			}else if(cc == ":"){
+				// start of a pseudo-selector match
+				endAll();
+				inPseudo = x;
+			}else if(cc == "["){
+				// start of an attribute match.
+				endAll();
+				inBrackets = x;
+				// provide a new structure for the attribute match to fill-in
+				_cp = {
+					/*=====
+					attr: null, type: null, matchFor: null
+					=====*/
+				};
+			}else if(cc == "("){
+				// we really only care if we've entered a parenthetical
+				// expression if we're already inside a pseudo-selector match
+				if(inPseudo >= 0){
+					// provide a new structure for the pseudo match to fill-in
+					_cp = {
+						name: ts(inPseudo+1, x),
+						value: null
+					};
+					currentPart.pseudos.push(_cp);
+				}
+				inParens = x;
+			}else if(
+				(cc == " ") &&
+				// if it's a space char and the last char is too, consume the
+				// current one without doing more work
+				(lc != cc)
+			){
+				endPart();
+			}
+		}
+		return queryParts;
+	};
+
+
+	////////////////////////////////////////////////////////////////////////
+	// DOM query infrastructure
+	////////////////////////////////////////////////////////////////////////
+
+	var agree = function(first, second){
+		// the basic building block of the yes/no chaining system. agree(f1,
+		// f2) generates a new function which returns the boolean results of
+		// both of the passed functions to a single logical-anded result. If
+		// either are not passed, the other is used exclusively.
+		if(!first){ return second; }
+		if(!second){ return first; }
+
+		return function(){
+			return first.apply(window, arguments) && second.apply(window, arguments);
+		}
+	};
+
+	var getArr = function(i, arr){
+		// helps us avoid array alloc when we don't need it
+		var r = arr||[]; // FIXME: should this be 'new d._NodeListCtor()' ?
+		if(i){ r.push(i); }
+		return r;
+	};
+
+	var _isElement = function(n){ return (1 == n.nodeType); };
+
+	// FIXME: need to coalesce _getAttr with defaultGetter
+	var blank = "";
+	var _getAttr = function(elem, attr){
+		if(!elem){ return blank; }
+		if(attr == "class"){
+			return elem.className || blank;
+		}
+		if(attr == "for"){
+			return elem.htmlFor || blank;
+		}
+		if(attr == "style"){
+			return elem.style.cssText || blank;
+		}
+		return (caseSensitive ? elem.getAttribute(attr) : elem.getAttribute(attr, 2)) || blank;
+	};
+
+	var attrs = {
+		"*=": function(attr, value){
+			return function(elem){
+				// E[foo*="bar"]
+				//		an E element whose "foo" attribute value contains
+				//		the substring "bar"
+				return (_getAttr(elem, attr).indexOf(value)>=0);
+			}
+		},
+		"^=": function(attr, value){
+			// E[foo^="bar"]
+			//		an E element whose "foo" attribute value begins exactly
+			//		with the string "bar"
+			return function(elem){
+				return (_getAttr(elem, attr).indexOf(value)==0);
+			}
+		},
+		"$=": function(attr, value){
+			// E[foo$="bar"]
+			//		an E element whose "foo" attribute value ends exactly
+			//		with the string "bar"
+			return function(elem){
+				var ea = " "+_getAttr(elem, attr);
+				return (ea.lastIndexOf(value)==(ea.length-value.length));
+			}
+		},
+		"~=": function(attr, value){
+			// E[foo~="bar"]
+			//		an E element whose "foo" attribute value is a list of
+			//		space-separated values, one of which is exactly equal
+			//		to "bar"
+
+			// return "[contains(concat(' ',@"+attr+",' '), ' "+ value +" ')]";
+			var tval = " "+value+" ";
+			return function(elem){
+				var ea = " "+_getAttr(elem, attr)+" ";
+				return (ea.indexOf(tval)>=0);
+			}
+		},
+		"|=": function(attr, value){
+			// E[hreflang|="en"]
+			//		an E element whose "hreflang" attribute has a
+			//		hyphen-separated list of values beginning (from the
+			//		left) with "en"
+			var valueDash = value+"-";
+			return function(elem){
+				var ea = _getAttr(elem, attr);
+				return (
+					(ea == value) ||
+					(ea.indexOf(valueDash)==0)
+				);
+			}
+		},
+		"=": function(attr, value){
+			return function(elem){
+				return (_getAttr(elem, attr) == value);
+			}
+		}
+	};
+
+	// avoid testing for node type if we can. Defining this in the negative
+	// here to avoid negation in the fast path.
+	var _noNES = (typeof getDoc().firstChild.nextElementSibling == "undefined");
+	var _ns = !_noNES ? "nextElementSibling" : "nextSibling";
+	var _ps = !_noNES ? "previousElementSibling" : "previousSibling";
+	var _simpleNodeTest = (_noNES ? _isElement : yesman);
+
+	var _lookLeft = function(node){
+		// look left
+		while(node = node[_ps]){
+			if(_simpleNodeTest(node)){ return false; }
+		}
+		return true;
+	};
+
+	var _lookRight = function(node){
+		// look right
+		while(node = node[_ns]){
+			if(_simpleNodeTest(node)){ return false; }
+		}
+		return true;
+	};
+
+	var getNodeIndex = function(node){
+		var root = node.parentNode;
+		var i = 0,
+			tret = root.children || root.childNodes,
+			ci = (node["_i"]||-1),
+			cl = (root["_l"]||-1);
+
+		if(!tret){ return -1; }
+		var l = tret.length;
+
+		// we calculate the parent length as a cheap way to invalidate the
+		// cache. It's not 100% accurate, but it's much more honest than what
+		// other libraries do
+		if( cl == l && ci >= 0 && cl >= 0 ){
+			// if it's legit, tag and release
+			return ci;
+		}
+
+		// else re-key things
+		root["_l"] = l;
+		ci = -1;
+		for(var te = root["firstElementChild"]||root["firstChild"]; te; te = te[_ns]){
+			if(_simpleNodeTest(te)){
+				te["_i"] = ++i;
+				if(node === te){
+					// NOTE:
+					//	shortcutting the return at this step in indexing works
+					//	very well for benchmarking but we avoid it here since
+					//	it leads to potential O(n^2) behavior in sequential
+					//	getNodexIndex operations on a previously un-indexed
+					//	parent. We may revisit this at a later time, but for
+					//	now we just want to get the right answer more often
+					//	than not.
+					ci = i;
+				}
+			}
+		}
+		return ci;
+	};
+
+	var isEven = function(elem){
+		return !((getNodeIndex(elem)) % 2);
+	};
+
+	var isOdd = function(elem){
+		return ((getNodeIndex(elem)) % 2);
+	};
+
+	var pseudos = {
+		"checked": function(name, condition){
+			return function(elem){
+				return !!("checked" in elem ? elem.checked : elem.selected);
+			}
+		},
+		"first-child": function(){ return _lookLeft; },
+		"last-child": function(){ return _lookRight; },
+		"only-child": function(name, condition){
+			return function(node){
+				return _lookLeft(node) && _lookRight(node);
+			};
+		},
+		"empty": function(name, condition){
+			return function(elem){
+				// DomQuery and jQuery get this wrong, oddly enough.
+				// The CSS 3 selectors spec is pretty explicit about it, too.
+				var cn = elem.childNodes;
+				var cnl = elem.childNodes.length;
+				// if(!cnl){ return true; }
+				for(var x=cnl-1; x >= 0; x--){
+					var nt = cn[x].nodeType;
+					if((nt === 1)||(nt == 3)){ return false; }
+				}
+				return true;
+			}
+		},
+		"contains": function(name, condition){
+			var cz = condition.charAt(0);
+			if( cz == '"' || cz == "'" ){ //remove quote
+				condition = condition.slice(1, -1);
+			}
+			return function(elem){
+				return (elem.innerHTML.indexOf(condition) >= 0);
+			}
+		},
+		"not": function(name, condition){
+			var p = getQueryParts(condition)[0];
+			var ignores = { el: 1 };
+			if(p.tag != "*"){
+				ignores.tag = 1;
+			}
+			if(!p.classes.length){
+				ignores.classes = 1;
+			}
+			var ntf = getSimpleFilterFunc(p, ignores);
+			return function(elem){
+				return (!ntf(elem));
+			}
+		},
+		"nth-child": function(name, condition){
+			var pi = parseInt;
+			// avoid re-defining function objects if we can
+			if(condition == "odd"){
+				return isOdd;
+			}else if(condition == "even"){
+				return isEven;
+			}
+			// FIXME: can we shorten this?
+			if(condition.indexOf("n") != -1){
+				var tparts = condition.split("n", 2);
+				var pred = tparts[0] ? ((tparts[0] == '-') ? -1 : pi(tparts[0])) : 1;
+				var idx = tparts[1] ? pi(tparts[1]) : 0;
+				var lb = 0, ub = -1;
+				if(pred > 0){
+					if(idx < 0){
+						idx = (idx % pred) && (pred + (idx % pred));
+					}else if(idx>0){
+						if(idx >= pred){
+							lb = idx - idx % pred;
+						}
+						idx = idx % pred;
+					}
+				}else if(pred<0){
+					pred *= -1;
+					// idx has to be greater than 0 when pred is negative;
+					// shall we throw an error here?
+					if(idx > 0){
+						ub = idx;
+						idx = idx % pred;
+					}
+				}
+				if(pred > 0){
+					return function(elem){
+						var i = getNodeIndex(elem);
+						return (i>=lb) && (ub<0 || i<=ub) && ((i % pred) == idx);
+					}
+				}else{
+					condition = idx;
+				}
+			}
+			var ncount = pi(condition);
+			return function(elem){
+				return (getNodeIndex(elem) == ncount);
+			}
+		}
+	};
+
+	var defaultGetter = (dojo.isIE && (dojo.isIE < 9 || dojo.isQuirks)) ? function(cond){
+		var clc = cond.toLowerCase();
+		if(clc == "class"){ cond = "className"; }
+		return function(elem){
+			return (caseSensitive ? elem.getAttribute(cond) : elem[cond]||elem[clc]);
+		}
+	} : function(cond){
+		return function(elem){
+			return (elem && elem.getAttribute && elem.hasAttribute(cond));
+		}
+	};
+
+	var getSimpleFilterFunc = function(query, ignores){
+		// generates a node tester function based on the passed query part. The
+		// query part is one of the structures generated by the query parser
+		// when it creates the query AST. The "ignores" object specifies which
+		// (if any) tests to skip, allowing the system to avoid duplicating
+		// work where it may have already been taken into account by other
+		// factors such as how the nodes to test were fetched in the first
+		// place
+		if(!query){ return yesman; }
+		ignores = ignores||{};
+
+		var ff = null;
+
+		if(!("el" in ignores)){
+			ff = agree(ff, _isElement);
+		}
+
+		if(!("tag" in ignores)){
+			if(query.tag != "*"){
+				ff = agree(ff, function(elem){
+					return (elem && (elem.tagName == query.getTag()));
+				});
+			}
+		}
+
+		if(!("classes" in ignores)){
+			each(query.classes, function(cname, idx, arr){
+				// get the class name
+				/*
+				var isWildcard = cname.charAt(cname.length-1) == "*";
+				if(isWildcard){
+					cname = cname.substr(0, cname.length-1);
+				}
+				// I dislike the regex thing, even if memoized in a cache, but it's VERY short
+				var re = new RegExp("(?:^|\\s)" + cname + (isWildcard ? ".*" : "") + "(?:\\s|$)");
+				*/
+				var re = new RegExp("(?:^|\\s)" + cname + "(?:\\s|$)");
+				ff = agree(ff, function(elem){
+					return re.test(elem.className);
+				});
+				ff.count = idx;
+			});
+		}
+
+		if(!("pseudos" in ignores)){
+			each(query.pseudos, function(pseudo){
+				var pn = pseudo.name;
+				if(pseudos[pn]){
+					ff = agree(ff, pseudos[pn](pn, pseudo.value));
+				}
+			});
+		}
+
+		if(!("attrs" in ignores)){
+			each(query.attrs, function(attr){
+				var matcher;
+				var a = attr.attr;
+				// type, attr, matchFor
+				if(attr.type && attrs[attr.type]){
+					matcher = attrs[attr.type](a, attr.matchFor);
+				}else if(a.length){
+					matcher = defaultGetter(a);
+				}
+				if(matcher){
+					ff = agree(ff, matcher);
+				}
+			});
+		}
+
+		if(!("id" in ignores)){
+			if(query.id){
+				ff = agree(ff, function(elem){
+					return (!!elem && (elem.id == query.id));
+				});
+			}
+		}
+
+		if(!ff){
+			if(!("default" in ignores)){
+				ff = yesman;
+			}
+		}
+		return ff;
+	};
+
+	var _nextSibling = function(filterFunc){
+		return function(node, ret, bag){
+			while(node = node[_ns]){
+				if(_noNES && (!_isElement(node))){ continue; }
+				if(
+					(!bag || _isUnique(node, bag)) &&
+					filterFunc(node)
+				){
+					ret.push(node);
+				}
+				break;
+			}
+			return ret;
+		}
+	};
+
+	var _nextSiblings = function(filterFunc){
+		return function(root, ret, bag){
+			var te = root[_ns];
+			while(te){
+				if(_simpleNodeTest(te)){
+					if(bag && !_isUnique(te, bag)){
+						break;
+					}
+					if(filterFunc(te)){
+						ret.push(te);
+					}
+				}
+				te = te[_ns];
+			}
+			return ret;
+		}
+	};
+
+	// get an array of child *elements*, skipping text and comment nodes
+	var _childElements = function(filterFunc){
+		filterFunc = filterFunc||yesman;
+		return function(root, ret, bag){
+			// get an array of child elements, skipping text and comment nodes
+			var te, x = 0, tret = root.children || root.childNodes;
+			while(te = tret[x++]){
+				if(
+					_simpleNodeTest(te) &&
+					(!bag || _isUnique(te, bag)) &&
+					(filterFunc(te, x))
+				){
+					ret.push(te);
+				}
+			}
+			return ret;
+		};
+	};
+
+	/*
+	// thanks, Dean!
+	var itemIsAfterRoot = d.isIE ? function(item, root){
+		return (item.sourceIndex > root.sourceIndex);
+	} : function(item, root){
+		return (item.compareDocumentPosition(root) == 2);
+	};
+	*/
+
+	// test to see if node is below root
+	var _isDescendant = function(node, root){
+		var pn = node.parentNode;
+		while(pn){
+			if(pn == root){
+				break;
+			}
+			pn = pn.parentNode;
+		}
+		return !!pn;
+	};
+
+	var _getElementsFuncCache = {};
+
+	var getElementsFunc = function(query){
+		var retFunc = _getElementsFuncCache[query.query];
+		// if we've got a cached dispatcher, just use that
+		if(retFunc){ return retFunc; }
+		// else, generate a new on
+
+		// NOTE:
+		//		this function returns a function that searches for nodes and
+		//		filters them.  The search may be specialized by infix operators
+		//		(">", "~", or "+") else it will default to searching all
+		//		descendants (the " " selector). Once a group of children is
+		//		found, a test function is applied to weed out the ones we
+		//		don't want. Many common cases can be fast-pathed. We spend a
+		//		lot of cycles to create a dispatcher that doesn't do more work
+		//		than necessary at any point since, unlike this function, the
+		//		dispatchers will be called every time. The logic of generating
+		//		efficient dispatchers looks like this in pseudo code:
+		//
+		//		# if it's a purely descendant query (no ">", "+", or "~" modifiers)
+		//		if infixOperator == " ":
+		//			if only(id):
+		//				return def(root):
+		//					return d.byId(id, root);
+		//
+		//			elif id:
+		//				return def(root):
+		//					return filter(d.byId(id, root));
+		//
+		//			elif cssClass && getElementsByClassName:
+		//				return def(root):
+		//					return filter(root.getElementsByClassName(cssClass));
+		//
+		//			elif only(tag):
+		//				return def(root):
+		//					return root.getElementsByTagName(tagName);
+		//
+		//			else:
+		//				# search by tag name, then filter
+		//				return def(root):
+		//					return filter(root.getElementsByTagName(tagName||"*"));
+		//
+		//		elif infixOperator == ">":
+		//			# search direct children
+		//			return def(root):
+		//				return filter(root.children);
+		//
+		//		elif infixOperator == "+":
+		//			# search next sibling
+		//			return def(root):
+		//				return filter(root.nextElementSibling);
+		//
+		//		elif infixOperator == "~":
+		//			# search rightward siblings
+		//			return def(root):
+		//				return filter(nextSiblings(root));
+
+		var io = query.infixOper;
+		var oper = (io ? io.oper : "");
+		// the default filter func which tests for all conditions in the query
+		// part. This is potentially inefficient, so some optimized paths may
+		// re-define it to test fewer things.
+		var filterFunc = getSimpleFilterFunc(query, { el: 1 });
+		var qt = query.tag;
+		var wildcardTag = ("*" == qt);
+		var ecs = getDoc()["getElementsByClassName"];
+
+		if(!oper){
+			// if there's no infix operator, then it's a descendant query. ID
+			// and "elements by class name" variants can be accelerated so we
+			// call them out explicitly:
+			if(query.id){
+				// testing shows that the overhead of yesman() is acceptable
+				// and can save us some bytes vs. re-defining the function
+				// everywhere.
+				filterFunc = (!query.loops && wildcardTag) ?
+					yesman :
+					getSimpleFilterFunc(query, { el: 1, id: 1 });
+
+				retFunc = function(root, arr){
+					var te = dom.byId(query.id, (root.ownerDocument||root));
+					if(!te || !filterFunc(te)){ return; }
+					if(9 == root.nodeType){ // if root's a doc, we just return directly
+						return getArr(te, arr);
+					}else{ // otherwise check ancestry
+						if(_isDescendant(te, root)){
+							return getArr(te, arr);
+						}
+					}
+				}
+			}else if(
+				ecs &&
+				// isAlien check. Workaround for Prototype.js being totally evil/dumb.
+				/\{\s*\[native code\]\s*\}/.test(String(ecs)) &&
+				query.classes.length &&
+				!cssCaseBug
+			){
+				// it's a class-based query and we've got a fast way to run it.
+
+				// ignore class and ID filters since we will have handled both
+				filterFunc = getSimpleFilterFunc(query, { el: 1, classes: 1, id: 1 });
+				var classesString = query.classes.join(" ");
+				retFunc = function(root, arr, bag){
+					var ret = getArr(0, arr), te, x=0;
+					var tret = root.getElementsByClassName(classesString);
+					while((te = tret[x++])){
+						if(filterFunc(te, root) && _isUnique(te, bag)){
+							ret.push(te);
+						}
+					}
+					return ret;
+				};
+
+			}else if(!wildcardTag && !query.loops){
+				// it's tag only. Fast-path it.
+				retFunc = function(root, arr, bag){
+					var ret = getArr(0, arr), te, x=0;
+					var tret = root.getElementsByTagName(query.getTag());
+					while((te = tret[x++])){
+						if(_isUnique(te, bag)){
+							ret.push(te);
+						}
+					}
+					return ret;
+				};
+			}else{
+				// the common case:
+				//		a descendant selector without a fast path. By now it's got
+				//		to have a tag selector, even if it's just "*" so we query
+				//		by that and filter
+				filterFunc = getSimpleFilterFunc(query, { el: 1, tag: 1, id: 1 });
+				retFunc = function(root, arr, bag){
+					var ret = getArr(0, arr), te, x=0;
+					// we use getTag() to avoid case sensitivity issues
+					var tret = root.getElementsByTagName(query.getTag());
+					while((te = tret[x++])){
+						if(filterFunc(te, root) && _isUnique(te, bag)){
+							ret.push(te);
+						}
+					}
+					return ret;
+				};
+			}
+		}else{
+			// the query is scoped in some way. Instead of querying by tag we
+			// use some other collection to find candidate nodes
+			var skipFilters = { el: 1 };
+			if(wildcardTag){
+				skipFilters.tag = 1;
+			}
+			filterFunc = getSimpleFilterFunc(query, skipFilters);
+			if("+" == oper){
+				retFunc = _nextSibling(filterFunc);
+			}else if("~" == oper){
+				retFunc = _nextSiblings(filterFunc);
+			}else if(">" == oper){
+				retFunc = _childElements(filterFunc);
+			}
+		}
+		// cache it and return
+		return _getElementsFuncCache[query.query] = retFunc;
+	};
+
+	var filterDown = function(root, queryParts){
+		// NOTE:
+		//		this is the guts of the DOM query system. It takes a list of
+		//		parsed query parts and a root and finds children which match
+		//		the selector represented by the parts
+		var candidates = getArr(root), qp, x, te, qpl = queryParts.length, bag, ret;
+
+		for(var i = 0; i < qpl; i++){
+			ret = [];
+			qp = queryParts[i];
+			x = candidates.length - 1;
+			if(x > 0){
+				// if we have more than one root at this level, provide a new
+				// hash to use for checking group membership but tell the
+				// system not to post-filter us since we will already have been
+				// gauranteed to be unique
+				bag = {};
+				ret.nozip = true;
+			}
+			var gef = getElementsFunc(qp);
+			for(var j = 0; (te = candidates[j]); j++){
+				// for every root, get the elements that match the descendant
+				// selector, adding them to the "ret" array and filtering them
+				// via membership in this level's bag. If there are more query
+				// parts, then this level's return will be used as the next
+				// level's candidates
+				gef(te, ret, bag);
+			}
+			if(!ret.length){ break; }
+			candidates = ret;
+		}
+		return ret;
+	};
+
+	////////////////////////////////////////////////////////////////////////
+	// the query runner
+	////////////////////////////////////////////////////////////////////////
+
+	// these are the primary caches for full-query results. The query
+	// dispatcher functions are generated then stored here for hash lookup in
+	// the future
+	var _queryFuncCacheDOM = {},
+		_queryFuncCacheQSA = {};
+
+	// this is the second level of spliting, from full-length queries (e.g.,
+	// "div.foo .bar") into simple query expressions (e.g., ["div.foo",
+	// ".bar"])
+	var getStepQueryFunc = function(query){
+		var qparts = getQueryParts(trim(query));
+
+		// if it's trivial, avoid iteration and zipping costs
+		if(qparts.length == 1){
+			// we optimize this case here to prevent dispatch further down the
+			// chain, potentially slowing things down. We could more elegantly
+			// handle this in filterDown(), but it's slower for simple things
+			// that need to be fast (e.g., "#someId").
+			var tef = getElementsFunc(qparts[0]);
+			return function(root){
+				var r = tef(root, []);
+				if(r){ r.nozip = true; }
+				return r;
+			}
+		}
+
+		// otherwise, break it up and return a runner that iterates over the parts recursively
+		return function(root){
+			return filterDown(root, qparts);
+		}
+	};
+
+	// NOTES:
+	//	* we can't trust QSA for anything but document-rooted queries, so
+	//	  caching is split into DOM query evaluators and QSA query evaluators
+	//	* caching query results is dirty and leak-prone (or, at a minimum,
+	//	  prone to unbounded growth). Other toolkits may go this route, but
+	//	  they totally destroy their own ability to manage their memory
+	//	  footprint. If we implement it, it should only ever be with a fixed
+	//	  total element reference # limit and an LRU-style algorithm since JS
+	//	  has no weakref support. Caching compiled query evaluators is also
+	//	  potentially problematic, but even on large documents the size of the
+	//	  query evaluators is often < 100 function objects per evaluator (and
+	//	  LRU can be applied if it's ever shown to be an issue).
+	//	* since IE's QSA support is currently only for HTML documents and even
+	//	  then only in IE 8's "standards mode", we have to detect our dispatch
+	//	  route at query time and keep 2 separate caches. Ugg.
+
+	// we need to determine if we think we can run a given query via
+	// querySelectorAll or if we'll need to fall back on DOM queries to get
+	// there. We need a lot of information about the environment and the query
+	// to make the determiniation (e.g. does it support QSA, does the query in
+	// question work in the native QSA impl, etc.).
+	var nua = navigator.userAgent;
+	// some versions of Safari provided QSA, but it was buggy and crash-prone.
+	// We need te detect the right "internal" webkit version to make this work.
+	var wk = "WebKit/";
+	var is525 = (
+		dojo.isWebKit &&
+		(nua.indexOf(wk) > 0) &&
+		(parseFloat(nua.split(wk)[1]) > 528)
+	);
+
+	// IE QSA queries may incorrectly include comment nodes, so we throw the
+	// zipping function into "remove" comments mode instead of the normal "skip
+	// it" which every other QSA-clued browser enjoys
+	var noZip = dojo.isIE ? "commentStrip" : "nozip";
+
+	var qsa = "querySelectorAll";
+	var qsaAvail = (
+		!!getDoc()[qsa] &&
+		// see #5832
+		(!dojo.isSafari || (dojo.isSafari > 3.1) || is525 )
+	);
+
+	//Don't bother with n+3 type of matches, IE complains if we modify those.
+	var infixSpaceRe = /n\+\d|([^ ])?([>~+])([^ =])?/g;
+	var infixSpaceFunc = function(match, pre, ch, post){
+		return ch ? (pre ? pre + " " : "") + ch + (post ? " " + post : "") : /*n+3*/ match;
+	};
+
+	var getQueryFunc = function(query, forceDOM){
+		//Normalize query. The CSS3 selectors spec allows for omitting spaces around
+		//infix operators, >, ~ and +
+		//Do the work here since detection for spaces is used as a simple "not use QSA"
+		//test below.
+		query = query.replace(infixSpaceRe, infixSpaceFunc);
+
+		if(qsaAvail){
+			// if we've got a cached variant and we think we can do it, run it!
+			var qsaCached = _queryFuncCacheQSA[query];
+			if(qsaCached && !forceDOM){ return qsaCached; }
+		}
+
+		// else if we've got a DOM cached variant, assume that we already know
+		// all we need to and use it
+		var domCached = _queryFuncCacheDOM[query];
+		if(domCached){ return domCached; }
+
+		// TODO:
+		//		today we're caching DOM and QSA branches separately so we
+		//		recalc useQSA every time. If we had a way to tag root+query
+		//		efficiently, we'd be in good shape to do a global cache.
+
+		var qcz = query.charAt(0);
+		var nospace = (-1 == query.indexOf(" "));
+
+		// byId searches are wicked fast compared to QSA, even when filtering
+		// is required
+		if( (query.indexOf("#") >= 0) && (nospace) ){
+			forceDOM = true;
+		}
+
+		var useQSA = (
+			qsaAvail && (!forceDOM) &&
+			// as per CSS 3, we can't currently start w/ combinator:
+			//		http://www.w3.org/TR/css3-selectors/#w3cselgrammar
+			(specials.indexOf(qcz) == -1) &&
+			// IE's QSA impl sucks on pseudos
+			(!dojo.isIE || (query.indexOf(":") == -1)) &&
+
+			(!(cssCaseBug && (query.indexOf(".") >= 0))) &&
+
+			// FIXME:
+			//		need to tighten up browser rules on ":contains" and "|=" to
+			//		figure out which aren't good
+			//		Latest webkit (around 531.21.8) does not seem to do well with :checked on option
+			//		elements, even though according to spec, selected options should
+			//		match :checked. So go nonQSA for it:
+			//		http://bugs.dojotoolkit.org/ticket/5179
+			(query.indexOf(":contains") == -1) && (query.indexOf(":checked") == -1) &&
+			(query.indexOf("|=") == -1) // some browsers don't grok it
+		);
+
+		// TODO:
+		//		if we've got a descendant query (e.g., "> .thinger" instead of
+		//		just ".thinger") in a QSA-able doc, but are passed a child as a
+		//		root, it should be possible to give the item a synthetic ID and
+		//		trivially rewrite the query to the form "#synid > .thinger" to
+		//		use the QSA branch
+
+
+		if(useQSA){
+			var tq = (specials.indexOf(query.charAt(query.length-1)) >= 0) ?
+						(query + " *") : query;
+			return _queryFuncCacheQSA[query] = function(root){
+				try{
+					// the QSA system contains an egregious spec bug which
+					// limits us, effectively, to only running QSA queries over
+					// entire documents.  See:
+					//		http://ejohn.org/blog/thoughts-on-queryselectorall/
+					//	despite this, we can also handle QSA runs on simple
+					//	selectors, but we don't want detection to be expensive
+					//	so we're just checking for the presence of a space char
+					//	right now. Not elegant, but it's cheaper than running
+					//	the query parser when we might not need to
+					if(!((9 == root.nodeType) || nospace)){ throw ""; }
+					var r = root[qsa](tq);
+					// skip expensive duplication checks and just wrap in a NodeList
+					r[noZip] = true;
+					return r;
+				}catch(e){
+					// else run the DOM branch on this query, ensuring that we
+					// default that way in the future
+					return getQueryFunc(query, true)(root);
+				}
+			}
+		}else{
+			// DOM branch
+			var parts = query.split(/\s*,\s*/);
+			return _queryFuncCacheDOM[query] = ((parts.length < 2) ?
+				// if not a compound query (e.g., ".foo, .bar"), cache and return a dispatcher
+				getStepQueryFunc(query) :
+				// if it *is* a complex query, break it up into its
+				// constituent parts and return a dispatcher that will
+				// merge the parts when run
+				function(root){
+					var pindex = 0, // avoid array alloc for every invocation
+						ret = [],
+						tp;
+					while((tp = parts[pindex++])){
+						ret = ret.concat(getStepQueryFunc(tp)(root));
+					}
+					return ret;
+				}
+			);
+		}
+	};
+
+	var _zipIdx = 0;
+
+	// NOTE:
+	//		this function is Moo inspired, but our own impl to deal correctly
+	//		with XML in IE
+	var _nodeUID = dojo.isIE ? function(node){
+		if(caseSensitive){
+			// XML docs don't have uniqueID on their nodes
+			return (node.getAttribute("_uid") || node.setAttribute("_uid", ++_zipIdx) || _zipIdx);
+
+		}else{
+			return node.uniqueID;
+		}
+	} :
+	function(node){
+		return (node._uid || (node._uid = ++_zipIdx));
+	};
+
+	// determine if a node in is unique in a "bag". In this case we don't want
+	// to flatten a list of unique items, but rather just tell if the item in
+	// question is already in the bag. Normally we'd just use hash lookup to do
+	// this for us but IE's DOM is busted so we can't really count on that. On
+	// the upside, it gives us a built in unique ID function.
+	var _isUnique = function(node, bag){
+		if(!bag){ return 1; }
+		var id = _nodeUID(node);
+		if(!bag[id]){ return bag[id] = 1; }
+		return 0;
+	};
+
+	// attempt to efficiently determine if an item in a list is a dupe,
+	// returning a list of "uniques", hopefully in doucment order
+	var _zipIdxName = "_zipIdx";
+	var _zip = function(arr){
+		if(arr && arr.nozip){
+			return arr;
+		}
+		var ret = [];
+		if(!arr || !arr.length){ return ret; }
+		if(arr[0]){
+			ret.push(arr[0]);
+		}
+		if(arr.length < 2){ return ret; }
+
+		_zipIdx++;
+
+		// we have to fork here for IE and XML docs because we can't set
+		// expandos on their nodes (apparently). *sigh*
+		if(dojo.isIE && caseSensitive){
+			var szidx = _zipIdx+"";
+			arr[0].setAttribute(_zipIdxName, szidx);
+			for(var x = 1, te; te = arr[x]; x++){
+				if(arr[x].getAttribute(_zipIdxName) != szidx){
+					ret.push(te);
+				}
+				te.setAttribute(_zipIdxName, szidx);
+			}
+		}else if(dojo.isIE && arr.commentStrip){
+			try{
+				for(var x = 1, te; te = arr[x]; x++){
+					if(_isElement(te)){
+						ret.push(te);
+					}
+				}
+			}catch(e){ /* squelch */ }
+		}else{
+			if(arr[0]){ arr[0][_zipIdxName] = _zipIdx; }
+			for(var x = 1, te; te = arr[x]; x++){
+				if(arr[x][_zipIdxName] != _zipIdx){
+					ret.push(te);
+				}
+				te[_zipIdxName] = _zipIdx;
+			}
+		}
+		return ret;
+	};
+
+	// the main executor
+	var query = function(/*String*/ query, /*String|DOMNode?*/ root){
+		//	summary:
+		//		Returns nodes which match the given CSS3 selector, searching the
+		//		entire document by default but optionally taking a node to scope
+		//		the search by. Returns an array.
+		//	description:
+		//		dojo.query() is the swiss army knife of DOM node manipulation in
+		//		Dojo. Much like Prototype's "$$" (bling-bling) function or JQuery's
+		//		"$" function, dojo.query provides robust, high-performance
+		//		CSS-based node selector support with the option of scoping searches
+		//		to a particular sub-tree of a document.
+		//
+		//		Supported Selectors:
+		//		--------------------
+		//
+		//		acme supports a rich set of CSS3 selectors, including:
+		//
+		//			* class selectors (e.g., `.foo`)
+		//			* node type selectors like `span`
+		//			* ` ` descendant selectors
+		//			* `>` child element selectors
+		//			* `#foo` style ID selectors
+		//			* `*` universal selector
+		//			* `~`, the preceded-by sibling selector
+		//			* `+`, the immediately preceded-by sibling selector
+		//			* attribute queries:
+		//			|	* `[foo]` attribute presence selector
+		//			|	* `[foo='bar']` attribute value exact match
+		//			|	* `[foo~='bar']` attribute value list item match
+		//			|	* `[foo^='bar']` attribute start match
+		//			|	* `[foo$='bar']` attribute end match
+		//			|	* `[foo*='bar']` attribute substring match
+		//			* `:first-child`, `:last-child`, and `:only-child` positional selectors
+		//			* `:empty` content emtpy selector
+		//			* `:checked` pseudo selector
+		//			* `:nth-child(n)`, `:nth-child(2n+1)` style positional calculations
+		//			* `:nth-child(even)`, `:nth-child(odd)` positional selectors
+		//			* `:not(...)` negation pseudo selectors
+		//
+		//		Any legal combination of these selectors will work with
+		//		`dojo.query()`, including compound selectors ("," delimited).
+		//		Very complex and useful searches can be constructed with this
+		//		palette of selectors and when combined with functions for
+		//		manipulation presented by dojo.NodeList, many types of DOM
+		//		manipulation operations become very straightforward.
+		//
+		//		Unsupported Selectors:
+		//		----------------------
+		//
+		//		While dojo.query handles many CSS3 selectors, some fall outside of
+		//		what's reasonable for a programmatic node querying engine to
+		//		handle. Currently unsupported selectors include:
+		//
+		//			* namespace-differentiated selectors of any form
+		//			* all `::` pseduo-element selectors
+		//			* certain pseduo-selectors which don't get a lot of day-to-day use:
+		//			|	* `:root`, `:lang()`, `:target`, `:focus`
+		//			* all visual and state selectors:
+		//			|	* `:root`, `:active`, `:hover`, `:visisted`, `:link`,
+		//				  `:enabled`, `:disabled`
+		//			* `:*-of-type` pseudo selectors
+		//
+		//		dojo.query and XML Documents:
+		//		-----------------------------
+		//
+		//		`dojo.query` (as of dojo 1.2) supports searching XML documents
+		//		in a case-sensitive manner. If an HTML document is served with
+		//		a doctype that forces case-sensitivity (e.g., XHTML 1.1
+		//		Strict), dojo.query() will detect this and "do the right
+		//		thing". Case sensitivity is dependent upon the document being
+		//		searched and not the query used. It is therefore possible to
+		//		use case-sensitive queries on strict sub-documents (iframes,
+		//		etc.) or XML documents while still assuming case-insensitivity
+		//		for a host/root document.
+		//
+		//		Non-selector Queries:
+		//		---------------------
+		//
+		//		If something other than a String is passed for the query,
+		//		`dojo.query` will return a new `dojo.NodeList` instance
+		//		constructed from that parameter alone and all further
+		//		processing will stop. This means that if you have a reference
+		//		to a node or NodeList, you can quickly construct a new NodeList
+		//		from the original by calling `dojo.query(node)` or
+		//		`dojo.query(list)`.
+		//
+		//	query:
+		//		The CSS3 expression to match against. For details on the syntax of
+		//		CSS3 selectors, see <http://www.w3.org/TR/css3-selectors/#selectors>
+		//	root:
+		//		A DOMNode (or node id) to scope the search from. Optional.
+		//	returns: Array
+		//	example:
+		//		search the entire document for elements with the class "foo":
+		//	|	dojo.query(".foo");
+		//		these elements will match:
+		//	|	<span class="foo"></span>
+		//	|	<span class="foo bar"></span>
+		//	|	<p class="thud foo"></p>
+		//	example:
+		//		search the entire document for elements with the classes "foo" *and* "bar":
+		//	|	dojo.query(".foo.bar");
+		//		these elements will match:
+		//	|	<span class="foo bar"></span>
+		//		while these will not:
+		//	|	<span class="foo"></span>
+		//	|	<p class="thud foo"></p>
+		//	example:
+		//		find `<span>` elements which are descendants of paragraphs and
+		//		which have a "highlighted" class:
+		//	|	dojo.query("p span.highlighted");
+		//		the innermost span in this fragment matches:
+		//	|	<p class="foo">
+		//	|		<span>...
+		//	|			<span class="highlighted foo bar">...</span>
+		//	|		</span>
+		//	|	</p>
+		//	example:
+		//		set an "odd" class on all odd table rows inside of the table
+		//		`#tabular_data`, using the `>` (direct child) selector to avoid
+		//		affecting any nested tables:
+		//	|	dojo.query("#tabular_data > tbody > tr:nth-child(odd)").addClass("odd");
+		//	example:
+		//		remove all elements with the class "error" from the document
+		//		and store them in a list:
+		//	|	var errors = dojo.query(".error").orphan();
+		//	example:
+		//		add an onclick handler to every submit button in the document
+		//		which causes the form to be sent via Ajax instead:
+		//	|	dojo.query("input[type='submit']").onclick(function(e){
+		//	|		dojo.stopEvent(e); // prevent sending the form
+		//	|		var btn = e.target;
+		//	|		dojo.xhrPost({
+		//	|			form: btn.form,
+		//	|			load: function(data){
+		//	|				// replace the form with the response
+		//	|				var div = dojo.doc.createElement("div");
+		//	|				dojo.place(div, btn.form, "after");
+		//	|				div.innerHTML = data;
+		//	|				dojo.style(btn.form, "display", "none");
+		//	|			}
+		//	|		});
+		//	|	});
+
+		root = root||getDoc();
+		var od = root.ownerDocument||root.documentElement;
+
+		// throw the big case sensitivity switch
+
+		// NOTE:
+		//		Opera in XHTML mode doesn't detect case-sensitivity correctly
+		//		and it's not clear that there's any way to test for it
+		caseSensitive = (root.contentType && root.contentType=="application/xml") ||
+						(dojo.isOpera && (root.doctype || od.toString() == "[object XMLDocument]")) ||
+						(!!od) &&
+				(dojo.isIE ? od.xml : (root.xmlVersion || od.xmlVersion));
+
+		// NOTE:
+		//		adding "true" as the 2nd argument to getQueryFunc is useful for
+		//		testing the DOM branch without worrying about the
+		//		behavior/performance of the QSA branch.
+		var r = getQueryFunc(query)(root);
+
+		// FIXME:
+		//		need to investigate this branch WRT #8074 and #8075
+		if(r && r.nozip){
+			return r;
+		}
+		return _zip(r); // dojo.NodeList
+	};
+	query.filter = function(/*Node[]*/ nodeList, /*String*/ filter, /*String|DOMNode?*/ root){
+		// summary:
+		// 		function for filtering a NodeList based on a selector, optimized for simple selectors
+		var tmpNodeList = [],
+			parts = getQueryParts(filter),
+			filterFunc =
+				(parts.length == 1 && !/[^\w#\.]/.test(filter)) ?
+				getSimpleFilterFunc(parts[0]) :
+				function(node){
+					return dojo.query(filter, root).indexOf(node) != -1;
+				};
+		for(var x = 0, te; te = nodeList[x]; x++){
+			if(filterFunc(te)){ tmpNodeList.push(te); }
+		}
+		return tmpNodeList;
+	};
+	return query;
+});//end defineQuery
diff --git a/js/dojo-1.7.2/dojo/selector/lite.js b/js/dojo-1.7.2/dojo/selector/lite.js
new file mode 100644
index 0000000..f2e97f1
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/selector/lite.js
@@ -0,0 +1,265 @@
+//>>built
+define("dojo/selector/lite", ["../has", "../_base/kernel"], function(has, dojo){
+"use strict";
+// summary:
+//		A small lightweight query selector engine that implements CSS2.1 selectors 
+// 		minus pseudo-classes and the sibling combinator, plus CSS3 attribute selectors
+var testDiv = document.createElement("div");
+var matchesSelector = testDiv.matchesSelector || testDiv.webkitMatchesSelector || testDiv.mozMatchesSelector || testDiv.msMatchesSelector || testDiv.oMatchesSelector; // IE9, WebKit, Firefox have this, but not Opera yet
+var querySelectorAll = testDiv.querySelectorAll;
+has.add("dom-matches-selector", !!matchesSelector);
+has.add("dom-qsa", !!querySelectorAll); 
+
+// this is a simple query engine. It has handles basic selectors, and for simple
+// common selectors is extremely fast
+var liteEngine = function(selector, root){
+	if(combine && selector.indexOf(',') > -1){
+		return combine(selector, root);
+	}
+	var match = (querySelectorAll ? 
+		/^([\w]*)#([\w\-]+$)|^(\.)([\w\-\*]+$)|^(\w+$)/ : // this one only matches on simple queries where we can beat qSA with specific methods
+		/^([\w]*)#([\w\-]+)(?:\s+(.*))?$|(?:^|(>|.+\s+))([\w\-\*]+)(\S*$)/) // this one matches parts of the query that we can use to speed up manual filtering
+			.exec(selector);
+	root = root || document;
+	if(match){
+		// fast path regardless of whether or not querySelectorAll exists
+		if(match[2]){
+			// an #id
+			// use dojo.byId if available as it fixes the id retrieval in IE
+			var found = dojo.byId ? dojo.byId(match[2]) : document.getElementById(match[2]);
+			if(!found || (match[1] && match[1] != found.tagName.toLowerCase())){
+				// if there is a tag qualifer and it doesn't match, no matches
+				return [];
+			}
+			if(root != document){
+				// there is a root element, make sure we are a child of it
+				var parent = found;
+				while(parent != root){
+					parent = parent.parentNode;
+					if(!parent){
+						return [];
+					}
+				}
+			}
+			return match[3] ?
+					liteEngine(match[3], found) 
+					: [found];
+		}
+		if(match[3] && root.getElementsByClassName){
+			// a .class
+			return root.getElementsByClassName(match[4]);
+		}
+		var found;
+		if(match[5]){
+			// a tag
+			found = root.getElementsByTagName(match[5]);
+			if(match[4] || match[6]){
+				selector = (match[4] || "") + match[6];
+			}else{
+				// that was the entirety of the query, return results
+				return found;
+			}
+		}
+	}
+	if(querySelectorAll){
+		// qSA works strangely on Element-rooted queries
+		// We can work around this by specifying an extra ID on the root
+		// and working up from there (Thanks to Andrew Dupont for the technique)
+		// IE 8 doesn't work on object elements
+		if (root.nodeType === 1 && root.nodeName.toLowerCase() !== "object"){				
+			return useRoot(root, selector, root.querySelectorAll);
+		}else{
+			// we can use the native qSA
+			return root.querySelectorAll(selector);
+		}
+	}else if(!found){
+		// search all children and then filter
+		found = root.getElementsByTagName("*");
+	}
+	// now we filter the nodes that were found using the matchesSelector
+	var results = [];
+	for(var i = 0, l = found.length; i < l; i++){
+		var node = found[i];
+		if(node.nodeType == 1 && jsMatchesSelector(node, selector, root)){
+			// keep the nodes that match the selector
+			results.push(node);
+		}
+	}
+	return results;
+};
+var useRoot = function(context, query, method){
+	// this function creates a temporary id so we can do rooted qSA queries, this is taken from sizzle
+	var oldContext = context,
+		old = context.getAttribute( "id" ),
+		nid = old || "__dojo__",
+		hasParent = context.parentNode,
+		relativeHierarchySelector = /^\s*[+~]/.test( query );
+
+	if(relativeHierarchySelector && !hasParent){
+		return [];
+	}
+	if(!old){
+		context.setAttribute("id", nid);
+	}else{
+		nid = nid.replace(/'/g, "\\$&");
+	}
+	if(relativeHierarchySelector && hasParent){
+		context = context.parentNode;
+	}
+
+	try {
+		return method.call(context, "[id='" + nid + "'] " + query );
+	} finally {
+		if ( !old ) {
+			oldContext.removeAttribute( "id" );
+		}
+	}
+};
+
+if(!has("dom-matches-selector")){
+	var jsMatchesSelector = (function(){
+		// a JS implementation of CSS selector matching, first we start with the various handlers
+		var caseFix = testDiv.tagName == "div" ? "toLowerCase" : "toUpperCase";
+		function tag(tagName){
+			tagName = tagName[caseFix]();
+			return function(node){
+				return node.tagName == tagName;
+			}
+		}
+		function className(className){
+			var classNameSpaced = ' ' + className + ' ';
+			return function(node){
+				return node.className.indexOf(className) > -1 && (' ' + node.className + ' ').indexOf(classNameSpaced) > -1;
+			}
+		}
+		var attrComparators = {
+			"^=": function(attrValue, value){
+				return attrValue.indexOf(value) == 0;
+			},
+			"*=": function(attrValue, value){
+				return attrValue.indexOf(value) > -1;
+			},
+			"$=": function(attrValue, value){
+				return attrValue.substring(attrValue.length - value.length, attrValue.length) == value;
+			},
+			"~=": function(attrValue, value){
+				return (' ' + attrValue + ' ').indexOf(' ' + value + ' ') > -1;
+			},
+			"|=": function(attrValue, value){
+				return (attrValue + '-').indexOf(value + '-') == 0;
+			},
+			"=": function(attrValue, value){
+				return attrValue == value;
+			},
+			"": function(attrValue, value){
+				return true;
+			}
+		};
+		function attr(name, value, type){
+			if(value.match(/['"]/)){
+				// it is quoted, do an eval to parse the string (CSS and JS parsing are close enough)
+				value = eval(value);
+			}
+			var comparator = attrComparators[type || ""];
+			return function(node){
+				var attrValue = node.getAttribute(name);
+				return attrValue && comparator(attrValue, value);
+			}
+		}
+		function ancestor(matcher){
+			return function(node, root){
+				while((node = node.parentNode) != root){
+					if(matcher(node, root)){
+						return true;
+					}
+				}
+			};
+		}
+		function parent(matcher){
+			return function(node, root){
+				node = node.parentNode;
+				return matcher ? 
+					node != root && matcher(node, root)
+					: node == root;
+			};
+		}
+		var cache = {};
+		function and(matcher, next){
+			return matcher ?
+				function(node, root){
+					return next(node) && matcher(node, root);
+				}
+				: next;
+		}
+		return function(node, selector, root){
+			// this returns true or false based on if the node matches the selector (optionally within the given root)
+			var matcher = cache[selector]; // check to see if we have created a matcher function for the given selector
+			if(!matcher){
+				// create a matcher function for the given selector
+				// parse the selectors
+				if(selector.replace(/(?:\s*([> ])\s*)|(\.)?([\w-]+)|\[([\w-]+)\s*(.?=)?\s*([^\]]*)\]/g, function(t, combinator, type, value, attrName, attrType, attrValue){
+					if(value){
+						if(type == "."){
+							matcher = and(matcher, className(value));
+						}
+						else{
+							matcher = and(matcher, tag(value));
+						}
+					}
+					else if(combinator){
+						matcher = (combinator == " " ? ancestor : parent)(matcher);
+					}
+					else if(attrName){
+						matcher = and(matcher, attr(attrName, attrValue, attrType));
+					}
+					return "";
+				})){
+					throw new Error("Syntax error in query");
+				}
+				if(!matcher){
+					return true;
+				}
+				cache[selector] = matcher;
+			}
+			// now run the matcher function on the node
+			return matcher(node, root);
+		};
+	})();
+}
+if(!has("dom-qsa")){
+	var combine = function(selector, root){
+		// combined queries
+		selector = selector.split(/\s*,\s*/);
+		var indexed = [];
+		// add all results and keep unique ones, this only runs in IE, so we take advantage 
+		// of known IE features, particularly sourceIndex which is unique and allows us to 
+		// order the results 
+		for(var i = 0; i < selector.length; i++){
+			var results = liteEngine(selector[i], root);
+			for(var j = 0, l = results.length; j < l; j++){
+				var node = results[j];
+				indexed[node.sourceIndex] = node;
+			}
+		}
+		// now convert from a sparse array to a dense array
+		var totalResults = [];
+		for(i in indexed){
+			totalResults.push(indexed[i]);
+		}
+		return totalResults;
+	};
+}
+
+liteEngine.match = matchesSelector ? function(node, selector, root){
+	if(root){
+		// doesn't support three args, use rooted id trick
+		return useRoot(root, selector, function(query){
+			return matchesSelector.call(node, query);
+		});
+	}
+	// we have a native matchesSelector, use that
+	return matchesSelector.call(node, selector);
+} : jsMatchesSelector; // otherwise use the JS matches impl
+
+return liteEngine;
+});
diff --git a/js/dojo-1.7.2/dojo/store/Cache.js b/js/dojo-1.7.2/dojo/store/Cache.js
new file mode 100644
index 0000000..198a001
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/store/Cache.js
@@ -0,0 +1,149 @@
+//>>built
+define("dojo/store/Cache", ["../_base/lang","../_base/Deferred"
+],function(lang, Deferred) {
+	// module:
+	//		dojo/store/Cache
+	// summary:
+	//		TODOC
+
+var store = lang.getObject("dojo.store", true);
+
+/*=====
+dojo.declare("dojo.store.__CacheArgs", null, {
+	constructor: function(){
+		// summary:
+		//		These are additional options for how caching is handled.
+		// isLoaded: Function?
+		//		This is a function that will be called for each item in a query response to determine
+		//		if it is cacheable. If isLoaded returns true, the item will be cached, otherwise it
+		//		will not be cached. If isLoaded is not provided, all items will be cached.
+		this.isLoaded = isLoaded;
+	}
+});
+=====*/
+store.Cache = function(masterStore, cachingStore, /*dojo.store.__CacheArgs*/ options){
+	// summary:
+	//		The Cache store wrapper takes a master store and a caching store,
+	//		caches data from the master into the caching store for faster
+	//		lookup. Normally one would use a memory store for the caching
+	//		store and a server store like JsonRest for the master store.
+	// masterStore:
+	//		This is the authoritative store, all uncached requests or non-safe requests will
+	//		be made against this store.
+	// cachingStore:
+	//		This is the caching store that will be used to store responses for quick access.
+	//		Typically this should be a local store.
+	// options:
+	//		These are additional options for how caching is handled.
+	options = options || {};
+	return lang.delegate(masterStore, {
+		query: function(query, directives){
+			var results = masterStore.query(query, directives);
+			results.forEach(function(object){
+				if(!options.isLoaded || options.isLoaded(object)){
+					cachingStore.put(object);
+				}
+			});
+			return results;
+		},
+		// look for a queryEngine in either store
+		queryEngine: masterStore.queryEngine || cachingStore.queryEngine,
+		get: function(id, directives){
+			return Deferred.when(cachingStore.get(id), function(result){
+				return result || Deferred.when(masterStore.get(id, directives), function(result){
+					if(result){
+						cachingStore.put(result, {id: id});
+					}
+					return result;
+				});
+			});
+		},
+		add: function(object, directives){
+			return Deferred.when(masterStore.add(object, directives), function(result){
+				// now put result in cache
+				return cachingStore.add(typeof result == "object" ? result : object, directives);
+			});
+		},
+		put: function(object, directives){
+			// first remove from the cache, so it is empty until we get a response from the master store
+			cachingStore.remove((directives && directives.id) || this.getIdentity(object));
+			return Deferred.when(masterStore.put(object, directives), function(result){
+				// now put result in cache
+				return cachingStore.put(typeof result == "object" ? result : object, directives);
+			});
+		},
+		remove: function(id, directives){
+			return Deferred.when(masterStore.remove(id, directives), function(result){
+				return cachingStore.remove(id, directives);
+			});
+		},
+		evict: function(id){
+			return cachingStore.remove(id);
+		}
+	});
+};
+/*=====
+dojo.declare("dojo.store.Cache", null, {
+	// example:
+	//	|	var master = new dojo.store.Memory(data);
+	//	|	var cacher = new dojo.store.Memory();
+	//	|	var store = new dojo.store.Cache(master, cacher);
+	//
+	query: function(query, directives){
+		// summary:
+		//		Query the underlying master store and cache any results.
+		// query: Object|String
+		//		The object or string containing query information. Dependent on the query engine used.
+		// directives: dojo.store.util.SimpleQueryEngine.__queryOptions?
+		//		An optional keyword arguments object with additional parameters describing the query.
+		// returns: dojo.store.util.QueryResults
+		//		A QueryResults object that can be used to iterate over.
+	},
+	get: function(id, directives){
+		// summary:
+		//		Get the object with the specific id.
+		// id: Number
+		//		The identifier for the object in question.
+		// directives: dojo.store.__GetOptions?
+		//		Any additional parameters needed to describe how the get should be performed.
+		// returns: dojo.store.util.QueryResults
+		//		A QueryResults object.
+	},
+	add: function(object, directives){
+		// summary:
+		//		Add the given object to the store.
+		// object: Object
+		//		The object to add to the store.
+		// directives: dojo.store.__AddOptions?
+		//		Any additional parameters needed to describe how the add should be performed.
+		// returns: Number
+		//		The new id for the object.
+	},
+	put: function(object, directives){
+		// summary:
+		//		Put the object into the store (similar to an HTTP PUT).
+		// object: Object
+		//		The object to put to the store.
+		// directives: dojo.store.__PutOptions?
+		//		Any additional parameters needed to describe how the put should be performed.
+		// returns: Number
+		//		The new id for the object.
+	},
+	remove: function(id, directives){
+		// summary:
+		//		Remove the object with the specific id.
+		// id: Number
+		//		The identifier for the object in question.
+		// directives: dojo.store.__RemoveOptions?
+		//		Any additional parameters needed to describe how the remove should be performed.
+	},
+	evict: function(id){
+		// summary:
+		//		Remove the object with the given id from the underlying caching store.
+		// id: Number
+		//		The identifier for the object in question.
+	}
+});
+=====*/
+return store.Cache;
+});
diff --git a/js/dojo-1.7.2/dojo/store/DataStore.js b/js/dojo-1.7.2/dojo/store/DataStore.js
new file mode 100644
index 0000000..dcb8d7b
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/store/DataStore.js
@@ -0,0 +1,171 @@
+//>>built
+define("dojo/store/DataStore", ["../_base/lang", "../_base/declare", "../_base/Deferred", "../_base/array", "./util/QueryResults"
+], function(lang,declare,Deferred,array,QueryResults) {
+	// module:
+	//		dojo/store/DataStore
+	// summary:
+	//		TODOC
+
+
+return declare("dojo.store.DataStore", null, {
+	target: "",
+	constructor: function(options){
+		// summary:
+		//		This is an adapter for using Dojo Data stores with an object store consumer.
+		//		You can provide a Dojo data store and use this adapter to interact with it through
+		//		the Dojo object store API
+		// options: Object?
+		//		This provides any configuration information that will be mixed into the store,
+		//		including a reference to the Dojo data store under the property "store".
+		lang.mixin(this, options);
+ 		if(!"idProperty" in options){
+			var idAttribute; 
+			try{
+				idAttribute = this.store.getIdentityAttributes(); 
+			}catch(e){ 
+	 		// some store are not requiring an item instance to give us the ID attributes 
+	 		// but some other do and throw errors in that case. 
+			} 
+			// if no idAttribute we have implicit id 
+			this.idProperty = (!idAttribute || !idAttributes[0]) || this.idProperty; 
+		}
+		var features = this.store.getFeatures();
+		// check the feature set and null out any methods that shouldn't be available
+		if(!features["dojo.data.api.Read"]){
+			this.get = null;
+		}
+		if(!features["dojo.data.api.Identity"]){
+			this.getIdentity = null;
+		}
+		if(!features["dojo.data.api.Write"]){
+			this.put = this.add = null;
+		}
+	},
+	// idProperty: String
+	//		The object property to use to store the identity of the store items.
+	idProperty: "id",
+	// store:
+	//		The object store to convert to a data store
+	store: null,
+	_objectConverter: function(callback){
+		var store = this.store;
+		var idProperty = this.idProperty;
+		return function(item){
+			var object = {};
+			var attributes = store.getAttributes(item);
+			for(var i = 0; i < attributes.length; i++){
+				object[attributes[i]] = store.getValue(item, attributes[i]);
+			}
+			if(!(idProperty in object)){
+				object[idProperty] = store.getIdentity(item);
+			}
+			return callback(object);
+		};
+	},
+	get: function(id, options){
+		// summary:
+		//		Retrieves an object by it's identity. This will trigger a fetchItemByIdentity
+		// id: Object?
+		//		The identity to use to lookup the object
+		var returnedObject, returnedError;
+		var deferred = new Deferred();
+		this.store.fetchItemByIdentity({
+			identity: id,
+			onItem: this._objectConverter(function(object){
+				deferred.resolve(returnedObject = object);
+			}),
+			onError: function(error){
+				deferred.reject(returnedError = error);
+			}
+		});
+		if(returnedObject){
+			// if it was returned synchronously
+			return returnedObject;
+		}
+		if(returnedError){
+			throw returnedError;
+		}
+		return deferred.promise;
+	},
+	put: function(object, options){
+		// summary:
+		//		Stores an object by its identity.
+		// object: Object
+		//		The object to store.
+		// options: Object?
+		//		Additional metadata for storing the data.  Includes a reference to an id
+		//		that the object may be stored with (i.e. { id: "foo" }).
+		var id = options && typeof options.id != "undefined" || this.getIdentity(object);
+		var store = this.store;
+		var idProperty = this.idProperty;
+		if(typeof id == "undefined"){
+			store.newItem(object);
+		}else{
+			store.fetchItemByIdentity({
+				identity: id,
+				onItem: function(item){
+					if(item){
+						for(var i in object){
+							if(i != idProperty && // don't copy id properties since they are immutable and should be omitted for implicit ids 
+									store.getValue(item, i) != object[i]){
+								store.setValue(item, i, object[i]);
+							}
+						}
+					}else{
+						store.newItem(object);
+					}
+				}
+			});
+		}
+	},
+	remove: function(id){
+		// summary:
+		//		Deletes an object by its identity.
+		// id: Object
+		//		The identity to use to delete the object
+		var store = this.store;
+		this.store.fetchItemByIdentity({
+			identity: id,
+			onItem: function(item){
+				store.deleteItem(item);
+			}
+		});
+	},
+	query: function(query, options){
+		// summary:
+		//		Queries the store for objects.
+		// query: Object
+		//		The query to use for retrieving objects from the store
+		// options: Object?
+		//		Optional options object as used by the underlying dojo.data Store.
+		// returns: dojo.store.util.QueryResults
+		//		A query results object that can be used to iterate over results.
+		var fetchHandle;
+		var deferred = new Deferred(function(){ fetchHandle.abort && fetchHandle.abort(); });
+		deferred.total = new Deferred();
+		var converter = this._objectConverter(function(object){return object;});
+		fetchHandle = this.store.fetch(lang.mixin({
+			query: query,
+			onBegin: function(count){
+				deferred.total.resolve(count);
+			},
+			onComplete: function(results){
+				deferred.resolve(array.map(results, converter));
+			},
+			onError: function(error){
+				deferred.reject(error);
+			}
+		}, options));
+		return QueryResults(deferred);
+	},
+	getIdentity: function(object){
+		// summary:
+		//		Fetch the identity for the given object.
+		// object: Object
+		//		The data object to get the identity from.
+		// returns: Number
+		//		The id of the given object.
+		return object[this.idProperty];
+	}
+});
+});
diff --git a/js/dojo-1.7.2/dojo/store/JsonRest.js b/js/dojo-1.7.2/dojo/store/JsonRest.js
new file mode 100644
index 0000000..9012d8e
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/store/JsonRest.js
@@ -0,0 +1,156 @@
+//>>built
+define("dojo/store/JsonRest", ["../_base/xhr", "../json", "../_base/declare", "./util/QueryResults"
+], function(xhr, JSON, declare, QueryResults) {
+  //  module:
+  //    dojo/store/JsonRest
+  //  summary:
+  //    The module defines a JSON/REST based object store 
+
+return declare("dojo.store.JsonRest", null, {
+	// summary:
+	//		This is a basic store for RESTful communicating with a server through JSON
+	//		formatted data. It implements dojo.store.api.Store.
+
+	constructor: function(/*dojo.store.JsonRest*/ options){
+		// summary:
+		//		This is a basic store for RESTful communicating with a server through JSON
+		//		formatted data.
+		// options:
+		//		This provides any configuration information that will be mixed into the store
+		declare.safeMixin(this, options);
+	},
+	// target: String
+	//		The target base URL to use for all requests to the server. This string will be
+	// 	prepended to the id to generate the URL (relative or absolute) for requests
+	// 	sent to the server
+	target: "",
+	// idProperty: String
+	//		Indicates the property to use as the identity property. The values of this
+	//		property should be unique.
+	idProperty: "id",
+	// sortParam: String
+	// 		The query parameter to used for holding sort information. If this is omitted, than
+	//		the sort information is included in a functional query token to avoid colliding 
+	// 		with the set of name/value pairs.
+	
+	get: function(id, options){
+		//	summary:
+		//		Retrieves an object by its identity. This will trigger a GET request to the server using
+		//		the url `this.target + id`.
+		//	id: Number
+		//		The identity to use to lookup the object
+		//	returns: Object
+		//		The object in the store that matches the given id.
+		var headers = options || {};
+		headers.Accept = this.accepts;
+		return xhr("GET", {
+			url:this.target + id,
+			handleAs: "json",
+			headers: headers
+		});
+	},
+	// accepts: String
+	//		Defines the Accept header to use on HTTP requests
+	accepts: "application/javascript, application/json", 
+	getIdentity: function(object){
+		// summary:
+		//		Returns an object's identity
+		// object: Object
+		//		The object to get the identity from
+		//	returns: Number
+		return object[this.idProperty];
+	},
+	put: function(object, options){
+		// summary:
+		//		Stores an object. This will trigger a PUT request to the server
+		//		if the object has an id, otherwise it will trigger a POST request.
+		// object: Object
+		//		The object to store.
+		// options: dojo.store.api.Store.PutDirectives?
+		//		Additional metadata for storing the data.  Includes an "id"
+		//		property if a specific id is to be used.
+		//	returns: Number
+		options = options || {};
+		var id = ("id" in options) ? options.id : this.getIdentity(object);
+		var hasId = typeof id != "undefined";
+		return xhr(hasId && !options.incremental ? "PUT" : "POST", {
+				url: hasId ? this.target + id : this.target,
+				postData: JSON.stringify(object),
+				handleAs: "json",
+				headers:{
+					"Content-Type": "application/json",
+					Accept: this.accepts,
+					"If-Match": options.overwrite === true ? "*" : null,
+					"If-None-Match": options.overwrite === false ? "*" : null
+				}
+			});
+	},
+	add: function(object, options){
+		// summary:
+		//		Adds an object. This will trigger a PUT request to the server
+		//		if the object has an id, otherwise it will trigger a POST request.
+		// object: Object
+		//		The object to store.
+		// options: dojo.store.api.Store.PutDirectives?
+		//		Additional metadata for storing the data.  Includes an "id"
+		//		property if a specific id is to be used.
+		options = options || {};
+		options.overwrite = false;
+		return this.put(object, options);
+	},
+	remove: function(id){
+		// summary:
+		//		Deletes an object by its identity. This will trigger a DELETE request to the server.
+		// id: Number
+		//		The identity to use to delete the object
+		return xhr("DELETE",{
+			url:this.target + id
+		});
+	},
+	query: function(query, options){
+		// summary:
+		//		Queries the store for objects. This will trigger a GET request to the server, with the
+		//		query added as a query string.
+		// query: Object
+		//		The query to use for retrieving objects from the store.
+		//	options: dojo.store.api.Store.QueryOptions?
+		//		The optional arguments to apply to the resultset.
+		//	returns: dojo.store.api.Store.QueryResults
+		//		The results of the query, extended with iterative methods.
+		var headers = {Accept: this.accepts};
+		options = options || {};
+
+		if(options.start >= 0 || options.count >= 0){
+			headers.Range = "items=" + (options.start || '0') + '-' +
+				(("count" in options && options.count != Infinity) ?
+					(options.count + (options.start || 0) - 1) : '');
+		}
+		if(query && typeof query == "object"){
+			query = xhr.objectToQuery(query);
+			query = query ? "?" + query: "";
+		}
+		if(options && options.sort){
+			var sortParam = this.sortParam;
+			query += (query ? "&" : "?") + (sortParam ? sortParam + '=' : "sort(");
+			for(var i = 0; i<options.sort.length; i++){
+				var sort = options.sort[i];
+				query += (i > 0 ? "," : "") + (sort.descending ? '-' : '+') + encodeURIComponent(sort.attribute);
+			}
+			if(!sortParam){
+				query += ")";
+			}
+		}
+		var results = xhr("GET", {
+			url: this.target + (query || ""),
+			handleAs: "json",
+			headers: headers
+		});
+		results.total = results.then(function(){
+			var range = results.ioArgs.xhr.getResponseHeader("Content-Range");
+			return range && (range=range.match(/\/(.*)/)) && +range[1];
+		});
+		return QueryResults(results);
+	}
+});
+
+});
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/store/Memory.js b/js/dojo-1.7.2/dojo/store/Memory.js
new file mode 100644
index 0000000..fe56595
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/store/Memory.js
@@ -0,0 +1,162 @@
+//>>built
+define("dojo/store/Memory", ["../_base/declare", "./util/QueryResults", "./util/SimpleQueryEngine"], function(declare, QueryResults, SimpleQueryEngine) {
+  //  module:
+  //    dojo/store/Memory
+  //  summary:
+  //    The module defines an in-memory object store.
+
+
+return declare("dojo.store.Memory", null, {
+	// summary:
+	//		This is a basic in-memory object store. It implements dojo.store.api.Store.
+	constructor: function(/*dojo.store.Memory*/ options){
+		// summary:
+		//		Creates a memory object store.
+		// options:
+		//		This provides any configuration information that will be mixed into the store.
+		// 		This should generally include the data property to provide the starting set of data.
+		for(var i in options){
+			this[i] = options[i];
+		}
+		this.setData(this.data || []);
+	},
+	// data: Array
+	//		The array of all the objects in the memory store
+	data:null,
+
+	// idProperty: String
+	//		Indicates the property to use as the identity property. The values of this
+	//		property should be unique.
+	idProperty: "id",
+
+	// index: Object
+	//		An index of data indices into the data array by id
+	index:null,
+
+	// queryEngine: Function
+	//		Defines the query engine to use for querying the data store
+	queryEngine: SimpleQueryEngine,
+	get: function(id){
+		//	summary:
+		//		Retrieves an object by its identity
+		//	id: Number
+		//		The identity to use to lookup the object
+		//	returns: Object
+		//		The object in the store that matches the given id.
+		return this.data[this.index[id]];
+	},
+	getIdentity: function(object){
+		// 	summary:
+		//		Returns an object's identity
+		// 	object: Object
+		//		The object to get the identity from
+		//	returns: Number
+		return object[this.idProperty];
+	},
+	put: function(object, options){
+		// 	summary:
+		//		Stores an object
+		// 	object: Object
+		//		The object to store.
+		// 	options: dojo.store.api.Store.PutDirectives??
+		//		Additional metadata for storing the data.  Includes an "id"
+		//		property if a specific id is to be used.
+		//	returns: Number
+		var data = this.data,
+			index = this.index,
+			idProperty = this.idProperty;
+		var id = (options && "id" in options) ? options.id : idProperty in object ? object[idProperty] : Math.random();
+		if(id in index){
+			// object exists
+			if(options && options.overwrite === false){
+				throw new Error("Object already exists");
+			}
+			// replace the entry in data
+			data[index[id]] = object;
+		}else{
+			// add the new object
+			index[id] = data.push(object) - 1;
+		}
+		return id;
+	},
+	add: function(object, options){
+		// 	summary:
+		//		Creates an object, throws an error if the object already exists
+		// 	object: Object
+		//		The object to store.
+		// 	options: dojo.store.api.Store.PutDirectives??
+		//		Additional metadata for storing the data.  Includes an "id"
+		//		property if a specific id is to be used.
+		//	returns: Number
+		(options = options || {}).overwrite = false;
+		// call put with overwrite being false
+		return this.put(object, options);
+	},
+	remove: function(id){
+		// 	summary:
+		//		Deletes an object by its identity
+		// 	id: Number
+		//		The identity to use to delete the object
+		// returns: Boolean
+		// 		Returns true if an object was removed, falsy (undefined) if no object matched the id
+		var index = this.index;
+		var data = this.data;
+		if(id in index){
+			data.splice(index[id], 1);
+			// now we have to reindex
+			this.setData(data);
+			return true;
+		}
+	},
+	query: function(query, options){
+		// 	summary:
+		//		Queries the store for objects.
+		// 	query: Object
+		//		The query to use for retrieving objects from the store.
+		//	options: dojo.store.api.Store.QueryOptions?
+		//		The optional arguments to apply to the resultset.
+		//	returns: dojo.store.api.Store.QueryResults
+		//		The results of the query, extended with iterative methods.
+		//
+		// 	example:
+		// 		Given the following store:
+		//
+		// 	|	var store = new dojo.store.Memory({
+		// 	|		data: [
+		// 	|			{id: 1, name: "one", prime: false },
+		//	|			{id: 2, name: "two", even: true, prime: true},
+		//	|			{id: 3, name: "three", prime: true},
+		//	|			{id: 4, name: "four", even: true, prime: false},
+		//	|			{id: 5, name: "five", prime: true}
+		//	|		]
+		//	|	});
+		//
+		//	...find all items where "prime" is true:
+		//
+		//	|	var results = store.query({ prime: true });
+		//
+		//	...or find all items where "even" is true:
+		//
+		//	|	var results = store.query({ even: true });
+		return QueryResults(this.queryEngine(query, options)(this.data));
+	},
+	setData: function(data){
+		// 	summary:
+		//		Sets the given data as the source for this store, and indexes it
+		//	data: Object[]
+		//		An array of objects to use as the source of data.
+		if(data.items){
+			// just for convenience with the data format IFRS expects
+			this.idProperty = data.identifier;
+			data = this.data = data.items;
+		}else{
+			this.data = data;
+		}
+		this.index = {};
+		for(var i = 0, l = data.length; i < l; i++){
+			this.index[data[i][this.idProperty]] = i;
+		}
+	}
+});
+
+});
diff --git a/js/dojo-1.7.2/dojo/store/Observable.js b/js/dojo-1.7.2/dojo/store/Observable.js
new file mode 100644
index 0000000..ee79dc2
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/store/Observable.js
@@ -0,0 +1,176 @@
+//>>built
+define("dojo/store/Observable", ["../_base/kernel", "../_base/lang", "../_base/Deferred", "../_base/array"
+], function(kernel, lang, Deferred, array) {
+	// module:
+	//		dojo/store/Observable
+	// summary:
+	//		TODOC
+
+var ds = lang.getObject("dojo.store", true);
+
+return ds.Observable = function(store){
+	// summary:
+	//		The Observable store wrapper takes a store and sets an observe method on query()
+	//		results that can be used to monitor results for changes.
+	//
+	// description:
+	//		Observable wraps an existing store so that notifications can be made when a query
+	//		is performed.
+	//
+	// example:
+	//		Create a Memory store that returns an observable query, and then log some
+	//		information about that query.
+	//
+	//	|	var store = dojo.store.Observable(new dojo.store.Memory({
+	//	|		data: [
+	//	|			{id: 1, name: "one", prime: false},
+	//	|			{id: 2, name: "two", even: true, prime: true},
+	//	|			{id: 3, name: "three", prime: true},
+	//	|			{id: 4, name: "four", even: true, prime: false},
+	//	|			{id: 5, name: "five", prime: true}
+	//	|		]
+	//	|	}));
+	//	|	var changes = [], results = store.query({ prime: true });
+	//	|	var observer = results.observe(function(object, previousIndex, newIndex){
+	//	|		changes.push({previousIndex:previousIndex, newIndex:newIndex, object:object});
+	//	|	});
+	//
+	//		See the Observable tests for more information.
+
+	var undef, queryUpdaters = [], revision = 0;
+	// a Comet driven store could directly call notify to notify observers when data has
+	// changed on the backend
+	store.notify = function(object, existingId){
+		revision++;
+		var updaters = queryUpdaters.slice();
+		for(var i = 0, l = updaters.length; i < l; i++){
+			updaters[i](object, existingId);
+		}
+	};
+	var originalQuery = store.query;
+	store.query = function(query, options){
+		options = options || {};
+		var results = originalQuery.apply(this, arguments);
+		if(results && results.forEach){
+			var nonPagedOptions = lang.mixin({}, options);
+			delete nonPagedOptions.start;
+			delete nonPagedOptions.count;
+
+			var queryExecutor = store.queryEngine && store.queryEngine(query, nonPagedOptions);
+			var queryRevision = revision;
+			var listeners = [], queryUpdater;
+			results.observe = function(listener, includeObjectUpdates){
+				if(listeners.push(listener) == 1){
+					// first listener was added, create the query checker and updater
+					queryUpdaters.push(queryUpdater = function(changed, existingId){
+						Deferred.when(results, function(resultsArray){
+							var atEnd = resultsArray.length != options.count;
+							var i, l, listener;
+							if(++queryRevision != revision){
+								throw new Error("Query is out of date, you must observe() the query prior to any data modifications");
+							}
+							var removedObject, removedFrom = -1, insertedInto = -1;
+							if(existingId !== undef){
+								// remove the old one
+								for(i = 0, l = resultsArray.length; i < l; i++){
+									var object = resultsArray[i];
+									if(store.getIdentity(object) == existingId){
+										removedObject = object;
+										removedFrom = i;
+										if(queryExecutor || !changed){// if it was changed and we don't have a queryExecutor, we shouldn't remove it because updated objects would be eliminated
+											resultsArray.splice(i, 1);
+										}
+										break;
+									}
+								}
+							}
+							if(queryExecutor){
+								// add the new one
+								if(changed &&
+										// if a matches function exists, use that (probably more efficient)
+										(queryExecutor.matches ? queryExecutor.matches(changed) : queryExecutor([changed]).length)){
+
+									var firstInsertedInto = removedFrom > -1 ? 
+										removedFrom : // put back in the original slot so it doesn't move unless it needs to (relying on a stable sort below)
+										resultsArray.length;
+									resultsArray.splice(firstInsertedInto, 0, changed); // add the new item
+									insertedInto = array.indexOf(queryExecutor(resultsArray), changed); // sort it
+									// we now need to push the chagne back into the original results array
+									resultsArray.splice(firstInsertedInto, 1); // remove the inserted item from the previous index
+									
+									if((options.start && insertedInto == 0) ||
+										(!atEnd && insertedInto == resultsArray.length)){
+										// if it is at the end of the page, assume it goes into the prev or next page
+										insertedInto = -1;
+									}else{
+										resultsArray.splice(insertedInto, 0, changed); // and insert into the results array with the correct index
+									}
+								}
+							}else if(changed && !options.start){
+								// we don't have a queryEngine, so we can't provide any information
+								// about where it was inserted, but we can at least indicate a new object
+								insertedInto = removedFrom >= 0 ? removedFrom : (store.defaultIndex || 0);
+							}
+							if((removedFrom > -1 || insertedInto > -1) &&
+									(includeObjectUpdates || !queryExecutor || (removedFrom != insertedInto))){
+								var copyListeners = listeners.slice();
+								for(i = 0;listener = copyListeners[i]; i++){
+									listener(changed || removedObject, removedFrom, insertedInto);
+								}
+							}
+						});
+					});
+				}
+				return {
+					cancel: function(){
+						// remove this listener
+						var index = array.indexOf(listeners, listener);
+						if(index > -1){ // check to make sure we haven't already called cancel
+							listeners.splice(index, 1);
+							if(!listeners.length){
+								// no more listeners, remove the query updater too
+								queryUpdaters.splice(array.indexOf(queryUpdaters, queryUpdater), 1);
+							}
+						}						
+					}
+				};
+			};
+		}
+		return results;
+	};
+	var inMethod;
+	function whenFinished(method, action){
+		var original = store[method];
+		if(original){
+			store[method] = function(value){
+				if(inMethod){
+					// if one method calls another (like add() calling put()) we don't want two events
+					return original.apply(this, arguments);
+				}
+				inMethod = true;
+				try{
+					var results = original.apply(this, arguments);
+					Deferred.when(results, function(results){
+						action((typeof results == "object" && results) || value);
+					});
+					return results;
+				}finally{
+					inMethod = false;
+				}
+			};
+		}
+	}
+	// monitor for updates by listening to these methods
+	whenFinished("put", function(object){
+		store.notify(object, store.getIdentity(object));
+	});
+	whenFinished("add", function(object){
+		store.notify(object);
+	});
+	whenFinished("remove", function(id){
+		store.notify(undefined, id);
+	});
+
+	return store;
+};
+});
diff --git a/js/dojo-1.7.2/dojo/store/README b/js/dojo-1.7.2/dojo/store/README
new file mode 100644
index 0000000..cb33da0
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/store/README
@@ -0,0 +1,10 @@
+This folder contains the stores and utilities implementing the proposed new Dojo Object Store API,
+a successor and unifier to Dojo Data, Dojo Storage, and potentially Dojo Model. These
+stores are brand new, and designed to provide simple lightweight implementations 
+providing core functionality for typical applications. These modules are under active 
+development, and exist here at this time to provide maximum visibility to the 
+efforts to design and develop this new API and set of base stores. The goal is 
+to have these stores ready for Dojo 1.6. In the meantime, these stores are likely to
+have API changes, may be missing some functionality, tests, and/or documentation.
+If these modules are not deemed suitably stable by the 1.6 release, this directory (or
+individual modules) will be removed and be given a later release target.  
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/store/api/Store.js b/js/dojo-1.7.2/dojo/store/api/Store.js
new file mode 100644
index 0000000..47f95eb
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/store/api/Store.js
@@ -0,0 +1,298 @@
+//>>built
+define("dojo/store/api/Store", ["dojo/_base/declare"], function(declare) {
+	// module:
+	//		dojo/store/api/Store
+	// summary:
+	//		The module defines the Dojo object store interface.
+
+var Store = declare("dojo.store.api.Store", null, {
+	// summary:
+	//		This is an abstract API that data provider implementations conform to.
+	//		This file defines methods signatures and intentionally leaves all the
+	//		methods unimplemented.  For more information on the dojo.store APIs,
+	//		please visit: http://dojotoolkit.org/reference-guide/dojo/store.html
+	//		Every method and property is optional, and is only needed if the functionality
+	//		it provides is required.
+	//		Every method may return a promise for the specified return value if the
+	//		execution of the operation is asynchronous (except
+	//		for query() which already defines an async return value).
+
+	// idProperty: String
+	//		If the store has a single primary key, this tndicates the property to use as the
+	//		identity property. The values of this property should be unique.
+	idProperty: "id",
+
+	// queryEngine: Function
+	//		If the store can be queried locally (on the client side in JS), this defines
+	//		the query engine to use for querying the data store.
+	//		This takes a query and query options and returns a function that can execute
+	//		the provided query on a JavaScript array. The queryEngine may be replace to
+	//		provide more sophisticated querying capabilities. For example:
+	//		| var query = store.queryEngine({foo:"bar"}, {count:10});
+	//		| query(someArray) -> filtered array
+	//		The returned query function may have a "matches" property that can be
+	//		used to determine if an object matches the query. For example:
+	//		| query.matches({id:"some-object", foo:"bar"}) -> true
+	//		| query.matches({id:"some-object", foo:"something else"}) -> false
+	queryEngine: null,
+
+	get: function(id){
+		// summary:
+		//		Retrieves an object by its identity
+		// id: Number
+		//		The identity to use to lookup the object
+		// returns: Object
+		//		The object in the store that matches the given id.
+	},
+	getIdentity: function(object){
+		// summary:
+		//		Returns an object's identity
+		// object: Object
+		//		The object to get the identity from
+		// returns: String|Number
+	},
+	put: function(object, directives){
+		// summary:
+		//		Stores an object
+		// object: Object
+		//		The object to store.
+		// directives: dojo.store.api.Store.PutDirectives?
+		//		Additional directives for storing objects.
+		// returns: Number|String
+	},
+	add: function(object, directives){
+		// summary:
+		//		Creates an object, throws an error if the object already exists
+		// object: Object
+		//		The object to store.
+		// directives: dojo.store.api.Store.PutDirectives?
+		//		Additional directives for creating objects.
+		// returns: Number|String
+	},
+	remove: function(id){
+		// summary:
+		//		Deletes an object by its identity
+		// id: Number
+		//		The identity to use to delete the object
+		delete this.index[id];
+		var data = this.data,
+			idProperty = this.idProperty;
+		for(var i = 0, l = data.length; i < l; i++){
+			if(data[i][idProperty] == id){
+				data.splice(i, 1);
+				return;
+			}
+		}
+	},
+	query: function(query, options){
+		// summary:
+		//		Queries the store for objects. This does not alter the store, but returns a
+		//		set of data from the store.
+		// query: String|Object|Function
+		//		The query to use for retrieving objects from the store.
+		// options: dojo.store.api.Store.QueryOptions
+		//		The optional arguments to apply to the resultset.
+		// returns: dojo.store.api.Store.QueryResults
+		//		The results of the query, extended with iterative methods.
+		//
+		// example:
+		//		Given the following store:
+		//
+		//	...find all items where "prime" is true:
+		//
+		//	|	store.query({ prime: true }).forEach(function(object){
+		//	|		// handle each object
+		//	|	});
+	},
+	transaction: function(){
+		// summary:
+		//		Starts a new transaction.
+		//		Note that a store user might not call transaction() prior to using put,
+		//		delete, etc. in which case these operations effectively could be thought of
+		//		as "auto-commit" style actions.
+		// returns: dojo.store.api.Store.Transaction
+		//		This represents the new current transaction.
+	},
+	getChildren: function(parent, options){
+		// summary:
+		//		Retrieves the children of an object.
+		// parent: Object
+		//		The object to find the children of.
+		// options: dojo.store.api.Store.QueryOptions?
+		//		Additional options to apply to the retrieval of the children.
+		// returns: dojo.store.api.Store.QueryResults
+		//		A result set of the children of the parent object.
+	},
+	getMetadata: function(object){
+		// summary:
+		//		Returns any metadata about the object. This may include attribution,
+		//		cache directives, history, or version information.
+		// object: Object
+		//		The object to return metadata for.
+		// returns: Object
+		//		An object containing metadata.
+	}
+});
+
+Store.PutDirectives = function(id, before, parent, overwrite){
+	// summary:
+	//		Directives passed to put() and add() handlers for guiding the update and
+	//		creation of stored objects.
+	// id: String|Number?
+	//		Indicates the identity of the object if a new object is created
+	// before: Object?
+	//		If the collection of objects in the store has a natural ordering,
+	//		this indicates that the created or updated object should be placed before the
+	//		object specified by the value of this property. A value of null indicates that the
+	//		object should be last.
+	// parent: Object?,
+	//		If the store is hierarchical (with single parenting) this property indicates the
+	//		new parent of the created or updated object.
+	// overwrite: Boolean?
+	//		If this is provided as a boolean it indicates that the object should or should not
+	//		overwrite an existing object. A value of true indicates that a new object
+	//		should not be created, the operation should update an existing object. A
+	//		value of false indicates that an existing object should not be updated, a new
+	//		object should be created (which is the same as an add() operation). When
+	//		this property is not provided, either an update or creation is acceptable.
+	this.id = id;
+	this.before = before;
+	this.parent = parent;
+	this.overwrite = overwrite;
+};
+
+Store.SortInformation = function(attribute, descending){
+	// summary:
+	//		An object describing what attribute to sort on, and the direction of the sort.
+	// attribute: String
+	//		The name of the attribute to sort on.
+	// descending: Boolean
+	//		The direction of the sort.  Default is false.
+	this.attribute = attribute;
+	this.descending = descending;
+};
+
+Store.QueryOptions = function(sort, start, count){
+	// summary:
+	//		Optional object with additional parameters for query results.
+	// sort: dojo.store.api.Store.SortInformation[]?
+	//		A list of attributes to sort on, as well as direction
+	//		For example:
+	//		| [{attribute:"price, descending: true}].
+	//		If the sort parameter is omitted, then the natural order of the store may be
+	//		applied if there is a natural order.
+	// start: Number?
+	//		The first result to begin iteration on
+	// count: Number?
+	//		The number of how many results should be returned.
+	this.sort = sort;
+	this.start = start;
+	this.count = count;
+};
+
+declare("dojo.store.api.Store.QueryResults", null, {
+	// summary:
+	//		This is an object returned from query() calls that provides access to the results
+	//		of a query. Queries may be executed asynchronously.
+
+	forEach: function(callback, thisObject){
+		// summary:
+		//		Iterates over the query results, based on
+		//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/forEach.
+		//		Note that this may executed asynchronously. The callback may be called
+		//		after this function returns.
+		// callback:
+		//		Function that is called for each object in the query results
+		// thisObject:
+		//		The object to use as |this| in the callback.
+
+	},
+	filter: function(callback, thisObject){
+		// summary:
+		//		Filters the query results, based on
+		//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter.
+		//		Note that this may executed asynchronously. The callback may be called
+		//		after this function returns.
+		// callback:
+		//		Function that is called for each object in the query results
+		// thisObject:
+		//		The object to use as |this| in the callback.
+		// returns: dojo.store.api.Store.QueryResults
+	},
+	map: function(callback, thisObject){
+		// summary:
+		//		Maps the query results, based on
+		//		https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map.
+		//		Note that this may executed asynchronously. The callback may be called
+		//		after this function returns.
+		// callback:
+		//		Function that is called for each object in the query results
+		// thisObject:
+		//		The object to use as |this| in the callback.
+		// returns: dojo.store.api.Store.QueryResults
+	},
+	then: function(callback, errorHandler){
+		// summary:
+		//		This registers a callback for when the query is complete, if the query is asynchronous.
+		//		This is an optional method, and may not be present for synchronous queries.
+		// callback:
+		//		This is called when the query is completed successfully, and is passed a single argument
+		//		that is an array representing the query results.
+		// errorHandler:
+		//		This is called if the query failed, and is passed a single argument that is the error
+		//		for the failure.
+	},
+	observe: function(listener, includeAllUpdates){
+		// summary:
+		//		This registers a callback for notification of when data is modified in the query results.
+		//		This is an optional method, and is usually provided by dojo.store.Observable.
+		// listener: Function
+		//		The listener function is called when objects in the query results are modified
+		//		to affect the query result. The listener function is called with the following
+		// arguments:
+		//		| listener(object, removedFrom, insertedInto);
+		//		* The object parameter indicates the object that was create, modified, or deleted.
+		//		* The removedFrom parameter indicates the index in the result array where
+		//		the object used to be. If the value is -1, then the object is an addition to
+		//		this result set (due to a new object being created, or changed such that it
+		//		is a part of the result set).
+		//		* The insertedInto parameter indicates the index in the result array where
+		//		the object should be now. If the value is -1, then the object is a removal
+		//		from this result set (due to an object being deleted, or changed such that it
+		//		is not a part of the result set).
+		// includeAllUpdates:
+		//		This indicates whether or not to include object updates that do not affect
+		//		the inclusion or order of the object in the query results. By default this is false,
+		//		which means that if any object is updated in such a way that it remains
+		//		in the result set and it's position in result sets is not affected, then the listener
+		//		will not be fired.
+
+	},
+	// total: Number|Promise?
+	//		This property should be included in if the query options included the "count"
+	//		property limiting the result set. This property indicates the total number of objects
+	//		matching the query (as if "start" and "count" weren't present). This may be
+	//		a promise if the query is asynchronous.
+	total: 0
+});
+
+declare("dojo.store.api.Store.Transaction", null, {
+	// summary:
+	//		This is an object returned from transaction() calls that represents the current
+	//		transaction.
+
+	commit: function(){
+		// summary:
+		//		Commits the transaction. This may throw an error if it fails. Of if the operation
+		//		is asynchronous, it may return a promise that represents the eventual success
+		//		or failure of the commit.
+	},
+	abort: function(callback, thisObject){
+		// summary:
+		//		Aborts the transaction. This may throw an error if it fails. Of if the operation
+		//		is asynchronous, it may return a promise that represents the eventual success
+		//		or failure of the abort.
+	}
+});
+return Store;
+});
diff --git a/js/dojo-1.7.2/dojo/store/util/QueryResults.js b/js/dojo-1.7.2/dojo/store/util/QueryResults.js
new file mode 100644
index 0000000..bf72856
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/store/util/QueryResults.js
@@ -0,0 +1,65 @@
+//>>built
+define("dojo/store/util/QueryResults", ["../../_base/array", "../../_base/lang", "../../_base/Deferred"
+], function(array, lang, Deferred) {
+  //  module:
+  //    dojo/store/util/QueryResults
+  //  summary:
+  //    The module defines a query results wrapper
+
+var util = lang.getObject("dojo.store.util", true);
+
+util.QueryResults = function(results){
+	// summary:
+	//		A function that wraps the results of a store query with additional
+	//		methods.
+	//
+	// description:
+	//		QueryResults is a basic wrapper that allows for array-like iteration
+	//		over any kind of returned data from a query.  While the simplest store
+	//		will return a plain array of data, other stores may return deferreds or
+	//		promises; this wrapper makes sure that *all* results can be treated
+	//		the same.
+	//
+	//		Additional methods include `forEach`, `filter` and `map`.
+	//
+	// returns: Object
+	//		An array-like object that can be used for iterating over.
+	//
+	// example:
+	//		Query a store and iterate over the results.
+	//
+	//	|	store.query({ prime: true }).forEach(function(item){
+	//	|		//	do something
+	//	|	});
+
+	if(!results){
+		return results;
+	}
+	// if it is a promise it may be frozen
+	if(results.then){
+		results = lang.delegate(results);
+	}
+	function addIterativeMethod(method){
+		if(!results[method]){
+			results[method] = function(){
+				var args = arguments;
+				return Deferred.when(results, function(results){
+					Array.prototype.unshift.call(args, results);
+					return util.QueryResults(array[method].apply(array, args));
+				});
+			};
+		}
+	}
+	addIterativeMethod("forEach");
+	addIterativeMethod("filter");
+	addIterativeMethod("map");
+	if(!results.total){
+		results.total = Deferred.when(results, function(results){
+			return results.length;
+		});
+	}
+	return results;
+};
+
+return util.QueryResults;
+});
diff --git a/js/dojo-1.7.2/dojo/store/util/SimpleQueryEngine.js b/js/dojo-1.7.2/dojo/store/util/SimpleQueryEngine.js
new file mode 100644
index 0000000..0cadc61
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/store/util/SimpleQueryEngine.js
@@ -0,0 +1,109 @@
+//>>built
+define("dojo/store/util/SimpleQueryEngine", ["../../_base/array"], function(arrayUtil) {
+  //  module:
+  //    dojo/store/util/SimpleQueryEngine
+  //  summary:
+  //    The module defines a simple filtering query engine for object stores. 
+
+return function(query, options){
+	// summary:
+	//		Simple query engine that matches using filter functions, named filter
+	//		functions or objects by name-value on a query object hash
+	//
+	// description:
+	//		The SimpleQueryEngine provides a way of getting a QueryResults through
+	//		the use of a simple object hash as a filter.  The hash will be used to
+	//		match properties on data objects with the corresponding value given. In
+	//		other words, only exact matches will be returned.
+	//
+	//		This function can be used as a template for more complex query engines;
+	//		for example, an engine can be created that accepts an object hash that
+	//		contains filtering functions, or a string that gets evaluated, etc.
+	//
+	//		When creating a new dojo.store, simply set the store's queryEngine
+	//		field as a reference to this function.
+	//
+	// query: Object
+	//		An object hash with fields that may match fields of items in the store.
+	//		Values in the hash will be compared by normal == operator, but regular expressions
+	//		or any object that provides a test() method are also supported and can be
+	// 		used to match strings by more complex expressions
+	// 		(and then the regex's or object's test() method will be used to match values).
+	//
+	// options: dojo.store.util.SimpleQueryEngine.__queryOptions?
+	//		An object that contains optional information such as sort, start, and count.
+	//
+	// returns: Function
+	//		A function that caches the passed query under the field "matches".  See any
+	//		of the "query" methods on dojo.stores.
+	//
+	// example:
+	//		Define a store with a reference to this engine, and set up a query method.
+	//
+	//	|	var myStore = function(options){
+	//	|		//	...more properties here
+	//	|		this.queryEngine = dojo.store.util.SimpleQueryEngine;
+	//	|		//	define our query method
+	//	|		this.query = function(query, options){
+	//	|			return dojo.store.util.QueryResults(this.queryEngine(query, options)(this.data));
+	//	|		};
+	//	|	};
+
+	// create our matching query function
+	switch(typeof query){
+		default:
+			throw new Error("Can not query with a " + typeof query);
+		case "object": case "undefined":
+			var queryObject = query;
+			query = function(object){
+				for(var key in queryObject){
+					var required = queryObject[key];
+					if(required && required.test){
+						if(!required.test(object[key])){
+							return false;
+						}
+					}else if(required != object[key]){
+						return false;
+					}
+				}
+				return true;
+			};
+			break;
+		case "string":
+			// named query
+			if(!this[query]){
+				throw new Error("No filter function " + query + " was found in store");
+			}
+			query = this[query];
+			// fall through
+		case "function":
+			// fall through
+	}
+	function execute(array){
+		// execute the whole query, first we filter
+		var results = arrayUtil.filter(array, query);
+		// next we sort
+		if(options && options.sort){
+			results.sort(function(a, b){
+				for(var sort, i=0; sort = options.sort[i]; i++){
+					var aValue = a[sort.attribute];
+					var bValue = b[sort.attribute];
+					if (aValue != bValue) {
+						return !!sort.descending == aValue > bValue ? -1 : 1;
+					}
+				}
+				return 0;
+			});
+		}
+		// now we paginate
+		if(options && (options.start || options.count)){
+			var total = results.length;
+			results = results.slice(options.start || 0, (options.start || 0) + (options.count || Infinity));
+			results.total = total;
+		}
+		return results;
+	}
+	execute.matches = query;
+	return execute;
+};
+});
diff --git a/js/dojo-1.7.2/dojo/string.js b/js/dojo-1.7.2/dojo/string.js
new file mode 100644
index 0000000..a66e152
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/string.js
@@ -0,0 +1,163 @@
+//>>built
+define("dojo/string", ["./_base/kernel", "./_base/lang"], function(dojo, lang) {
+	// module:
+	//		dojo/string
+	// summary:
+	//		TODOC
+
+lang.getObject("string", true, dojo);
+
+/*=====
+dojo.string = {
+	// summary: String utilities for Dojo
+};
+=====*/
+
+dojo.string.rep = function(/*String*/str, /*Integer*/num){
+	// summary:
+	//		Efficiently replicate a string `n` times.
+	// str:
+	//		the string to replicate
+	// num:
+	//		number of times to replicate the string
+
+	if(num <= 0 || !str){ return ""; }
+
+	var buf = [];
+	for(;;){
+		if(num & 1){
+			buf.push(str);
+		}
+		if(!(num >>= 1)){ break; }
+		str += str;
+	}
+	return buf.join("");	// String
+};
+
+dojo.string.pad = function(/*String*/text, /*Integer*/size, /*String?*/ch, /*Boolean?*/end){
+	// summary:
+	//		Pad a string to guarantee that it is at least `size` length by
+	//		filling with the character `ch` at either the start or end of the
+	//		string. Pads at the start, by default.
+	// text:
+	//		the string to pad
+	// size:
+	//		length to provide padding
+	// ch:
+	//		character to pad, defaults to '0'
+	// end:
+	//		adds padding at the end if true, otherwise pads at start
+	// example:
+	//	|	// Fill the string to length 10 with "+" characters on the right.  Yields "Dojo++++++".
+	//	|	dojo.string.pad("Dojo", 10, "+", true);
+
+	if(!ch){
+		ch = '0';
+	}
+	var out = String(text),
+		pad = dojo.string.rep(ch, Math.ceil((size - out.length) / ch.length));
+	return end ? out + pad : pad + out;	// String
+};
+
+dojo.string.substitute = function(	/*String*/		template,
+									/*Object|Array*/map,
+									/*Function?*/	transform,
+									/*Object?*/		thisObject){
+	// summary:
+	//		Performs parameterized substitutions on a string. Throws an
+	//		exception if any parameter is unmatched.
+	// template:
+	//		a string with expressions in the form `${key}` to be replaced or
+	//		`${key:format}` which specifies a format function. keys are case-sensitive.
+	// map:
+	//		hash to search for substitutions
+	// transform:
+	//		a function to process all parameters before substitution takes
+	//		place, e.g. mylib.encodeXML
+	// thisObject:
+	//		where to look for optional format function; default to the global
+	//		namespace
+	// example:
+	//		Substitutes two expressions in a string from an Array or Object
+	//	|	// returns "File 'foo.html' is not found in directory '/temp'."
+	//	|	// by providing substitution data in an Array
+	//	|	dojo.string.substitute(
+	//	|		"File '${0}' is not found in directory '${1}'.",
+	//	|		["foo.html","/temp"]
+	//	|	);
+	//	|
+	//	|	// also returns "File 'foo.html' is not found in directory '/temp'."
+	//	|	// but provides substitution data in an Object structure.  Dotted
+	//	|	// notation may be used to traverse the structure.
+	//	|	dojo.string.substitute(
+	//	|		"File '${name}' is not found in directory '${info.dir}'.",
+	//	|		{ name: "foo.html", info: { dir: "/temp" } }
+	//	|	);
+	// example:
+	//		Use a transform function to modify the values:
+	//	|	// returns "file 'foo.html' is not found in directory '/temp'."
+	//	|	dojo.string.substitute(
+	//	|		"${0} is not found in ${1}.",
+	//	|		["foo.html","/temp"],
+	//	|		function(str){
+	//	|			// try to figure out the type
+	//	|			var prefix = (str.charAt(0) == "/") ? "directory": "file";
+	//	|			return prefix + " '" + str + "'";
+	//	|		}
+	//	|	);
+	// example:
+	//		Use a formatter
+	//	|	// returns "thinger -- howdy"
+	//	|	dojo.string.substitute(
+	//	|		"${0:postfix}", ["thinger"], null, {
+	//	|			postfix: function(value, key){
+	//	|				return value + " -- howdy";
+	//	|			}
+	//	|		}
+	//	|	);
+
+	thisObject = thisObject || dojo.global;
+	transform = transform ?
+		lang.hitch(thisObject, transform) : function(v){ return v; };
+
+	return template.replace(/\$\{([^\s\:\}]+)(?:\:([^\s\:\}]+))?\}/g,
+		function(match, key, format){
+			var value = lang.getObject(key, false, map);
+			if(format){
+				value = lang.getObject(format, false, thisObject).call(thisObject, value, key);
+			}
+			return transform(value, key).toString();
+		}); // String
+};
+
+/*=====
+dojo.string.trim = function(str){
+	// summary:
+	//		Trims whitespace from both sides of the string
+	// str: String
+	//		String to be trimmed
+	// returns: String
+	//		Returns the trimmed string
+	// description:
+	//		This version of trim() was taken from [Steven Levithan's blog](http://blog.stevenlevithan.com/archives/faster-trim-javascript).
+	//		The short yet performant version of this function is dojo.trim(),
+	//		which is part of Dojo base.  Uses String.prototype.trim instead, if available.
+	return "";	// String
+}
+=====*/
+
+dojo.string.trim = String.prototype.trim ?
+	lang.trim : // aliasing to the native function
+	function(str){
+		str = str.replace(/^\s+/, '');
+		for(var i = str.length - 1; i >= 0; i--){
+			if(/\S/.test(str.charAt(i))){
+				str = str.substring(0, i + 1);
+				break;
+			}
+		}
+		return str;
+	};
+
+return dojo.string;
+});
diff --git a/js/dojo-1.7.2/dojo/text.js b/js/dojo-1.7.2/dojo/text.js
new file mode 100644
index 0000000..b805cea
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/text.js
@@ -0,0 +1,213 @@
+//>>built
+define("dojo/text", ["./_base/kernel", "require", "./has", "./_base/xhr"], function(dojo, require, has, xhr){
+	// module:
+	//		dojo/text
+	// summary:
+	//		This module implements the !dojo/text plugin and the dojo.cache API.
+	// description:
+	//		We choose to include our own plugin to leverage functionality already contained in dojo
+	//		and thereby reduce the size of the plugin compared to various foreign loader implementations.
+	//		Also, this allows foreign AMD loaders to be used without their plugins.
+	//
+	//		CAUTION: this module is designed to optionally function synchronously to support the dojo v1.x synchronous
+	//		loader. This feature is outside the scope of the CommonJS plugins specification.
+
+	var getText;
+	if(1){
+		getText= function(url, sync, load){
+			xhr("GET", {url:url, sync:!!sync, load:load});
+		};
+	}else{
+		// TODOC: only works for dojo AMD loader
+		if(require.getText){
+			getText= require.getText;
+		}else{
+			console.error("dojo/text plugin failed to load because loader does not support getText");
+		}
+	}
+
+	var
+		theCache= {},
+
+		strip= function(text){
+			//Strips <?xml ...?> declarations so that external SVG and XML
+			//documents can be added to a document without worry. Also, if the string
+			//is an HTML document, only the part inside the body tag is returned.
+			if(text){
+				text= text.replace(/^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, "");
+				var matches= text.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+				if(matches){
+					text= matches[1];
+				}
+			}else{
+				text = "";
+			}
+			return text;
+		},
+
+		notFound = {},
+
+		pending = {},
+
+		result= {
+			dynamic:
+				// the dojo/text caches it's own resources because of dojo.cache
+				true,
+
+			normalize:function(id, toAbsMid){
+				// id is something like (path may be relative):
+				//
+				//	 "path/to/text.html"
+				//	 "path/to/text.html!strip"
+				var parts= id.split("!"),
+					url= parts[0];
+				return (/^\./.test(url) ? toAbsMid(url) : url) + (parts[1] ? "!" + parts[1] : "");
+			},
+
+			load:function(id, require, load){
+				// id is something like (path is always absolute):
+				//
+				//	 "path/to/text.html"
+				//	 "path/to/text.html!strip"
+				var
+					parts= id.split("!"),
+					stripFlag= parts.length>1,
+					absMid= parts[0],
+					url = require.toUrl(parts[0]),
+					text = notFound,
+					finish = function(text){
+						load(stripFlag ? strip(text) : text);
+					};
+				if(absMid in theCache){
+					text = theCache[absMid];
+				}else if(url in require.cache){
+					text = require.cache[url];
+				}else if(url in theCache){
+					text = theCache[url];
+				}
+				if(text===notFound){
+					if(pending[url]){
+						pending[url].push(finish);
+					}else{
+						var pendingList = pending[url] = [finish];
+						getText(url, !require.async, function(text){
+							theCache[absMid]= theCache[url]= text;
+							for(var i = 0; i<pendingList.length;){
+								pendingList[i++](text);
+							}
+							delete pending[url];
+						});
+					}
+				}else{
+					finish(text);
+				}
+			}
+		};
+
+	dojo.cache= function(/*String||Object*/module, /*String*/url, /*String||Object?*/value){
+		//	 * (string string [value]) => (module, url, value)
+		//	 * (object [value])        => (module, value), url defaults to ""
+		//
+		//	 * if module is an object, then it must be convertable to a string
+		//	 * (module, url) module + (url ? ("/" + url) : "") must be a legal argument to require.toUrl
+		//	 * value may be a string or an object; if an object then may have the properties "value" and/or "sanitize"
+		var key;
+		if(typeof module=="string"){
+			if(/\//.test(module)){
+				// module is a version 1.7+ resolved path
+				key = module;
+				value = url;
+			}else{
+				// module is a version 1.6- argument to dojo.moduleUrl
+				key = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : ""));
+			}
+		}else{
+			key = module + "";
+			value = url;
+		}
+		var
+			val = (value != undefined && typeof value != "string") ? value.value : value,
+			sanitize = value && value.sanitize;
+
+		if(typeof val == "string"){
+			//We have a string, set cache value
+			theCache[key] = val;
+			return sanitize ? strip(val) : val;
+		}else if(val === null){
+			//Remove cached value
+			delete theCache[key];
+			return null;
+		}else{
+			//Allow cache values to be empty strings. If key property does
+			//not exist, fetch it.
+			if(!(key in theCache)){
+				getText(key, true, function(text){
+					theCache[key]= text;
+				});
+			}
+			return sanitize ? strip(theCache[key]) : theCache[key];
+		}
+	};
+
+	return result;
+
+/*=====
+dojo.cache = function(module, url, value){
+	// summary:
+	//		A getter and setter for storing the string content associated with the
+	//		module and url arguments.
+	// description:
+	//		If module is a string that contains slashes, then it is interpretted as a fully
+	//		resolved path (typically a result returned by require.toUrl), and url should not be
+	//		provided. This is the preferred signature. If module is a string that does not
+	//		contain slashes, then url must also be provided and module and url are used to
+	//		call `dojo.moduleUrl()` to generate a module URL. This signature is deprecated.
+	//		If value is specified, the cache value for the moduleUrl will be set to
+	//		that value. Otherwise, dojo.cache will fetch the moduleUrl and store it
+	//		in its internal cache and return that cached value for the URL. To clear
+	//		a cache value pass null for value. Since XMLHttpRequest (XHR) is used to fetch the
+	//		the URL contents, only modules on the same domain of the page can use this capability.
+	//		The build system can inline the cache values though, to allow for xdomain hosting.
+	// module: String||Object
+	//		If a String with slashes, a fully resolved path; if a String without slashes, the
+	//		module name to use for the base part of the URL, similar to module argument
+	//		to `dojo.moduleUrl`. If an Object, something that has a .toString() method that
+	//		generates a valid path for the cache item. For example, a dojo._Url object.
+	// url: String
+	//		The rest of the path to append to the path derived from the module argument. If
+	//		module is an object, then this second argument should be the "value" argument instead.
+	// value: String||Object?
+	//		If a String, the value to use in the cache for the module/url combination.
+	//		If an Object, it can have two properties: value and sanitize. The value property
+	//		should be the value to use in the cache, and sanitize can be set to true or false,
+	//		to indicate if XML declarations should be removed from the value and if the HTML
+	//		inside a body tag in the value should be extracted as the real value. The value argument
+	//		or the value property on the value argument are usually only used by the build system
+	//		as it inlines cache content.
+	//	example:
+	//		To ask dojo.cache to fetch content and store it in the cache (the dojo["cache"] style
+	//		of call is used to avoid an issue with the build system erroneously trying to intern
+	//		this example. To get the build system to intern your dojo.cache calls, use the
+	//		"dojo.cache" style of call):
+	//		| //If template.html contains "<h1>Hello</h1>" that will be
+	//		| //the value for the text variable.
+	//		| var text = dojo["cache"]("my.module", "template.html");
+	//	example:
+	//		To ask dojo.cache to fetch content and store it in the cache, and sanitize the input
+	//		 (the dojo["cache"] style of call is used to avoid an issue with the build system
+	//		erroneously trying to intern this example. To get the build system to intern your
+	//		dojo.cache calls, use the "dojo.cache" style of call):
+	//		| //If template.html contains "<html><body><h1>Hello</h1></body></html>", the
+	//		| //text variable will contain just "<h1>Hello</h1>".
+	//		| var text = dojo["cache"]("my.module", "template.html", {sanitize: true});
+	//	example:
+	//		Same example as previous, but demostrates how an object can be passed in as
+	//		the first argument, then the value argument can then be the second argument.
+	//		| //If template.html contains "<html><body><h1>Hello</h1></body></html>", the
+	//		| //text variable will contain just "<h1>Hello</h1>".
+	//		| var text = dojo["cache"](new dojo._Url("my/module/template.html"), {sanitize: true});
+	return val; //String
+};
+=====*/
+});
+
diff --git a/js/dojo-1.7.2/dojo/topic.js b/js/dojo-1.7.2/dojo/topic.js
new file mode 100644
index 0000000..7b1f529
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/topic.js
@@ -0,0 +1,34 @@
+//>>built
+define("dojo/topic", ["./Evented"], function(Evented){
+	// summary:
+	//		The export of this module is a pubsub hub
+	//		You can also use listen function itself as a pub/sub hub:
+	//		| 	topic.subscribe("some/topic", function(event){
+	//		|	... do something with event
+	//		|	});
+	//		|	topic.publish("some/topic", {name:"some event", ...});
+
+	var hub = new Evented;
+	return {
+		publish: function(topic, event){
+			// summary:
+			//		Publishes a message to a topic on the pub/sub hub. All arguments after
+			// 		the first will be passed to the subscribers, so any number of arguments
+			// 		can be provided (not just event).
+			// topic: String
+			//		The name of the topic to publish to
+			// event: Object
+			//		An event to distribute to the topic listeners
+			return hub.emit.apply(hub, arguments);
+		},
+		subscribe: function(topic, listener){
+			// summary:
+			//		Subcribes to a topic on the pub/sub hub
+			// topic: String
+			//		The topic to subscribe to
+			//	listener: Function
+			//		A function to call when a message is published to the given topic
+			return hub.on.apply(hub, arguments);
+		}
+	}
+});
diff --git a/js/dojo-1.7.2/dojo/touch.js b/js/dojo-1.7.2/dojo/touch.js
new file mode 100644
index 0000000..c86b749
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/touch.js
@@ -0,0 +1,90 @@
+//>>built
+define("dojo/touch", ["./_base/kernel", "./on", "./has", "./mouse"], function(dojo, on, has, mouse){
+// module:
+//		dojo/touch
+
+/*=====
+	dojo.touch = {
+		// summary:
+		//		This module provides unified touch event handlers by exporting
+		//		press, move, release and cancel which can also run well on desktop.
+		//		Based on http://dvcs.w3.org/hg/webevents/raw-file/tip/touchevents.html
+		//
+		// example:
+		//		1. Used with dojo.connect()
+		//		|	dojo.connect(node, dojo.touch.press, function(e){});
+		//		|	dojo.connect(node, dojo.touch.move, function(e){});
+		//		|	dojo.connect(node, dojo.touch.release, function(e){});
+		//		|	dojo.connect(node, dojo.touch.cancel, function(e){});
+		//
+		//		2. Used with dojo.on
+		//		|	define(["dojo/on", "dojo/touch"], function(on, touch){
+		//		|		on(node, touch.press, function(e){});
+		//		|		on(node, touch.move, function(e){});
+		//		|		on(node, touch.release, function(e){});
+		//		|		on(node, touch.cancel, function(e){});
+		//
+		//		3. Used with dojo.touch.* directly
+		//		|	dojo.touch.press(node, function(e){});
+		//		|	dojo.touch.move(node, function(e){});
+		//		|	dojo.touch.release(node, function(e){});
+		//		|	dojo.touch.cancel(node, function(e){});
+		
+		press: function(node, listener){
+			// summary:
+			//		Register a listener to 'touchstart'|'mousedown' for the given node
+			// node: Dom
+			//		Target node to listen to
+			// listener: Function
+			//		Callback function
+			// returns:
+			//		A handle which will be used to remove the listener by handle.remove()
+		},
+		move: function(node, listener){
+			// summary:
+			//		Register a listener to 'touchmove'|'mousemove' for the given node
+			// node: Dom
+			//		Target node to listen to
+			// listener: Function
+			//		Callback function
+			// returns:
+			//		A handle which will be used to remove the listener by handle.remove()
+		},
+		release: function(node, listener){
+			// summary:
+			//		Register a listener to 'touchend'|'mouseup' for the given node
+			// node: Dom
+			//		Target node to listen to
+			// listener: Function
+			//		Callback function
+			// returns:
+			//		A handle which will be used to remove the listener by handle.remove()
+		},
+		cancel: function(node, listener){
+			// summary:
+			//		Register a listener to 'touchcancel'|'mouseleave' for the given node
+			// node: Dom
+			//		Target node to listen to
+			// listener: Function
+			//		Callback function
+			// returns:
+			//		A handle which will be used to remove the listener by handle.remove()
+		}
+	};
+=====*/
+
+	function _handle(/*String - press | move | release | cancel*/type){
+		return function(node, listener){//called by on(), see dojo.on
+			return on(node, type, listener);
+		};
+	}
+	var touch = has("touch");
+	//device neutral events - dojo.touch.press|move|release|cancel
+	dojo.touch = {
+		press: _handle(touch ? "touchstart": "mousedown"),
+		move: _handle(touch ? "touchmove": "mousemove"),
+		release: _handle(touch ? "touchend": "mouseup"),
+		cancel: touch ? _handle("touchcancel") : mouse.leave
+	};
+	return dojo.touch;
+});
\ No newline at end of file
diff --git a/js/dojo-1.7.2/dojo/uacss.js b/js/dojo-1.7.2/dojo/uacss.js
new file mode 100644
index 0000000..663f8fa
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/uacss.js
@@ -0,0 +1,67 @@
+//>>built
+define("dojo/uacss", ["./dom-geometry", "./_base/lang", "./ready", "./_base/sniff", "./_base/window"],
+	function(geometry, lang, ready, has, baseWindow){
+	// module:
+	//		dojo/uacss
+	// summary:
+	//		Applies pre-set CSS classes to the top-level HTML node, based on:
+	//			- browser (ex: dj_ie)
+	//			- browser version (ex: dj_ie6)
+	//			- box model (ex: dj_contentBox)
+	//			- text direction (ex: dijitRtl)
+	//
+	//		In addition, browser, browser version, and box model are
+	//		combined with an RTL flag when browser text is RTL. ex: dj_ie-rtl.
+
+	var
+		html = baseWindow.doc.documentElement,
+		ie = has("ie"),
+		opera = has("opera"),
+		maj = Math.floor,
+		ff = has("ff"),
+		boxModel = geometry.boxModel.replace(/-/,''),
+
+		classes = {
+			"dj_ie": ie,
+			"dj_ie6": maj(ie) == 6,
+			"dj_ie7": maj(ie) == 7,
+			"dj_ie8": maj(ie) == 8,
+			"dj_ie9": maj(ie) == 9,
+			"dj_quirks": has("quirks"),
+			"dj_iequirks": ie && has("quirks"),
+
+			// NOTE: Opera not supported by dijit
+			"dj_opera": opera,
+
+			"dj_khtml": has("khtml"),
+
+			"dj_webkit": has("webkit"),
+			"dj_safari": has("safari"),
+			"dj_chrome": has("chrome"),
+
+			"dj_gecko": has("mozilla"),
+			"dj_ff3": maj(ff) == 3
+		}; // no dojo unsupported browsers
+
+	classes["dj_" + boxModel] = true;
+
+	// apply browser, browser version, and box model class names
+	var classStr = "";
+	for(var clz in classes){
+		if(classes[clz]){
+			classStr += clz + " ";
+		}
+	}
+	html.className = lang.trim(html.className + " " + classStr);
+
+	// If RTL mode, then add dj_rtl flag plus repeat existing classes with -rtl extension.
+	// We can't run the code below until the <body> tag has loaded (so we can check for dir=rtl).
+	// priority is 90 to run ahead of parser priority of 100
+	ready(90, function(){
+		if(!geometry.isBodyLtr()){
+			var rtlClassStr = "dj_rtl dijitRtl " + classStr.replace(/ /g, "-rtl ");
+			html.className = lang.trim(html.className + " " + rtlClassStr + "dj_rtl dijitRtl " + classStr.replace(/ /g, "-rtl "));
+		}
+	});
+	return has;
+});
diff --git a/js/dojo-1.7.2/dojo/window.js b/js/dojo-1.7.2/dojo/window.js
new file mode 100644
index 0000000..ac3a254
--- /dev/null
+++ b/js/dojo-1.7.2/dojo/window.js
@@ -0,0 +1,170 @@
+//>>built
+define("dojo/window", ["./_base/lang", "./_base/sniff", "./_base/window", "./dom", "./dom-geometry", "./dom-style"],
+	function(lang, has, baseWindow, dom, geom, style) {
+
+// module:
+//		dojo/window
+// summary:
+//		TODOC
+
+var window = lang.getObject("dojo.window", true);
+
+/*=====
+dojo.window = {
+	// summary:
+	//		TODO
+};
+window = dojo.window;
+=====*/
+
+window.getBox = function(){
+	// summary:
+	//		Returns the dimensions and scroll position of the viewable area of a browser window
+
+	var
+		scrollRoot = (baseWindow.doc.compatMode == 'BackCompat') ? baseWindow.body() : baseWindow.doc.documentElement,
+		// get scroll position
+		scroll = geom.docScroll(), // scrollRoot.scrollTop/Left should work
+		w, h;
+
+	if(has("touch")){ // if(scrollbars not supported)
+		var uiWindow = baseWindow.doc.parentWindow || baseWindow.doc.defaultView;   // use UI window, not dojo.global window. baseWindow.doc.parentWindow probably not needed since it's not defined for webkit
+		// on mobile, scrollRoot.clientHeight <= uiWindow.innerHeight <= scrollRoot.offsetHeight, return uiWindow.innerHeight
+		w = uiWindow.innerWidth || scrollRoot.clientWidth; // || scrollRoot.clientXXX probably never evaluated
+		h = uiWindow.innerHeight || scrollRoot.clientHeight;
+	}else{
+		// on desktops, scrollRoot.clientHeight <= scrollRoot.offsetHeight <= uiWindow.innerHeight, return scrollRoot.clientHeight
+		// uiWindow.innerWidth/Height includes the scrollbar and cannot be used
+		w = scrollRoot.clientWidth;
+		h = scrollRoot.clientHeight;
+	}
+	return {
+		l: scroll.x,
+		t: scroll.y,
+		w: w,
+		h: h
+	};
+};
+
+window.get = function(doc){
+	// summary:
+	// 		Get window object associated with document doc
+
+	// In some IE versions (at least 6.0), document.parentWindow does not return a
+	// reference to the real window object (maybe a copy), so we must fix it as well
+	// We use IE specific execScript to attach the real window reference to
+	// document._parentWindow for later use
+	if(has("ie") && window !== document.parentWindow){
+		/*
+		In IE 6, only the variable "window" can be used to connect events (others
+		may be only copies).
+		*/
+		doc.parentWindow.execScript("document._parentWindow = window;", "Javascript");
+		//to prevent memory leak, unset it after use
+		//another possibility is to add an onUnload handler which seems overkill to me (liucougar)
+		var win = doc._parentWindow;
+		doc._parentWindow = null;
+		return win;	//	Window
+	}
+
+	return doc.parentWindow || doc.defaultView;	//	Window
+};
+
+window.scrollIntoView = function(/*DomNode*/ node, /*Object?*/ pos){
+	// summary:
+	//		Scroll the passed node into view, if it is not already.
+
+	// don't rely on node.scrollIntoView working just because the function is there
+
+	try{ // catch unexpected/unrecreatable errors (#7808) since we can recover using a semi-acceptable native method
+		node = dom.byId(node);
+		var doc = node.ownerDocument || baseWindow.doc,
+			body = doc.body || baseWindow.body(),
+			html = doc.documentElement || body.parentNode,
+			isIE = has("ie"), isWK = has("webkit");
+		// if an untested browser, then use the native method
+		if((!(has("mozilla") || isIE || isWK || has("opera")) || node == body || node == html) && (typeof node.scrollIntoView != "undefined")){
+			node.scrollIntoView(false); // short-circuit to native if possible
+			return;
+		}
+		var backCompat = doc.compatMode == 'BackCompat',
+			clientAreaRoot = (isIE >= 9 && node.ownerDocument.parentWindow.frameElement)
+				? ((html.clientHeight > 0 && html.clientWidth > 0 && (body.clientHeight == 0 || body.clientWidth == 0 || body.clientHeight > html.clientHeight || body.clientWidth > html.clientWidth)) ? html : body)
+				: (backCompat ? body : html),
+			scrollRoot = isWK ? body : clientAreaRoot,
+			rootWidth = clientAreaRoot.clientWidth,
+			rootHeight = clientAreaRoot.clientHeight,
+			rtl = !geom.isBodyLtr(),
+			nodePos = pos || geom.position(node),
+			el = node.parentNode,
+			isFixed = function(el){
+				return ((isIE <= 6 || (isIE && backCompat))? false : (style.get(el, 'position').toLowerCase() == "fixed"));
+			};
+		if(isFixed(node)){ return; } // nothing to do
+
+		while(el){
+			if(el == body){ el = scrollRoot; }
+			var elPos = geom.position(el),
+				fixedPos = isFixed(el);
+
+			if(el == scrollRoot){
+				elPos.w = rootWidth; elPos.h = rootHeight;
+				if(scrollRoot == html && isIE && rtl){ elPos.x += scrollRoot.offsetWidth-elPos.w; } // IE workaround where scrollbar causes negative x
+				if(elPos.x < 0 || !isIE){ elPos.x = 0; } // IE can have values > 0
+				if(elPos.y < 0 || !isIE){ elPos.y = 0; }
+			}else{
+				var pb = geom.getPadBorderExtents(el);
+				elPos.w -= pb.w; elPos.h -= pb.h; elPos.x += pb.l; elPos.y += pb.t;
+				var clientSize = el.clientWidth,
+					scrollBarSize = elPos.w - clientSize;
+				if(clientSize > 0 && scrollBarSize > 0){
+					elPos.w = clientSize;
+					elPos.x += (rtl && (isIE || el.clientLeft > pb.l/*Chrome*/)) ? scrollBarSize : 0;
+				}
+				clientSize = el.clientHeight;
+				scrollBarSize = elPos.h - clientSize;
+				if(clientSize > 0 && scrollBarSize > 0){
+					elPos.h = clientSize;
+				}
+			}
+			if(fixedPos){ // bounded by viewport, not parents
+				if(elPos.y < 0){
+					elPos.h += elPos.y; elPos.y = 0;
+				}
+				if(elPos.x < 0){
+					elPos.w += elPos.x; elPos.x = 0;
+				}
+				if(elPos.y + elPos.h > rootHeight){
+					elPos.h = rootHeight - elPos.y;
+				}
+				if(elPos.x + elPos.w > rootWidth){
+					elPos.w = rootWidth - elPos.x;
+				}
+			}
+			// calculate overflow in all 4 directions
+			var l = nodePos.x - elPos.x, // beyond left: < 0
+				t = nodePos.y - Math.max(elPos.y, 0), // beyond top: < 0
+				r = l + nodePos.w - elPos.w, // beyond right: > 0
+				bot = t + nodePos.h - elPos.h; // beyond bottom: > 0
+			if(r * l > 0){
+				var s = Math[l < 0? "max" : "min"](l, r);
+				if(rtl && ((isIE == 8 && !backCompat) || isIE >= 9)){ s = -s; }
+				nodePos.x += el.scrollLeft;
+				el.scrollLeft += s;
+				nodePos.x -= el.scrollLeft;
+			}
+			if(bot * t > 0){
+				nodePos.y += el.scrollTop;
+				el.scrollTop += Math[t < 0? "max" : "min"](t, bot);
+				nodePos.y -= el.scrollTop;
+			}
+			el = (el != scrollRoot) && !fixedPos && el.parentNode;
+		}
+	}catch(error){
+		console.error('scrollIntoView: ' + error);
+		node.scrollIntoView(false);
+	}
+};
+
+return window;
+});