if(!dojo._hasResource["dojox.dtl._base"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojox.dtl._base"] = true;

dojo.provide("dojox.dtl._base");



dojo.require("dojox.string.Builder");

dojo.require("dojox.string.tokenize");



dojox.dtl.Context = function(dict){

	dojo.mixin(this, dict || {});

	this._dicts = [];

	this._this = {};

}

dojo.extend(dojox.dtl.Context, {

	_dicts: [],

	_this: {},

	extend: function(/*dojox.dtl.Context|Object*/ obj){

		// summary: Returns a clone of this context object, with the items from the

		//		passed objecct mixed in.

		var context = new dojox.dtl.Context();

		var keys = this.getKeys();

		for(var i = 0, key; key = keys[i]; i++){

			if(typeof obj[key] != "undefined"){

				context[key] = obj[key];

			}else{

				context[key] = this[key];

			}

		}



		if(obj instanceof dojox.dtl.Context){

			keys = obj.getKeys();

		}else if(typeof obj == "object"){

			keys = [];

			for(var key in obj){

				keys.push(key);

			}

		}



		for(var i = 0, key; key = keys[i]; i++){

			context[key] = obj[key];

		}



		return context;

	},

	filter: function(/*dojox.dtl.Context|Object|String...*/ filter){

		// summary: Returns a clone of this context, only containing the items

		//		defined in the filter.

		var context = new dojox.dtl.Context();

		var keys = [];

		if(filter instanceof dojox.dtl.Context){

			keys = filter.getKeys();

		}else if(typeof filter == "object"){

			for(var key in filter){

				keys.push(key);

			}

		}else{

			for(var i = 0, arg; arg = arguments[i]; i++){

				if(typeof arg == "string"){

					keys.push(arg);

				}

			}

		}



		for(var i = 0, key; key = keys[i]; i++){

			context[key] = this[key];

		}



		return context;

	},

	setThis: function(/*Object*/ _this){

		this._this = _this;

	},

	getThis: function(){

		return this._this;

	},

	push: function(){

		var dict = {};

		var keys = this.getKeys();

		for(var i = 0, key; key = keys[i]; i++){

			dict[key] = this[key];

			delete this[key];

		}

		this._dicts.unshift(dict);

	},

	pop: function(){

		if(!this._dicts.length){

			throw new Error("pop() has been called more times than push() on the Context");

		}

		var dict = this._dicts.shift();

		dojo.mixin(this, dict);

	},

	hasKey: function(key){

		if(typeof this[key] != "undefined"){

			return true;

		}



		for(var i = 0, dict; dict = this._dicts[i]; i++){

			if(typeof dict[key] != "undefined"){

				return true;

			}

		}



		return false;

	},

	getKeys: function(){

		var keys = [];

		for(var key in this){

			if(isNaN(key)){

				var found = false;

				for(var protoKey in dojox.dtl.Context.prototype){

					if(key == protoKey){

						found = true;

						break;

					}

				}

				if(!found){

					keys.push(key);

				}

			}

		}

		return keys;

	},

	get: function(key, otherwise){

		if(typeof this[key] != "undefined"){

			return this[key];

		}



		for(var i = 0, dict; dict = this._dicts[i]; i++){

			if(typeof dict[key] != "undefined"){

				return dict[key];

			}

		}



		return otherwise;

	},

	update: function(dict){

		this.push();

		if(dict){

			dojo.mixin(this, dict);

		}

	},

	toString: function(){ return "dojox.dtl.Context"; }

});



dojox.dtl.text = {

	types: {tag: -1, varr: -2,	text: 3},

	pySplit: function(str){

		// summary: Split a string according to Python's split function

		str = str.replace(/^\s+|\s+$/, "");

		if(!str.length){

			return [];

		}

		return str.split(/\s+/g);

	},

	urlquote: function(/*String*/ url, /*String?*/ safe){

		if(!safe){

			safe = "/";

		}

		return dojox.string.tokenize(url, /([^\w-_.])/g, function(token){

			if(safe.indexOf(token) == -1){

				if(token == " "){

					return "+";

				}else{

					return "%" + token.charCodeAt(0).toString(16).toUpperCase();

				}

			}

			return token;

		}).join("");

	},

	_get: function(module, name, errorless){

		// summary: Used to find both tags and filters

		var params = dojox.dtl.register.get(module, name, errorless);

		if(!params) return;



		var require = params.getRequire();

		var obj = params.getObj();

		var fn = params.getFn();



		if(fn.indexOf(":") != -1){

			var parts = fn.split(":");

			fn = parts.pop();

		}



		dojo.requireIf(true, require);



		var parent = window;

		var parts = obj.split(".");

		for(var i = 0, part; part = parts[i]; i++){

			if(!parent[part]) return;

			parent = parent[part];

		}

		return parent[fn || name] || parent[name + "_"];

	},

	getTag: function(name, errorless){

		return dojox.dtl.text._get("tag", name, errorless);

	},

	getFilter: function(name, errorless){

		return dojox.dtl.text._get("filter", name, errorless);

	},

	getTemplate: function(file){

		return new dojox.dtl.Template(dojox.dtl.getTemplateString(file));

	},

	getTemplateString: function(file){

		return dojo._getText(file.toString()) || "";

	},

	_re: /(?:\{\{\s*(.+?)\s*\}\}|\{%\s*(.+?)\s*%\})/g,

	tokenize: function(str){

		return dojox.string.tokenize(str, dojox.dtl.text._re, dojox.dtl.text._parseDelims);

	},

	_parseDelims: function(varr, tag){

		var types = dojox.dtl.text.types;

		if(varr){

			return [types.varr, varr];

		}else{

			return [types.tag, tag];

		}

	}

}



dojox.dtl.Template = function(str){

	var st = dojox.dtl;

	var tokens = st.text.tokenize(str);

	var parser = new st.Parser(tokens);

	this.nodelist = parser.parse();

}

dojo.extend(dojox.dtl.Template, {

	render: function(context, /*concatenatable?*/ buffer){

		context = context || new dojox.dtl.Context({});

		if(!buffer){

			dojo.require("dojox.string.Builder");

			buffer = new dojox.string.Builder();

		}

		return this.nodelist.render(context, buffer) + "";

	},

	toString: function(){ return "dojox.dtl.Template"; }

});



dojox.dtl.Filter = function(token){

	// summary: Uses a string to find (and manipulate) a variable

	if(!token) throw new Error("Filter must be called with variable name");

	this.contents = token;

	var key = null;

	var re = this._re;

	var matches, filter, arg, fn;

	var filters = [];

	while(matches = re.exec(token)){

		if(key === null){

			if(this._exists(matches, 3)){

				// variable

				key = matches[3];

			}else if(this._exists(matches, 1)){

				// _("text")

				key = '"' + matches[1] + '"';

			}else if(this._exists(matches, 2)){

				// "text"

				key = '"' + matches[2] + '"';

			}else if(this._exists(matches, 9)){

				// 'text'

				key = '"' + matches[9] + '"';

			}

		}else{

			if(this._exists(matches, 7)){

				// :variable

				arg = [true, matches[7]];

			}else if(this._exists(matches, 5)){

				// :_("text")

				arg = [false, dojox.dtl.replace(matches[5], '\\"', '"')];

			}else if(this._exists(matches, 6)){

				// :"text"

				arg = [false, dojox.dtl.replace(matches[6], '\\"', '"')];

			}else if(this._exists(matches, 8)){

				// :"text"

				arg = [false, dojox.dtl.replace(matches[8], "\\'", "'")];

			}

			// Get a named filter

			fn = dojox.dtl.text.getFilter(matches[4]);

			if(typeof fn != "function") throw new Error(matches[4] + " is not registered as a filter");

			filters.push([fn, arg]);

		}

	}



	this.key = key;

	this.filters = filters;

} 

dojo.extend(dojox.dtl.Filter, {

	_re: /(?:^_\("([^\\"]*(?:\\.[^\\"])*)"\)|^"([^\\"]*(?:\\.[^\\"]*)*)"|^([a-zA-Z0-9_.]+)|\|(\w+)(?::(?:_\("([^\\"]*(?:\\.[^\\"])*)"\)|"([^\\"]*(?:\\.[^\\"]*)*)"|([a-zA-Z0-9_.]+)|'([^\\']*(?:\\.[^\\']*)*)'))?|^'([^\\']*(?:\\.[^\\']*)*)')/g,

	_exists: function(arr, index){

		if(typeof arr[index] != "undefined" && arr[index] !== ""){

			return true;

		}

		return false;

	},

	resolve: function(context){

		var str = this.resolvePath(this.key, context);

		for(var i = 0, filter; filter = this.filters[i]; i++){

			// Each filter has the function in [0], a boolean in [1][0] of whether it's a variable or a string

			// and [1][1] is either the variable name of the string content.

			if(filter[1]){

				if(filter[1][0]){

					str = filter[0](str, this.resolvePath(filter[1][1], context));

				}else{

					str = filter[0](str, filter[1][1]);

				}

			}else{

				str = filter[0](str);

			}

		}

		return str;

	},

	resolvePath: function(path, context){

		var current, parts;

		var first = path.charAt(0);

		var last = path.charAt(path.length - 1);

		if(!isNaN(parseInt(first))){

			current = (path.indexOf(".") == -1) ? parseInt(path) : parseFloat(path);

		}else if(first == '"' && first == last){

			current = path.substring(1, path.length - 1);

		}else{;

			if(path == "true") return true;

			if(path == "false") return false;

			if(path == "null" || path == "None") return null;

			parts = path.split(".");

			current = context.get(parts.shift());

			while(parts.length){

				if(current && typeof current[parts[0]] != "undefined"){

					current = current[parts[0]];

					if(typeof current == "function"){

						if(current.alters_data){

							current = "";

						}else{

							current = current();

						}

					}

				}else{

					return "";

				}

				parts.shift();

			}

		}

		return current;

	},

	toString: function(){ return "dojox.dtl.Filter"; }

});



dojox.dtl.Node = function(/*Object*/ obj){

	// summary: Basic catch-all node

	this.contents = obj;

}

dojo.extend(dojox.dtl.Node, {

	render: function(context, buffer){

		// summary: Adds content onto the buffer

		return buffer.concat(this.contents);

	},

	toString: function(){ return "dojox.dtl.Node"; }

});



dojox.dtl.NodeList = function(/*Node[]*/ nodes){

	// summary: Allows us to render a group of nodes

	this.contents = nodes || [];

}

dojo.extend(dojox.dtl.NodeList, {

	push: function(node){

		// summary: Add a new node to the list

		this.contents.push(node);

	},

	render: function(context, buffer){

		// summary: Adds all content onto the buffer

		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");

		}

		return buffer;

	},

	unrender: function(context, buffer){ return buffer; },

	clone: function(){ return this; },

	toString: function(){ return "dojox.dtl.NodeList"; }

});



dojox.dtl.TextNode = dojox.dtl.Node;



dojox.dtl.VarNode = function(str){

	// summary: A node to be processed as a variable

	this.contents = new dojox.dtl.Filter(str);

}

dojo.extend(dojox.dtl.VarNode, {

	render: function(context, buffer){

		var str = this.contents.resolve(context);

		return buffer.concat(str);

	},

	toString: function(){ return "dojox.dtl.VarNode"; }

});



dojox.dtl.Parser = function(tokens){

	// summary: Parser used during initialization and for tag groups.

	this.contents = tokens;

}

dojo.extend(dojox.dtl.Parser, {

	parse: function(/*Array?*/ stop_at){

		// summary: Turns tokens into nodes

		// description: Steps into tags are they're found. Blocks use the parse object

		//		to find their closing tag (the stop_at array). stop_at is inclusive, it

		//		returns the node that matched.

		var st = dojox.dtl;

		var types = st.text.types;

		var terminators = {};

		var tokens = this.contents;

		stop_at = stop_at || [];

		for(var i = 0; i < stop_at.length; i++){

			terminators[stop_at[i]] = true;

		}



		var nodelist = new st.NodeList();

		while(tokens.length){

			token = tokens.shift();

			if(typeof token == "string"){

				nodelist.push(new st.TextNode(token));

			}else{

				var type = token[0];

				var text = token[1];

				if(type == types.varr){

					nodelist.push(new st.VarNode(text));

				}else if(type == types.tag){

					if(terminators[text]){

						tokens.unshift(token);

						return nodelist;

					}

					var cmd = text.split(/\s+/g);

					if(cmd.length){

						cmd = cmd[0];

						var fn = dojox.dtl.text.getTag(cmd);

						if(fn){

							nodelist.push(fn(this, text));

						}

					}

				}

			}

		}



		if(stop_at.length){

			throw new Error("Could not find closing tag(s): " + stop_at.toString());

		}



		return nodelist;

	},

	next: function(){

		// summary: Returns the next token in the list.

		var token = this.contents.shift();

		return {type: token[0], text: token[1]};

	},

	skipPast: function(endtag){

		var types = dojox.dtl.text.types;

		while(this.contents.length){

			var token = this.contents.shift();

			if(token[0] == types.tag && token[1] == endtag){

				return;

			}

		}

		throw new Error("Unclosed tag found when looking for " + endtag);

	},

	getVarNode: function(){

		return dojox.dtl.VarNode;

	},

	getTextNode: function(){

		return dojox.dtl.TextNode;

	},

	getTemplate: function(file){

		return new dojox.dtl.Template(file);

	},

	toString: function(){ return "dojox.dtl.Parser"; }

});



dojox.dtl.register = function(module, cols, args, /*Function*/ normalize){

	// summary: Used to create dojox.dtl.register[module] function, and as a namespace

	// expand: Used if the call structure is reformatted for a more compact view.

	//		Should return an array of normalized arguments.

	// description: The function produced will accept a "name"

	//		as the first parameter and all other parameters will

	//		be associated with the parameter names listed in cols.

	var ddr = dojox.dtl.register;

	var registry = ddr._mod[module] = {

		params: [],

		Getter: function(params){

			ddr._params = params || {};

		}

	};



	cols.unshift("name");

	for(var i = 0, col; col = cols[i]; i++){

		registry.Getter.prototype["get" + col.substring(0, 1).toUpperCase() + col.substring(1, col.length)] = ddr._ret(i);

	}



	ddr[module] = function(/*String*/ name, /*mixed...*/ parameters){

		if(normalize){

			var normalized = normalize(arguments);

		}else{

			var normalized = [arguments];

		}



		for(var i = 0, args; args = normalized[i]; i++){

			var params = [];

			for(var j = 0; j < cols.length; j++){

				params.push(args[j] || null);

			}

			if(typeof args[0] == "string"){

				// Strings before regexes for speed

				registry.params.unshift(params);

			}else{

				// break

				// module RegExp

				registry.params.push(params);

			}

		}

	}



	ddr[module].apply(null, args);

}

dojo.mixin(dojox.dtl.register, {

	_mod: {},

	_ret: function(i){

		// summary: Just lets use i and _params within a closure

		return function(){

			return dojox.dtl.register._params[i] || "";

		}

	},

	get: function(/*String*/ module, /*String*/ name, /*Boolean*/ errorless){

		// summary: Returns a "Getter", based on the registry

		// description: The getter functions correspond with the registered cols

		//		used in dojo.register

		var registry = this._mod[module] || {};

		if(registry.params){

			for(var i = 0, param; param = registry.params[i]; i++){

				var search = param[0];

				if(typeof search == "string"){

					if(search == name){

						return new registry.Getter(param);

					}

				}else if(name.match(search)){

					var matches = search.exec(name);

					var mixin = [];

					dojo.mixin(mixin, param);

					mixin[0] = matches[1];

					return new registry.Getter(param);

				}

			}

		}

		if(!errorless) throw new Error("'" + module + "' of name '" + name + "' does not exist");

	},

	_normalize: function(args){

		// summary:

		//		Translates to the signature (/*String*/ name, /*String*/ require, /*String*/ obj, /*String*/ fn)

		var items = args[2];

		var output = [];

		for(var i = 0, item; item = items[i]; i++){

			if(typeof item == "string"){

				output.push([item, args[0], args[1], item]);

			}else{

				output.push([item[0], args[0], args[1], item[1]]);

			}

		}

		return output;

	},

 	tag: function(/*String*/ require, /*String*/ obj, /*String[]|[RegExp, String][]*/ fns){

		// summary:

		//		Specify the location of a given tag function.

		// require:

		//		The file this function is in

		// obj:

		//		The base object to use for lookups

		// fn:

		//		List of functions within obj to use

		// description:

		//		When we are looking up a tag as specified in a template, we either use a

		//		string in the fns array, or the RegExp item of the [RegExp, String] pair.

		//		When that string is found, it requires the file specified in the require

		//		parameter, uses the base object as a starting point and checks for obj.fn

		//		or obj.fn_ in case fn is a reserved word.

		this("tag", ["require", "obj", "fn"], arguments, this._normalize);

	},

	filter: function(/*String*/ require, /*String*/ obj, /*String[]|[RegExp, String][]*/ fns){

		// summary:

		//		Specify the location of a given filter function.

		// require:

		//		The file this function is in

		// obj:

		//		The base object to use for lookups

		// fn:

		//		List of functions within obj to use

		// description:

		//		When we are looking up a tag as specified in a template, we either use a

		//		string in the fns array, or the RegExp item of the [RegExp, String] pair.

		//		When that string is found, it requires the file specified in the require

		//		parameter, uses the base object as a starting point and checks for obj.fn

		//		or obj.fn_ in case fn is a reserved word.

		this("filter", ["require", "obj", "fn"], arguments, this._normalize);

	}

});



(function(){

	var register = dojox.dtl.register;

	var dtt = "dojox.dtl.tag";

	register.tag(dtt + ".logic", dtt + ".logic", ["if", "for"]);

	register.tag(dtt + ".loader", dtt + ".loader", ["extends", "block"]);

	register.tag(dtt + ".misc", dtt + ".misc", ["comment", "debug", "filter"]);

	register.tag(dtt + ".loop", dtt + ".loop", ["cycle"]);



	var dtf = "dojox.dtl.filter";

	register.filter(dtf + ".dates", dtf + ".dates", ["date", "time", "timesince", "timeuntil"]);

	register.filter(dtf + ".htmlstrings", dtf + ".htmlstrings", ["escape", "linebreaks", "linebreaksbr", "removetags", "striptags"]);

	register.filter(dtf + ".integers", dtf + ".integers", ["add", "get_digit"]);

	register.filter(dtf + ".lists", dtf + ".lists", ["dictsort", "dictsortreversed", "first", "join", "length", "length_is", "random", "slice", "unordered_list"]);

	register.filter(dtf + ".logic", dtf + ".logic", ["default", "default_if_none", "divisibleby", "yesno"]);

	register.filter(dtf + ".misc", dtf + ".misc", ["filesizeformat", "pluralize", "phone2numeric", "pprint"]);

	register.filter(dtf + ".strings", dtf + ".strings", ["addslashes", "capfirst", "center", "cut", "fix_ampersands", "floatformat", "iriencode", "linenumbers", "ljust", "lower", "make_list", "rjust", "slugify", "stringformat", "title", "truncatewords", "truncatewords_html", "upper", "urlencode", "urlize", "urlizetrunc", "wordcount", "wordwrap"]);

})();



dojox.dtl.replace = function(str, token, repl){

	repl = repl || "";	

	var pos, len = token.length;

	while(1){

		pos = str.indexOf(token);

		if(pos == -1) break;

		str = str.substring(0, pos) + repl + str.substring(pos + len);

	}

	return str;

}



dojox.dtl.resolveVariable = function(token, context){

	// summary: Quickly resolve a variables

	var filter = new dojox.dtl.Filter(token);

	return filter.resolve(context);

}



}