/*!

	PURE Unobtrusive Rendering Engine for HTML

	Licensed under the MIT licenses.

	More information at: http://www.opensource.org

	Copyright (c) 2012 Michael Cvilic - BeeBole.com

	Thanks to Rog Peppe for the functional JS jump

	revision: 2.72

*/

var $p, pure = $p = function(){

	var sel = arguments[0],

		ctxt = false;

	if(typeof sel === 'string'){

		ctxt = arguments[1] || false;

	}else if(sel && !sel[0] && !sel.length){

		sel = [sel];

	}

	return $p.core(sel, ctxt);

};

$p.core = function(sel, ctxt, plugins){

	//get an instance of the plugins

	var templates = [];

	plugins = plugins || getPlugins();

	//search for the template node(s)

	switch(typeof sel){

		case 'string':

			templates = plugins.find(ctxt || document, sel);

			if(templates.length === 0) {

				error('The template "' + sel + '" was not found');

			}

		break;

		case 'undefined':

			error('The root of the template is undefined, check your selector');

		break;

		default:

			templates = sel;

	}

	for(var i = 0, ii = templates.length; i < ii; i++){

		plugins[i] = templates[i];

	}

	plugins.length = ii;

	// set the signature string that will be replaced at render time

	var Sig = '_s' + Math.floor( Math.random() * 1000000 ) + '_',

		// another signature to prepend to attributes and avoid checks: style, height, on[events]...

		attPfx = '_a' + Math.floor( Math.random() * 1000000 ) + '_',

		// rx to parse selectors, e.g. "+tr.foo[class]"

		selRx = /^(\+)?([^\@\+]+)?\@?([^\+]+)?(\+)?$/,

		// set automatically attributes for some tags

		autoAttr = {

			IMG:'src',

			INPUT:'value'

		},

		// check if the argument is an array - thanks salty-horse (Ori Avtalion)

		isArray = Array.isArray ?

			function(o) {

				return Array.isArray(o);

			} :

			function(o) {

				return Object.prototype.toString.call(o) === "[object Array]";

			};

	/* * * * * * * * * * * * * * * * * * * * * * * * * *

		core functions

	 * * * * * * * * * * * * * * * * * * * * * * * * * */

	// error utility

	function error(e){

		if(typeof console !== 'undefined'){

			console.log(e);

			debugger;

		}

		throw('pure error: ' + e);

	}

	//return a new instance of plugins

	function getPlugins(){

		var plugins = $p.plugins,

			f = function(){};

		f.prototype = plugins;

		// do not overwrite functions if external definition

		f.prototype.compile    = plugins.compile || compile;

		f.prototype.render     = plugins.render || render;

		f.prototype.autoRender = plugins.autoRender || autoRender;

		f.prototype.find       = plugins.find || find;

		// give the compiler and the error handling to the plugin context

		f.prototype._compiler  = compiler;

		f.prototype._error     = error;

		return new f();

	}

	// returns the outer HTML of a node

	function outerHTML(node){

		// if IE, Chrome take the internal method otherwise build one

		return node.outerHTML || (

			function(n){

			var div = document.createElement('div'), h;

			div.appendChild( n.cloneNode(true) );

				h = div.innerHTML;

				div = null;

				return h;

			})(node);

	}

	// returns the string generator function

	function wrapquote(qfn, f){

		return function(ctxt){

			return qfn('' + f.call(ctxt.item || ctxt.context, ctxt));

		};

	}

	// default find using querySelector when available on the browser

	function find(n, sel){

		if(typeof n === 'string'){

			sel = n;

			n = false;

		}

		if(typeof document.querySelectorAll !== 'undefined'){

			return (n||document).querySelectorAll( sel );

		}else{

			return error('You can test PURE standalone with: iPhone, FF3.5+, Safari4+ and IE8+\n\nTo run PURE on your browser, you need a JS library/framework with a CSS selector engine');

		}

	}

	// create a function that concatenates constant string

	// sections (given in parts) and the results of called

	// functions to fill in the gaps between parts (fns).

	// fns[n] fills in the gap between parts[n-1] and parts[n];

	// fns[0] is unused.

	// this is the inner template evaluation loop.

	function concatenator(parts, fns){

		return function(ctxt){

			var strs = [ parts[ 0 ] ],

				n = parts.length,

				fnVal, pVal, attLine, pos;

			for(var i = 1; i < n; i++){

				fnVal = fns[i].call( this, ctxt );

				pVal = parts[i];

				// if the value is empty and attribute, remove it

				if(fnVal === ''){

					attLine = strs[ strs.length - 1 ];

					if( ( pos = attLine.search( /[^\s]+=\"?$/ ) ) > -1){

						strs[ strs.length - 1 ] = attLine.substring( 0, pos );

						pVal = pVal.substr( 1 );

					}

				}

				strs[ strs.length ] = fnVal;

				strs[ strs.length ] = pVal;

			}

			return strs.join('');

		};

	}

	// parse and check the loop directive

	function parseloopspec(p){

		var m = p.match( /^(\w+)\s*<-\s*(\S+)?$/ );

		if(m === null){

			error('bad loop spec: "' + p + '"');

		}

		if(m[1] === 'item'){

			error('"item<-..." is a reserved word for the current running iteration.\n\nPlease choose another name for your loop.');

		}

		if( !m[2] || (m[2] && (/context/i).test(m[2]))){ //undefined or space(IE)

			m[2] = function(ctxt){return ctxt.context;};

		}

		return {name: m[1], sel: m[2]};

	}

	// parse a data selector and return a function that

	// can traverse the data accordingly, given a context.

	function dataselectfn (sel){

		if( typeof(sel) === 'function' ){

			//handle false values in function directive

			return function ( ctxt ){

				var r = sel.call( ctxt.item || ctxt.context || ctxt, ctxt ); 

				return !r && r !== 0 ? '' : r;

			};

		}

		//check for a valid js variable name with hyphen(for properties only), $, _ and :

		var m = sel.match(/^[a-zA-Z\$_\@][\w\$:-]*(\.[\w\$:-]*[^\.])*$/);

		if(m === null){

			var found = false, s = sel, parts = [], pfns = [], i = 0, retStr;

			// check if literal

			if(/\'|\"/.test( s.charAt(0) )){

				if(/\'|\"/.test( s.charAt(s.length-1) )){

					retStr = s.substring(1, s.length-1);

					return function(){ return retStr; };

				}

			}else{

				// check if literal + #{var}

				while((m = s.match(/#\{([^{}]+)\}/)) !== null){

					found = true;

					parts[i++] = s.slice(0, m.index);

					pfns[i] = dataselectfn(m[1]);

					s = s.slice(m.index + m[0].length, s.length);

				}

			}

			if(!found){

				return function(){ return sel; };

			}

			parts[i] = s;

			return concatenator(parts, pfns);

		}

		m = sel.split('.');

		return function(ctxt){

			var data = ctxt.context || ctxt,

				v = ctxt[m[0]],

				i = 0;

			if(v && v.item){

				i += 1;

				if(m[i] === 'pos'){

					//allow pos to be kept by string. Tx to Adam Freidin

					return v.pos;

				}else{

					data = v.item;

				}

			}

			var n = m.length;

			for(; i < n; i++){

				if(!data){break;}

				data = data[m[i]];

			}

			return (!data && data !== 0) ? '':data;

		};

	}

	// wrap in an object the target node/attr and their properties

	function gettarget(dom, sel, isloop){

		var osel, prepend, selector, attr, append, target = [];

		if( typeof sel === 'string' ){

			osel = sel;

			var m = sel.match(selRx);

			if( !m ){

				error( 'bad selector syntax: ' + sel );

			}

			prepend = m[1];

			selector = m[2];

			attr = m[3];

			append = m[4];

			if(selector === '.' || ( !selector && attr ) ){

				target[0] = dom;

			}else{

				target = plugins.find(dom, selector);

			}

			if(!target || target.length === 0){

				return error('The node "' + sel + '" was not found in the template:\n' + outerHTML(dom).replace(/\t/g,'  '));

			}

		}else{

			// autoRender node

			prepend = sel.prepend;

			attr = sel.attr;

			append = sel.append;

			target = [dom];

		}

		if( prepend || append ){

			if( prepend && append ){

				error('append/prepend cannot take place at the same time');

			}else if( isloop ){

				error('no append/prepend/replace modifiers allowed for loop target');

			}else if( append && isloop ){

				error('cannot append with loop (sel: ' + osel + ')');

			}

		}

		var setstr, getstr, quotefn, isStyle, isClass, attName, setfn;

		if(attr){

			isStyle = (/^style$/i).test(attr);

			isClass = (/^class$/i).test(attr);

			attName = isClass ? 'className' : attr;

			setstr = function(node, s) {

				node.setAttribute(attPfx + attr, s);

				if (attName in node && !isStyle) {

					try{node[attName] = '';}catch(e){} //FF4 gives an error sometimes

				}

				if (node.nodeType === 1) {

					node.removeAttribute(attr);

					isClass && node.removeAttribute(attName);

				}

			};

			if (isStyle || isClass) {//IE no quotes special care

				if(isStyle){

					getstr = function(n){ return n.style.cssText; };

				}else{

					getstr = function(n){ return n.className;	};

				}

			}else {

				getstr = function(n){ return n.getAttribute(attr); };

			}

			quotefn = function(s){ return s.replace(/\"/g, '"'); };

			if(prepend){

				setfn = function(node, s){ setstr( node, s + getstr( node )); };

			}else if(append){

				setfn = function(node, s){ setstr( node, getstr( node ) + s); };

			}else{

				setfn = function(node, s){ setstr( node, s ); };

			}

		}else{

			if (isloop) {

				setfn = function(node, s) {

					var pn = node.parentNode;

					if (pn) {

						//replace node with s

						pn.insertBefore(document.createTextNode(s), node.nextSibling);

						pn.removeChild(node);

					}

				};

			} else {

				if (prepend) {

					setfn = function(node, s) { node.insertBefore(document.createTextNode(s), node.firstChild);	};

				} else if (append) {

					setfn = function(node, s) { node.appendChild(document.createTextNode(s));};

				} else {

					setfn = function(node, s) {

						while (node.firstChild) { node.removeChild(node.firstChild); }

						node.appendChild(document.createTextNode(s));

					};

				}

			}

			quotefn = function(s) { return s; };

		}

		return { attr: attr, nodes: target, set: setfn, sel: osel, quotefn: quotefn };

	}

	function setsig(target, n){

		var sig = Sig + n + ':';

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