1 files changed, 1042 insertions, 0 deletions
diff --git a/js/dojo-1.6/dojox/dtl/dom.js b/js/dojo-1.6/dojox/dtl/dom.js
new file mode 100644
index 0000000..86f0f32
--- /dev/null
+++ b/js/dojo-1.6/dojox/dtl/dom.js
@@ -0,0 +1,1042 @@
+/*
+	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
+*/
+
+
+if(!dojo._hasResource["dojox.dtl.dom"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.dtl.dom"] = true;
+dojo.provide("dojox.dtl.dom");
+
+dojo.require("dojox.dtl._base");
+dojo.require("dojox.dtl.Context");
+
+(function(){
+	var dd = dojox.dtl;
+
+	dd.BOOLS = {checked: 1, disabled: 1, readonly: 1};
+	dd.TOKEN_CHANGE = -11;
+	dd.TOKEN_ATTR = -12;
+	dd.TOKEN_CUSTOM = -13;
+	dd.TOKEN_NODE = 1;
+
+	var ddt = dd.text;
+	var ddh = dd.dom = {
+		_attributes: {},
+		_uppers: {},
+		_re4: /^function anonymous\(\)\s*{\s*(.*)\s*}$/,
+		_reTrim: /(?:^[\n\s]*(\{%)?\s*|\s*(%\})?[\n\s]*$)/g,
+		_reSplit: /\s*%\}[\n\s]*\{%\s*/g,
+		getTemplate: function(text){
+			if(typeof this._commentable == "undefined"){
+				// Check to see if the browser can handle comments
+				this._commentable = false;
+				var div = document.createElement("div");
+				div.innerHTML = "<!--Test comment handling, and long comments, using comments whenever possible.-->";
+				if(div.childNodes.length && div.childNodes[0].nodeType == 8 && div.childNodes[0].data == "comment"){
+					this._commentable = true;
+				}
+			}
+
+			if(!this._commentable){
+				// Strip comments
+				text = text.replace(/<!--({({|%).*?(%|})})-->/g, "$1");
+			}
+
+			if(dojo.isIE){
+				text = text.replace(/\b(checked|disabled|readonly|style)="/g, 't$1="');
+			}
+			text = text.replace(/\bstyle="/g, 'tstyle="');
+
+			var match;
+			var table = dojo.isWebKit;
+			var pairs = [ // Format: [enable, parent, allowed children (first for nesting), nestings]
+				[true, "select", "option"],
+				[table, "tr", "td|th"],
+				[table, "thead", "tr", "th"],
+				[table, "tbody", "tr", "td"],
+				[table, "table", "tbody|thead|tr", "tr", "td"]
+			];
+			var replacements = [];
+			// Some tags can't contain text. So we wrap the text in tags that they can have.
+			for(var i = 0, pair; pair = pairs[i]; i++){
+				if(!pair[0]){
+					continue;
+				}
+				if(text.indexOf("<" + pair[1]) != -1){
+					var selectRe = new RegExp("<" + pair[1] + "(?:.|\n)*?>((?:.|\n)+?)</" + pair[1] + ">", "ig");
+					tagLoop: while(match = selectRe.exec(text)){
+						// Do it like this to make sure we don't double-wrap
+						var inners = pair[2].split("|");
+						var innerRe = [];
+						for(var j = 0, inner; inner = inners[j]; j++){
+							innerRe.push("<" + inner + "(?:.|\n)*?>(?:.|\n)*?</" + inner + ">");
+						}
+						var tags = [];
+						var tokens = dojox.string.tokenize(match[1], new RegExp("(" + innerRe.join("|") + ")", "ig"), function(data){
+							var tag = /<(\w+)/.exec(data)[1];
+							if(!tags[tag]){
+								tags[tag] = true;
+								tags.push(tag);
+							}
+							return {data: data};
+						});
+						if(tags.length){
+							var tag = (tags.length == 1) ? tags[0] : pair[2].split("|")[0];
+
+							var replace = [];
+							for(var j = 0, jl = tokens.length; j < jl; j++) {
+								var token = tokens[j];
+								if(dojo.isObject(token)){
+									replace.push(token.data);
+								}else{
+									var stripped = token.replace(this._reTrim, "");
+									if(!stripped){ continue; }
+									token = stripped.split(this._reSplit);
+									for(var k = 0, kl = token.length; k < kl; k++){
+										var replacement = "";
+										for(var p = 2, pl = pair.length; p < pl; p++){
+											if(p == 2){
+												replacement += "<" + tag + ' dtlinstruction="{% ' + token[k].replace('"', '\\"') + ' %}">';
+											}else if(tag == pair[p]) {
+												continue;
+											}else{
+												replacement += "<" + pair[p] + ">";
+											}
+										}
+										replacement += "DTL";
+										for(var p = pair.length - 1; p > 1; p--){
+											if(p == 2){
+												replacement += "</" + tag + ">";
+											}else if(tag == pair[p]) {
+												continue;
+											}else{
+												replacement += "</" + pair[p] + ">";
+											}
+										}
+										replace.push("\xFF" + replacements.length);
+										replacements.push(replacement);
+									}
+								}
+							}
+							text = text.replace(match[1], replace.join(""));
+						}
+					}
+				}
+			}
+
+			for(var i=replacements.length; i--;){
+				text = text.replace("\xFF" + i, replacements[i]);
+			}
+
+			var re = /\b([a-zA-Z_:][a-zA-Z0-9_\-\.:]*)=['"]/g;
+			while(match = re.exec(text)){
+				var lower = match[1].toLowerCase();
+				if(lower == "dtlinstruction"){ continue; }
+				if(lower != match[1]){
+					this._uppers[lower] = match[1];
+				}
+				this._attributes[lower] = true;
+			}
+			var div = document.createElement("div");
+			div.innerHTML = text;
+			var output = {nodes: []};
+			while(div.childNodes.length){
+				output.nodes.push(div.removeChild(div.childNodes[0]))
+			}
+
+			return output;
+		},
+		tokenize: function(/*Node*/ nodes){
+			var tokens = [];
+
+			for(var i = 0, node; node = nodes[i++];){
+				if(node.nodeType != 1){
+					this.__tokenize(node, tokens);
+				}else{
+					this._tokenize(node, tokens);
+				}
+			}
+
+			return tokens;
+		},
+		_swallowed: [],
+		_tokenize: function(/*Node*/ node, /*Array*/ tokens){
+			var first = false;
+			var swallowed = this._swallowed;
+			var i, j, tag, child;
+
+			if(!tokens.first){
+				// Try to efficiently associate tags that use an attribute to
+				// remove the node from DOM (eg dojoType) so that we can efficiently
+				// locate them later in the tokenizing.
+				first = tokens.first = true;
+				var tags = dd.register.getAttributeTags();
+				for(i = 0; tag = tags[i]; i++){
+					try{
+						(tag[2])({ swallowNode: function(){ throw 1; }}, new dd.Token(dd.TOKEN_ATTR, ""));
+					}catch(e){
+						swallowed.push(tag);
+					}
+				}
+			}
+
+			for(i = 0; tag = swallowed[i]; i++){
+				var text = node.getAttribute(tag[0]);
+				if(text){
+					var swallowed = false;
+					var custom = (tag[2])({ swallowNode: function(){ swallowed = true; return node; }}, new dd.Token(dd.TOKEN_ATTR, tag[0] + " " + text));
+					if(swallowed){
+						if(node.parentNode && node.parentNode.removeChild){
+							node.parentNode.removeChild(node);
+						}
+						tokens.push([dd.TOKEN_CUSTOM, custom]);
+						return;
+					}
+				}
+			}
+
+			var children = [];
+			if(dojo.isIE && node.tagName == "SCRIPT"){
+				children.push({
+					nodeType: 3,
+					data: node.text
+				});
+				node.text = "";
+			}else{
+				for(i = 0; child = node.childNodes[i]; i++){
+					children.push(child);
+				}
+			}
+
+			tokens.push([dd.TOKEN_NODE, node]);
+
+			var change = false;
+			if(children.length){
+				// Only do a change request if we need to
+				tokens.push([dd.TOKEN_CHANGE, node]);
+				change = true;
+			}
+
+			for(var key in this._attributes){
+				var clear = false;
+
+				var value = "";
+				if(key == "class"){
+					value = node.className || value;
+				}else if(key == "for"){
+					value = node.htmlFor || value;
+				}else if(key == "value" && node.value == node.innerHTML){
+					// Sometimes .value is set the same as the contents of the item (button)
+					continue;
+				}else if(node.getAttribute){
+					value = node.getAttribute(key, 2) || value;
+					if(key == "href" || key == "src"){
+						if(dojo.isIE){
+							var hash = location.href.lastIndexOf(location.hash);
+							var href = location.href.substring(0, hash).split("/");
+							href.pop();
+							href = href.join("/") + "/";
+							if(value.indexOf(href) == 0){
+								value = value.replace(href, "");
+							}
+							value = decodeURIComponent(value);
+						}
+					}else if(key == "tstyle"){
+						clear = key; // Placeholder because we can't use style
+						key = "style";
+					}else if(dd.BOOLS[key.slice(1)] && dojo.trim(value)){
+						key = key.slice(1);
+					}else if(this._uppers[key] && dojo.trim(value)){
+						clear = this._uppers[key]; // Replaced by lowercase
+					}
+				}
+
+				if(clear){
+					// Clear out values that are different than will
+					// be used in plugins
+					node.setAttribute(clear, "");
+					node.removeAttribute(clear);
+				}
+
+				if(typeof value == "function"){
+					value = value.toString().replace(this._re4, "$1");
+				}
+
+				if(!change){
+					// Only do a change request if we need to
+					tokens.push([dd.TOKEN_CHANGE, node]);
+					change = true;
+				}
+
+				// We'll have to resolve attributes during parsing (some ref plugins)
+
+				tokens.push([dd.TOKEN_ATTR, node, key, value]);
+			}
+
+			for(i = 0, child; child = children[i]; i++){
+				if(child.nodeType == 1){
+					var instruction = child.getAttribute("dtlinstruction");
+					if(instruction){
+						child.parentNode.removeChild(child);
+						child = {
+							nodeType: 8,
+							data: instruction
+						};
+					}
+				}
+				this.__tokenize(child, tokens);
+			}
+
+			if(!first && node.parentNode && node.parentNode.tagName){
+				if(change){
+					tokens.push([dd.TOKEN_CHANGE, node, true]);
+				}
+				tokens.push([dd.TOKEN_CHANGE, node.parentNode]);
+				node.parentNode.removeChild(node);
+			}else{
+				// If this node is parentless, it's a base node, so we have to "up" change to itself
+				// and note that it's a top-level to watch for errors
+				tokens.push([dd.TOKEN_CHANGE, node, true, true]);
+			}
+		},
+		__tokenize: function(child, tokens){
+			var data = child.data;
+			switch(child.nodeType){
+				case 1:
+					this._tokenize(child, tokens);
+					return;
+				case 3:
+					if(data.match(/[^\s\n]/) && (data.indexOf("{{") != -1 || data.indexOf("{%") != -1)){
+						var texts = ddt.tokenize(data);
+						for(var j = 0, text; text = texts[j]; j++){
+							if(typeof text == "string"){
+								tokens.push([dd.TOKEN_TEXT, text]);
+							}else{
+								tokens.push(text);
+							}
+						}
+					}else{
+						tokens.push([child.nodeType, child]);
+					}
+					if(child.parentNode) child.parentNode.removeChild(child);
+					return;
+				case 8:
+					if(data.indexOf("{%") == 0){
+						var text = dojo.trim(data.slice(2, -2));
+						if(text.substr(0, 5) == "load "){
+							var parts = dojo.trim(text).split(/\s+/g);
+							for(var i = 1, part; part = parts[i]; i++){
+								dojo["require"](part);
+							}
+						}
+						tokens.push([dd.TOKEN_BLOCK, text]);
+					}
+					if(data.indexOf("{{") == 0){
+						tokens.push([dd.TOKEN_VAR, dojo.trim(data.slice(2, -2))]);
+					}
+					if(child.parentNode) child.parentNode.removeChild(child);
+					return;
+			}
+		}
+	};
+
+	dd.DomTemplate = dojo.extend(function(/*String|DOMNode|dojo._Url*/ obj){
+		// summary: Use this object for DOM templating
+		if(!obj.nodes){
+			var node = dojo.byId(obj);
+			if(node && node.nodeType == 1){
+				dojo.forEach(["class", "src", "href", "name", "value"], function(item){
+					ddh._attributes[item] = true;
+				});
+				obj = {
+					nodes: [node]
+				};
+			}else{
+				if(typeof obj == "object"){
+					obj = ddt.getTemplateString(obj);
+				}
+				obj = ddh.getTemplate(obj);
+			}
+		}
+
+		var tokens = ddh.tokenize(obj.nodes);
+		if(dd.tests){
+			this.tokens = tokens.slice(0);
+		}
+
+		var parser = new dd._DomParser(tokens);
+		this.nodelist = parser.parse();
+	},
+	{
+		_count: 0,
+		_re: /\bdojo:([a-zA-Z0-9_]+)\b/g,
+		setClass: function(str){
+			this.getRootNode().className = str;
+		},
+		getRootNode: function(){
+			return this.buffer.rootNode;
+		},
+		getBuffer: function(){
+			return new dd.DomBuffer();
+		},
+		render: function(context, buffer){
+			buffer = this.buffer = buffer || this.getBuffer();
+			this.rootNode = null;
+			var output = this.nodelist.render(context || new dd.Context({}), buffer);
+			for(var i = 0, node; node = buffer._cache[i]; i++){
+				if(node._cache){
+					node._cache.length = 0;
+				}
+			}
+			return output;
+		},
+		unrender: function(context, buffer){
+			return this.nodelist.unrender(context, buffer);
+		}
+	});
+
+	dd.DomBuffer = dojo.extend(function(/*Node*/ parent){
+		// summary: Allows the manipulation of DOM
+		// description:
+		//		Use this to append a child, change the parent, or
+		//		change the attribute of the current node.
+		this._parent = parent;
+		this._cache = [];
+	},
+	{
+		concat: function(/*DOMNode*/ node){
+			var parent = this._parent;
+			if(parent && node.parentNode && node.parentNode === parent && !parent._dirty){
+				return this;
+			}
+
+			if(node.nodeType == 1 && !this.rootNode){
+				this.rootNode = node || true;
+				return this;
+			}
+
+			if(!parent){
+				if(node.nodeType == 3 && dojo.trim(node.data)){
+					throw new Error("Text should not exist outside of the root node in template");
+				}
+				return this;
+			}
+			if(this._closed){
+				if(node.nodeType == 3 && !dojo.trim(node.data)){
+					return this;
+				}else{
+					throw new Error("Content should not exist outside of the root node in template");
+				}
+			}
+			if(parent._dirty){
+				if(node._drawn && node.parentNode == parent){
+					var caches = parent._cache;
+					if(caches){
+						for(var i = 0, cache; cache = caches[i]; i++){
+							this.onAddNode && this.onAddNode(cache);
+							parent.insertBefore(cache, node);
+							this.onAddNodeComplete && this.onAddNodeComplete(cache);
+						}
+						caches.length = 0;
+					}
+				}
+				parent._dirty = false;
+			}
+			if(!parent._cache){
+				parent._cache = [];
+				this._cache.push(parent);
+			}
+			parent._dirty = true;
+			parent._cache.push(node);
+			return this;
+		},
+		remove: function(obj){
+			if(typeof obj == "string"){
+				if(this._parent){
+					this._parent.removeAttribute(obj);
+				}
+			}else{
+				if(obj.nodeType == 1 && !this.getRootNode() && !this._removed){
+					this._removed = true;
+					return this;
+				}
+				if(obj.parentNode){
+					this.onRemoveNode && this.onRemoveNode(obj);
+					if(obj.parentNode){
+						obj.parentNode.removeChild(obj);
+					}
+				}
+			}
+			return this;
+		},
+		setAttribute: function(key, value){
+			var old = dojo.attr(this._parent, key);
+			if(this.onChangeAttribute && old != value){
+				this.onChangeAttribute(this._parent, key, old, value);
+			}
+			if(key == "style"){
+				//console.log(value);
+				this._parent.style.cssText = value;
+			}else{
+				dojo.attr(this._parent, key, value);
+				//console.log(this._parent, key, value);
+			}
+			return this;
+		},
+		addEvent: function(context, type, fn, /*Array|Function*/ args){
+			if(!context.getThis()){ throw new Error("You must use Context.setObject(instance)"); }
+			this.onAddEvent && this.onAddEvent(this.getParent(), type, fn);
+			var resolved = fn;
+			if(dojo.isArray(args)){
+				resolved = function(e){
+					this[fn].apply(this, [e].concat(args));
+				}
+			}
+			return dojo.connect(this.getParent(), type, context.getThis(), resolved);
+		},
+		setParent: function(node, /*Boolean?*/ up, /*Boolean?*/ root){
+			if(!this._parent) this._parent = this._first = node;
+
+			if(up && root && node === this._first){
+				this._closed = true;
+			}
+
+			if(up){
+				var parent = this._parent;
+				var script = "";
+				var ie = dojo.isIE && parent.tagName == "SCRIPT";
+				if(ie){
+					parent.text = "";
+				}
+				if(parent._dirty){
+					var caches = parent._cache;
+					var select = (parent.tagName == "SELECT" && !parent.options.length);
+					for(var i = 0, cache; cache = caches[i]; i++){
+						if(cache !== parent){
+							this.onAddNode && this.onAddNode(cache);
+							if(ie){
+								script += cache.data;
+							}else{
+								parent.appendChild(cache);
+								if(select && cache.defaultSelected && i){
+									select = i;
+								}
+							}
+							this.onAddNodeComplete && this.onAddNodeComplete(cache);
+						}
+					}
+					if(select){
+						parent.options.selectedIndex = (typeof select == "number") ? select : 0;
+					}
+					caches.length = 0;
+					parent._dirty = false;
+				}
+				if(ie){
+					parent.text = script;
+				}
+			}
+
+			this._parent = node;
+			this.onSetParent && this.onSetParent(node, up, root);
+			return this;
+		},
+		getParent: function(){
+			return this._parent;
+		},
+		getRootNode: function(){
+			return this.rootNode;
+		}
+		/*=====
+		,
+		onSetParent: function(node, up){
+			// summary: Stub called when setParent is used.
+		},
+		onAddNode: function(node){
+			// summary: Stub called before new nodes are added
+		},
+		onAddNodeComplete: function(node){
+			// summary: Stub called after new nodes are added
+		},
+		onRemoveNode: function(node){
+			// summary: Stub called when nodes are removed
+		},
+		onChangeAttribute: function(node, attribute, old, updated){
+			// summary: Stub called when an attribute is changed
+		},
+		onChangeData: function(node, old, updated){
+			// summary: Stub called when a data in a node is changed
+		},
+		onClone: function(from, to){
+			// summary: Stub called when a node is duplicated
+			// from: DOMNode
+			// to: DOMNode
+		},
+		onAddEvent: function(node, type, description){
+			// summary: Stub to call when you're adding an event
+			// node: DOMNode
+			// type: String
+			// description: String
+		}
+		=====*/
+	});
+
+	dd._DomNode = dojo.extend(function(node){
+		// summary: Places a node into DOM
+		this.contents = node;
+	},
+	{
+		render: function(context, buffer){
+			this._rendered = true;
+			return buffer.concat(this.contents);
+		},
+		unrender: function(context, buffer){
+			if(!this._rendered){
+				return buffer;
+			}
+			this._rendered = false;
+			return buffer.remove(this.contents);
+		},
+		clone: function(buffer){
+			return new this.constructor(this.contents);
+		}
+	});
+
+	dd._DomNodeList = dojo.extend(function(/*Node[]*/ nodes){
+		// summary: A list of any DOM-specific node objects
+		// description:
+		//		Any object that's used in the constructor or added
+		//		through the push function much implement the
+		//		render, unrender, and clone functions.
+		this.contents = nodes || [];
+	},
+	{
+		push: function(node){
+			this.contents.push(node);
+		},
+		unshift: function(node){
+			this.contents.unshift(node);
+		},
+		render: function(context, buffer, /*Node*/ instance){
+			buffer = buffer || dd.DomTemplate.prototype.getBuffer();
+
+			if(instance){
+				var parent = buffer.getParent();
+			}
+			for(var i = 0; i < this.contents.length; i++){
+				buffer = this.contents[i].render(context, buffer);
+				if(!buffer) throw new Error("Template node render functions must return their buffer");
+			}
+			if(parent){
+				buffer.setParent(parent);
+			}
+			return buffer;
+		},
+		dummyRender: function(context, buffer, asNode){
+			// summary: A really expensive way of checking to see how a rendering will look.
+			//		Used in the ifchanged tag
+			var div = document.createElement("div");
+
+			var parent = buffer.getParent();
+			var old = parent._clone;
+			// Tell the clone system to attach itself to our new div
+			parent._clone = div;
+			var nodelist = this.clone(buffer, div);
+			if(old){
+				// Restore state if there was a previous clone
+				parent._clone = old;
+			}else{
+				// Remove if there was no clone
+				parent._clone = null;
+			}
+
+			buffer = dd.DomTemplate.prototype.getBuffer();
+			nodelist.unshift(new dd.ChangeNode(div));
+			nodelist.unshift(new dd._DomNode(div));
+			nodelist.push(new dd.ChangeNode(div, true));
+			nodelist.render(context, buffer);
+
+			if(asNode){
+				return buffer.getRootNode();
+			}
+
+			var html = div.innerHTML;
+			return (dojo.isIE) ? html.replace(/\s*_(dirty|clone)="[^"]*"/g, "") : html;
+		},
+		unrender: function(context, buffer, instance){
+			if(instance){
+				var parent = buffer.getParent();
+			}
+			for(var i = 0; i < this.contents.length; i++){
+				buffer = this.contents[i].unrender(context, buffer);
+				if(!buffer) throw new Error("Template node render functions must return their buffer");
+			}
+			if(parent){
+				buffer.setParent(parent);
+			}
+			return buffer;
+		},
+		clone: function(buffer){
+			// summary:
+			//		Used to create an identical copy of a NodeList, useful for things like the for tag.
+			var parent = buffer.getParent();
+			var contents = this.contents;
+			var nodelist = new dd._DomNodeList();
+			var cloned = [];
+			for(var i = 0; i < contents.length; i++){
+				var clone = contents[i].clone(buffer);
+				if(clone instanceof dd.ChangeNode || clone instanceof dd._DomNode){
+					var item = clone.contents._clone;
+					if(item){
+						clone.contents = item;
+					}else if(parent != clone.contents && clone instanceof dd._DomNode){
+						var node = clone.contents;
+						clone.contents = clone.contents.cloneNode(false);
+						buffer.onClone && buffer.onClone(node, clone.contents);
+						cloned.push(node);
+						node._clone = clone.contents;
+					}
+				}
+				nodelist.push(clone);
+			}
+
+			for(var i = 0, clone; clone = cloned[i]; i++){
+				clone._clone = null;
+			}
+
+			return nodelist;
+		},
+		rtrim: function(){
+			while(1){
+				var i = this.contents.length - 1;
+				if(this.contents[i] instanceof dd._DomTextNode && this.contents[i].isEmpty()){
+					this.contents.pop();
+				}else{
+					break;
+				}
+			}
+
+			return this;
+		}
+	});
+
+	dd._DomVarNode = dojo.extend(function(str){
+		// summary: A node to be processed as a variable
+		// description:
+		//		Will render an object that supports the render function
+		// 		and the getRootNode function
+		this.contents = new dd._Filter(str);
+	},
+	{
+		render: function(context, buffer){
+			var str = this.contents.resolve(context);
+
+			// What type of rendering?
+			var type = "text";
+			if(str){
+				if(str.render && str.getRootNode){
+					type = "injection";
+				}else if(str.safe){
+					if(str.nodeType){
+						type = "node";
+					}else if(str.toString){
+						str = str.toString();
+						type = "html";
+					}
+				}
+			}
+
+			// Has the typed changed?
+			if(this._type && type != this._type){
+				this.unrender(context, buffer);
+			}
+			this._type = type;
+
+			// Now render
+			switch(type){
+			case "text":
+				this._rendered = true;
+				this._txt = this._txt || document.createTextNode(str);
+				if(this._txt.data != str){
+					var old = this._txt.data;
+					this._txt.data = str;
+					buffer.onChangeData && buffer.onChangeData(this._txt, old, this._txt.data);
+				}
+				return buffer.concat(this._txt);
+			case "injection":
+				var root = str.getRootNode();
+
+				if(this._rendered && root != this._root){
+					buffer = this.unrender(context, buffer);
+				}
+				this._root = root;
+
+				var injected = this._injected = new dd._DomNodeList();
+				injected.push(new dd.ChangeNode(buffer.getParent()));
+				injected.push(new dd._DomNode(root));
+				injected.push(str);
+				injected.push(new dd.ChangeNode(buffer.getParent()));
+				this._rendered = true;
+
+				return injected.render(context, buffer);
+			case "node":
+				this._rendered = true;
+				if(this._node && this._node != str && this._node.parentNode && this._node.parentNode === buffer.getParent()){
+					this._node.parentNode.removeChild(this._node);
+				}
+				this._node = str;
+				return buffer.concat(str);
+			case "html":
+				if(this._rendered && this._src != str){
+					buffer = this.unrender(context, buffer);
+				}
+				this._src = str;
+
+				// This can get reset in the above tag
+				if(!this._rendered){
+					this._rendered = true;
+					this._html = this._html || [];
+					var div = (this._div = this._div || document.createElement("div"));
+					div.innerHTML = str;
+					var children = div.childNodes;
+					while(children.length){
+						var removed = div.removeChild(children[0]);
+						this._html.push(removed);
+						buffer = buffer.concat(removed);
+					}
+				}
+
+				return buffer;
+			default:
+				return buffer;
+			}
+		},
+		unrender: function(context, buffer){
+			if(!this._rendered){
+				return buffer;
+			}
+			this._rendered = false;
+
+			// Unrender injected nodes
+			switch(this._type){
+			case "text":
+				return buffer.remove(this._txt);
+			case "injection":
+				return this._injection.unrender(context, buffer);
+			case "node":
+				if(this._node.parentNode === buffer.getParent()){
+					return buffer.remove(this._node);
+				}
+				return buffer;
+			case "html":
+				for(var i=0, l=this._html.length; i<l; i++){
+					buffer = buffer.remove(this._html[i]);
+				}
+				return buffer;
+			default:
+				return buffer;
+			}
+		},
+		clone: function(){
+			return new this.constructor(this.contents.getExpression());
+		}
+	});
+
+	dd.ChangeNode = dojo.extend(function(node, /*Boolean?*/ up, /*Bookean*/ root){
+		// summary: Changes the parent during render/unrender
+		this.contents = node;
+		this.up = up;
+		this.root = root;
+	},
+	{
+		render: function(context, buffer){
+			return buffer.setParent(this.contents, this.up, this.root);
+		},
+		unrender: function(context, buffer){
+			if(!buffer.getParent()){
+				return buffer;
+			}
+			return buffer.setParent(this.contents);
+		},
+		clone: function(){
+			return new this.constructor(this.contents, this.up, this.root);
+		}
+	});
+
+	dd.AttributeNode = dojo.extend(function(key, value){
+		// summary: Works on attributes
+		this.key = key;
+		this.value = value;
+		this.contents = value;
+		if(this._pool[value]){
+			this.nodelist = this._pool[value];
+		}else{
+			if(!(this.nodelist = dd.quickFilter(value))){
+				this.nodelist = (new dd.Template(value, true)).nodelist;
+			}
+			this._pool[value] = this.nodelist;
+		}
+
+		this.contents = "";
+	},
+	{
+		_pool: {},
+		render: function(context, buffer){
+			var key = this.key;
+			var value = this.nodelist.dummyRender(context);
+			if(dd.BOOLS[key]){
+				value = !(value == "false" || value == "undefined" || !value);
+			}
+			if(value !== this.contents){
+				this.contents = value;
+				return buffer.setAttribute(key, value);
+			}
+			return buffer;
+		},
+		unrender: function(context, buffer){
+			this.contents = "";
+			return buffer.remove(this.key);
+		},
+		clone: function(buffer){
+			return new this.constructor(this.key, this.value);
+		}
+	});
+
+	dd._DomTextNode = dojo.extend(function(str){
+		// summary: Adds a straight text node without any processing
+		this.contents = document.createTextNode(str);
+		this.upcoming = str;
+	},
+	{
+		set: function(data){
+			this.upcoming = data;
+			return this;
+		},
+		render: function(context, buffer){
+			if(this.contents.data != this.upcoming){
+				var old = this.contents.data;
+				this.contents.data = this.upcoming;
+				buffer.onChangeData && buffer.onChangeData(this.contents, old, this.upcoming);
+			}
+			return buffer.concat(this.contents);
+		},
+		unrender: function(context, buffer){
+			return buffer.remove(this.contents);
+		},
+		isEmpty: function(){
+			return !dojo.trim(this.contents.data);
+		},
+		clone: function(){
+			return new this.constructor(this.contents.data);
+		}
+	});
+
+	dd._DomParser = dojo.extend(function(tokens){
+		// summary: Turn a simple array into a set of objects
+		// description:
+		//	This is also used by all tags to move through
+		//	the list of nodes.
+		this.contents = tokens;
+	},
+	{
+		i: 0,
+		parse: function(/*Array?*/ stop_at){
+			var terminators = {};
+			var tokens = this.contents;
+			if(!stop_at){
+				stop_at = [];
+			}
+			for(var i = 0; i < stop_at.length; i++){
+				terminators[stop_at[i]] = true;
+			}
+			var nodelist = new dd._DomNodeList();
+			while(this.i < tokens.length){
+				var token = tokens[this.i++];
+				var type = token[0];
+				var value = token[1];
+				if(type == dd.TOKEN_CUSTOM){
+					nodelist.push(value);
+				}else if(type == dd.TOKEN_CHANGE){
+					var changeNode = new dd.ChangeNode(value, token[2], token[3]);
+					value[changeNode.attr] = changeNode;
+					nodelist.push(changeNode);
+				}else if(type == dd.TOKEN_ATTR){
+					var fn = ddt.getTag("attr:" + token[2], true);
+					if(fn && token[3]){
+						if (token[3].indexOf("{%") != -1 || token[3].indexOf("{{") != -1) {
+							value.setAttribute(token[2], "");
+						}
+						nodelist.push(fn(null, new dd.Token(type, token[2] + " " + token[3])));
+					}else if(dojo.isString(token[3])){
+						if(token[2] == "style" || token[3].indexOf("{%") != -1 || token[3].indexOf("{{") != -1){
+							nodelist.push(new dd.AttributeNode(token[2], token[3]));
+						}else if(dojo.trim(token[3])){
+							try{
+								dojo.attr(value, token[2], token[3]);
+							}catch(e){}
+						}
+					}
+				}else if(type == dd.TOKEN_NODE){
+					var fn = ddt.getTag("node:" + value.tagName.toLowerCase(), true);
+					if(fn){
+						// TODO: We need to move this to tokenization so that it's before the
+						// 				node and the parser can be passed here instead of null
+						nodelist.push(fn(null, new dd.Token(type, value), value.tagName.toLowerCase()));
+					}
+					nodelist.push(new dd._DomNode(value));
+				}else if(type == dd.TOKEN_VAR){
+					nodelist.push(new dd._DomVarNode(value));
+				}else if(type == dd.TOKEN_TEXT){
+					nodelist.push(new dd._DomTextNode(value.data || value));
+				}else if(type == dd.TOKEN_BLOCK){
+					if(terminators[value]){
+						--this.i;
+						return nodelist;
+					}
+					var cmd = value.split(/\s+/g);
+					if(cmd.length){
+						cmd = cmd[0];
+						var fn = ddt.getTag(cmd);
+						if(typeof fn != "function"){
+							throw new Error("Function not found for " + cmd);
+						}
+						var tpl = fn(this, new dd.Token(type, value));
+						if(tpl){
+							nodelist.push(tpl);
+						}
+					}
+				}
+			}
+
+			if(stop_at.length){
+				throw new Error("Could not find closing tag(s): " + stop_at.toString());
+			}
+
+			return nodelist;
+		},
+		next_token: function(){
+			// summary: Returns the next token in the list.
+			var token = this.contents[this.i++];
+			return new dd.Token(token[0], token[1]);
+		},
+		delete_first_token: function(){
+			this.i++;
+		},
+		skip_past: function(endtag){
+			return dd._Parser.prototype.skip_past.call(this, endtag);
+		},
+		create_variable_node: function(expr){
+			return new dd._DomVarNode(expr);
+		},
+		create_text_node: function(expr){
+			return new dd._DomTextNode(expr || "");
+		},
+		getTemplate: function(/*String*/ loc){
+			return new dd.DomTemplate(ddh.getTemplate(loc));
+		}
+	});
+
+})();
+
+}