initial commit

+{
+  "name": "docker-panel-demo",
+  "description": "Dynamic docking panels",
+  "version": "0.0.1",
+  "keywords": [
+    "css",
+    "js",
+    "front-end",
+    "framework",
+    "web",
+    "dynamic"
+  ],
+  "homepage": "http://docker.webcabin.org/",
+  "main": [
+    "Build",
+    "Build/Themes"
+  ],
+  "ignore": [
+    "/.*",
+    "index.html",
+    "Code",
+    "Compiler",
+    "images",
+    "Themes",
+    "package.json"
+  ],
+  "dependencies": {
+    "jquery": "1.11.1",
+    "jQuery-contextMenu": "1.6.6",
+    "font-awesome": "4.6.0"
+  },
+  "devDependencies": {
+    "dcl": "1.1.2",
+    "requirejs": "2.1.x",
+    "requirejs-domready": "2.0.x",
+    "almond": "0.3.1",
+    "lodash-compat": "3.10.1-amd",
+    "dojo": "1.9.1"
+  },
+  "license": "MIT"
+}

+{
+  "name": "almond",
+  "version": "0.3.1",
+  "main": "almond.js",
+  "ignore": [
+    "tests",
+    "shrinktest.sh"
+  ],
+  "homepage": "https://github.com/jrburke/almond",
+  "_release": "0.3.1",
+  "_resolution": {
+    "type": "version",
+    "tag": "0.3.1",
+    "commit": "8336992b1a3fee8d10310822d4222fb82d24f097"
+  },
+  "_source": "https://github.com/jrburke/almond.git",
+  "_target": "0.3.1",
+  "_originalSource": "almond"
+}
\ No newline at end of file

+.DS_Store

+tests
+*.sh

+language: node_js
+node_js:  0.10
+
+before_script:
+  - node tests/server.js &
+  - sleep 1
+
+script: phantomjs tests/runner.js
+
+after_script:
+  - kill -9 `cat tests/pid.txt`
+  - rm tests/pid.txt

+almond is released under two licenses: new BSD, and MIT. You may pick the
+license that best suits your development needs. The text of both licenses are
+provided below.
+
+
+The "New" BSD License:
+----------------------
+
+Copyright (c) 2010-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.
+
+
+
+MIT License
+-----------
+
+Copyright (c) 2010-2011, The Dojo Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS 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. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

+#almond
+
+A replacement [AMD](https://github.com/amdjs/amdjs-api/wiki/AMD) loader for
+[RequireJS](http://requirejs.org). It provides a minimal AMD API footprint that includes [loader plugin](http://requirejs.org/docs/plugins.html) support. Only useful for built/bundled AMD modules, does not do dynamic loading.
+
+## Why
+
+Some developers like to use the AMD API to code modular JavaScript, but after doing an optimized build,
+they do not want to include a full AMD loader like RequireJS, since they do not need all that functionality.
+Some use cases, like mobile, are very sensitive to file sizes.
+
+By including almond in the built file, there is no need for RequireJS.
+almond is around **1 kilobyte** when minified with Closure Compiler and gzipped.
+
+Since it can support certain types of loader plugin-optimized resources, it is a great
+fit for a library that wants to use [text templates](http://requirejs.org/docs/api.html#text)
+or [CoffeeScript](https://github.com/jrburke/require-cs) as part of
+their project, but get a tiny download in one file after using the
+[RequireJS Optimizer](http://requirejs.org/docs/optimization.html).
+
+If you are building a library, the wrap=true support in the RequireJS optimizer
+will wrap the optimized file in a closure, so the define/require AMD API does not
+escape the file. Users of your optimized file will only see the global API you decide
+to export, not the AMD API. See the usage section below for more details.
+
+So, you get great code cleanliness with AMD and the use of powerful loader plugins
+in a tiny wrapper that makes it easy for others to use your code even if they do not use AMD.
+
+If you want a single file build output but without the module APIs included, you might want to consider [AMDclean](https://github.com/gfranko/amdclean).
+
+## Restrictions
+
+It is best used for libraries or apps that use AMD and:
+
+* optimize all the modules into one file -- no dynamic code loading.
+* all modules have IDs and dependency arrays in their define() calls -- the RequireJS optimizer will take care of this for you.
+* only have **one** requirejs.config() or require.config() call.
+* the requirejs.config/require.config call needs to be included in the build output. This is particularly important for making sure any [map config](http://requirejs.org/docs/api.html#config-map) use still works.
+* do not use the `var require = {};` style of [passing config](http://requirejs.org/docs/api.html#config).
+* do not use [RequireJS multiversion support/contexts](http://requirejs.org/docs/api.html#multiversion).
+* do not use require.toUrl() or require.nameToUrl().
+* do not use [packages/packagePaths config](http://requirejs.org/docs/api.html#packages). If you need to use packages that have a main property, [volo](https://github.com/volojs/volo) can create an adapter module so that it can work without this config. Use the `amdify add` command to add the dependency to your project.
+
+What is supported:
+
+* dependencies with relative IDs.
+* define('id', {}) definitions.
+* define(), require() and requirejs() calls.
+* loader plugins that can inline their resources into optimized files, and
+can access those inlined resources synchronously after the optimization pass.
+The [text](http://requirejs.org/docs/api.html#text) and
+[CoffeeScript](https://github.com/jrburke/require-cs) plugins are two such plugins.
+
+## Download
+
+[Latest release](https://github.com/jrburke/almond/raw/latest/almond.js)
+
+
+## Usage
+
+[Download the RequireJS optimizer](http://requirejs.org/docs/download.html#rjs).
+
+[Download the current release of almond.js](https://github.com/jrburke/almond/raw/latest/almond.js).
+
+Run the optimizer using [Node](http://nodejs.org) (also [works in Java](https://github.com/jrburke/r.js/blob/master/README.md)):
+
+    node r.js -o baseUrl=. name=path/to/almond include=main out=main-built.js wrap=true
+
+This assumes your project's top-level script file is called main.js and the command
+above is run from the directory containing main.js. If you prefer to use a build.js build profile instead of command line arguments, [this RequireJS optimization section](http://requirejs.org/docs/optimization.html#pitfalls) has info on how to do that.
+
+wrap=true will add this wrapper around the main-built.js contents (which will be minified by UglifyJS:
+
+    (function () {
+        //almond will be here
+        //main and its nested dependencies will be here
+    }());
+
+If you do not want that wrapper, leave off the wrap=true argument.
+
+These optimizer arguments can also be used in a build config object, so it can be used
+in [runtime-generated server builds](https://github.com/jrburke/r.js/blob/master/build/tests/http/httpBuild.js).
+
+
+## Triggering module execution <a name="execution"></a>
+
+As of RequireJS 2.0 and almond 0.1, modules are only executed if they are
+called by a top level require call. The data-main attribute on a script tag
+for require.js counts as a top level require call.
+
+However with almond, it does not look for a data-main attribute, and if your
+main JS module does not use a top level require() or requirejs() call to
+trigger module loading/execution, after a build, it may appear that the code
+broke -- no modules execute.
+
+The 2.0 RequireJS optimizer has a build config, option **insertRequire** that you
+can use to specify that a require([]) call is inserted at the end of the built
+file to trigger module loading. Example:
+
+    node r.js -o baseUrl=. name=path/to/almond.js include=main insertRequire=main out=main-built.js wrap=true
+
+or, if using a build config file:
+
+```javascript
+{
+    baseUrl: '.',
+    name: 'path/to/almond',
+    include: ['main'],
+    insertRequire: ['main'],
+    out: 'main-built.js',
+    wrap: true
+}
+```
+
+This will result with `require(["main"]);` at the bottom of main-built.js.
+
+## Exporting a public API
+
+If you are making a library that is made up of AMD modules in source form, but will be built with almond into one file, and you want to export a small public
+API for that library, you can use the `wrap` build config to do so. Build
+config:
+
+```javascript
+{
+    baseUrl: '.',
+    name: 'path/to/almond',
+    include: ['main'],
+    out: 'lib-built.js',
+    wrap: {
+        startFile: 'path/to/start.frag',
+        endFile: 'path/to/end.frag'
+    }
+}
+```
+
+Where start.frag could look like this:
+
+```javascript
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        //Allow using this built library as an AMD module
+        //in another project. That other project will only
+        //see this AMD call, not the internal modules in
+        //the closure below.
+        define([], factory);
+    } else {
+        //Browser globals case. Just assign the
+        //result to a property on the global.
+        root.libGlobalName = factory();
+    }
+}(this, function () {
+    //almond, and your modules will be inlined here
+```
+
+and end.frag is like this:
+```javascript
+    //The modules for your project will be inlined above
+    //this snippet. Ask almond to synchronously require the
+    //module value for 'main' here and return it as the
+    //value to use for the public API for the built file.
+    return require('main');
+}));
+```
+
+After the build, then the built file should be structured like so:
+
+* start.frag
+* almond.js
+* modules for your lib, including 'main'
+* end.frag
+
+## Common errors
+
+Explanations of common errors:
+
+### incorrect module build, no module name
+
+In almond 3.0.0 and earlier, this would show up as "deps is undefined", where
+this line is mentioned:
+
+    if (!deps.splice) {
+
+In 3.0.1+ the error is explicitly: "incorrect module build, no module name".
+
+This means that there is a define()'d module, but it is missing a name,
+something that looks like this:
+
+    define(function () {});
+    //or
+    define([], function () {});
+
+
+when it should look like:
+
+    define('someName', function () {});
+    //or
+    define('someName', [], function () {});
+
+
+This is usually a sign that the tool you used to combine all the modules
+together did not properly name an anonymous AMD module.
+
+Multiple modules built into a single file **must** have names in the define calls.
+Otherwise almond has no way to assign the module to a name key for use in the code.
+
+The fix is to use a build tool that understand AMD modules and inserts the module
+IDs in the build. The
+[requirejs optimizer](http://requirejs.org/docs/optimization.html) is a build tool
+that can do this correctly.
+
+### x missing y
+
+It means that module 'x' asked for module 'y', but module 'y' was not available.
+
+This usually means that 'y' was not included in the built file that includes almond.
+
+almond can only handle modules built in with it, it cannot dynamically load
+modules from the network.
+
+
+### No y
+
+It means that a `require('y')` call was done but y was not available.
+
+This usually means that 'y' was not included in the built file that includes almond.
+
+almond can only handle modules built in with it, it cannot dynamically load
+modules from the network.
+
+## How to get help
+
+* Contact the [requirejs list](https://groups.google.com/group/requirejs).
+* Open issues in the [issue tracker](https://github.com/jrburke/almond/issues).
+
+## Contributing
+
+Almond follows the
+[same contribution model as requirejs](http://requirejs.org/docs/contributing.html)
+and is considered a sub-project of requirejs.
\ No newline at end of file

+{
+  "name": "almond",
+  "version": "0.3.1",
+  "main": "almond.js",
+  "ignore": [
+    "tests",
+    "shrinktest.sh"
+  ]
+}

+{
+  "name": "almond",
+  "description": "A minimal AMD API implementation for use in optimized browser builds.",
+  "version": "0.3.1",
+  "homepage": "http://github.com/jrburke/almond",
+  "author": "James Burke <jrburke@gmail.com> (http://github.com/jrburke)",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jrburke/almond.git"
+  },
+  "licenses": [
+    {
+      "type": "BSD",
+      "url": "https://github.com/jrburke/almond/blob/master/LICENSE"
+    },
+    {
+      "type": "MIT",
+      "url": "https://github.com/jrburke/almond/blob/master/LICENSE"
+    }
+  ],
+  "main": "almond.js",
+  "engines": {
+    "node": ">=0.4.0"
+  },
+  "devDependencies": {
+    "connect": "^3.3.4",
+    "serve-static": "^1.9.1"
+  }
+}

+{
+  "name": "dcl",
+  "version": "1.1.2",
+  "main": "dcl.js",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ],
+  "homepage": "https://github.com/uhop/dcl",
+  "_release": "1.1.2",
+  "_resolution": {
+    "type": "version",
+    "tag": "1.1.2",
+    "commit": "64bfb2b736e787b1c2323ac31e1c7042bb7388c3"
+  },
+  "_source": "https://github.com/uhop/dcl.git",
+  "_target": "1.1.2",
+  "_originalSource": "dcl"
+}
\ No newline at end of file

+Eugene Lazutkin <eugene.lazutkin@gmail.com> (http://lazutkin.com/)

+Contribution guidelines
+=======================
+
+## For end-users
+
+If you are experiencing problems, and need help, please start with [the support web site](http://www.dcljs.org/support/).
+
+## For contributors
+
+* Please search the [issue tracker](https://github.com/uhop/dcl/issues) before submitting new issues
+  to avoid duplicates.
+* For any non-trivial contributions (new features, etc.), please create a new issue in the issue tracker
+  to track discussion prior to submitting a [pull request](http://help.github.com/send-pull-requests).
+* For the time being, you must have a signed [Dojo Foundation CLA](http://dojofoundation.org/about/claForm)
+  for any non-trivial patches to be accepted.
+* Any submitted code should conform to the project’s code style guidelines.
+* If appropriate, a test case should be part of the pull request.
+* Thank you for your contribution!
+
+## For committers
+
+* Provide rigorous code review for contributors.
+* When in doubt, ask for a second review; don’t commit code that smells wrong just because it exists.
+* Squash all pull requests into a single commit.
+* Put `[ci skip]` at the end of commit messages for commits that do not modify any code
+  (readme changes, etc.)

+(function(factory){
+	if(typeof define != "undefined"){
+		define(["../dcl"], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory(require("../dcl"));
+	}else{
+		dclAdvicesCounter = factory(dcl);
+	}
+})(function(dcl){
+	"use strict";
+	var Counter = new dcl(null, {
+		declaredClass: "dcl/advices/counter/Counter",
+		constructor: function(){
+			this.reset();
+		},
+		reset: function(){
+			this.calls = this.errors = 0;
+		},
+		advice: function(){
+			var self = this;
+			return {
+				before: function(){
+					++self.calls;
+				},
+				after: function(args, result){
+					if(result instanceof Error){
+						++self.errors;
+					}
+				}
+			};
+		}
+	});
+
+	return function(){ return new Counter; };
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define([], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory();
+	}else{
+		dclAdvicesFlow = factory();
+	}
+})(function(){
+	"use strict";
+	var flowStack = [], flowCount = {};
+	return {
+		advice: function(name){
+			return {
+				before: function(){
+					flowStack.push(name);
+					if(flowCount[name]){
+						++flowCount[name];
+					}else{
+						flowCount[name] = 1;
+					}
+				},
+				after: function(){
+					--flowCount[name];
+					flowStack.pop();
+				}
+			};
+		},
+		inFlowOf: function(name){
+			return flowCount[name];
+		},
+		getStack: function(){
+			return flowStack;
+		},
+		getCount: function(){
+			return flowCount;
+		}
+	};
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define([], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory();
+	}else{
+		dclAdvicesMemoize = factory();
+	}
+})(function(){
+	"use strict";
+	return {
+		advice: function(name, keyMaker){
+			return keyMaker ?
+				{
+					around: function(sup){
+						return function(){
+							var key = keyMaker(this, arguments), cache = this.__memoizerCache, dict;
+							if(!cache){
+								cache = this.__memoizerCache = {};
+							}
+							if(cache.hasOwnProperty(name)){
+								dict = cache[name];
+							}else{
+								dict = cache[name] = {};
+							}
+							if(dict.hasOwnProperty(key)){
+								return dict[key];
+							}
+							return dict[key] = sup ? sup.apply(this, arguments) : undefined;
+						}
+					}
+				} :
+				{
+					around: function(sup){
+						return function(first){
+							var cache = this.__memoizerCache, dict;
+							if(!cache){
+								cache = this.__memoizerCache = {};
+							}
+							if(cache.hasOwnProperty(name)){
+								dict = cache[name];
+							}else{
+								dict = cache[name] = {};
+							}
+							if(dict.hasOwnProperty(first)){
+								return dict[first];
+							}
+							return dict[first] = sup ? sup.apply(this, arguments) : undefined;
+						}
+					}
+				};
+		},
+		guard: function(name){
+			return {
+				after: function(){
+					var cache = this.__memoizerCache;
+					if(cache && name){
+						delete cache[name]
+					}else{
+						this.__memoizerCache = {};
+					}
+				}
+			};
+		}
+	};
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define([], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory();
+	}else{
+		dclAdvicesTime = factory();
+	}
+})(function(){
+	"use strict";
+	var uniq = 0;
+	return function(name){
+		var inCall = 0, label = name || ("Timer #" + uniq++);
+		return {
+			before: function(){
+				if(!(inCall++)){
+					console.time(label);
+				}
+			},
+			after: function(){
+				if(!--inCall){
+					console.timeEnd(label);
+				}
+			}
+		};
+	};
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define([], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory();
+	}else{
+		dclAdvicesTrace = factory();
+	}
+})(function(){
+	"use strict";
+	var lvl = 0;
+	function rep(ch, n){
+		if(n < 1){ return ""; }
+		if(n == 1){ return ch; }
+		var h = rep(ch, Math.floor(n / 2));
+		return h + h + ((n & 1) ? ch : "");
+
+	}
+	function pad(value, width, ch){
+		var v = value.toString();
+		return v + rep(ch || " ", width - v.length);
+	}
+	return function(name, level){
+		return {
+			before: function(){
+				++lvl;
+				console.log((level ? pad(lvl, 2 * lvl) : "") + this + " => " +
+					name + "(" + Array.prototype.join.call(arguments, ", ") + ")");
+			},
+			after: function(args, result){
+				console.log((level ? pad(lvl, 2 * lvl) : "") + this + " => " +
+					name + (result && result instanceof Error ? " throws" : " returns") +
+					" " + result);
+				--lvl;
+			}
+		};
+	};
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define([], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory();
+	}else{
+		advise = factory();
+	}
+})(function(){
+	"use strict";
+
+	function Node(instance, name){
+		this.next_before = this.prev_before = this.next_after = this.prev_after =
+			this.next_around = this.prev_around = this;
+		this.instance = instance;
+		this.name = name;
+	}
+	var p = Node.prototype = {
+		add: function(before, after, around, original){
+			var node = new Node(this.instance, this.name);
+			node.parent = this;
+			node.before = before;
+			this._add("before", node);
+			node.after = after;
+			this._add("after", node);
+			node.around = around;
+			this._add("around", node, original);
+			node.original = original;
+			if(original){ node.around = advise._instantiate(original, node.prev_around.around, this); }
+			return node;
+		},
+		_add: function(topic, node, flag){
+			if(node[topic] || flag){
+				var n = "next_" + topic, p = "prev_" + topic;
+				(node[p] = this[p])[n] = (node[n] = this)[p] = node;
+			}
+		},
+		remove: function(node){
+			this._remove("before", node);
+			this._remove("after",  node);
+			this._remove("around", node);
+		},
+		_remove: function(topic, node){
+			var n = "next_" + topic, p = "prev_" + topic;
+			node[n][p] = node[p];
+			node[p][n] = node[n];
+		},
+		destroy: function(){
+			var around = this.prev_around.around, t = this.next_around, parent = this.parent;
+			this.remove(this);
+			if(t !== this){
+				for(; t !== parent; around = t.around, t = t.next_around){
+					if(t.original){
+						t.around = advise._instantiate(t.original, around, this);
+					}
+				}
+			}
+			this.instance = 0;
+		}
+	};
+	p.unadvise = p.destroy;   // alias
+
+	function makeAOPStub(node){
+		var f = function(){
+			var p, r, t = this, a = arguments, thrown;
+			// running the before chain
+			for(p = node.prev_before; p !== node; p = p.prev_before){
+				p.before.apply(t, a);
+			}
+			// running the around chain
+			try{
+				if(node.prev_around !== node){ r = node.prev_around.around.apply(t, a); }
+			}catch(e){
+				r = e;
+				thrown = true;
+			}
+			// running the after chain
+			for(p = node.next_after; p !== node; p = p.next_after){
+				p.after.call(t, a, r);
+			}
+			if(thrown){
+				throw r;
+			}
+			return r;
+		};
+		f.adviceNode = node;
+		return f;
+	}
+
+	function advise(instance, name, advice){
+		var f = instance[name], node;
+		if(f && f.adviceNode && f.adviceNode instanceof Node){
+			node = f.adviceNode;
+		}else{
+			node = new Node(instance, name);
+			if(f && f.advices){
+				f = f.advices;
+				node.add(f.before, f.after, f.around);
+			}else{
+				node.add(0, 0, f);
+			}
+			instance[name] = makeAOPStub(node);
+		}
+		if(typeof advice == "function"){ advice = advice(name, instance); }
+		return node.add(advice.before, advice.after, 0, advice.around);
+	}
+
+	advise.before = function(instance, name, f){ return advise(instance, name, {before: f}); };
+	advise.after  = function(instance, name, f){ return advise(instance, name, {after:  f}); };
+	advise.around = function(instance, name, f){ return advise(instance, name, {around: f}); };
+	advise.Node = Node;
+
+	advise._instantiate = function(advice, previous, node){ return advice(previous); };
+
+	return advise;
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define(["../mini"], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory(require("../mini"));
+	}else{
+		dclBasesMixer = factory(dcl);
+	}
+})(function(dcl){
+	"use strict";
+	return dcl(null, {
+		declaredClass: "dcl/bases/Mixer",
+		constructor: function(x){
+			dcl.mix(this, x);
+		}
+	});
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define(["../mini"], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory(require("../mini"));
+	}else{
+		dclBasesReplacer = factory(dcl);
+	}
+})(function(dcl){
+	"use strict";
+	return dcl(null, {
+		declaredClass: "dcl/bases/Replacer",
+		constructor: function(x){
+			var empty = {};
+			dcl.allKeys(x).forEach(function(name){
+				if(name in this){
+					var t = x[name], e = empty[name];
+					if(t !== e){
+						this[name] = t;
+					}
+				}
+			}, this);
+		}
+	});
+});

+{
+  "name": "dcl",
+  "version": "1.1.1",
+  "main": "dcl.js",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "test",
+    "tests"
+  ]
+}

+(function(factory){
+	if(typeof define != "undefined"){
+		define(["./mini"], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory(require("./mini"));
+	}else{
+		dcl = factory(dcl);
+	}
+})(function(dcl){
+	"use strict";
+
+	function nop(){}
+
+	var Advice = dcl(dcl.Super, {
+		//declaredClass: "dcl.Advice",
+		constructor: function(){
+			this.before = this.around.before;
+			this.after  = this.around.after;
+			this.around = this.around.around;
+		}
+	});
+	function advise(advice){ return dcl._makeSuper(advice, Advice); }
+
+	function makeAOPStub(before, after, around){
+		var beforeChain = before || nop,
+			afterChain  = after  || nop,
+			aroundChain = around || nop,
+			stub = function(){
+				var r, thrown;
+				// running the before chain
+				beforeChain.apply(this, arguments);
+				// running the around chain
+				try{
+					r = aroundChain.apply(this, arguments);
+				}catch(e){
+					r = e;
+					thrown = true;
+				}
+				// running the after chain
+				afterChain.call(this, arguments, r);
+				if(thrown){
+					throw r;
+				}
+				return r;
+			};
+		stub.advices = {before: before, after: after, around: around};
+		return stub;
+	}
+
+	function chain(id){
+		return function(ctor, name){
+			var meta = ctor._meta, rule;
+			if(meta){
+				rule = +meta.weaver[name] || 0;
+				if(rule && rule != id){
+					dcl._error("set chaining", name, ctor, id, rule);
+				}
+				meta.weaver[name] = id;
+			}
+		};
+	}
+
+	dcl.mix(dcl, {
+		// public API
+		Advice: Advice,
+		advise: advise,
+		// expose helper methods
+		before: function(f){ return dcl.advise({before: f}); },
+		after:  function(f){ return dcl.advise({after:  f}); },
+		around: dcl.superCall,
+		// chains
+		chainBefore: chain(1),
+		chainAfter:  chain(2),
+		isInstanceOf: function(o, ctor){
+			if(o instanceof ctor){
+				return true;
+			}
+			var t = o.constructor._meta, i;
+			if(t){
+				for(t = t.bases, i = t.length - 1; i >= 0; --i){
+					if(t[i] === ctor){
+						return true;
+					}
+				}
+			}
+			return false;
+		},
+		// protected API starts with _ (don't use it!)
+		_stub: /*generic stub*/ function(id, bases, name, chains){
+			var f = chains[name] = dcl._extractChain(bases, name, "around"),
+				b = dcl._extractChain(bases, name, "before").reverse(),
+				a = dcl._extractChain(bases, name, "after");
+			f = id ? dcl._stubChainSuper(f, id == 1 ? function(f){ return dcl._stubChain(f.reverse()); } : dcl._stubChain, name) : dcl._stubSuper(f, name);
+			return !b.length && !a.length ? f || function(){} : makeAOPStub(dcl._stubChain(b), dcl._stubChain(a), f);
+		}
+	});
+
+	return dcl;
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define(["./mini", "./advise"], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory(require("./mini"), require("./advise"));
+	}else{
+		dclDebug = factory(dcl, advise);
+	}
+})(function(dcl, advise){
+	function DclError(message){
+		if(Error.captureStackTrace){
+			Error.captureStackTrace(this, DclError);
+		}
+		var e = Error.call(this, message), name;
+		dcl.allKeys(e).forEach(function(name){
+			if(e.hasOwnProperty(name)){
+				this[name] = e[name];
+			}
+		});
+		this.message = message;
+	}
+	DclError.prototype = dcl.delegate(Error.prototype);
+	DclError.prototype.constructor = DclError;
+
+	var CycleError = dcl(DclError, {declaredClass: "dcl/debug/CycleError"}),
+		ChainingError = dcl(DclError, {declaredClass: "dcl/debug/ChainingError"}),
+		SetChainingError = dcl(DclError, {declaredClass: "dcl/debug/SetChainingError"}),
+		SuperCallError = dcl(DclError, {declaredClass: "dcl/debug/SuperCallError"}),
+		SuperError = dcl(DclError, {declaredClass: "dcl/debug/SuperError"}),
+		SuperResultError = dcl(DclError, {declaredClass: "dcl/debug/SuperResultError"});
+
+	var chainNames = ["UNCHAINED BUT CONTAINS ADVICE(S)", "CHAINED BEFORE", "CHAINED AFTER",
+			"ERRONEOUSLY CHAINED BEFORE AND AFTER"];
+	function chainName(id){
+		return id >= 0 && id <= 3 ? chainNames[id] : "UNKNOWN (" + id + ")";
+	}
+
+	var noDecls = " (specify 'declaredClass' string in your classes to get better diagnostics)";
+	advise.around(dcl, "_error", function(/*sup*/){
+		return function(reason, a1, a2, a3, a4, a5){
+			var cName, someUnknown, i, base, name, names = [], c = {};
+			switch(reason){
+				case "cycle":
+					cName = a1.hasOwnProperty("declaredClass") && a1.declaredClass;
+					someUnknown = !cName;
+					for(i = a2.length - 1; i >= 0; --i){
+						base = a2[i][0];
+						name = base.prototype.hasOwnProperty("declaredClass") && base.prototype.declaredClass;
+						if(!name){
+							name = "UNNAMED_" + base._uniqueId;
+							someUnknown = true;
+						}
+						if(!c[name]){
+							names.push(name);
+							c[name] = 1;
+						}
+					}
+					throw new CycleError("dcl: base class cycle found in: " + (cName || "UNNAMED") +
+						" - bases: " + names.join(", ") + " are mutually dependent" +
+						(someUnknown ? noDecls : ""));
+				case "chain":
+					cName = a2.prototype.hasOwnProperty("declaredClass") && a2.prototype.declaredClass;
+					name = a4.prototype.hasOwnProperty("declaredClass") && a4.prototype.declaredClass;
+					someUnknown = !(cName && name);
+					throw new ChainingError("dcl: conflicting chain directives from bases found in: " + (cName || ("UNNAMED_" + a2._uniqueId)) +
+						", method: " + a1 + " - it was " + chainName(a3) + " yet " +
+						(name || ("UNNAMED_" + a4._uniqueId)) + " sets it to " + chainName(a5) +
+						(someUnknown ? noDecls : ""));
+				case "set chaining":
+					cName = a2.prototype.hasOwnProperty("declaredClass") && a2.prototype.declaredClass;
+					someUnknown = !cName;
+					throw new SetChainingError("dcl: attempt to set conflicting chain directives in: " + (cName || ("UNNAMED_" + a2._uniqueId)) +
+						", method: " + a1 + " - it was " + chainName(a4) + " yet being changed to " + chainName(a3) +
+						(someUnknown ? noDecls : ""));
+				case "wrong super call":
+					cName = a1.prototype.hasOwnProperty("declaredClass") && a1.prototype.declaredClass;
+					someUnknown = !cName;
+					throw new SuperCallError("dcl: argument of around advice or supercall decorator should be a function in: " +
+						(cName || ("UNNAMED_" + a1._uniqueId)) + ", method: " + a2 + (someUnknown ? noDecls : ""));
+				case "wrong super":
+					cName = a1.prototype.hasOwnProperty("declaredClass") && a1.prototype.declaredClass;
+					someUnknown = !cName;
+					throw new SuperError("dcl: super method should be a function in: " +
+						(cName || ("UNNAMED_" + a1._uniqueId)) + ", method: " + a2 + (someUnknown ? noDecls : ""));
+				case "wrong super result":
+					cName = a1.prototype.hasOwnProperty("declaredClass") && a1.prototype.declaredClass;
+					someUnknown = !cName;
+					throw new SuperResultError("dcl: around advice or supercall should return a function in: " +
+						(cName || ("UNNAMED_" + a1._uniqueId)) + ", method: " + a2 + (someUnknown ? noDecls : ""));
+			}
+			throw new DclError("dcl: " + reason);
+		};
+	});
+
+	advise.after(dcl, "_postprocess", function(args, ctor){
+		// validate that chaining is consistent
+		var meta = ctor._meta, weaver = meta.weaver, bases = meta.bases,
+			name, chain, base, i, rule;
+		dcl.allKeys(weaver).forEach(function(name){
+			chain = (+weaver[name] || 0);
+			for(i = bases.length - 1; i >= 0; --i){
+				base = bases[i];
+				meta = base._meta;
+				if(meta){
+					rule = (+meta.weaver[name] || 0);
+					if(chain != rule && (!chain || rule)){
+						dcl._error("chain", name, ctor, chain, base, rule);
+					}
+				}
+			}
+		});
+	});
+
+	advise.around(dcl, "_instantiate", function(/*sup*/){
+		return function(advice, previous, node){
+			if(!advice || !advice.spr || typeof advice.spr.around != "function"){
+				dcl._error("wrong super call", advice.ctr, node);
+			}
+			if(previous && typeof previous != "function"){
+				dcl._error("wrong super", advice.ctr, node);
+			}
+			var t = advice.spr.around(previous);
+			if(typeof t != "function"){
+				dcl._error("wrong super result", advice.ctr, node);
+			}
+			t.ctr = advice.ctr;
+			return t;
+		};
+	});
+
+	advise(advise, "_instantiate", {
+		before: function(advice, previous, node){
+			if(typeof advice != "function"){
+				dcl._error("wrong super call", node.instance.constructor, node.name);
+			}
+			if(previous && typeof previous != "function"){
+				dcl._error("wrong super", node.instance.constructor, node.name);
+			}
+		},
+		after: function(a, result){
+			if(typeof result != "function"){
+				dcl._error("wrong super result", a[2].instance.constructor, a[2].name);
+			}
+		}
+	});
+
+	function logCtor(ctor){
+		var meta = ctor._meta;
+		if(!meta){
+			console.log("*** class does not have meta information compatible with dcl");
+			return;
+		}
+		var weaver = meta.weaver, bases = meta.bases, chains = meta.chains, names = [], base, name, someUnknown, i;
+		for(i = 0; i < bases.length; ++i){
+			base = bases[i];
+			name = base.prototype.hasOwnProperty("declaredClass") && base.prototype.declaredClass;
+			if(!name){
+				name = "UNNAMED_" + (base.hasOwnProperty("_uniqueId") ? base._uniqueId : "");
+				someUnknown = true;
+			}
+			names.push(name);
+		}
+		console.log("*** class " + names[0] + " depends on " + (names.length - 1) + " classes");
+		if(names.length > 1){
+			console.log("    dependencies: " + names.slice(1).join(", "));
+		}
+		if(someUnknown){
+			console.log("    " + noDecls);
+		}
+		dcl.allKeys(weaver).forEach(function(name){
+			i = +weaver[name];
+			if(!isNaN(i)){
+				var hasStub = typeof ctor.prototype[name].advices == "object";
+				if(hasStub){
+					var b = dcl._extractChain(bases, name, "b").length,
+						f = dcl._extractChain(bases, name, "f").length,
+						a = dcl._extractChain(bases, name, "a").length;
+				}
+				console.log("    class method " + name + " is " + chainName(i) +
+					(hasStub ?
+						", and has an AOP stub (before: " + b + ", around: " + f + ", after: " + a + ")" :
+						" (length: " + chains[name].length + ")" ));
+			}
+		});
+	}
+
+	function countAdvices(node, chain){
+		for(var counter = 0, p = node[chain]; p != node; p = p[chain], ++counter);
+		return counter;
+	}
+
+	function log(o, suppressCtor){
+		switch(typeof o){
+			case "function":
+				logCtor(o);
+				return;
+			case "object":
+				var base = o.constructor,
+					name = base.prototype.hasOwnProperty("declaredClass") && base.prototype.declaredClass;
+				if(!name){
+					name = "UNNAMED_" + (base.hasOwnProperty("_uniqueId") ? base._uniqueId : "");
+				}
+				console.log("*** object of class " + name);
+				// log the constructor
+				if(!suppressCtor){
+					logCtor(base);
+				}
+				// log methods
+				dcl.allKeys(o).forEach(function(name){
+					var f = o[name], b, r, a;
+					if(typeof f == "function"){
+						if(f.adviceNode && f.adviceNode instanceof advise.Node){
+							b = countAdvices(f.adviceNode, "pb");
+							r = countAdvices(f.adviceNode, "pf");
+							a = countAdvices(f.adviceNode, "pa");
+							console.log("    object method " + name + " has an AOP stub (before: " +
+								b + ", around: " + r + ", after: " + a + ")");
+						}
+					}
+				});
+				return;
+		}
+		console.log(o);
+	}
+
+	return {
+		log: log,
+		DclError: DclError,
+		CycleError: CycleError,
+		ChainingError: ChainingError,
+		SetChainingError: SetChainingError,
+		SuperCallError: SuperCallError,
+		SuperError: SuperError,
+		SuperResultError: SuperResultError
+	};
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define(["./mini", "./advise"], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory(require("./mini"), require("./advise"));
+	}else{
+		factory(dcl, advise);
+	}
+})(function(dcl, advise){
+	var empty = {}, t;
+
+	function inherited(ctor, name, args){
+		var callee = arguments.length < 3 && ctor.callee, // callee is truthy if in non-strict mode.
+			f = get.call(this, callee ? callee.ctr : ctor, callee ? callee.nom : name);
+		if(f){ return f.apply(this, callee ? ctor || name : args); }
+		// intentionally no return
+	}
+
+	function get(ctor, name){
+		var meta = this.constructor._meta, bases, base, i, l;
+		if(+meta.weaver[name]){
+			return; // return undefined
+		}
+		if(meta){
+			if(meta.chains.hasOwnProperty(name)){
+				if((bases = meta.chains[name])){	// intentional assignment
+					for(i = bases.length - 1; i >= 0; --i){
+						base = bases[i];
+						if(base.ctr === ctor){
+							return i > 0 ? bases[i - 1] : 0;
+						}
+					}
+				}
+				return; // return undefined
+			}
+			for(bases = meta.bases, i = bases.length - 1; i >= 0; --i){
+				if(bases[i] === ctor){
+					break;
+				}
+			}
+			if(i >= 0){
+				for(++i, l = bases.length; i < l; ++i){
+					if((meta = (base = bases[i])._meta)){	// intentional assignments
+						if((meta = meta.ownProps).hasOwnProperty(name)){	// intentional assignment
+							return meta[name];
+						}
+					}else{
+						return base.prototype[name];
+					}
+				}
+			}
+		}
+		return empty[name];
+	}
+
+	advise.after(dcl, "_postprocess", function(args, ctor){
+		// decorate all methods with necessary nom/ctr variables
+		var bases = ctor._meta.bases, i = bases.length - 1, base, meta, name, f;
+		for(; i >= 0; --i){
+			base = bases[i];
+			if((meta = base._meta)){ // intentional assignment
+				meta = meta.ownProps;
+				dcl.allKeys(meta).some(function(name){
+					f = meta[name];
+					if(typeof f == "function"){
+						if(f.nom === name){ return 1; }
+						f.nom = name;
+						f.ctr = base;
+					}
+				});
+			}
+		}
+		ctor.prototype.inherited = inherited;
+		ctor.prototype.getInherited = get;
+	});
+
+	dcl.getInherited = inherited.get = get;
+	return dcl.inherited = inherited;   // intentional assignment
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define([], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory();
+	}else{
+		dcl = factory();
+	}
+})(function(){
+	"use strict";
+
+	var shadowedNames = ["hasOwnProperty", "valueOf", "isPrototypeOf", "propertyIsEnumerable",
+		"toLocaleString", "toString", "constructor"], op = Object.prototype;
+	for(var post in {toString: 1}){
+		shadowedNames = [];
+	}
+
+	function allKeys(o){
+		var keys = [];
+		for(var name in o){
+			var t = o[name];
+			if(t !== op[name] || !(name in op)){
+				keys.push(name);
+			}
+		}
+		for(var i = 0; name = shadowedNames[i]; ++i){	// intentional assignment
+			var t = o[name];
+			if(t !== op[name] || !(name in op)){
+				keys.push(name);
+			}
+		}
+		return keys;
+	}
+
+	var counter = 0, cname = "constructor", pname = "prototype", empty = {}, mix;
+
+	function dcl(superClass, props){
+		var bases = [0], proto, base, ctor, meta, connectionMap,
+			output, vector, superClasses, i, j = 0, n;
+
+		if(superClass){
+			if(superClass instanceof Array){
+				// mixins: C3 MRO
+				connectionMap = {};
+				superClasses = superClass.slice(0).reverse();
+				for(i = superClasses.length - 1; i >= 0; --i){
+					base = superClasses[i];
+					// pre-process a base
+					// 1) add a unique id
+					base._uniqueId = base._uniqueId || counter++;
+					// 2) build a connection map and the base list
+					if((proto = base._meta)){   // intentional assignment
+						for(vector = proto.bases, j = vector.length - 1; j > 0; --j){
+							n = vector[j]._uniqueId;
+							connectionMap[n] = (connectionMap[n] || 0) + 1;
+						}
+						superClasses[i] = vector.slice(0);
+					}else{
+						superClasses[i] = [base];
+					}
+				}
+				// build output
+				output = {};
+				c: while(superClasses.length){
+					for(i = 0; i < superClasses.length; ++i){
+						vector = superClasses[i];
+						base = vector[0];
+						n = base._uniqueId;
+						if(!connectionMap[n]){
+							if(!output[n]){
+								bases.push(base);
+								output[n] = 1;
+							}
+							vector.shift();
+							if(vector.length){
+								--connectionMap[vector[0]._uniqueId];
+							}else{
+								superClasses.splice(i, 1);
+							}
+							continue c;
+						}
+					}
+					// error
+					dcl._error("cycle", props, superClasses);
+				}
+				// calculate a base class
+				superClass = superClass[0];
+				j = bases.length - ((meta = superClass._meta) && superClass === bases[bases.length - (j = meta.bases.length)] ? j : 1) - 1; // intentional assignments
+			}else{
+				// 1) add a unique id
+				superClass._uniqueId = superClass._uniqueId || counter++;
+				// 2) single inheritance
+				bases = bases.concat((meta = superClass._meta) ? meta.bases : superClass);   // intentional assignment
+			}
+		}
+		// create a base class
+		proto = superClass ? dcl.delegate(superClass[pname]) : {};
+		// the next line assumes that constructor is actually named "constructor", should be changed if desired
+		vector = superClass && (meta = superClass._meta) ? dcl.delegate(meta.weaver) : {constructor: 2};   // intentional assignment
+
+		// create prototype: mix in mixins and props
+		for(; j > 0; --j){
+			base = bases[j];
+			meta = base._meta;
+			dcl.mix(proto, meta && meta.ownProps || base[pname]);
+			if(meta){
+				allKeys(superClasses = meta.weaver).forEach(function(n){	// intentional assignment
+					vector[n] = (+vector[n] || 0) | superClasses[n];
+				});
+			}
+		}
+		allKeys(props).forEach(function(n){
+			if(isSuper(meta = props[n])){  // intentional assignment
+				vector[n] = +vector[n] || 0;
+			}else{
+				proto[n] = meta;
+			}
+		});
+
+		// create stubs with fake constructor
+		//
+		meta = {bases: bases, ownProps: props, weaver: vector, chains: {}};
+		// meta information is coded like that:
+		// bases: an array of super classes (bases) and mixins
+		// ownProps: a bag of immediate prototype properties for the constructor
+		// weaver: a bag of chain instructions (before is 1, after is 2)
+		// chains: a bag of chains (ordered arrays)
+
+		bases[0] = {_meta: meta, prototype: proto};
+		buildStubs(meta, proto);
+		ctor = proto[cname];
+
+		// put in place all decorations and return a constructor
+		ctor._meta  = meta;
+		ctor[pname] = proto;
+		//proto.constructor = ctor; // uncomment if constructor is not named "constructor"
+		bases[0] = ctor;
+
+		// each constructor may have two properties on it:
+		// _meta: a meta information object as above
+		// _uniqueId: a unique number, which is used to id the constructor
+
+		return dcl._postprocess(ctor);    // fully prepared constructor
+	}
+
+	// decorators
+
+	function Super(f){ this.around = f; }
+	function isSuper(f){ return f && f.spr instanceof Super; }
+
+	// utilities
+
+	(mix = function(a, b){
+		allKeys(b).forEach(function(n){
+			a[n] = b[n];
+		});
+	})(dcl, {
+		// piblic API
+		mix: mix,
+		delegate: function(o){
+			return Object.create(o);
+		},
+		allKeys: allKeys,
+		Super: Super,
+		superCall: function superCall(f){ return dcl._makeSuper(f); },
+
+		// protected API starts with _ (don't use it!)
+
+		// make a Super marker
+		_makeSuper: function makeSuper(advice, S){ var f = function(){}; f.spr = new (S || Super)(advice); return f; },
+
+		// post-processor for a constructor, can be used to add more functionality
+		// or augment its behavior
+		_postprocess: function(ctor){ return ctor; },   // identity, used to hang on advices
+
+		// error function, augmented by debug.js
+		_error: function(msg){ throw Error("dcl: " + msg); },
+
+		// supercall instantiation, augmented by debug.js
+		_instantiate: function(advice, previous, node){ var t = advice.spr.around(previous); t.ctr = advice.ctr; return t; },
+
+		// the "buildStubs()" helpers, can be overwritten
+		_extractChain: function(bases, name, advice){
+			var i = bases.length - 1, chain = [], base, f, around = advice == "around";
+			for(; base = bases[i]; --i){
+				// next line contains 5 intentional assignments
+				if((f = base._meta) ? (f = f.ownProps).hasOwnProperty(name) && (isSuper(f = f[name]) ? (around ? f.spr.around : (f = f.spr[advice])) : around) : around && (f = name == cname ? base : base[pname][name]) && f !== empty[name]){
+					f.ctr = base;
+					chain.push(f);
+				}
+			}
+			return chain;
+		},
+		_stubChain: function(chain){ // this is "after" chain
+			var l = chain.length, f;
+			return !l ? 0 : l == 1 ?
+				(f = chain[0], function(){
+					f.apply(this, arguments);
+				}) :
+				function(){
+					for(var i = 0; i < l; ++i){
+						chain[i].apply(this, arguments);
+					}
+				};
+		},
+		_stubSuper: function(chain, name){
+			var i = 0, f, p = empty[name];
+			for(; f = chain[i]; ++i){
+				p = isSuper(f) ? (chain[i] = dcl._instantiate(f, p, name)) : f;
+			}
+			return name != cname ? p : function(){ p.apply(this, arguments); };
+		},
+		_stubChainSuper: function(chain, stub, name){
+			var i = 0, f, diff, pi = 0;
+			for(; f = chain[i]; ++i){
+				if(isSuper(f)){
+					diff = i - pi;
+					chain[i] = dcl._instantiate(f, !diff ? 0 : diff == 1 ? chain[pi] : stub(chain.slice(pi, i)), name);
+					pi = i;
+				}
+			}
+			diff = i - pi;
+			return !diff ? 0 : diff == 1 && name != cname ? chain[pi] : stub(pi ? chain.slice(pi) : chain);
+		},
+		_stub: /*generic stub*/ function(id, bases, name, chains){
+			var f = chains[name] = dcl._extractChain(bases, name, "around");
+			return (id ? dcl._stubChainSuper(f, dcl._stubChain, name) : dcl._stubSuper(f, name)) || function(){};
+		}
+	});
+
+	function buildStubs(meta, proto){
+		var weaver = meta.weaver, bases = meta.bases, chains = meta.chains;
+		allKeys(weaver).forEach(function(name){
+			proto[name] = dcl._stub(weaver[name], bases, name, chains);
+		});
+	}
+
+	return dcl;
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define([], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory();
+	}else{
+		dcl = factory();
+	}
+})(function(){
+	"use strict";
+
+	var counter = 0, cname = "constructor", pname = "prototype", empty = {}, mix;
+
+	function dcl(superClass, props){
+		var bases = [0], proto, base, ctor, meta, connectionMap,
+			output, vector, superClasses, i, j = 0, n;
+
+		if(superClass){
+			if(superClass instanceof Array){
+				// mixins: C3 MRO
+				connectionMap = {};
+				superClasses = superClass.slice(0).reverse();
+				for(i = superClasses.length - 1; i >= 0; --i){
+					base = superClasses[i];
+					// pre-process a base
+					// 1) add a unique id
+					base._uniqueId = base._uniqueId || counter++;
+					// 2) build a connection map and the base list
+					if((proto = base._meta)){   // intentional assignment
+						for(vector = proto.bases, j = vector.length - 1; j > 0; --j){
+							n = vector[j]._uniqueId;
+							connectionMap[n] = (connectionMap[n] || 0) + 1;
+						}
+						superClasses[i] = vector.slice(0);
+					}else{
+						superClasses[i] = [base];
+					}
+				}
+				// build output
+				output = {};
+				c: while(superClasses.length){
+					for(i = 0; i < superClasses.length; ++i){
+						vector = superClasses[i];
+						base = vector[0];
+						n = base._uniqueId;
+						if(!connectionMap[n]){
+							if(!output[n]){
+								bases.push(base);
+								output[n] = 1;
+							}
+							vector.shift();
+							if(vector.length){
+								--connectionMap[vector[0]._uniqueId];
+							}else{
+								superClasses.splice(i, 1);
+							}
+							continue c;
+						}
+					}
+					// error
+					dcl._error("cycle", props, superClasses);
+				}
+				// calculate a base class
+				superClass = superClass[0];
+				j = bases.length - ((meta = superClass._meta) && superClass === bases[bases.length - (j = meta.bases.length)] ? j : 1) - 1; // intentional assignments
+			}else{
+				// 1) add a unique id
+				superClass._uniqueId = superClass._uniqueId || counter++;
+				// 2) single inheritance
+				bases = bases.concat((meta = superClass._meta) ? meta.bases : superClass);   // intentional assignment
+			}
+		}
+		// create a base class
+		proto = superClass ? dcl.delegate(superClass[pname]) : {};
+		// the next line assumes that constructor is actually named "constructor", should be changed if desired
+		vector = superClass && (meta = superClass._meta) ? dcl.delegate(meta.weaver) : {constructor: 2};   // intentional assignment
+
+		// create prototype: mix in mixins and props
+		for(; j > 0; --j){
+			base = bases[j];
+			meta = base._meta;
+			dcl.mix(proto, meta && meta.ownProps || base[pname]);
+			if(meta){
+				for(n in (superClasses = meta.weaver)){    // intentional assignment
+					vector[n] = (+vector[n] || 0) | superClasses[n];
+				}
+			}
+		}
+		for(n in props){
+			if(isSuper(meta = props[n])){  // intentional assignment
+				vector[n] = +vector[n] || 0;
+			}else{
+				proto[n] = meta;
+			}
+		}
+
+		// create stubs with fake constructor
+		//
+		meta = {bases: bases, ownProps: props, weaver: vector, chains: {}};
+		// meta information is coded like that:
+		// bases: an array of super classes (bases) and mixins
+		// ownProps: a bag of immediate prototype properties for the constructor
+		// weaver: a bag of chain instructions (before is 1, after is 2)
+		// chains: a bag of chains (ordered arrays)
+
+		bases[0] = {_meta: meta, prototype: proto};
+		buildStubs(meta, proto);
+		ctor = proto[cname];
+
+		// put in place all decorations and return a constructor
+		ctor._meta  = meta;
+		ctor[pname] = proto;
+		//proto.constructor = ctor; // uncomment if constructor is not named "constructor"
+		bases[0] = ctor;
+
+		// each constructor may have two properties on it:
+		// _meta: a meta information object as above
+		// _uniqueId: a unique number, which is used to id the constructor
+
+		return dcl._postprocess(ctor);    // fully prepared constructor
+	}
+
+	// decorators
+
+	function Super(f){ this.around = f; }
+	function isSuper(f){ return f && f.spr instanceof Super; }
+
+	// utilities
+
+	function allKeys(o){
+		var keys = [];
+		for(var name in o){
+			keys.push(name);
+		}
+		return keys;
+	}
+
+	(mix = function(a, b){
+		for(var n in b){
+			a[n] = b[n];
+		}
+	})(dcl, {
+		// piblic API
+		mix: mix,
+		delegate: function(o){
+			return Object.create(o);
+		},
+		allKeys: allKeys,
+		Super: Super,
+		superCall: function superCall(f){ return dcl._makeSuper(f); },
+
+		// protected API starts with _ (don't use it!)
+
+		// make a Super marker
+		_makeSuper: function makeSuper(advice, S){ var f = function(){}; f.spr = new (S || Super)(advice); return f; },
+
+		// post-processor for a constructor, can be used to add more functionality
+		// or augment its behavior
+		_postprocess: function(ctor){ return ctor; },   // identity, used to hang on advices
+
+		// error function, augmented by debug.js
+		_error: function(msg){ throw Error("dcl: " + msg); },
+
+		// supercall instantiation, augmented by debug.js
+		_instantiate: function(advice, previous, node){ var t = advice.spr.around(previous); t.ctr = advice.ctr; return t; },
+
+		// the "buildStubs()" helpers, can be overwritten
+		_extractChain: function(bases, name, advice){
+			var i = bases.length - 1, chain = [], base, f, around = advice == "around";
+			for(; base = bases[i]; --i){
+				// next line contains 5 intentional assignments
+				if((f = base._meta) ? (f = f.ownProps).hasOwnProperty(name) && (isSuper(f = f[name]) ? (around ? f.spr.around : (f = f.spr[advice])) : around) : around && (f = name == cname ? base : base[pname][name]) && f !== empty[name]){
+					f.ctr = base;
+					chain.push(f);
+				}
+			}
+			return chain;
+		},
+		_stubChain: function(chain){ // this is "after" chain
+			var l = chain.length, f;
+			return !l ? 0 : l == 1 ?
+				(f = chain[0], function(){
+					f.apply(this, arguments);
+				}) :
+				function(){
+					for(var i = 0; i < l; ++i){
+						chain[i].apply(this, arguments);
+					}
+				};
+		},
+		_stubSuper: function(chain, name){
+			var i = 0, f, p = empty[name];
+			for(; f = chain[i]; ++i){
+				p = isSuper(f) ? (chain[i] = dcl._instantiate(f, p, name)) : f;
+			}
+			return name != cname ? p : function(){ p.apply(this, arguments); };
+		},
+		_stubChainSuper: function(chain, stub, name){
+			var i = 0, f, diff, pi = 0;
+			for(; f = chain[i]; ++i){
+				if(isSuper(f)){
+					diff = i - pi;
+					chain[i] = dcl._instantiate(f, !diff ? 0 : diff == 1 ? chain[pi] : stub(chain.slice(pi, i)), name);
+					pi = i;
+				}
+			}
+			diff = i - pi;
+			return !diff ? 0 : diff == 1 && name != cname ? chain[pi] : stub(pi ? chain.slice(pi) : chain);
+		},
+		_stub: /*generic stub*/ function(id, bases, name, chains){
+			var f = chains[name] = dcl._extractChain(bases, name, "around");
+			return (id ? dcl._stubChainSuper(f, dcl._stubChain, name) : dcl._stubSuper(f, name)) || function(){};
+		}
+	});
+
+	function buildStubs(meta, proto){
+		var weaver = meta.weaver, bases = meta.bases, chains = meta.chains;
+		for(var name in weaver){
+			proto[name] = dcl._stub(weaver[name], bases, name, chains);
+		}
+	}
+
+	return dcl;
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define(["../dcl", "./Destroyable"], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory(require("../dcl"), require("./Destroyable"));
+	}else{
+		dclMixinsCleanup = factory(dcl, dclMixinsDestroyable);
+	}
+})(function(dcl, Destroyable){
+	"use strict";
+	return dcl(Destroyable, {
+		declaredClass: "dcl/mixins/Cleanup",
+		constructor: function(){
+			this.__cleanupStack = [];
+		},
+		pushCleanup: function(resource, cleanup){
+			var f = cleanup ? function(){ cleanup(resource); } : function(){ resource.destroy(); };
+			this.__cleanupStack.push(f);
+			return f;
+		},
+		popCleanup: function(dontRun){
+			if(dontRun){
+				return this.__cleanupStack.pop();
+			}
+			this.__cleanupStack.pop()();
+		},
+		removeCleanup: function(f){
+			for(var i = this.__cleanupStack.length - 1; i >= 0; --i){
+				if(this.__cleanupStack[i] === f){
+					this.__cleanupStack.splice(i, 1);
+					return true;
+				}
+			}
+		},
+		cleanup: function(){
+			while(this.__cleanupStack.length){
+				this.__cleanupStack.pop()();
+			}
+		},
+		destroy: function(){
+			this.cleanup();
+		}
+	});
+});

+(function(factory){
+	if(typeof define != "undefined"){
+		define(["../dcl"], factory);
+	}else if(typeof module != "undefined"){
+		module.exports = factory(require("../dcl"));
+	}else{
+		dclMixinsDestroyable = factory(dcl);
+	}
+})(function(dcl){
+	"use strict";
+	var Destroyable = dcl(null, {declaredClass: "dcl/mixins/Destroyable"});
+	dcl.chainBefore(Destroyable, "destroy");
+	return Destroyable;
+});

+var miniExcludes = {
+		"dcl/AUTHORS": 1,
+		"dcl/CONTRIBUTING.md": 1,
+		"dcl/LICENSE": 1,
+		"dcl/README.md": 1,
+		"dcl/package": 1
+	},
+	isTestRe = /\/tests\//;
+
+var profile = {
+	resourceTags: {
+		test: function(filename, mid){
+			return isTestRe.test(filename);
+		},
+
+		miniExclude: function(filename, mid){
+			return /\/tests\//.test(filename) || mid in miniExcludes;
+		},
+
+		amd: function(filename, mid){
+			return /\.js$/.test(filename);
+		}
+	}
+};

+{
+  "name": "dcl",
+  "version": "1.1.2",
+  "description": "Elegant minimalistic implementation of OOP with mixins + AOP.",
+  "homepage": "http://www.dcljs.org",
+  "bugs": "http://github.com/uhop/dcl/issues",
+  "main": "dcl.js",
+  "directories": {
+    "test": "tests"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "heya-unit": ">=0.1"
+  },
+  "scripts": {
+    "test": "node tests/tests.js"
+  },
+  "github": "http://github.com/uhop/dcl",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/uhop/dcl.git"
+  },
+  "keywords": [
+    "object-oriented",
+    "programming",
+    "aspect-oriented",
+    "OOP",
+    "AOP",
+    "OO"
+  ],
+  "author": "Eugene Lazutkin <eugene.lazutkin@gmail.com> (http://lazutkin.com/)",
+  "licenses": [
+    {
+      "type": "New BSD",
+      "url": "http://github.com/uhop/dcl/blob/master/LICENSE"
+    },
+    {
+      "type": "AFL 2.1",
+      "url": "http://github.com/uhop/dcl/blob/master/LICENSE"
+    }
+  ],
+  "icon": "http://www.dcljs.org/fav144.png",
+  "dojoBuild": "package.js"
+}

+{
+  "name": "dojo",
+  "homepage": "https://github.com/dojo/dojo",
+  "version": "1.9.1",
+  "_release": "1.9.1",
+  "_resolution": {
+    "type": "version",
+    "tag": "1.9.1",
+    "commit": "b0cf6ea0b62865cd72cb14ccc7bd2478e8867cb8"
+  },
+  "_source": "https://github.com/dojo/dojo.git",
+  "_target": "1.9.1",
+  "_originalSource": "dojo"
+}
\ No newline at end of file

+define(["./_base/kernel", "./_base/lang"], function(dojo, lang){
+// module:
+//		dojo/AdapterRegistry
+
+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
+};
+
+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;
+});

+define([
+	"./has",
+	"./_base/lang",
+	"./errors/CancelError",
+	"./promise/Promise",
+	"./has!config-deferredInstrumentation?./promise/instrumentation"
+], function(has, lang, CancelError, Promise, instrumentation){
+	"use strict";
+
+	// module:
+	//		dojo/Deferred
+
+	var PROGRESS = 0,
+			RESOLVED = 1,
+			REJECTED = 2;
+	var FULFILLED_ERROR_MESSAGE = "This deferred has already been fulfilled.";
+
+	var freezeObject = Object.freeze || function(){};
+
+	var signalWaiting = function(waiting, type, result, rejection, deferred){
+		if(has("config-deferredInstrumentation")){
+			if(type === REJECTED && Deferred.instrumentRejected && waiting.length === 0){
+				Deferred.instrumentRejected(result, false, rejection, deferred);
+			}
+		}
+
+		for(var i = 0; i < waiting.length; i++){
+			signalListener(waiting[i], type, result, rejection);
+		}
+	};
+
+	var signalListener = function(listener, type, result, rejection){
+		var func = listener[type];
+		var deferred = listener.deferred;
+		if(func){
+			try{
+				var newResult = func(result);
+				if(type === PROGRESS){
+					if(typeof newResult !== "undefined"){
+						signalDeferred(deferred, type, newResult);
+					}
+				}else{
+					if(newResult && typeof newResult.then === "function"){
+						listener.cancel = newResult.cancel;
+						newResult.then(
+								// Only make resolvers if they're actually going to be used
+								makeDeferredSignaler(deferred, RESOLVED),
+								makeDeferredSignaler(deferred, REJECTED),
+								makeDeferredSignaler(deferred, PROGRESS));
+						return;
+					}
+					signalDeferred(deferred, RESOLVED, newResult);
+				}
+			}catch(error){
+				signalDeferred(deferred, REJECTED, error);
+			}
+		}else{
+			signalDeferred(deferred, type, result);
+		}
+
+		if(has("config-deferredInstrumentation")){
+			if(type === REJECTED && Deferred.instrumentRejected){
+				Deferred.instrumentRejected(result, !!func, rejection, deferred.promise);
+			}
+		}
+	};
+
+	var makeDeferredSignaler = function(deferred, type){
+		return function(value){
+			signalDeferred(deferred, type, value);
+		};
+	};
+
+	var signalDeferred = function(deferred, type, result){
+		if(!deferred.isCanceled()){
+			switch(type){
+				case PROGRESS:
+					deferred.progress(result);
+					break;
+				case RESOLVED:
+					deferred.resolve(result);
+					break;
+				case REJECTED:
+					deferred.reject(result);
+					break;
+			}
+		}
+	};
+
+	var Deferred = function(canceler){
+		// summary:
+		//		Creates a new deferred. This API is preferred over
+		//		`dojo/_base/Deferred`.
+		// description:
+		//		Creates a new deferred, as an abstraction over (primarily)
+		//		asynchronous operations. The deferred is the private interface
+		//		that should not be returned to calling code. That's what the
+		//		`promise` is for. See `dojo/promise/Promise`.
+		// canceler: Function?
+		//		Will be invoked if the deferred is canceled. The canceler
+		//		receives the reason the deferred was canceled as its argument.
+		//		The deferred is rejected with its return value, or a new
+		//		`dojo/errors/CancelError` instance.
+
+		// promise: dojo/promise/Promise
+		//		The public promise object that clients can add callbacks to. 
+		var promise = this.promise = new Promise();
+
+		var deferred = this;
+		var fulfilled, result, rejection;
+		var canceled = false;
+		var waiting = [];
+
+		if(has("config-deferredInstrumentation") && Error.captureStackTrace){
+			Error.captureStackTrace(deferred, Deferred);
+			Error.captureStackTrace(promise, Deferred);
+		}
+
+		this.isResolved = promise.isResolved = function(){
+			// summary:
+			//		Checks whether the deferred has been resolved.
+			// returns: Boolean
+
+			return fulfilled === RESOLVED;
+		};
+
+		this.isRejected = promise.isRejected = function(){
+			// summary:
+			//		Checks whether the deferred has been rejected.
+			// returns: Boolean
+
+			return fulfilled === REJECTED;
+		};
+
+		this.isFulfilled = promise.isFulfilled = function(){
+			// summary:
+			//		Checks whether the deferred has been resolved or rejected.
+			// returns: Boolean
+
+			return !!fulfilled;
+		};
+
+		this.isCanceled = promise.isCanceled = function(){
+			// summary:
+			//		Checks whether the deferred has been canceled.
+			// returns: Boolean
+
+			return canceled;
+		};
+
+		this.progress = function(update, strict){
+			// summary:
+			//		Emit a progress update on the deferred.
+			// description:
+			//		Emit a progress update on the deferred. Progress updates
+			//		can be used to communicate updates about the asynchronous
+			//		operation before it has finished.
+			// update: any
+			//		The progress update. Passed to progbacks.
+			// strict: Boolean?
+			//		If strict, will throw an error if the deferred has already
+			//		been fulfilled and consequently no progress can be emitted.
+			// returns: dojo/promise/Promise
+			//		Returns the original promise for the deferred.
+
+			if(!fulfilled){
+				signalWaiting(waiting, PROGRESS, update, null, deferred);
+				return promise;
+			}else if(strict === true){
+				throw new Error(FULFILLED_ERROR_MESSAGE);
+			}else{
+				return promise;
+			}
+		};
+
+		this.resolve = function(value, strict){
+			// summary:
+			//		Resolve the deferred.
+			// description:
+			//		Resolve the deferred, putting it in a success state.
+			// value: any
+			//		The result of the deferred. Passed to callbacks.
+			// strict: Boolean?
+			//		If strict, will throw an error if the deferred has already
+			//		been fulfilled and consequently cannot be resolved.
+			// returns: dojo/promise/Promise
+			//		Returns the original promise for the deferred.
+
+			if(!fulfilled){
+				// Set fulfilled, store value. After signaling waiting listeners unset
+				// waiting.
+				signalWaiting(waiting, fulfilled = RESOLVED, result = value, null, deferred);
+				waiting = null;
+				return promise;
+			}else if(strict === true){
+				throw new Error(FULFILLED_ERROR_MESSAGE);
+			}else{
+				return promise;
+			}
+		};
+
+		var reject = this.reject = function(error, strict){
+			// summary:
+			//		Reject the deferred.
+			// description:
+			//		Reject the deferred, putting it in an error state.
+			// error: any
+			//		The error result of the deferred. Passed to errbacks.
+			// strict: Boolean?
+			//		If strict, will throw an error if the deferred has already
+			//		been fulfilled and consequently cannot be rejected.
+			// returns: dojo/promise/Promise
+			//		Returns the original promise for the deferred.
+
+			if(!fulfilled){
+				if(has("config-deferredInstrumentation") && Error.captureStackTrace){
+					Error.captureStackTrace(rejection = {}, reject);
+				}
+				signalWaiting(waiting, fulfilled = REJECTED, result = error, rejection, deferred);
+				waiting = null;
+				return promise;
+			}else if(strict === true){
+				throw new Error(FULFILLED_ERROR_MESSAGE);
+			}else{
+				return promise;
+			}
+		};
+
+		this.then = promise.then = function(callback, errback, progback){
+			// summary:
+			//		Add new callbacks to the deferred.
+			// description:
+			//		Add new callbacks to the deferred. Callbacks can be added
+			//		before or after the deferred is fulfilled.
+			// callback: Function?
+			//		Callback to be invoked when the promise is resolved.
+			//		Receives the resolution value.
+			// errback: Function?
+			//		Callback to be invoked when the promise is rejected.
+			//		Receives the rejection error.
+			// progback: Function?
+			//		Callback to be invoked when the promise emits a progress
+			//		update. Receives the progress update.
+			// returns: dojo/promise/Promise
+			//		Returns a new promise for the result of the callback(s).
+			//		This can be used for chaining many asynchronous operations.
+
+			var listener = [progback, callback, errback];
+			// Ensure we cancel the promise we're waiting for, or if callback/errback
+			// have returned a promise, cancel that one.
+			listener.cancel = promise.cancel;
+			listener.deferred = new Deferred(function(reason){
+				// Check whether cancel is really available, returned promises are not
+				// required to expose `cancel`
+				return listener.cancel && listener.cancel(reason);
+			});
+			if(fulfilled && !waiting){
+				signalListener(listener, fulfilled, result, rejection);
+			}else{
+				waiting.push(listener);
+			}
+			return listener.deferred.promise;
+		};
+
+		this.cancel = promise.cancel = function(reason, strict){
+			// summary:
+			//		Inform the deferred it may cancel its asynchronous operation.
+			// description:
+			//		Inform the deferred it may cancel its asynchronous operation.
+			//		The deferred's (optional) canceler is invoked and the
+			//		deferred will be left in a rejected state. Can affect other
+			//		promises that originate with the same deferred.
+			// reason: any
+			//		A message that may be sent to the deferred's canceler,
+			//		explaining why it's being canceled.
+			// strict: Boolean?
+			//		If strict, will throw an error if the deferred has already
+			//		been fulfilled and consequently cannot be canceled.
+			// returns: any
+			//		Returns the rejection reason if the deferred was canceled
+			//		normally.
+
+			if(!fulfilled){
+				// Cancel can be called even after the deferred is fulfilled
+				if(canceler){
+					var returnedReason = canceler(reason);
+					reason = typeof returnedReason === "undefined" ? reason : returnedReason;
+				}
+				canceled = true;
+				if(!fulfilled){
+					// Allow canceler to provide its own reason, but fall back to a CancelError
+					if(typeof reason === "undefined"){
+						reason = new CancelError();
+					}
+					reject(reason);
+					return reason;
+				}else if(fulfilled === REJECTED && result === reason){
+					return reason;
+				}
+			}else if(strict === true){
+				throw new Error(FULFILLED_ERROR_MESSAGE);
+			}
+		};
+
+		freezeObject(promise);
+	};
+
+	Deferred.prototype.toString = function(){
+		// returns: String
+		//		Returns `[object Deferred]`.
+
+		return "[object Deferred]";
+	};
+
+	if(instrumentation){
+		instrumentation(Deferred);
+	}
+
+	return Deferred;
+});

+define(["./_base/kernel", "./_base/Deferred", "./_base/array"], function(dojo, Deferred, darray){
+	// module:
+	//		dojo/DeferredList
+
+
+dojo.DeferredList = function(/*Array*/ list, /*Boolean?*/ fireOnOneCallback, /*Boolean?*/ fireOnOneErrback, /*Boolean?*/ consumeErrors, /*Function?*/ canceller){
+	// summary:
+	//		Deprecated, use dojo/promise/all instead.
+	//		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;
+});

+define(["./aspect", "./on"], function(aspect, on){
+	// module:
+	//		dojo/Evented
+
+ 	"use strict";
+ 	var after = aspect.after;
+	function Evented(){
+		// summary:
+		//		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 emitting 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", ...});
+	}
+	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;
+});

+define([
+	"./_base/kernel", "./query", "./_base/lang", "./_base/array", "./dom-attr"
+], function(dojo, query, lang, array, attr){
+
+	// module:
+	//		dojo/NodeList-data
+
+	/*=====
+	return function(){
+		// summary:
+		//		Adds data() and removeData() methods to NodeList, and returns NodeList constructor.
+	};
+	=====*/
+
+	var NodeList = query.NodeList;
+
+	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;
+		}
+	;
+
+	//>>excludeStart("debugging", true);
+	// An alias to the private dataCache for NodeList-data. NEVER USE THIS!
+	// This private is only exposed for the benefit of unit testing, and is
+	// removed during the build process.
+	NodeList._nodeDataCache = dojo._nodeDataCache = dataCache;
+	//>>excludeEnd("debugging");
+
+	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];
+			}
+		}
+	};
+
+	NodeList._gcNodeData = 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)
+	});
+
+	/*=====
+	 lang.extend(NodeList, {
+		 data: function(key, value){
+			 // summary:
+			 //		stash or get some arbitrary data on/from these nodes.
+			 //
+			 // description:
+			 //		Stash or get some arbitrary 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 chaining. 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)
+		 },
+
+		 removeData: function(key){
+			 // summary:
+			 //		Remove the data associated with these nodes.
+			 // key: String?
+			 //		If omitted, clean all data for this node.
+			 //		If passed, remove the data item found at `key`
+		 }
+	 });
+	 =====*/
+
+// TODO: this is the basic implementation of adaptWithConditionAndWhenMappedConsiderLength, 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; // NodeList|Array|SingleItem
+//	};
+
+	return NodeList;
+
+});

+define(["./query", "./_base/lang", "./aspect", "./_base/fx", "./fx"],
+function(query, lang, aspect, baseFx, coreFx){
+
+// module:
+//		dojo/NodeList-fx
+
+/*=====
+return function(){
+	// 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.
+};
+=====*/
+
+var NodeList = query.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/_base/fx.Animation|dojo/NodeList
+	},
+
+	wipeIn: function(args){
+		// summary:
+		//		wipe in all elements of this NodeList via `dojo/fx.wipeIn()`
+		//
+		// args: Object?
+		//		Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo/_base/fx.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/_base/fx.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/_base/fx.Animation|dojo/NodeList
+	},
+
+	wipeOut: function(args){
+		// summary:
+		//		wipe out all elements of this NodeList via `dojo/fx.wipeOut()`
+		//
+		// args: Object?
+		//		Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo/_base/fx.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/_base/fx.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/_base/fx.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/_base/fx.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo/_base/fx.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/_base/fx.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/_base/fx.Animation|dojo/NodeList
+	},
+
+
+	fadeIn: function(args){
+		// summary:
+		//		fade in all elements of this NodeList via `dojo.fadeIn`
+		//
+		// args: Object?
+		//		Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo/_base/fx.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/_base/fx.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/_base/fx.Animation|dojo/NodeList
+	},
+
+	fadeOut: function(args){
+		// summary:
+		//		fade out all elements of this NodeList via `dojo.fadeOut`
+		//
+		// args: Object?
+		//		Additional dojo/_base/fx.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo/_base/fx.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/_base/fx.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();
+		//		|	aspect.after(fo, "onEnd", function(){ /*...*/ }, true);
+		//		|	fo.play();
+		// example:
+		//		Using `auto`:
+		//		|	dojo.query("li").fadeOut({ auto:true }).filter(filterFn).forEach(doit);
+		//
+		return this._anim(baseFx, "fadeOut", args); // dojo/_base/fx.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/_base/fx.Animation arguments to mix into this set with the addition of
+		//		an `auto` parameter.
+		//
+		// returns: dojo/_base/fx.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/_base/fx.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/_base/fx.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){
+			aspect.after(canim, "onEnd", onEnd, true);
+		}
+		return canim.play(delay||0); // dojo/_base/fx.Animation
+	}
+});
+
+return NodeList;
+});

+define(["./query", "./_base/lang", "./html"], function(query, lang, html){
+
+// module:
+//		dojo/NodeList-html
+
+/*=====
+return function(){
+	// summary:
+	//		Adds a chainable html method to dojo.query() / NodeList instances for setting/replacing node content
+};
+=====*/
+
+var NodeList = query.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:
+		//	| query(".thingList").html("<li data-dojo-type='dojo/dnd/Moveable'>1</li><li data-dojo-type='dojo/dnd/Moveable'>2</li><li data-dojo-type='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;
+});

+define(["./query"], function(query){
+	// This class is just for documentation purposes, so NodeList shows up well in the API viewer,
+	// and to simplify writing API doc for all the methods that take NodeList as a parameter, or return a NodeList.
+	return query.NodeList;
+});
+

+/*******************************************************************************
+ * 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 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 = {};
+		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);
+			}
+		};
+
+		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", {});
+
+}

+define(["./_base/declare", "./_base/lang", "./_base/array", "./when"], function(declare, lang, array, when){
+	// module:
+	//		dojo/Stateful
+
+return 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
+	//
+	//		The class also provides the functionality to auto-magically manage getters
+	//		and setters for object attributes/properties.
+	//		
+	//		Getters and Setters should follow the format of _xxxGetter or _xxxSetter where 
+	//		the xxx is a name of the attribute to handle.  So an attribute of "foo" 
+	//		would have a custom getter of _fooGetter and a custom setter of _fooSetter.
+	//
+	// example:
+	//	|	var obj = new dojo.Stateful();
+	//	|	obj.watch("foo", function(){
+	//	|		console.log("foo changed to " + this.get("foo"));
+	//	|	});
+	//	|	obj.set("foo","bar");
+
+	// _attrPairNames: Hash
+	//		Used across all instances a hash to cache attribute names and their getter 
+	//		and setter names.
+	_attrPairNames: {},
+
+	_getAttrNames: function(name){
+		// summary:
+		//		Helper function for get() and set().
+		//		Caches attribute name values so we don't do the string ops every time.
+		// tags:
+		//		private
+
+		var apn = this._attrPairNames;
+		if(apn[name]){ return apn[name]; }
+		return (apn[name] = {
+			s: "_" + name + "Setter",
+			g: "_" + name + "Getter"
+		});
+	},
+
+	postscript: function(/*Object?*/ params){
+		// Automatic setting of params during construction
+		if (params){ this.set(params); }
+	},
+
+	_get: function(name, names){
+		// summary:
+		//		Private function that does a get based off a hash of names
+		// names:
+		//		Hash of names of custom attributes
+		return typeof this[names.g] === "function" ? this[names.g]() : this[name];
+	},
+	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._get(name, this._getAttrNames(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 an object is used, iterate through object
+		if(typeof name === "object"){
+			for(var x in name){
+				if(name.hasOwnProperty(x) && x !="_watchCallbacks"){
+					this.set(x, name[x]);
+				}
+			}
+			return this;
+		}
+
+		var names = this._getAttrNames(name),
+			oldValue = this._get(name, names),
+			setter = this[names.s],
+			result;
+		if(typeof setter === "function"){
+			// use the explicit setter
+			result = setter.apply(this, Array.prototype.slice.call(arguments, 1));
+		}else{
+			// no setter so set attribute directly
+			this[name] = value;
+		}
+		if(this._watchCallbacks){
+			var self = this;
+			// If setter returned a promise, wait for it to complete, otherwise call watches immediatly
+			when(result, function(){
+				self._watchCallbacks(name, oldValue, value);
+			});
+		}
+		return this; // dojo/Stateful
+	},
+	_changeAttrValue: function(name, value){
+		// summary:
+		//		Internal helper for directly changing an attribute value.
+		//
+		// name: String
+		//		The property to set.
+		// value: Mixed
+		//		The value to set in the property.
+		//
+		// description:
+		//		Directly change the value of an attribute on an object, bypassing any 
+		//		accessor setter.  Also handles the calling of watch and emitting events. 
+		//		It is designed to be used by descendent class when there are two values 
+		//		of attributes that are linked, but calling .set() is not appropriate.
+
+		var oldValue = this.get(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++){
+							propertyCallbacks[i].call(self, name, oldValue, value);
+						}
+					}
+				};
+				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);
+
+		// TODO: Remove unwatch in 2.0
+		var handle = {};
+		handle.unwatch = handle.remove = function(){
+			var index = array.indexOf(propertyCallbacks, callback);
+			if(index > -1){
+				propertyCallbacks.splice(index, 1);
+			}
+		};
+		return handle; //Object
+	}
+
+});
+
+});

+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 `Color` object
+		//		and creates a new Color instance to work from.
+		//
+		// example:
+		//		Work with a Color instance:
+		//	 | var c = new 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 Color(color);
+		//	 | // adjust the color some
+		//	 | n.r *= .5;
+		//	 | console.log(n.toString()); // rgb(128, 255, 255);
+		if(color){ this.setColor(color); }
+	};
+
+	// FIXME:
+	// there's got to be a more space-efficient way to encode or discover
+	// these!! Use hex?
+	Color.named = {
+		// summary:
+		//		Dictionary list of all CSS named colors, by name. Values are 3-item arrays with corresponding RG and B values.
+		"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 `Color` object
+			//		and sets this color instance to that value.
+			//
+			// example:
+			//	|	var c = new 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;	// 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;	// Color
+		},
+		toRgb: function(){
+			// summary:
+			//		Returns 3 component array of rgb values
+			// example:
+			//	|	var c = new 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 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 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(
+		/*Color*/ start,
+		/*Color*/ end,
+		/*Number*/ weight,
+		/*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 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();	// Color
+	};
+
+	Color.fromRgb = dojo.colorFromRgb = function(/*String*/ color, /*Color?*/ obj){
+		// summary:
+		//		Returns a `Color` instance from a string of the form
+		//		"rgb(...)" or "rgba(...)". Optionally accepts a `Color`
+		//		object to update with the parsed value and return instead of
+		//		creating a new object.
+		// returns:
+		//		A 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);	// Color
+	};
+
+	Color.fromHex = dojo.colorFromHex = function(/*String*/ color, /*Color?*/ obj){
+		// summary:
+		//		Converts a hex string with a '#' prefix to a color object.
+		//		Supports 12-bit #rgb shorthand. Optionally accepts a
+		//		`Color` object to update with the parsed value.
+		//
+		// returns:
+		//		A 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; // 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;	// Color
+	};
+
+	Color.fromArray = dojo.colorFromArray = function(/*Array*/ a, /*Color?*/ obj){
+		// summary:
+		//		Builds a `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 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();	// Color
+	};
+
+	Color.fromString = dojo.colorFromString = function(/*String*/ str, /*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 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);	// Color
+	};
+
+	return Color;
+});

+define(["./kernel", "../query", "./array", "./html", "../NodeList-dom"], function(dojo, query, array){
+	// module:
+	//		dojo/_base/NodeList
+
+	/*=====
+	return {
+		// summary:
+		//		This module extends dojo/NodeList with the legacy connect(), coords(),
+		//		blur(), focus(), change(), click(), error(), keydown(), keypress(),
+		//		keyup(), load(), mousedown(), mouseenter(), mouseleave(), mousemove(),
+		//		mouseout(), mouseover(), mouseup(), and submit() methods.
+	};
+	=====*/
+ 
+	var NodeList = query.NodeList,
+		nlp = NodeList.prototype;
+
+	nlp.connect = NodeList._adaptAsForEach(function(){
+		// don't bind early to dojo.connect since we no longer explicitly depend on it
+		return dojo.connect.apply(this, arguments);
+	});
+	/*=====
+	nlp.connect = function(methodName, objOrFunc, funcName){
+		// summary:
+		//		Attach event handlers to every item of the NodeList. Uses dojo.connect()
+		//		so event properties are normalized.
+		//
+		//		Application must manually require() "dojo/_base/connect" before using this method.
+		// 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
+		//		|	query("div:nth-child(odd)").connect("onclick", function(e){
+		//		|		console.log("clicked!");
+		//		|	});
+		// example:
+		//		attach foo.bar() to every odd div's onmouseover
+		//		|	query("div:nth-child(odd)").connect("onmouseover", foo, "bar");
+
+		return null;	// NodeList
+	};
+	=====*/
+
+	nlp.coords = NodeList._adaptAsMap(dojo.coords);
+	/*=====
+	nlp.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 `domGeom.coords`, though assumes
+		//		the node passed is each node in this list.
+
+		return []; // Array
+	};
+	=====*/
+
+	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 NodeList;
+});

+if(require.has){
+	require.has.add("config-selectorEngine", "acme");
+}
+define([
+	"../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
+
+	/*=====
+	return {
+		// summary:
+		//		This module causes the browser-only base modules to be loaded.
+	};
+	=====*/
+
+	return dojo;
+});

+define(["../has", "require"], function(has, require){
+	// module:
+	//		dojo/_base/config
+
+/*=====
+return {
+	// 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-unique 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
+	//		|	});
+
+	// 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: [deprecated] 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. Specifying
+	//		`djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
+	//		of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
+	//		modules may be configured via `djConfig.modulePaths`.
+	modulePaths: {},
+
+	// addOnLoad: Function|Array
+	//		Adds a callback via dojo/ready. Useful when Dojo is added after
+	//		the page loads and djConfig.afterOnLoad is true. Supports the same
+	//		arguments as dojo/ready. 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,
+
+	// parseOnLoad: Boolean
+	//		Run the parser after the page is loaded
+	parseOnLoad: false,
+
+	// require: String[]
+	//		An array of module names to be loaded immediately after dojo.js has been included
+	//		in a page.
+	require: [],
+
+	// defaultDuration: Number
+	//		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/topic.publish(). See dojo/main.__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,
+	
+	// deps: Function|Array
+	//		Defines dependencies to be used before the loader has been loaded.
+	//		When provided, they cause the loader to execute require(deps, callback) 
+	//		once it has finished loading. Should be used with callback.
+	deps: undefined,
+	
+	// callback: Function|Array
+	//		Defines a callback to be used when dependencies are defined before 
+	//		the loader has been loaded. When provided, they cause the loader to 
+	//		execute require(deps, callback) once it has finished loading. 
+	//		Should be used with deps.
+	callback: undefined,
+	
+	// deferredInstrumentation: Boolean
+	//		Whether deferred instrumentation should be loaded or included
+	//		in builds.
+	deferredInstrumentation: true,
+
+	// useDeferredInstrumentation: Boolean|String
+	//		Whether the deferred instrumentation should be used.
+	//
+	//		* `"report-rejections"`: report each rejection as it occurs.
+	//		* `true` or `1` or `"report-unhandled-rejections"`: wait 1 second
+	//			in an attempt to detect unhandled rejections.
+	useDeferredInstrumentation: "report-unhandled-rejections"
+};
+=====*/
+
+	var result = {};
+	if(has("dojo-config-api")){
+		// 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 = has("dojo-loader") ?
+			// 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);
+	}
+
+	if(!result.locale && typeof navigator != "undefined"){
+		// Default locale for browsers.
+		result.locale = (navigator.language || navigator.userLanguage).toLowerCase();
+	}
+
+	return result;
+});
+

+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'),
+		path = require('path');
+
+	// reset some configuration switches with node-appropriate values
+	var nodeConfig = {
+		baseUrl: path.dirname(process.argv[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];
+	}
+};

+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];
+	}
+}

+// TODO: this file needs to be converted to the v1.7 loader
+
+// module:
+//		configSpidermonkey
+// summary:
+//		 SpiderMonkey host environment
+
+if(dojo.config["baseUrl"]){
+	dojo.baseUrl = dojo.config["baseUrl"];
+}else{
+	dojo.baseUrl = "./";
+}
+
+dojo._name = '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]);
+	}
+}

+define(["./kernel", "../on", "../has", "../dom-geometry"], function(dojo, on, has, dom){
+	// module:
+	//		dojo/_base/event
+
+	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;
+		};		
+	}
+	
+	var ret = {
+		// summary:
+		//		This module defines dojo DOM event API.   Usually you should use dojo/on, and evt.stopPropagation() +
+		//		evt.preventDefault(), rather than this module.
+
+		fix: 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
+		},
+	
+		stop: 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);
+			}
+		}
+	};
+
+	if(has("extend-dojo")){
+		dojo.fixEvent = ret.fix;
+		dojo.stopEvent = ret.stop;
+	}
+
+	return ret;
+});

+define(["./kernel", "../json"], function(dojo, json){
+
+// module:
+//		dojo/_base/json
+
+/*=====
+return {
+	// 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;
+});

+define(["../query", "./NodeList"], function(query){
+	// module:
+	//		dojo/_base/query
+
+	/*=====
+	return {
+		// summary:
+		//		Deprecated.   Use dojo/query instead.
+	};
+	=====*/
+
+	return query;
+});

+define(["./kernel", "./lang", "../sniff"], function(dojo, lang, has){
+	// module:
+	//		dojo/_base/sniff
+
+	/*=====
+	return {
+		// summary:
+		//		Deprecated.   New code should use dojo/sniff.
+		//		This module populates the dojo browser version sniffing properties like dojo.isIE.
+	};
+	=====*/
+
+	if(!has("host-browser")){
+		return has;
+	}
+
+	// no idea what this is for, or if it's used
+	dojo._name = "browser";
+
+	lang.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: has("ff"),
+
+		// 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: has("ie"),
+
+		// isKhtml: Number|undefined
+		//		Version as a Number if client is a KHTML browser. undefined otherwise. Corresponds to major
+		//		detected version.
+		isKhtml: has("khtml"),
+
+		// isWebKit: Number|undefined
+		//		Version as a Number if client is a WebKit-derived browser (Konqueror,
+		//		Safari, Chrome, etc.). undefined otherwise.
+		isWebKit: has("webkit"),
+
+		// isMozilla: Number|undefined
+		//		Version as a Number if client is a Mozilla-based browser (Firefox,
+		//		SeaMonkey). undefined otherwise. Corresponds to major detected version.
+		isMozilla: has("mozilla"),
+		// isMoz: Number|undefined
+		//		Version as a Number if client is a Mozilla-based browser (Firefox,
+		//		SeaMonkey). undefined otherwise. Corresponds to major detected version.
+		isMoz: has("mozilla"),
+
+		// isOpera: Number|undefined
+		//		Version as a Number if client is Opera. undefined otherwise. Corresponds to
+		//		major detected version.
+		isOpera: has("opera"),
+
+		// isSafari: Number|undefined
+		//		Version as a Number if client is Safari or iPhone. undefined otherwise.
+		isSafari: has("safari"),
+
+		// isChrome: Number|undefined
+		//		Version as a Number if client is Chrome browser. undefined otherwise.
+		isChrome: has("chrome"),
+
+		// isMac: Boolean
+		//		True if the client runs on Mac
+		isMac: has("mac"),
+
+		// isIos: Number|undefined
+		//		Version as a Number if client is iPhone, iPod, or iPad. undefined otherwise.
+		isIos: has("ios"),
+
+		// isAndroid: Number|undefined
+		//		Version as a Number if client is android browser. undefined otherwise.
+		isAndroid: has("android"),
+
+		// isWii: Boolean
+		//		True if client is Wii
+		isWii: has("wii"),
+
+		// isQuirks: Boolean
+		//		Page is in quirks mode.
+		isQuirks: has("quirks"),
+
+		// isAir: Boolean
+		//		True if client is Adobe Air
+		isAir: has("air")
+	});
+
+	return has;
+});

+define(["./kernel", "./lang", "../on"], function(dojo, lang, on){
+
+// module:
+//		dojo/unload
+
+var win = window;
+
+var unload = {
+	// summary:
+	//		This module contains the document and window unload detection API.
+
+	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
+		//		destroy "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
+		//		addOnUnload() if you need to modify the DOM or do
+		//		heavy JavaScript work since it fires at the equivalent of
+		//		the page's "onbeforeunload" event.
+		// example:
+		//	|	unload.addOnWindowUnload(functionPointer)
+		//	|	unload.addOnWindowUnload(object, "functionName");
+		//	|	unload.addOnWindowUnload(object, function(){ /* ... */});
+
+		if (!dojo.windowUnloaded){
+			on(win, "unload", (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
+				//		addOnWindowUnload(). This behavior started in Dojo 1.3.
+				//		Previous versions always triggered windowUnloaded(). See
+				//		addOnWindowUnload for more info.
+			}));
+		}
+		on(win, "unload", lang.hitch(obj, functionName));
+	},
+
+	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 environment, 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(){ /* ... */});
+
+		on(win, "beforeunload", lang.hitch(obj, functionName));
+	}
+};
+
+dojo.addOnWindowUnload = unload.addOnWindowUnload;
+dojo.addOnUnload = unload.addOnUnload;
+
+return unload;
+
+});

+define(["./kernel"], function(dojo){
+	// module:
+	//		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;
+});

+define(["./kernel", "./lang", "../sniff"], function(dojo, lang, has){
+// module:
+//		dojo/_base/window
+
+var ret = {
+	// summary:
+	//		API to save/set/restore the global/document scope.
+
+	global: dojo.global,
+	/*=====
+	 global: {
+		 // summary:
+		 //		Alias for the current window. 'global' can be modified
+		 //		for temporary context shifting. See also withGlobal().
+		 // description:
+		 //		Use this rather than referring to 'window' to ensure your code runs
+		 //		correctly in managed contexts.
+	 },
+	 =====*/
+
+	doc: this["document"] || null,
+	/*=====
+	doc: {
+		// summary:
+		//		Alias for the current document. 'doc' can be modified
+		//		for temporary context shifting. See also withDoc().
+		// description:
+		//		Use this rather than referring to 'window.document' to ensure your code runs
+		//		correctly in managed contexts.
+		// example:
+		//	|	n.appendChild(dojo.doc.createElement('div'));
+	},
+	=====*/
+
+	body: function(/*Document?*/ doc){
+		// summary:
+		//		Return the body element of the specified document or of dojo/_base/window::doc.
+		// example:
+		//	|	win.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().
+		doc = doc || dojo.doc;
+		return doc.body || doc.getElementsByTagName("body")[0]; // Node
+	},
+
+	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;
+	},
+
+	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 ret.withDoc.call(null, globalObject.document, callback, thisObject, cbArguments);
+		}finally{
+			dojo.global = ret.global = oldGlob;
+		}
+	},
+
+	withDoc: function(	/*DocumentElement*/ documentObject,
+						/*Function*/ callback,
+						/*Object?*/ thisObject,
+						/*Array?*/ cbArguments){
+		// summary:
+		//		Invoke callback with documentObject as dojo/_base/window::doc.
+		// description:
+		//		Invoke callback with documentObject as dojo/_base/window::doc. If provided,
+		//		callback will be executed in the context of object thisObject
+		//		When callback() returns or throws an error, the dojo/_base/window::doc will
+		//		be restored to its previous state.
+
+		var oldDoc = ret.doc,
+			oldQ = has("quirks"),
+			oldIE = has("ie"), isIE, mode, pwin;
+
+		try{
+			dojo.doc = ret.doc = documentObject;
+			// update dojo.isQuirks and the value of the has feature "quirks".
+			// remove setting dojo.isQuirks and dojo.isIE for 2.0
+			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);
+		}
+	}
+};
+
+has("extend-dojo") && lang.mixin(dojo, ret);
+
+return ret;
+
+});

+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.

+.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;
+}