dojo-rails 0.9.8 → 0.9.9

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

@@ -0,0 +1,243 @@
+define("dojo/hash", ["./_base/kernel", "require", "./_base/connect", "./_base/lang", "./ready", "./_base/sniff"],
+	function(dojo, require, connect, lang, ready, has) {
+	// module:
+	//		dojo/hash
+	// summary:
+	//		TODOC
+
+
+//TODOC: where does this go?
+// summary:
+//		Methods for monitoring and updating the hash in the browser URL.
+//
+// example:
+//		dojo.subscribe("/dojo/hashchange", context, callback);
+//
+//		function callback (hashValue){
+//			// do something based on the hash value.
+//		}
+
+	dojo.hash = function(/* String? */ hash, /* Boolean? */ replace){
+		//	summary:
+		//		Gets or sets the hash string.
+		//	description:
+		//		Handles getting and setting of location.hash.
+		//		 - If no arguments are passed, acts as a getter.
+		//		 - If a string is passed, acts as a setter.
+		//	hash:
+		//		the hash is set - #string.
+		//	replace:
+		//		If true, updates the hash value in the current history
+		//		state instead of creating a new history state.
+		//	returns:
+		//		when used as a getter, returns the current hash string.
+		//		when used as a setter, returns the new hash string.
+
+		// getter
+		if(!arguments.length){
+			return _getHash();
+		}
+		// setter
+		if(hash.charAt(0) == "#"){
+			hash = hash.substring(1);
+		}
+		if(replace){
+			_replace(hash);
+		}else{
+			location.href = "#" + hash;
+		}
+		return hash; // String
+	};
+
+	// Global vars
+	var _recentHash, _ieUriMonitor, _connect,
+		_pollFrequency = dojo.config.hashPollFrequency || 100;
+
+	//Internal functions
+	function _getSegment(str, delimiter){
+		var i = str.indexOf(delimiter);
+		return (i >= 0) ? str.substring(i+1) : "";
+	}
+
+	function _getHash(){
+		return _getSegment(location.href, "#");
+	}
+
+	function _dispatchEvent(){
+		connect.publish("/dojo/hashchange", [_getHash()]);
+	}
+
+	function _pollLocation(){
+		if(_getHash() === _recentHash){
+			return;
+		}
+		_recentHash = _getHash();
+		_dispatchEvent();
+	}
+
+	function _replace(hash){
+		if(_ieUriMonitor){
+			if(_ieUriMonitor.isTransitioning()){
+				setTimeout(lang.hitch(null,_replace,hash), _pollFrequency);
+				return;
+			}
+			var href = _ieUriMonitor.iframe.location.href;
+			var index = href.indexOf('?');
+			// main frame will detect and update itself
+			_ieUriMonitor.iframe.location.replace(href.substring(0, index) + "?" + hash);
+			return;
+		}
+		location.replace("#"+hash);
+		!_connect && _pollLocation();
+	}
+
+	function IEUriMonitor(){
+		// summary:
+		//		Determine if the browser's URI has changed or if the user has pressed the
+		//		back or forward button. If so, call _dispatchEvent.
+		//
+		//	description:
+		//		IE doesn't add changes to the URI's hash into the history unless the hash
+		//		value corresponds to an actual named anchor in the document. To get around
+		//		this IE difference, we use a background IFrame to maintain a back-forward
+		//		history, by updating the IFrame's query string to correspond to the
+		//		value of the main browser location's hash value.
+		//
+		//		E.g. if the value of the browser window's location changes to
+		//
+		//		#action=someAction
+		//
+		//		... then we'd update the IFrame's source to:
+		//
+		//		?action=someAction
+		//
+		//		This design leads to a somewhat complex state machine, which is
+		//		described below:
+		//
+		//		s1: Stable state - neither the window's location has changed nor
+		//			has the IFrame's location. Note that this is the 99.9% case, so
+		//			we optimize for it.
+		//			Transitions: s1, s2, s3
+		//		s2: Window's location changed - when a user clicks a hyperlink or
+		//			code programmatically changes the window's URI.
+		//			Transitions: s4
+		//		s3: Iframe's location changed as a result of user pressing back or
+		//			forward - when the user presses back or forward, the location of
+		//			the background's iframe changes to the previous or next value in
+		//			its history.
+		//			Transitions: s1
+		//		s4: IEUriMonitor has programmatically changed the location of the
+		//			background iframe, but it's location hasn't yet changed. In this
+		//			case we do nothing because we need to wait for the iframe's
+		//			location to reflect its actual state.
+		//			Transitions: s4, s5
+		//		s5: IEUriMonitor has programmatically changed the location of the
+		//			background iframe, and the iframe's location has caught up with
+		//			reality. In this case we need to transition to s1.
+		//			Transitions: s1
+		//
+		//		The hashchange event is always dispatched on the transition back to s1.
+		//
+
+		// create and append iframe
+		var ifr = document.createElement("iframe"),
+			IFRAME_ID = "dojo-hash-iframe",
+			ifrSrc = dojo.config.dojoBlankHtmlUrl || require.toUrl("./resources/blank.html");
+
+		if(dojo.config.useXDomain && !dojo.config.dojoBlankHtmlUrl){
+			console.warn("dojo.hash: When using cross-domain Dojo builds,"
+				+ " please save dojo/resources/blank.html to your domain and set djConfig.dojoBlankHtmlUrl"
+				+ " to the path on your domain to blank.html");
+		}
+
+		ifr.id = IFRAME_ID;
+		ifr.src = ifrSrc + "?" + _getHash();
+		ifr.style.display = "none";
+		document.body.appendChild(ifr);
+
+		this.iframe = dojo.global[IFRAME_ID];
+		var recentIframeQuery, transitioning, expectedIFrameQuery, docTitle, ifrOffline,
+			iframeLoc = this.iframe.location;
+
+		function resetState(){
+			_recentHash = _getHash();
+			recentIframeQuery = ifrOffline ? _recentHash : _getSegment(iframeLoc.href, "?");
+			transitioning = false;
+			expectedIFrameQuery = null;
+		}
+
+		this.isTransitioning = function(){
+			return transitioning;
+		};
+
+		this.pollLocation = function(){
+			if(!ifrOffline) {
+				try{
+					//see if we can access the iframe's location without a permission denied error
+					var iframeSearch = _getSegment(iframeLoc.href, "?");
+					//good, the iframe is same origin (no thrown exception)
+					if(document.title != docTitle){ //sync title of main window with title of iframe.
+						docTitle = this.iframe.document.title = document.title;
+					}
+				}catch(e){
+					//permission denied - server cannot be reached.
+					ifrOffline = true;
+					console.error("dojo.hash: Error adding history entry. Server unreachable.");
+				}
+			}
+			var hash = _getHash();
+			if(transitioning && _recentHash === hash){
+				// we're in an iframe transition (s4 or s5)
+				if(ifrOffline || iframeSearch === expectedIFrameQuery){
+					// s5 (iframe caught up to main window or iframe offline), transition back to s1
+					resetState();
+					_dispatchEvent();
+				}else{
+					// s4 (waiting for iframe to catch up to main window)
+					setTimeout(lang.hitch(this,this.pollLocation),0);
+					return;
+				}
+			}else if(_recentHash === hash && (ifrOffline || recentIframeQuery === iframeSearch)){
+				// we're in stable state (s1, iframe query == main window hash), do nothing
+			}else{
+				// the user has initiated a URL change somehow.
+				// sync iframe query <-> main window hash
+				if(_recentHash !== hash){
+					// s2 (main window location changed), set iframe url and transition to s4
+					_recentHash = hash;
+					transitioning = true;
+					expectedIFrameQuery = hash;
+					ifr.src = ifrSrc + "?" + expectedIFrameQuery;
+					ifrOffline = false; //we're updating the iframe src - set offline to false so we can check again on next poll.
+					setTimeout(lang.hitch(this,this.pollLocation),0); //yielded transition to s4 while iframe reloads.
+					return;
+				}else if(!ifrOffline){
+					// s3 (iframe location changed via back/forward button), set main window url and transition to s1.
+					location.href = "#" + iframeLoc.search.substring(1);
+					resetState();
+					_dispatchEvent();
+				}
+			}
+			setTimeout(lang.hitch(this,this.pollLocation), _pollFrequency);
+		};
+		resetState(); // initialize state (transition to s1)
+		setTimeout(lang.hitch(this,this.pollLocation), _pollFrequency);
+	}
+	ready(function(){
+		if("onhashchange" in dojo.global && (!has("ie") || (has("ie") >= 8 && document.compatMode != "BackCompat"))){	//need this IE browser test because "onhashchange" exists in IE8 in IE7 mode
+			_connect = connect.connect(dojo.global,"onhashchange",_dispatchEvent);
+		}else{
+			if(document.addEventListener){ // Non-IE
+				_recentHash = _getHash();
+				setInterval(_pollLocation, _pollFrequency); //Poll the window location for changes
+			}else if(document.attachEvent){ // IE7-
+				//Use hidden iframe in versions of IE that don't have onhashchange event
+				_ieUriMonitor = new IEUriMonitor();
+			}
+			// else non-supported browser, do nothing.
+		}
+	});
+
+	return dojo.hash;
+
+});

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

@@ -0,0 +1,148 @@
+/*
+	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/html",["./_base/kernel","./_base/lang","./_base/array","./_base/declare","./dom","./dom-construct","./parser"],function(_1,_2,_3,_4,_5,_6,_7){
+_2.getObject("html",true,_1);
+var _8=0;
+_1.html._secureForInnerHtml=function(_9){
+return _9.replace(/(?:\s*<!DOCTYPE\s[^>]+>|<title[^>]*>[\s\S]*?<\/title>)/ig,"");
+};
+_1.html._emptyNode=_6.empty;
+_1.html._setNodeContent=function(_a,_b){
+_6.empty(_a);
+if(_b){
+if(typeof _b=="string"){
+_b=_6.toDom(_b,_a.ownerDocument);
+}
+if(!_b.nodeType&&_2.isArrayLike(_b)){
+for(var _c=_b.length,i=0;i<_b.length;i=_c==_b.length?i+1:0){
+_6.place(_b[i],_a,"last");
+}
+}else{
+_6.place(_b,_a,"last");
+}
+}
+return _a;
+};
+_4("dojo.html._ContentSetter",null,{node:"",content:"",id:"",cleanContent:false,extractContent:false,parseContent:false,parserScope:_1._scopeName,startup:true,constructor:function(_d,_e){
+_2.mixin(this,_d||{});
+_e=this.node=_5.byId(this.node||_e);
+if(!this.id){
+this.id=["Setter",(_e)?_e.id||_e.tagName:"",_8++].join("_");
+}
+},set:function(_f,_10){
+if(undefined!==_f){
+this.content=_f;
+}
+if(_10){
+this._mixin(_10);
+}
+this.onBegin();
+this.setContent();
+this.onEnd();
+return this.node;
+},setContent:function(){
+var _11=this.node;
+if(!_11){
+throw new Error(this.declaredClass+": setContent given no node");
+}
+try{
+_11=_1.html._setNodeContent(_11,this.content);
+}
+catch(e){
+var _12=this.onContentError(e);
+try{
+_11.innerHTML=_12;
+}
+catch(e){
+console.error("Fatal "+this.declaredClass+".setContent could not change content due to "+e.message,e);
+}
+}
+this.node=_11;
+},empty:function(){
+if(this.parseResults&&this.parseResults.length){
+_3.forEach(this.parseResults,function(w){
+if(w.destroy){
+w.destroy();
+}
+});
+delete this.parseResults;
+}
+_1.html._emptyNode(this.node);
+},onBegin:function(){
+var _13=this.content;
+if(_2.isString(_13)){
+if(this.cleanContent){
+_13=_1.html._secureForInnerHtml(_13);
+}
+if(this.extractContent){
+var _14=_13.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+if(_14){
+_13=_14[1];
+}
+}
+}
+this.empty();
+this.content=_13;
+return this.node;
+},onEnd:function(){
+if(this.parseContent){
+this._parse();
+}
+return this.node;
+},tearDown:function(){
+delete this.parseResults;
+delete this.node;
+delete this.content;
+},onContentError:function(err){
+return "Error occured setting content: "+err;
+},_mixin:function(_15){
+var _16={},key;
+for(key in _15){
+if(key in _16){
+continue;
+}
+this[key]=_15[key];
+}
+},_parse:function(){
+var _17=this.node;
+try{
+var _18={};
+_3.forEach(["dir","lang","textDir"],function(_19){
+if(this[_19]){
+_18[_19]=this[_19];
+}
+},this);
+this.parseResults=_7.parse({rootNode:_17,noStart:!this.startup,inherited:_18,scope:this.parserScope});
+}
+catch(e){
+this._onError("Content",e,"Error parsing in _ContentSetter#"+this.id);
+}
+},_onError:function(_1a,err,_1b){
+var _1c=this["on"+_1a+"Error"].call(this,err);
+if(_1b){
+console.error(_1b,err);
+}else{
+if(_1c){
+_1.html._setNodeContent(this.node,_1c,true);
+}
+}
+}});
+_1.html.set=function(_1d,_1e,_1f){
+if(undefined==_1e){
+console.warn("dojo.html.set: no cont argument provided, using empty string");
+_1e="";
+}
+if(!_1f){
+return _1.html._setNodeContent(_1d,_1e,true);
+}else{
+var op=new _1.html._ContentSetter(_2.mixin(_1f,{content:_1e,node:_1d}));
+return op.set();
+}
+};
+return _1.html;
+});

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

@@ -0,0 +1,342 @@
+define("dojo/html", ["./_base/kernel", "./_base/lang", "./_base/array", "./_base/declare", "./dom", "./dom-construct", "./parser"], function(dojo, lang, darray, declare, dom, domConstruct, parser) {
+	// module:
+	//		dojo/html
+	// summary:
+	//		TODOC
+
+	lang.getObject("html", true, dojo);
+
+	// the parser might be needed..
+
+	// idCounter is incremented with each instantiation to allow asignment of a unique id for tracking, logging purposes
+	var idCounter = 0;
+
+	dojo.html._secureForInnerHtml = function(/*String*/ cont){
+		// summary:
+		//		removes !DOCTYPE and title elements from the html string.
+		//
+		//		khtml is picky about dom faults, you can't attach a style or <title> node as child of body
+		//		must go into head, so we need to cut out those tags
+		//	cont:
+		//		An html string for insertion into the dom
+		//
+		return cont.replace(/(?:\s*<!DOCTYPE\s[^>]+>|<title[^>]*>[\s\S]*?<\/title>)/ig, ""); // String
+	};
+
+/*====
+	dojo.html._emptyNode = function(node){
+		// summary:
+		//		removes all child nodes from the given node
+		//	node: DOMNode
+		//		the parent element
+	};
+=====*/
+	dojo.html._emptyNode = domConstruct.empty;
+
+	dojo.html._setNodeContent = function(/* DomNode */ node, /* String|DomNode|NodeList */ cont){
+		// summary:
+		//		inserts the given content into the given node
+		//	node:
+		//		the parent element
+		//	content:
+		//		the content to be set on the parent element.
+		//		This can be an html string, a node reference or a NodeList, dojo.NodeList, Array or other enumerable list of nodes
+
+		// always empty
+		domConstruct.empty(node);
+
+		if(cont) {
+			if(typeof cont == "string") {
+				cont = domConstruct.toDom(cont, node.ownerDocument);
+			}
+			if(!cont.nodeType && lang.isArrayLike(cont)) {
+				// handle as enumerable, but it may shrink as we enumerate it
+				for(var startlen=cont.length, i=0; i<cont.length; i=startlen==cont.length ? i+1 : 0) {
+					domConstruct.place( cont[i], node, "last");
+				}
+			} else {
+				// pass nodes, documentFragments and unknowns through to dojo.place
+				domConstruct.place(cont, node, "last");
+			}
+		}
+
+		// return DomNode
+		return node;
+	};
+
+	// we wrap up the content-setting operation in a object
+	declare("dojo.html._ContentSetter", null,
+		{
+			// node: DomNode|String
+			//		An node which will be the parent element that we set content into
+			node: "",
+
+			// content: String|DomNode|DomNode[]
+			//		The content to be placed in the node. Can be an HTML string, a node reference, or a enumerable list of nodes
+			content: "",
+
+			// id: String?
+			//		Usually only used internally, and auto-generated with each instance
+			id: "",
+
+			// cleanContent: Boolean
+			//		Should the content be treated as a full html document,
+			//		and the real content stripped of <html>, <body> wrapper before injection
+			cleanContent: false,
+
+			// extractContent: Boolean
+			//		Should the content be treated as a full html document, and the real content stripped of <html>, <body> wrapper before injection
+			extractContent: false,
+
+			// parseContent: Boolean
+			//		Should the node by passed to the parser after the new content is set
+			parseContent: false,
+
+			// parserScope: String
+			//		Flag passed to parser.	Root for attribute names to search for.	  If scopeName is dojo,
+			//		will search for data-dojo-type (or dojoType).  For backwards compatibility
+			//		reasons defaults to dojo._scopeName (which is "dojo" except when
+			//		multi-version support is used, when it will be something like dojo16, dojo20, etc.)
+			parserScope: dojo._scopeName,
+
+			// startup: Boolean
+			//		Start the child widgets after parsing them.	  Only obeyed if parseContent is true.
+			startup: true,
+
+			// lifecyle methods
+			constructor: function(/* Object */params, /* String|DomNode */node){
+				//	summary:
+				//		Provides a configurable, extensible object to wrap the setting on content on a node
+				//		call the set() method to actually set the content..
+
+				// the original params are mixed directly into the instance "this"
+				lang.mixin(this, params || {});
+
+				// give precedence to params.node vs. the node argument
+				// and ensure its a node, not an id string
+				node = this.node = dom.byId( this.node || node );
+
+				if(!this.id){
+					this.id = [
+						"Setter",
+						(node) ? node.id || node.tagName : "",
+						idCounter++
+					].join("_");
+				}
+			},
+			set: function(/* String|DomNode|NodeList? */ cont, /* Object? */ params){
+				// summary:
+				//		front-end to the set-content sequence
+				//	cont:
+				//		An html string, node or enumerable list of nodes for insertion into the dom
+				//		If not provided, the object's content property will be used
+				if(undefined !== cont){
+					this.content = cont;
+				}
+				// in the re-use scenario, set needs to be able to mixin new configuration
+				if(params){
+					this._mixin(params);
+				}
+
+				this.onBegin();
+				this.setContent();
+				this.onEnd();
+
+				return this.node;
+			},
+			setContent: function(){
+				// summary:
+				//		sets the content on the node
+
+				var node = this.node;
+				if(!node) {
+					// can't proceed
+					throw new Error(this.declaredClass + ": setContent given no node");
+				}
+				try{
+					node = dojo.html._setNodeContent(node, this.content);
+				}catch(e){
+					// check if a domfault occurs when we are appending this.errorMessage
+					// like for instance if domNode is a UL and we try append a DIV
+
+					// FIXME: need to allow the user to provide a content error message string
+					var errMess = this.onContentError(e);
+					try{
+						node.innerHTML = errMess;
+					}catch(e){
+						console.error('Fatal ' + this.declaredClass + '.setContent could not change content due to '+e.message, e);
+					}
+				}
+				// always put back the node for the next method
+				this.node = node; // DomNode
+			},
+
+			empty: function() {
+				// summary
+				//	cleanly empty out existing content
+
+				// destroy any widgets from a previous run
+				// NOTE: if you dont want this you'll need to empty
+				// the parseResults array property yourself to avoid bad things happenning
+				if(this.parseResults && this.parseResults.length) {
+					darray.forEach(this.parseResults, function(w) {
+						if(w.destroy){
+							w.destroy();
+						}
+					});
+					delete this.parseResults;
+				}
+				// this is fast, but if you know its already empty or safe, you could
+				// override empty to skip this step
+				dojo.html._emptyNode(this.node);
+			},
+
+			onBegin: function(){
+				// summary
+				//		Called after instantiation, but before set();
+				//		It allows modification of any of the object properties
+				//		- including the node and content provided - before the set operation actually takes place
+				//		This default implementation checks for cleanContent and extractContent flags to
+				//		optionally pre-process html string content
+				var cont = this.content;
+
+				if(lang.isString(cont)){
+					if(this.cleanContent){
+						cont = dojo.html._secureForInnerHtml(cont);
+					}
+
+					if(this.extractContent){
+						var match = cont.match(/<body[^>]*>\s*([\s\S]+)\s*<\/body>/im);
+						if(match){ cont = match[1]; }
+					}
+				}
+
+				// clean out the node and any cruft associated with it - like widgets
+				this.empty();
+
+				this.content = cont;
+				return this.node; /* DomNode */
+			},
+
+			onEnd: function(){
+				// summary
+				//		Called after set(), when the new content has been pushed into the node
+				//		It provides an opportunity for post-processing before handing back the node to the caller
+				//		This default implementation checks a parseContent flag to optionally run the dojo parser over the new content
+				if(this.parseContent){
+					// populates this.parseResults if you need those..
+					this._parse();
+				}
+				return this.node; /* DomNode */
+			},
+
+			tearDown: function(){
+				// summary
+				//		manually reset the Setter instance if its being re-used for example for another set()
+				// description
+				//		tearDown() is not called automatically.
+				//		In normal use, the Setter instance properties are simply allowed to fall out of scope
+				//		but the tearDown method can be called to explicitly reset this instance.
+				delete this.parseResults;
+				delete this.node;
+				delete this.content;
+			},
+
+			onContentError: function(err){
+				return "Error occured setting content: " + err;
+			},
+
+			_mixin: function(params){
+				// mix properties/methods into the instance
+				// TODO: the intention with tearDown is to put the Setter's state
+				// back to that of the original constructor (vs. deleting/resetting everything regardless of ctor params)
+				// so we could do something here to move the original properties aside for later restoration
+				var empty = {}, key;
+				for(key in params){
+					if(key in empty){ continue; }
+					// TODO: here's our opportunity to mask the properties we dont consider configurable/overridable
+					// .. but history shows we'll almost always guess wrong
+					this[key] = params[key];
+				}
+			},
+			_parse: function(){
+				// summary:
+				//		runs the dojo parser over the node contents, storing any results in this.parseResults
+				//		Any errors resulting from parsing are passed to _onError for handling
+
+				var rootNode = this.node;
+				try{
+					// store the results (widgets, whatever) for potential retrieval
+					var inherited = {};
+					darray.forEach(["dir", "lang", "textDir"], function(name){
+						if(this[name]){
+							inherited[name] = this[name];
+						}
+					}, this);
+					this.parseResults = parser.parse({
+						rootNode: rootNode,
+						noStart: !this.startup,
+						inherited: inherited,
+						scope: this.parserScope
+					});
+				}catch(e){
+					this._onError('Content', e, "Error parsing in _ContentSetter#"+this.id);
+				}
+			},
+
+			_onError: function(type, err, consoleText){
+				// summary:
+				//		shows user the string that is returned by on[type]Error
+				//		overide/implement on[type]Error and return your own string to customize
+				var errText = this['on' + type + 'Error'].call(this, err);
+				if(consoleText){
+					console.error(consoleText, err);
+				}else if(errText){ // a empty string won't change current content
+					dojo.html._setNodeContent(this.node, errText, true);
+				}
+			}
+	}); // end dojo.declare()
+
+	dojo.html.set = function(/* DomNode */ node, /* String|DomNode|NodeList */ cont, /* Object? */ params){
+			// summary:
+			//		inserts (replaces) the given content into the given node. dojo.place(cont, node, "only")
+			//		may be a better choice for simple HTML insertion.
+			// description:
+			//		Unless you need to use the params capabilities of this method, you should use
+			//		dojo.place(cont, node, "only"). dojo.place() has more robust support for injecting
+			//		an HTML string into the DOM, but it only handles inserting an HTML string as DOM
+			//		elements, or inserting a DOM node. dojo.place does not handle NodeList insertions
+			//		or the other capabilities as defined by the params object for this method.
+			//	node:
+			//		the parent element that will receive the content
+			//	cont:
+			//		the content to be set on the parent element.
+			//		This can be an html string, a node reference or a NodeList, dojo.NodeList, Array or other enumerable list of nodes
+			//	params:
+			//		Optional flags/properties to configure the content-setting. See dojo.html._ContentSetter
+			//	example:
+			//		A safe string/node/nodelist content replacement/injection with hooks for extension
+			//		Example Usage:
+			//		dojo.html.set(node, "some string");
+			//		dojo.html.set(node, contentNode, {options});
+			//		dojo.html.set(node, myNode.childNodes, {options});
+		if(undefined == cont){
+			console.warn("dojo.html.set: no cont argument provided, using empty string");
+			cont = "";
+		}
+		if(!params){
+			// simple and fast
+			return dojo.html._setNodeContent(node, cont, true);
+		}else{
+			// more options but slower
+			// note the arguments are reversed in order, to match the convention for instantiation via the parser
+			var op = new dojo.html._ContentSetter(lang.mixin(
+					params,
+					{ content: cont, node: node }
+			));
+			return op.set();
+		}
+	};
+
+	return dojo.html;
+});