dojo-rails 0.9.8 → 0.9.9

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

@@ -0,0 +1,40 @@
+var profile = (function(){
+	var testResourceRe = /^dojo\/tests\//,
+
+		copyOnly = function(filename, mid){
+			var list = {
+				"dojo/dojo.profile":1,
+				"dojo/package.json":1,
+				"dojo/OpenAjax":1,
+				"dojo/tests":1,
+				// these are test modules that are not intended to ever be built
+				"dojo/tests/_base/loader/requirejs/requirejs-setup":1,
+				"dojo/tests/_base/loader/requirejs/dataMain":1,
+				"dojo/tests/_base/loader/requirejs/depoverlap":1,
+				"dojo/tests/_base/loader/requirejs/simple-tests":1,
+				"dojo/tests/_base/loader/requirejs/relative/relative-tests":1,
+				"dojo/tests/_base/loader/requirejs/exports/exports-tests":1
+			};
+			return (mid in list) || /^dojo\/_base\/config\w+$/.test(mid) || (/^dojo\/resources\//.test(mid) && !/\.css$/.test(filename)) || /(png|jpg|jpeg|gif|tiff)$/.test(filename);
+		};
+
+	return {
+		resourceTags:{
+			test: function(filename, mid){
+				return testResourceRe.test(mid) || mid=="dojo/tests" || mid=="dojo/robot" || mid=="dojo/robotx";
+			},
+
+			copyOnly: function(filename, mid){
+				return copyOnly(filename, mid);
+			},
+
+			amd: function(filename, mid){
+				return !testResourceRe.test(mid) && !copyOnly(filename, mid) && /\.js$/.test(filename);
+			}
+		},
+
+		trees:[
+			[".", ".", /(\/\.)|(~$)/]
+		]
+	};
+})();

data/vendor/assets/javascripts/dojo/dom-attr.js

@@ -0,0 +1,62 @@
+/*
+	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/dom-attr",["exports","./_base/sniff","./_base/lang","./dom","./dom-style","./dom-prop"],function(_1,_2,_3,_4,_5,_6){
+var _7={innerHTML:1,className:1,htmlFor:_2("ie"),value:1},_8={classname:"class",htmlfor:"for",tabindex:"tabIndex",readonly:"readOnly"};
+function _9(_a,_b){
+var _c=_a.getAttributeNode&&_a.getAttributeNode(_b);
+return _c&&_c.specified;
+};
+_1.has=function hasAttr(_d,_e){
+var lc=_e.toLowerCase();
+return _7[_6.names[lc]||_e]||_9(_4.byId(_d),_8[lc]||_e);
+};
+_1.get=function getAttr(_f,_10){
+_f=_4.byId(_f);
+var lc=_10.toLowerCase(),_11=_6.names[lc]||_10,_12=_7[_11];
+value=_f[_11];
+if(_12&&typeof value!="undefined"){
+return value;
+}
+if(_11!="href"&&(typeof value=="boolean"||_3.isFunction(value))){
+return value;
+}
+var _13=_8[lc]||_10;
+return _9(_f,_13)?_f.getAttribute(_13):null;
+};
+_1.set=function setAttr(_14,_15,_16){
+_14=_4.byId(_14);
+if(arguments.length==2){
+for(var x in _15){
+_1.set(_14,x,_15[x]);
+}
+return _14;
+}
+var lc=_15.toLowerCase(),_17=_6.names[lc]||_15,_18=_7[_17];
+if(_17=="style"&&typeof _16!="string"){
+_5.set(_14,_16);
+return _14;
+}
+if(_18||typeof _16=="boolean"||_3.isFunction(_16)){
+return _6.set(_14,_15,_16);
+}
+_14.setAttribute(_8[lc]||_15,_16);
+return _14;
+};
+_1.remove=function removeAttr(_19,_1a){
+_4.byId(_19).removeAttribute(_8[_1a.toLowerCase()]||_1a);
+};
+_1.getNodeProp=function getNodeProp(_1b,_1c){
+_1b=_4.byId(_1b);
+var lc=_1c.toLowerCase(),_1d=_6.names[lc]||_1c;
+if((_1d in _1b)&&_1d!="href"){
+return _1b[_1d];
+}
+var _1e=_8[lc]||_1c;
+return _9(_1b,_1e)?_1b.getAttribute(_1e):null;
+};
+});

data/vendor/assets/javascripts/dojo/dom-attr.js.uncompressed.js

@@ -0,0 +1,238 @@
+define("dojo/dom-attr", ["exports", "./_base/sniff", "./_base/lang", "./dom", "./dom-style", "./dom-prop"],
+		function(exports, has, lang, dom, style, prop){
+	// module:
+	//		dojo/dom-attr
+	// summary:
+	//		This module defines the core dojo DOM attributes API.
+
+	// =============================
+	// Element attribute Functions
+	// =============================
+
+	// This module will be obsolete soon. Use dojo.prop instead.
+
+	// dojo.attr() should conform to http://www.w3.org/TR/DOM-Level-2-Core/
+
+	// attribute-related functions (to be obsolete soon)
+
+	/*=====
+	dojo.hasAttr = function(node, name){
+		// summary:
+		//		Returns true if the requested attribute is specified on the
+		//		given element, and false otherwise.
+		// node: DOMNode|String
+		//		id or reference to the element to check
+		// name: String
+		//		the name of the attribute
+		// returns: Boolean
+		//		true if the requested attribute is specified on the
+		//		given element, and false otherwise
+	};
+	=====*/
+
+	/*=====
+	dojo.getAttr = function(node, name){
+		// summary:
+		//		Gets an attribute on an HTML element.
+		// description:
+		//		Handles normalized getting of attributes on DOM Nodes.
+		// node: DOMNode|String
+		//		id or reference to the element to get the attribute on
+		// name: String
+		//		the name of the attribute to get.
+		// returns:
+		//		the value of the requested attribute or null if that attribute does not have a specified or
+		//		default value;
+		//
+		// example:
+		//	|	// get the current value of the "foo" attribute on a node
+		//	|	dojo.getAttr(dojo.byId("nodeId"), "foo");
+		//	|	// or we can just pass the id:
+		//	|	dojo.getAttr("nodeId", "foo");
+	};
+	=====*/
+
+	/*=====
+	dojo.setAttr = function(node, name, value){
+		// summary:
+		//		Sets an attribute on an HTML element.
+		// description:
+		//		Handles normalized setting of attributes on DOM Nodes.
+		//
+		//		When passing functions as values, note that they will not be
+		//		directly assigned to slots on the node, but rather the default
+		//		behavior will be removed and the new behavior will be added
+		//		using `dojo.connect()`, meaning that event handler properties
+		//		will be normalized and that some caveats with regards to
+		//		non-standard behaviors for onsubmit apply. Namely that you
+		//		should cancel form submission using `dojo.stopEvent()` on the
+		//		passed event object instead of returning a boolean value from
+		//		the handler itself.
+		// node: DOMNode|String
+		//		id or reference to the element to set the attribute on
+		// name: String|Object
+		//		the name of the attribute to set, or a hash of key-value pairs to set.
+		// value: String?
+		//		the value to set for the attribute, if the name is a string.
+		// returns:
+		//		the DOM node
+		//
+		// example:
+		//	|	// use attr() to set the tab index
+		//	|	dojo.setAttr("nodeId", "tabIndex", 3);
+		//
+		// example:
+		//	Set multiple values at once, including event handlers:
+		//	|	dojo.setAttr("formId", {
+		//	|		"foo": "bar",
+		//	|		"tabIndex": -1,
+		//	|		"method": "POST",
+		//	|		"onsubmit": function(e){
+		//	|			// stop submitting the form. Note that the IE behavior
+		//	|			// of returning true or false will have no effect here
+		//	|			// since our handler is connect()ed to the built-in
+		//	|			// onsubmit behavior and so we need to use
+		//	|			// dojo.stopEvent() to ensure that the submission
+		//	|			// doesn't proceed.
+		//	|			dojo.stopEvent(e);
+		//	|
+		//	|			// submit the form with Ajax
+		//	|			dojo.xhrPost({ form: "formId" });
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Style is s special case: Only set with an object hash of styles
+		//	|	dojo.setAttr("someNode",{
+		//	|		id:"bar",
+		//	|		style:{
+		//	|			width:"200px", height:"100px", color:"#000"
+		//	|		}
+		//	|	});
+		//
+		// example:
+		//	Again, only set style as an object hash of styles:
+		//	|	var obj = { color:"#fff", backgroundColor:"#000" };
+		//	|	dojo.setAttr("someNode", "style", obj);
+		//	|
+		//	|	// though shorter to use `dojo.style()` in this case:
+		//	|	dojo.setStyle("someNode", obj);
+	};
+	=====*/
+
+	/*=====
+	dojo.removeAttr = function(node, name){
+		// summary:
+		//		Removes an attribute from an HTML element.
+		// node: DOMNode|String
+		//		id or reference to the element to remove the attribute from
+		// name: String
+		//		the name of the attribute to remove
+	};
+	=====*/
+
+	/*=====
+	dojo.getNodeProp = function(node, name){
+		// summary:
+		//		Returns an effective value of a property or an attribute.
+		// node: DOMNode|String
+		//		id or reference to the element to remove the attribute from
+		// name: String
+		//		the name of the attribute
+		// returns:
+		//      the value of the attribute
+	};
+	=====*/
+
+	var forcePropNames = {
+			innerHTML:	1,
+			className:	1,
+			htmlFor:	has("ie"),
+			value:		1
+		},
+		attrNames = {
+			// original attribute names
+			classname: "class",
+			htmlfor: "for",
+			// for IE
+			tabindex: "tabIndex",
+			readonly: "readOnly"
+		};
+
+	function _hasAttr(node, name){
+		var attr = node.getAttributeNode && node.getAttributeNode(name);
+		return attr && attr.specified; // Boolean
+	}
+
+	// There is a difference in the presence of certain properties and their default values
+	// between browsers. For example, on IE "disabled" is present on all elements,
+	// but it is value is "false"; "tabIndex" of <div> returns 0 by default on IE, yet other browsers
+	// can return -1.
+
+	exports.has = function hasAttr(/*DOMNode|String*/node, /*String*/name){
+		var lc = name.toLowerCase();
+		return forcePropNames[prop.names[lc] || name] || _hasAttr(dom.byId(node), attrNames[lc] || name);	// Boolean
+	};
+
+	exports.get = function getAttr(/*DOMNode|String*/node, /*String*/name){
+		node = dom.byId(node);
+		var lc = name.toLowerCase(),
+			propName = prop.names[lc] || name,
+			forceProp = forcePropNames[propName];
+		// should we access this attribute via a property or via getAttribute()?
+		value = node[propName];
+		if(forceProp && typeof value != "undefined"){
+			// node's property
+			return value;	// Anything
+		}
+		if(propName != "href" && (typeof value == "boolean" || lang.isFunction(value))){
+			// node's property
+			return value;	// Anything
+		}
+		// node's attribute
+		// we need _hasAttr() here to guard against IE returning a default value
+		var attrName = attrNames[lc] || name;
+		return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
+	};
+
+	exports.set = function setAttr(/*DOMNode|String*/node, /*String|Object*/name, /*String?*/value){
+		node = dom.byId(node);
+		if(arguments.length == 2){ // inline'd type check
+			// the object form of setter: the 2nd argument is a dictionary
+			for(var x in name){
+				exports.set(node, x, name[x]);
+			}
+			return node; // DomNode
+		}
+		var lc = name.toLowerCase(),
+			propName = prop.names[lc] || name,
+			forceProp = forcePropNames[propName];
+		if(propName == "style" && typeof value != "string"){ // inline'd type check
+			// special case: setting a style
+			style.set(node, value);
+			return node; // DomNode
+		}
+		if(forceProp || typeof value == "boolean" || lang.isFunction(value)){
+			return prop.set(node, name, value)
+		}
+		// node's attribute
+		node.setAttribute(attrNames[lc] || name, value);
+		return node; // DomNode
+	};
+
+	exports.remove = function removeAttr(/*DOMNode|String*/ node, /*String*/ name){
+		dom.byId(node).removeAttribute(attrNames[name.toLowerCase()] || name);
+	};
+
+	exports.getNodeProp = function getNodeProp(/*DomNode|String*/ node, /*String*/ name){
+		node = dom.byId(node);
+		var lc = name.toLowerCase(), propName = prop.names[lc] || name;
+		if((propName in node) && propName != "href"){
+			// node's property
+			return node[propName];	// Anything
+		}
+		// node's attribute
+		var attrName = attrNames[lc] || name;
+		return _hasAttr(node, attrName) ? node.getAttribute(attrName) : null; // Anything
+	};
+});

data/vendor/assets/javascripts/dojo/dom-class.js

@@ -0,0 +1,89 @@
+/*
+	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/dom-class",["./_base/lang","./_base/array","./dom"],function(_1,_2,_3){
+var _4="className";
+var _5,_6=/\s+/,a1=[""];
+function _7(s){
+if(typeof s=="string"||s instanceof String){
+if(s&&!_6.test(s)){
+a1[0]=s;
+return a1;
+}
+var a=s.split(_6);
+if(a.length&&!a[0]){
+a.shift();
+}
+if(a.length&&!a[a.length-1]){
+a.pop();
+}
+return a;
+}
+if(!s){
+return [];
+}
+return _2.filter(s,function(x){
+return x;
+});
+};
+var _8={};
+_5={contains:function containsClass(_9,_a){
+return ((" "+_3.byId(_9)[_4]+" ").indexOf(" "+_a+" ")>=0);
+},add:function addClass(_b,_c){
+_b=_3.byId(_b);
+_c=_7(_c);
+var _d=_b[_4],_e;
+_d=_d?" "+_d+" ":" ";
+_e=_d.length;
+for(var i=0,_f=_c.length,c;i<_f;++i){
+c=_c[i];
+if(c&&_d.indexOf(" "+c+" ")<0){
+_d+=c+" ";
+}
+}
+if(_e<_d.length){
+_b[_4]=_d.substr(1,_d.length-2);
+}
+},remove:function removeClass(_10,_11){
+_10=_3.byId(_10);
+var cls;
+if(_11!==undefined){
+_11=_7(_11);
+cls=" "+_10[_4]+" ";
+for(var i=0,len=_11.length;i<len;++i){
+cls=cls.replace(" "+_11[i]+" "," ");
+}
+cls=_1.trim(cls);
+}else{
+cls="";
+}
+if(_10[_4]!=cls){
+_10[_4]=cls;
+}
+},replace:function replaceClass(_12,_13,_14){
+_12=_3.byId(_12);
+_8[_4]=_12[_4];
+_5.remove(_8,_14);
+_5.add(_8,_13);
+if(_12[_4]!==_8[_4]){
+_12[_4]=_8[_4];
+}
+},toggle:function toggleClass(_15,_16,_17){
+_15=_3.byId(_15);
+if(_17===undefined){
+_16=_7(_16);
+for(var i=0,len=_16.length,c;i<len;++i){
+c=_16[i];
+_5[_5.contains(_15,c)?"remove":"add"](_15,c);
+}
+}else{
+_5[_17?"add":"remove"](_15,_16);
+}
+return _17;
+}};
+return _5;
+});

data/vendor/assets/javascripts/dojo/dom-class.js.uncompressed.js

@@ -0,0 +1,320 @@
+define("dojo/dom-class", ["./_base/lang", "./_base/array", "./dom"], function(lang, array, dom){
+	// module:
+	//		dojo/dom-class
+	// summary:
+	//		This module defines the core dojo DOM class API.
+
+	var className = "className";
+
+	/* Part I of classList-based implementation is preserved here for posterity
+	var classList = "classList";
+	has.add("dom-classList", function(){
+		return classList in document.createElement("p");
+	});
+	*/
+
+	// =============================
+	// (CSS) Class Functions
+	// =============================
+
+	/*=====
+	dojo.hasClass = function(node, classStr){
+		// summary:
+		//		Returns whether or not the specified classes are a portion of the
+		//		class list currently applied to the node.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to check the class for.
+		//
+		// classStr: String
+		//		A string class name to look for.
+		//
+		// returns: Boolean
+		//
+		// example:
+		//		Do something if a node with id="someNode" has class="aSillyClassName" present
+		//	|	if(dojo.hasClass("someNode","aSillyClassName")){ ... }
+	};
+	=====*/
+
+	/*=====
+	dojo.addClass = function(node, classStr){
+		// summary:
+		//		Adds the specified classes to the end of the class list on the
+		//		passed node. Will not re-apply duplicate classes.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to add a class string too
+		//
+		// classStr: String|Array
+		//		A String class name to add, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// example:
+		//		Add a class to some node:
+		//	|	dojo.addClass("someNode", "anewClass");
+		//
+		// example:
+		//		Add two classes at once:
+		//	|	dojo.addClass("someNode", "firstClass secondClass");
+		//
+		// example:
+		//		Add two classes at once (using array):
+		//	|	dojo.addClass("someNode", ["firstClass", "secondClass"]);
+		//
+		// example:
+		//		Available in `dojo.NodeList` for multiple additions
+		//	|	dojo.query("ul > li").addClass("firstLevel");
+	};
+	=====*/
+
+	/*=====
+	dojo.removeClass = function(node, classStr){
+		// summary:
+		//		Removes the specified classes from node. No `dojo.hasClass`
+		//		check is required.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to remove the class from.
+		//
+		// classStr: String|Array
+		//		An optional String class name to remove, or several space-separated
+		//		class names, or an array of class names. If omitted, all class names
+		//		will be deleted.
+		//
+		// example:
+		//		Remove a class from some node:
+		//	|	dojo.removeClass("someNode", "firstClass");
+		//
+		// example:
+		//		Remove two classes from some node:
+		//	|	dojo.removeClass("someNode", "firstClass secondClass");
+		//
+		// example:
+		//		Remove two classes from some node (using array):
+		//	|	dojo.removeClass("someNode", ["firstClass", "secondClass"]);
+		//
+		// example:
+		//		Remove all classes from some node:
+		//	|	dojo.removeClass("someNode");
+		//
+		// example:
+		//		Available in `dojo.NodeList()` for multiple removal
+		//	|	dojo.query(".foo").removeClass("foo");
+	};
+	=====*/
+
+	/*=====
+	dojo.replaceClass = function(node, addClassStr, removeClassStr){
+		// summary:
+		//		Replaces one or more classes on a node if not present.
+		//		Operates more quickly than calling dojo.removeClass and dojo.addClass
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to remove the class from.
+		//
+		// addClassStr: String|Array
+		//		A String class name to add, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// removeClassStr: String|Array?
+		//		A String class name to remove, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// example:
+		//	|	dojo.replaceClass("someNode", "add1 add2", "remove1 remove2");
+		//
+		// example:
+		//	Replace all classes with addMe
+		//	|	dojo.replaceClass("someNode", "addMe");
+		//
+		// example:
+		//	Available in `dojo.NodeList()` for multiple toggles
+		//	|	dojo.query(".findMe").replaceClass("addMe", "removeMe");
+	};
+	=====*/
+
+	/*=====
+	dojo.toggleClass = function(node, classStr, condition){
+		// summary:
+		//		Adds a class to node if not present, or removes if present.
+		//		Pass a boolean condition if you want to explicitly add or remove.
+		//      Returns the condition that was specified directly or indirectly.
+		//
+		// node: String|DOMNode
+		//		String ID or DomNode reference to toggle a class string
+		//
+		// classStr: String|Array
+		//		A String class name to toggle, or several space-separated class names,
+		//		or an array of class names.
+		//
+		// condition:
+		//		If passed, true means to add the class, false means to remove.
+		//      Otherwise dojo.hasClass(node, classStr) is used to detect the class presence.
+		//
+		// example:
+		//	|	dojo.toggleClass("someNode", "hovered");
+		//
+		// example:
+		//		Forcefully add a class
+		//	|	dojo.toggleClass("someNode", "hovered", true);
+		//
+		// example:
+		//		Available in `dojo.NodeList()` for multiple toggles
+		//	|	dojo.query(".toggleMe").toggleClass("toggleMe");
+	};
+	=====*/
+
+	var cls, // exports object
+		spaces = /\s+/, a1 = [""];
+
+	function str2array(s){
+		if(typeof s == "string" || s instanceof String){
+			if(s && !spaces.test(s)){
+				a1[0] = s;
+				return a1;
+			}
+			var a = s.split(spaces);
+			if(a.length && !a[0]){
+				a.shift();
+			}
+			if(a.length && !a[a.length - 1]){
+				a.pop();
+			}
+			return a;
+		}
+		// assumed to be an array
+		if(!s){
+			return [];
+		}
+		return array.filter(s, function(x){ return x; });
+	}
+
+	/* Part II of classList-based implementation is preserved here for posterity
+	if(has("dom-classList")){
+		// new classList version
+		cls = {
+			contains: function containsClass(node, classStr){
+				var clslst = classStr && dom.byId(node)[classList];
+				return clslst && clslst.contains(classStr); // Boolean
+			},
+
+			add: function addClass(node, classStr){
+				node = dom.byId(node);
+				classStr = str2array(classStr);
+				for(var i = 0, len = classStr.length; i < len; ++i){
+					node[classList].add(classStr[i]);
+				}
+			},
+
+			remove: function removeClass(node, classStr){
+				node = dom.byId(node);
+				if(classStr === undefined){
+					node[className] = "";
+				}else{
+					classStr = str2array(classStr);
+					for(var i = 0, len = classStr.length; i < len; ++i){
+						node[classList].remove(classStr[i]);
+					}
+				}
+			},
+
+			replace: function replaceClass(node, addClassStr, removeClassStr){
+				node = dom.byId(node);
+				if(removeClassStr === undefined){
+					node[className] = "";
+				}else{
+					removeClassStr = str2array(removeClassStr);
+					for(var i = 0, len = removeClassStr.length; i < len; ++i){
+						node[classList].remove(removeClassStr[i]);
+					}
+				}
+				addClassStr = str2array(addClassStr);
+				for(i = 0, len = addClassStr.length; i < len; ++i){
+					node[classList].add(addClassStr[i]);
+				}
+			},
+
+			toggle: function toggleClass(node, classStr, condition){
+				node = dom.byId(node);
+				if(condition === undefined){
+					classStr = str2array(classStr);
+					for(var i = 0, len = classStr.length; i < len; ++i){
+						node[classList].toggle(classStr[i]);
+					}
+				}else{
+					cls[condition ? "add" : "remove"](node, classStr);
+				}
+				return condition;   // Boolean
+			}
+		}
+	}
+	*/
+
+	// regular DOM version
+	var fakeNode = {};  // for effective replacement
+	cls = {
+		contains: function containsClass(/*DomNode|String*/node, /*String*/classStr){
+			return ((" " + dom.byId(node)[className] + " ").indexOf(" " + classStr + " ") >= 0); // Boolean
+		},
+
+		add: function addClass(/*DomNode|String*/node, /*String|Array*/classStr){
+			node = dom.byId(node);
+			classStr = str2array(classStr);
+			var cls = node[className], oldLen;
+			cls = cls ? " " + cls + " " : " ";
+			oldLen = cls.length;
+			for(var i = 0, len = classStr.length, c; i < len; ++i){
+				c = classStr[i];
+				if(c && cls.indexOf(" " + c + " ") < 0){
+					cls += c + " ";
+				}
+			}
+			if(oldLen < cls.length){
+				node[className] = cls.substr(1, cls.length - 2);
+			}
+		},
+
+		remove: function removeClass(/*DomNode|String*/node, /*String|Array?*/classStr){
+			node = dom.byId(node);
+			var cls;
+			if(classStr !== undefined){
+				classStr = str2array(classStr);
+				cls = " " + node[className] + " ";
+				for(var i = 0, len = classStr.length; i < len; ++i){
+					cls = cls.replace(" " + classStr[i] + " ", " ");
+				}
+				cls = lang.trim(cls);
+			}else{
+				cls = "";
+			}
+			if(node[className] != cls){ node[className] = cls; }
+		},
+
+		replace: function replaceClass(/*DomNode|String*/node, /*String|Array*/addClassStr, /*String|Array?*/removeClassStr){
+			node = dom.byId(node);
+			fakeNode[className] = node[className];
+			cls.remove(fakeNode, removeClassStr);
+			cls.add(fakeNode, addClassStr);
+			if(node[className] !== fakeNode[className]){
+				node[className] = fakeNode[className];
+			}
+		},
+
+		toggle: function toggleClass(/*DomNode|String*/node, /*String|Array*/classStr, /*Boolean?*/condition){
+			node = dom.byId(node);
+			if(condition === undefined){
+				classStr = str2array(classStr);
+				for(var i = 0, len = classStr.length, c; i < len; ++i){
+					c = classStr[i];
+					cls[cls.contains(node, c) ? "remove" : "add"](node, c);
+				}
+			}else{
+				cls[condition ? "add" : "remove"](node, classStr);
+			}
+			return condition;   // Boolean
+		}
+	};
+
+	return cls;
+});