dojo-rails 0.9.8 → 0.9.9

data/vendor/assets/javascripts/dojo/package.json

@@ -0,0 +1,23 @@
+{
+	"name": "dojo",
+	"version":"1.7.3",
+	"directories": {
+		"lib": "."
+	},
+	"main": "main",
+	"description": "Dojo core is a powerful, lightweight library that makes common tasks quicker and easier. Animate elements, manipulate the DOM, and query with easy CSS syntax, all without sacrificing performance.",
+	"licenses": [
+		 {
+				 "type": "AFLv2.1",
+				 "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L43"
+		 },
+		 {
+				 "type": "BSD",
+				 "url": "http://trac.dojotoolkit.org/browser/dojo/trunk/LICENSE#L13"
+		 }
+	],
+	"bugs": "http://bugs.dojotoolkit.org/",
+	"keywords": ["JavaScript", "Dojo", "Toolkit"],
+	"homepage": "http://dojotoolkit.org/",
+	"dojoBuild": "dojo.profile.js"
+}

data/vendor/assets/javascripts/dojo/parser.js

@@ -0,0 +1,299 @@
+/*
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+//>>built
+define("dojo/parser",["./_base/kernel","./_base/lang","./_base/array","./_base/html","./_base/window","./_base/url","./_base/json","./aspect","./date/stamp","./query","./on","./ready"],function(_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,_b){
+new Date("X");
+var _c={"dom-attributes-explicit":document.createElement("div").attributes.length<40};
+function _d(_e){
+return _c[_e];
+};
+_1.parser=new function(){
+var _f={};
+function _10(_11){
+var map={};
+for(var _12 in _11){
+if(_12.charAt(0)=="_"){
+continue;
+}
+map[_12.toLowerCase()]=_12;
+}
+return map;
+};
+_8.after(_2,"extend",function(){
+_f={};
+},true);
+var _13={};
+this._functionFromScript=function(_14,_15){
+var _16="";
+var _17="";
+var _18=(_14.getAttribute(_15+"args")||_14.getAttribute("args"));
+if(_18){
+_3.forEach(_18.split(/\s*,\s*/),function(_19,idx){
+_16+="var "+_19+" = arguments["+idx+"]; ";
+});
+}
+var _1a=_14.getAttribute("with");
+if(_1a&&_1a.length){
+_3.forEach(_1a.split(/\s*,\s*/),function(_1b){
+_16+="with("+_1b+"){";
+_17+="}";
+});
+}
+return new Function(_16+_14.innerHTML+_17);
+};
+this.instantiate=function(_1c,_1d,_1e){
+var _1f=[],_1d=_1d||{};
+_1e=_1e||{};
+var _20=(_1e.scope||_1._scopeName)+"Type",_21="data-"+(_1e.scope||_1._scopeName)+"-",_22=_21+"type",_23=_21+"props",_24=_21+"attach-point",_25=_21+"attach-event",_26=_21+"id";
+var _27={};
+_3.forEach([_23,_22,_20,_26,"jsId",_24,_25,"dojoAttachPoint","dojoAttachEvent","class","style"],function(_28){
+_27[_28.toLowerCase()]=_28.replace(_1e.scope,"dojo");
+});
+_3.forEach(_1c,function(obj){
+if(!obj){
+return;
+}
+var _29=obj.node||obj,_2a=_20 in _1d?_1d[_20]:obj.node?obj.type:(_29.getAttribute(_22)||_29.getAttribute(_20)),_2b=_13[_2a]||(_13[_2a]=_2.getObject(_2a)),_2c=_2b&&_2b.prototype;
+if(!_2b){
+throw new Error("Could not load class '"+_2a);
+}
+var _2d={};
+if(_1e.defaults){
+_2.mixin(_2d,_1e.defaults);
+}
+if(obj.inherited){
+_2.mixin(_2d,obj.inherited);
+}
+var _2e;
+if(_d("dom-attributes-explicit")){
+_2e=_29.attributes;
+}else{
+var _2f=/^input$|^img$/i.test(_29.nodeName)?_29:_29.cloneNode(false),_30=_2f.outerHTML.replace(/=[^\s"']+|="[^"]*"|='[^']*'/g,"").replace(/^\s*<[a-zA-Z0-9]*/,"").replace(/>.*$/,"");
+_2e=_3.map(_30.split(/\s+/),function(_31){
+var _32=_31.toLowerCase();
+return {name:_31,value:(_29.nodeName=="LI"&&_31=="value")||_32=="enctype"?_29.getAttribute(_32):_29.getAttributeNode(_32).value,specified:true};
+});
+}
+var i=0,_33;
+while(_33=_2e[i++]){
+if(!_33||!_33.specified){
+continue;
+}
+var _34=_33.name,_35=_34.toLowerCase(),_36=_33.value;
+if(_35 in _27){
+switch(_27[_35]){
+case "data-dojo-props":
+var _37=_36;
+break;
+case "data-dojo-id":
+case "jsId":
+var _38=_36;
+break;
+case "data-dojo-attach-point":
+case "dojoAttachPoint":
+_2d.dojoAttachPoint=_36;
+break;
+case "data-dojo-attach-event":
+case "dojoAttachEvent":
+_2d.dojoAttachEvent=_36;
+break;
+case "class":
+_2d["class"]=_29.className;
+break;
+case "style":
+_2d["style"]=_29.style&&_29.style.cssText;
+break;
+}
+}else{
+if(!(_34 in _2c)){
+var map=(_f[_2a]||(_f[_2a]=_10(_2c)));
+_34=map[_35]||_34;
+}
+if(_34 in _2c){
+switch(typeof _2c[_34]){
+case "string":
+_2d[_34]=_36;
+break;
+case "number":
+_2d[_34]=_36.length?Number(_36):NaN;
+break;
+case "boolean":
+_2d[_34]=_36.toLowerCase()!="false";
+break;
+case "function":
+if(_36===""||_36.search(/[^\w\.]+/i)!=-1){
+_2d[_34]=new Function(_36);
+}else{
+_2d[_34]=_2.getObject(_36,false)||new Function(_36);
+}
+break;
+default:
+var _39=_2c[_34];
+_2d[_34]=(_39&&"length" in _39)?(_36?_36.split(/\s*,\s*/):[]):(_39 instanceof Date)?(_36==""?new Date(""):_36=="now"?new Date():_9.fromISOString(_36)):(_39 instanceof _1._Url)?(_1.baseUrl+_36):_7.fromJson(_36);
+}
+}else{
+_2d[_34]=_36;
+}
+}
+}
+if(_37){
+try{
+_37=_7.fromJson.call(_1e.propsThis,"{"+_37+"}");
+_2.mixin(_2d,_37);
+}
+catch(e){
+throw new Error(e.toString()+" in data-dojo-props='"+_37+"'");
+}
+}
+_2.mixin(_2d,_1d);
+var _3a=obj.node?obj.scripts:(_2b&&(_2b._noScript||_2c._noScript)?[]:_a("> script[type^='dojo/']",_29));
+var _3b=[],_3c=[],_3d=[],on=[];
+if(_3a){
+for(i=0;i<_3a.length;i++){
+var _3e=_3a[i];
+_29.removeChild(_3e);
+var _3f=(_3e.getAttribute(_21+"event")||_3e.getAttribute("event")),_40=_3e.getAttribute(_21+"prop"),_2a=_3e.getAttribute("type"),nf=this._functionFromScript(_3e,_21);
+if(_3f){
+if(_2a=="dojo/connect"){
+_3b.push({event:_3f,func:nf});
+}else{
+if(_2a=="dojo/on"){
+on.push({event:_3f,func:nf});
+}else{
+_2d[_3f]=nf;
+}
+}
+}else{
+if(_2a=="dojo/watch"){
+_3d.push({prop:_40,func:nf});
+}else{
+_3c.push(nf);
+}
+}
+}
+}
+var _41=_2b.markupFactory||_2c.markupFactory;
+var _42=_41?_41(_2d,_29,_2b):new _2b(_2d,_29);
+_1f.push(_42);
+if(_38){
+_2.setObject(_38,_42);
+}
+for(i=0;i<_3b.length;i++){
+_8.after(_42,_3b[i].event,_1.hitch(_42,_3b[i].func),true);
+}
+for(i=0;i<_3c.length;i++){
+_3c[i].call(_42);
+}
+for(i=0;i<_3d.length;i++){
+_42.watch(_3d[i].prop,_3d[i].func);
+}
+for(i=0;i<on.length;i++){
+_b(_42,on[i].event,on[i].func);
+}
+},this);
+if(!_1d._started){
+_3.forEach(_1f,function(_43){
+if(!_1e.noStart&&_43&&_2.isFunction(_43.startup)&&!_43._started){
+_43.startup();
+}
+});
+}
+return _1f;
+};
+this.parse=function(_44,_45){
+var _46;
+if(!_45&&_44&&_44.rootNode){
+_45=_44;
+_46=_45.rootNode;
+}else{
+_46=_44;
+}
+_46=_46?_4.byId(_46):_5.body();
+_45=_45||{};
+var _47=(_45.scope||_1._scopeName)+"Type",_48="data-"+(_45.scope||_1._scopeName)+"-",_49=_48+"type",_4a=_48+"textdir";
+var _4b=[];
+var _4c=_46.firstChild;
+var _4d=_45&&_45.inherited;
+if(!_4d){
+function _4e(_4f,_50){
+return (_4f.getAttribute&&_4f.getAttribute(_50))||(_4f!==_5.doc&&_4f!==_5.doc.documentElement&&_4f.parentNode?_4e(_4f.parentNode,_50):null);
+};
+_4d={dir:_4e(_46,"dir"),lang:_4e(_46,"lang"),textDir:_4e(_46,_4a)};
+for(var key in _4d){
+if(!_4d[key]){
+delete _4d[key];
+}
+}
+}
+var _51={inherited:_4d};
+var _52;
+var _53;
+function _54(_55){
+if(!_55.inherited){
+_55.inherited={};
+var _56=_55.node,_57=_54(_55.parent);
+var _58={dir:_56.getAttribute("dir")||_57.dir,lang:_56.getAttribute("lang")||_57.lang,textDir:_56.getAttribute(_4a)||_57.textDir};
+for(var key in _58){
+if(_58[key]){
+_55.inherited[key]=_58[key];
+}
+}
+}
+return _55.inherited;
+};
+while(true){
+if(!_4c){
+if(!_51||!_51.node){
+break;
+}
+_4c=_51.node.nextSibling;
+_52=_51.scripts;
+_53=false;
+_51=_51.parent;
+continue;
+}
+if(_4c.nodeType!=1){
+_4c=_4c.nextSibling;
+continue;
+}
+if(_52&&_4c.nodeName.toLowerCase()=="script"){
+_59=_4c.getAttribute("type");
+if(_59&&/^dojo\/\w/i.test(_59)){
+_52.push(_4c);
+}
+_4c=_4c.nextSibling;
+continue;
+}
+if(_53){
+_4c=_4c.nextSibling;
+continue;
+}
+var _59=_4c.getAttribute(_49)||_4c.getAttribute(_47);
+var _5a=_4c.firstChild;
+if(!_59&&(!_5a||(_5a.nodeType==3&&!_5a.nextSibling))){
+_4c=_4c.nextSibling;
+continue;
+}
+var _5b={node:_4c,scripts:_52,parent:_51};
+var _5c=_59&&(_13[_59]||(_13[_59]=_2.getObject(_59))),_5d=_5c&&!_5c.prototype._noScript?[]:null;
+if(_59){
+_4b.push({"type":_59,node:_4c,scripts:_5d,inherited:_54(_5b)});
+}
+_4c=_5a;
+_52=_5d;
+_53=_5c&&_5c.prototype.stopParser&&!(_45&&_45.template);
+_51=_5b;
+}
+var _5e=_45&&_45.template?{template:true}:null;
+return this.instantiate(_4b,_5e,_45);
+};
+}();
+if(_1.config.parseOnLoad){
+_1.ready(100,_1.parser,"parse");
+}
+return _1.parser;
+});

data/vendor/assets/javascripts/dojo/parser.js.uncompressed.js

@@ -0,0 +1,594 @@
+define(
+	"dojo/parser", ["./_base/kernel", "./_base/lang", "./_base/array", "./_base/html", "./_base/window", "./_base/url",
+		"./_base/json", "./aspect", "./date/stamp", "./query", "./on", "./ready"],
+	function(dojo, dlang, darray, dhtml, dwindow, _Url, djson, aspect, dates, query, don){
+
+// module:
+//		dojo/parser
+// summary:
+//		The Dom/Widget parsing package
+
+new Date("X"); // workaround for #11279, new Date("") == NaN
+
+var features = {
+	// Feature detection for when node.attributes only lists the attributes specified in the markup
+	// rather than old IE/quirks behavior where it lists every default value too
+	"dom-attributes-explicit": document.createElement("div").attributes.length < 40
+};
+function has(feature){
+	return features[feature];
+}
+
+
+dojo.parser = new function(){
+	// summary:
+	//		The Dom/Widget parsing package
+
+	var _nameMap = {
+		// Map from widget name (ex: "dijit.form.Button") to structure mapping
+		// lowercase version of attribute names to the version in the widget ex:
+		//	{
+		//		label: "label",
+		//		onclick: "onClick"
+		//	}
+	};
+	function getNameMap(proto){
+		// summary:
+		//		Returns map from lowercase name to attribute name in class, ex: {onclick: "onClick"}
+		var map = {};
+		for(var name in proto){
+			if(name.charAt(0)=="_"){ continue; }	// skip internal properties
+			map[name.toLowerCase()] = name;
+		}
+		return map;
+	}
+	// Widgets like BorderContainer add properties to _Widget via dojo.extend().
+	// If BorderContainer is loaded after _Widget's parameter list has been cached,
+	// we need to refresh that parameter list (for _Widget and all widgets that extend _Widget).
+	aspect.after(dlang, "extend", function(){
+		_nameMap = {};
+	}, true);
+
+	// Map from widget name (ex: "dijit.form.Button") to constructor
+	var _ctorMap = {};
+
+	this._functionFromScript = function(script, attrData){
+		// summary:
+		//		Convert a <script type="dojo/method" args="a, b, c"> ... </script>
+		//		into a function
+		// script: DOMNode
+		//		The <script> DOMNode
+		// attrData: String
+		//		For HTML5 compliance, searches for attrData + "args" (typically
+		//		"data-dojo-args") instead of "args"
+		var preamble = "";
+		var suffix = "";
+		var argsStr = (script.getAttribute(attrData + "args") || script.getAttribute("args"));
+		if(argsStr){
+			darray.forEach(argsStr.split(/\s*,\s*/), function(part, idx){
+				preamble += "var "+part+" = arguments["+idx+"]; ";
+			});
+		}
+		var withStr = script.getAttribute("with");
+		if(withStr && withStr.length){
+			darray.forEach(withStr.split(/\s*,\s*/), function(part){
+				preamble += "with("+part+"){";
+				suffix += "}";
+			});
+		}
+		return new Function(preamble+script.innerHTML+suffix);
+	};
+
+	this.instantiate = /*====== dojo.parser.instantiate= ======*/function(nodes, mixin, args){
+		// summary:
+		//		Takes array of nodes, and turns them into class instances and
+		//		potentially calls a startup method to allow them to connect with
+		//		any children.
+		// nodes: Array
+		//		Array of nodes or objects like
+		//	|		{
+		//	|			type: "dijit.form.Button",
+		//	|			node: DOMNode,
+		//	|			scripts: [ ... ],	// array of <script type="dojo/..."> children of node
+		//	|			inherited: { ... }	// settings inherited from ancestors like dir, theme, etc.
+		//	|		}
+		// mixin: Object?
+		//		An object that will be mixed in with each node in the array.
+		//		Values in the mixin will override values in the node, if they
+		//		exist.
+		// args: Object?
+		//		An object used to hold kwArgs for instantiation.
+		//		See parse.args argument for details.
+
+		var thelist = [],
+		mixin = mixin||{};
+		args = args||{};
+
+		// Precompute names of special attributes we are looking for
+		// TODO: for 2.0 default to data-dojo- regardless of scopeName (or maybe scopeName won't exist in 2.0)
+		var dojoType = (args.scope || dojo._scopeName) + "Type",		// typically "dojoType"
+			attrData = "data-" + (args.scope || dojo._scopeName) + "-",// typically "data-dojo-"
+			dataDojoType = attrData + "type",						// typically "data-dojo-type"
+			dataDojoProps = attrData + "props",						// typically "data-dojo-props"
+			dataDojoAttachPoint = attrData + "attach-point",
+			dataDojoAttachEvent = attrData + "attach-event",
+			dataDojoId = attrData + "id";
+
+		// And make hash to quickly check if a given attribute is special, and to map the name to something friendly
+		var specialAttrs = {};
+		darray.forEach([dataDojoProps, dataDojoType, dojoType, dataDojoId, "jsId", dataDojoAttachPoint,
+				dataDojoAttachEvent, "dojoAttachPoint", "dojoAttachEvent", "class", "style"], function(name){
+			specialAttrs[name.toLowerCase()] = name.replace(args.scope, "dojo");
+		});
+
+		darray.forEach(nodes, function(obj){
+			if(!obj){ return; }
+
+			var node = obj.node || obj,
+				type = dojoType in mixin ? mixin[dojoType] : obj.node ? obj.type : (node.getAttribute(dataDojoType) || node.getAttribute(dojoType)),
+				ctor = _ctorMap[type] || (_ctorMap[type] = dlang.getObject(type)),
+				proto = ctor && ctor.prototype;
+			if(!ctor){
+				throw new Error("Could not load class '" + type);
+			}
+
+			// Setup hash to hold parameter settings for this widget.	Start with the parameter
+			// settings inherited from ancestors ("dir" and "lang").
+			// Inherited setting may later be overridden by explicit settings on node itself.
+			var params = {};
+
+			if(args.defaults){
+				// settings for the document itself (or whatever subtree is being parsed)
+				dlang.mixin(params, args.defaults);
+			}
+			if(obj.inherited){
+				// settings from dir=rtl or lang=... on a node above this node
+				dlang.mixin(params, obj.inherited);
+			}
+
+			// Get list of attributes explicitly listed in the markup
+			var attributes;
+			if(has("dom-attributes-explicit")){
+				// Standard path to get list of user specified attributes
+				attributes = node.attributes;
+			}else{
+				// Special path for IE, avoid (sometimes >100) bogus entries in node.attributes
+				var clone = /^input$|^img$/i.test(node.nodeName) ? node : node.cloneNode(false),
+					attrs = clone.outerHTML.replace(/=[^\s"']+|="[^"]*"|='[^']*'/g, "").replace(/^\s*<[a-zA-Z0-9]*/, "").replace(/>.*$/, "");
+
+				attributes = darray.map(attrs.split(/\s+/), function(name){
+					var lcName = name.toLowerCase();
+					return {
+						name: name,
+						// getAttribute() doesn't work for button.value, returns innerHTML of button.
+						// but getAttributeNode().value doesn't work for the form.encType or li.value
+						value: (node.nodeName == "LI" && name == "value") || lcName == "enctype" ?
+								node.getAttribute(lcName) : node.getAttributeNode(lcName).value,
+						specified: true
+					};
+				});
+			}
+
+			// Read in attributes and process them, including data-dojo-props, data-dojo-type,
+			// dojoAttachPoint, etc., as well as normal foo=bar attributes.
+			var i=0, item;
+			while(item = attributes[i++]){
+				if(!item || !item.specified){
+					continue;
+				}
+
+				var name = item.name,
+					lcName = name.toLowerCase(),
+					value = item.value;
+
+				if(lcName in specialAttrs){
+					switch(specialAttrs[lcName]){
+
+					// Data-dojo-props.   Save for later to make sure it overrides direct foo=bar settings
+					case "data-dojo-props":
+						var extra = value;
+						break;
+
+					// data-dojo-id or jsId. TODO: drop jsId in 2.0
+					case "data-dojo-id":
+					case "jsId":
+						var jsname = value;
+						break;
+
+					// For the benefit of _Templated
+					case "data-dojo-attach-point":
+					case "dojoAttachPoint":
+						params.dojoAttachPoint = value;
+						break;
+					case "data-dojo-attach-event":
+					case "dojoAttachEvent":
+						params.dojoAttachEvent = value;
+						break;
+
+					// Special parameter handling needed for IE
+					case "class":
+						params["class"] = node.className;
+						break;
+					case "style":
+						params["style"] = node.style && node.style.cssText;
+						break;
+					}
+				}else{
+					// Normal attribute, ex: value="123"
+
+					// Find attribute in widget corresponding to specified name.
+					// May involve case conversion, ex: onclick --> onClick
+					if(!(name in proto)){
+						var map = (_nameMap[type] || (_nameMap[type] = getNameMap(proto)));
+						name = map[lcName] || name;
+					}
+
+					// Set params[name] to value, doing type conversion
+					if(name in proto){
+						switch(typeof proto[name]){
+						case "string":
+							params[name] = value;
+							break;
+						case "number":
+							params[name] = value.length ? Number(value) : NaN;
+							break;
+						case "boolean":
+							// for checked/disabled value might be "" or "checked".	 interpret as true.
+							params[name] = value.toLowerCase() != "false";
+							break;
+						case "function":
+							if(value === "" || value.search(/[^\w\.]+/i) != -1){
+								// The user has specified some text for a function like "return x+5"
+								params[name] = new Function(value);
+							}else{
+								// The user has specified the name of a function like "myOnClick"
+								// or a single word function "return"
+								params[name] = dlang.getObject(value, false) || new Function(value);
+							}
+							break;
+						default:
+							var pVal = proto[name];
+							params[name] =
+								(pVal && "length" in pVal) ? (value ? value.split(/\s*,\s*/) : []) :	// array
+									(pVal instanceof Date) ?
+										(value == "" ? new Date("") :	// the NaN of dates
+										value == "now" ? new Date() :	// current date
+										dates.fromISOString(value)) :
+								(pVal instanceof dojo._Url) ? (dojo.baseUrl + value) :
+								djson.fromJson(value);
+						}
+					}else{
+						params[name] = value;
+					}
+				}
+			}
+
+			// Mix things found in data-dojo-props into the params, overriding any direct settings
+			if(extra){
+				try{
+					extra = djson.fromJson.call(args.propsThis, "{" + extra + "}");
+					dlang.mixin(params, extra);
+				}catch(e){
+					// give the user a pointer to their invalid parameters. FIXME: can we kill this in production?
+					throw new Error(e.toString() + " in data-dojo-props='" + extra + "'");
+				}
+			}
+
+			// Any parameters specified in "mixin" override everything else.
+			dlang.mixin(params, mixin);
+
+			var scripts = obj.node ? obj.scripts : (ctor && (ctor._noScript || proto._noScript) ? [] :
+						query("> script[type^='dojo/']", node));
+
+			// Process <script type="dojo/*"> script tags
+			// <script type="dojo/method" event="foo"> tags are added to params, and passed to
+			// the widget on instantiation.
+			// <script type="dojo/method"> tags (with no event) are executed after instantiation
+			// <script type="dojo/connect" data-dojo-event="foo"> tags are dojo.connected after instantiation
+			// <script type="dojo/watch" data-dojo-prop="foo"> tags are dojo.watch after instantiation
+			// <script type="dojo/on" data-dojo-event="foo"> tags are dojo.on after instantiation
+			// note: dojo/* script tags cannot exist in self closing widgets, like <input />
+			var connects = [],	// functions to connect after instantiation
+				calls = [],		// functions to call after instantiation
+				watch = [],  //functions to watch after instantiation
+				on = []; //functions to on after instantiation
+
+			if(scripts){
+				for(i=0; i<scripts.length; i++){
+					var script = scripts[i];
+					node.removeChild(script);
+					// FIXME: drop event="" support in 2.0. use data-dojo-event="" instead
+					var event = (script.getAttribute(attrData + "event") || script.getAttribute("event")),
+						prop = script.getAttribute(attrData + "prop"),
+						type = script.getAttribute("type"),
+						nf = this._functionFromScript(script, attrData);
+					if(event){
+						if(type == "dojo/connect"){
+							connects.push({event: event, func: nf});
+						}else if(type == "dojo/on"){
+							on.push({event: event, func: nf});
+						}else{
+							params[event] = nf;
+						}
+					}else if(type == "dojo/watch"){
+						watch.push({prop: prop, func: nf});
+					}else{
+						calls.push(nf);
+					}
+				}
+			}
+
+			// create the instance
+			var markupFactory = ctor.markupFactory || proto.markupFactory;
+			var instance = markupFactory ? markupFactory(params, node, ctor) : new ctor(params, node);
+			thelist.push(instance);
+
+			// map it to the JS namespace if that makes sense
+			if(jsname){
+				dlang.setObject(jsname, instance);
+			}
+
+			// process connections and startup functions
+			for(i=0; i<connects.length; i++){
+				aspect.after(instance, connects[i].event, dojo.hitch(instance, connects[i].func), true);
+			}
+			for(i=0; i<calls.length; i++){
+				calls[i].call(instance);
+			}
+			for(i=0; i<watch.length; i++){
+				instance.watch(watch[i].prop, watch[i].func);
+			}
+			for(i=0; i<on.length; i++){
+				don(instance, on[i].event, on[i].func);
+			}
+		}, this);
+
+		// Call startup on each top level instance if it makes sense (as for
+		// widgets).  Parent widgets will recursively call startup on their
+		// (non-top level) children
+		if(!mixin._started){
+			darray.forEach(thelist, function(instance){
+				if( !args.noStart && instance  &&
+					dlang.isFunction(instance.startup) &&
+					!instance._started
+				){
+					instance.startup();
+				}
+			});
+		}
+		return thelist;
+	};
+
+	this.parse = /*====== dojo.parser.parse= ======*/ function(rootNode, args){
+		// summary:
+		//		Scan the DOM for class instances, and instantiate them.
+		//
+		// description:
+		//		Search specified node (or root node) recursively for class instances,
+		//		and instantiate them. Searches for either data-dojo-type="Class" or
+		//		dojoType="Class" where "Class" is a a fully qualified class name,
+		//		like `dijit.form.Button`
+		//
+		//		Using `data-dojo-type`:
+		//		Attributes using can be mixed into the parameters used to instantiate the
+		//		Class by using a `data-dojo-props` attribute on the node being converted.
+		//		`data-dojo-props` should be a string attribute to be converted from JSON.
+		//
+		//		Using `dojoType`:
+		//		Attributes are read from the original domNode and converted to appropriate
+		//		types by looking up the Class prototype values. This is the default behavior
+		//		from Dojo 1.0 to Dojo 1.5. `dojoType` support is deprecated, and will
+		//		go away in Dojo 2.0.
+		//
+		// rootNode: DomNode?
+		//		A default starting root node from which to start the parsing. Can be
+		//		omitted, defaulting to the entire document. If omitted, the `args`
+		//		object can be passed in this place. If the `args` object has a
+		//		`rootNode` member, that is used.
+		//
+		// args: Object
+		//		a kwArgs object passed along to instantiate()
+		//
+		//			* noStart: Boolean?
+		//				when set will prevent the parser from calling .startup()
+		//				when locating the nodes.
+		//			* rootNode: DomNode?
+		//				identical to the function's `rootNode` argument, though
+		//				allowed to be passed in via this `args object.
+		//			* template: Boolean
+		//				If true, ignores ContentPane's stopParser flag and parses contents inside of
+		//				a ContentPane inside of a template.   This allows dojoAttachPoint on widgets/nodes
+		//				nested inside the ContentPane to work.
+		//			* inherited: Object
+		//				Hash possibly containing dir and lang settings to be applied to
+		//				parsed widgets, unless there's another setting on a sub-node that overrides
+		//			* scope: String
+		//				Root for attribute names to search for.   If scopeName is dojo,
+		//				will search for data-dojo-type (or dojoType).   For backwards compatibility
+		//				reasons defaults to dojo._scopeName (which is "dojo" except when
+		//				multi-version support is used, when it will be something like dojo16, dojo20, etc.)
+		//			* propsThis: Object
+		//				If specified, "this" referenced from data-dojo-props will refer to propsThis.
+		//				Intended for use from the widgets-in-template feature of `dijit._WidgetsInTemplateMixin`
+		//
+		// example:
+		//		Parse all widgets on a page:
+		//	|		dojo.parser.parse();
+		//
+		// example:
+		//		Parse all classes within the node with id="foo"
+		//	|		dojo.parser.parse(dojo.byId('foo'));
+		//
+		// example:
+		//		Parse all classes in a page, but do not call .startup() on any
+		//		child
+		//	|		dojo.parser.parse({ noStart: true })
+		//
+		// example:
+		//		Parse all classes in a node, but do not call .startup()
+		//	|		dojo.parser.parse(someNode, { noStart:true });
+		//	|		// or
+		//	|		dojo.parser.parse({ noStart:true, rootNode: someNode });
+
+		// determine the root node based on the passed arguments.
+		var root;
+		if(!args && rootNode && rootNode.rootNode){
+			args = rootNode;
+			root = args.rootNode;
+		}else{
+			root = rootNode;
+		}
+		root = root ? dhtml.byId(root) : dwindow.body();
+		args = args || {};
+
+		var dojoType = (args.scope || dojo._scopeName) + "Type",		// typically "dojoType"
+			attrData = "data-" + (args.scope || dojo._scopeName) + "-",	// typically "data-dojo-"
+			dataDojoType = attrData + "type",						// typically "data-dojo-type"
+			dataDojoTextDir = attrData + "textdir";					// typically "data-dojo-textdir"
+
+		// List of all nodes on page w/dojoType specified
+		var list = [];
+
+		// Info on DOMNode currently being processed
+		var node = root.firstChild;
+
+		// Info on parent of DOMNode currently being processed
+		//	- inherited: dir, lang, and textDir setting of parent, or inherited by parent
+		//	- parent: pointer to identical structure for my parent (or null if no parent)
+		//	- scripts: if specified, collects <script type="dojo/..."> type nodes from children
+		var inherited = args && args.inherited;
+		if(!inherited){
+			function findAncestorAttr(node, attr){
+				return (node.getAttribute && node.getAttribute(attr)) ||
+					(node !== dwindow.doc && node !== dwindow.doc.documentElement && node.parentNode ? findAncestorAttr(node.parentNode, attr) : null);
+			}
+			inherited = {
+				dir: findAncestorAttr(root, "dir"),
+				lang: findAncestorAttr(root, "lang"),
+				textDir: findAncestorAttr(root, dataDojoTextDir)
+			};
+			for(var key in inherited){
+				if(!inherited[key]){ delete inherited[key]; }
+			}
+		}
+		var parent = {
+			inherited: inherited
+		};
+
+		// For collecting <script type="dojo/..."> type nodes (when null, we don't need to collect)
+		var scripts;
+
+		// when true, only look for <script type="dojo/..."> tags, and don't recurse to children
+		var scriptsOnly;
+
+		function getEffective(parent){
+			// summary:
+			//		Get effective dir, lang, textDir settings for specified obj
+			//		(matching "parent" object structure above), and do caching.
+			//		Take care not to return null entries.
+			if(!parent.inherited){
+				parent.inherited = {};
+				var node = parent.node,
+					grandparent = getEffective(parent.parent);
+				var inherited  = {
+					dir: node.getAttribute("dir") || grandparent.dir,
+					lang: node.getAttribute("lang") || grandparent.lang,
+					textDir: node.getAttribute(dataDojoTextDir) || grandparent.textDir
+				};
+				for(var key in inherited){
+					if(inherited[key]){
+						parent.inherited[key] = inherited[key];
+					}
+				}
+			}
+			return parent.inherited;
+		}
+
+		// DFS on DOM tree, collecting nodes with data-dojo-type specified.
+		while(true){
+			if(!node){
+				// Finished this level, continue to parent's next sibling
+				if(!parent || !parent.node){
+					break;
+				}
+				node = parent.node.nextSibling;
+				scripts = parent.scripts;
+				scriptsOnly = false;
+				parent = parent.parent;
+				continue;
+			}
+
+			if(node.nodeType != 1){
+				// Text or comment node, skip to next sibling
+				node = node.nextSibling;
+				continue;
+			}
+
+			if(scripts && node.nodeName.toLowerCase() == "script"){
+				// Save <script type="dojo/..."> for parent, then continue to next sibling
+				type = node.getAttribute("type");
+				if(type && /^dojo\/\w/i.test(type)){
+					scripts.push(node);
+				}
+				node = node.nextSibling;
+				continue;
+			}
+			if(scriptsOnly){
+				node = node.nextSibling;
+				continue;
+			}
+
+			// Check for data-dojo-type attribute, fallback to backward compatible dojoType
+			var type = node.getAttribute(dataDojoType) || node.getAttribute(dojoType);
+
+			// Short circuit for leaf nodes containing nothing [but text]
+			var firstChild = node.firstChild;
+			if(!type && (!firstChild || (firstChild.nodeType == 3 && !firstChild.nextSibling))){
+				node = node.nextSibling;
+				continue;
+			}
+
+			// Setup data structure to save info on current node for when we return from processing descendant nodes
+			var current = {
+				node: node,
+				scripts: scripts,
+				parent: parent
+			};
+
+			// If dojoType/data-dojo-type specified, add to output array of nodes to instantiate
+			var ctor = type && (_ctorMap[type] || (_ctorMap[type] = dlang.getObject(type))), // note: won't find classes declared via dojo.Declaration
+				childScripts = ctor && !ctor.prototype._noScript ? [] : null; // <script> nodes that are parent's children
+			if(type){
+				list.push({
+					"type": type,
+					node: node,
+					scripts: childScripts,
+					inherited: getEffective(current) // dir & lang settings for current node, explicit or inherited
+				});
+			}
+
+			// Recurse, collecting <script type="dojo/..."> children, and also looking for
+			// descendant nodes with dojoType specified (unless the widget has the stopParser flag).
+			// When finished with children, go to my next sibling.
+			node = firstChild;
+			scripts = childScripts;
+			scriptsOnly = ctor && ctor.prototype.stopParser && !(args && args.template);
+			parent = current;
+
+		}
+
+		// go build the object instances
+		var mixin = args && args.template ? {template: true} : null;
+		return this.instantiate(list, mixin, args); // Array
+	};
+}();
+
+
+//Register the parser callback. It should be the first callback
+//after the a11y test.
+if(dojo.config.parseOnLoad){
+	dojo.ready(100, dojo.parser, "parse");
+}
+
+return dojo.parser;
+});