/*! JsRender v1.0pre - (jsrender.js version: does not require jQuery): http://github.com/BorisMoore/jsrender */
/*
* Optimized version of jQuery Templates, fosr rendering to string, using 'codeless' markup.
*
* Copyright 2011, Boris Moore
* Released under the MIT License.
*/
window.JsViews || window.jQuery && jQuery.views || (function (window, undefined) {

    var $, _$, JsViews, viewsNs, tmplEncode, render, rTag, registerTags, registerHelpers, extend,
	FALSE = false, TRUE = true,
	jQuery = window.jQuery, document = window.document,
	htmlExpr = /^[^<]*(<[\w\W]+>)[^>]*$|\{\{\! /,
	rPath = /^(true|false|null|[\d\.]+)|(\w+|\$(view|data|ctx|(\w+)))([\w\.]*)|((['"])(?:\\\1|.)*\7)$/g,
	rParams = /(\$?[\w\.\[\]]+)(?:(\()|\s*(===|!==|==|!=|<|>|<=|>=)\s*|\s*(\=)\s*)?|(\,\s*)|\\?(\')|\\?(\")|(\))|(\s+)/g,
	rNewLine = /\r?\n/g,
	rUnescapeQuotes = /\\(['"])/g,
	rEscapeQuotes = /\\?(['"])/g,
	rBuildHash = /\x08([^\x08]+)\x08/g,
	autoName = 0,
	escapeMapForHtml = {
	    "&": "&amp;",
	    "<": "&lt;",
	    ">": "&gt;"
	},
	htmlSpecialChar = /[\x00"&'<>]/g,
	slice = Array.prototype.slice;

    if (jQuery) {

        ////////////////////////////////////////////////////////////////////////////////////////////////
        // jQuery is loaded, so make $ the jQuery object
        $ = jQuery;

        $.fn.extend({
            // Use first wrapped element as template markup.
            // Return string obtained by rendering the template against data.
            render: function (data, context, parentView, path) {
                return render(data, this[0], context, parentView, path);
            },

            // Consider the first wrapped element as a template declaration, and get the compiled template or store it as a named template.
            template: function (name, context) {
                return $.template(name, this[0], context);
            }
        });

    } else {

        ////////////////////////////////////////////////////////////////////////////////////////////////
        // jQuery is not loaded. Make $ the JsViews object

        // Map over the $ in case of overwrite
        _$ = window.$;

        window.JsViews = JsViews = window.$ = $ = {
            extend: function (target, source) {
                var name;
                for (name in source) {
                    target[name] = source[name];
                }
                return target;
            },
            isArray: Array.isArray || function (obj) {
                return Object.prototype.toString.call(obj) === "[object Array]";
            },
            noConflict: function () {
                if (window.$ === JsViews) {
                    window.$ = _$;
                }
                return JsViews;
            }
        };
    }

    extend = $.extend;

    //=================
    // View constructor
    //=================

    function View(context, path, parentView, data, template) {
        // Returns a view data structure for a new rendered instance of a template.
        // The content field is a hierarchical array of strings and nested views.

        parentView = parentView || { viewsCount: 0, ctx: viewsNs.helpers };

        var parentContext = parentView && parentView.ctx;

        return {
            jsViews: "v1.0pre",
            path: path || "",
            // inherit context from parentView, merged with new context.
            itemNumber: ++parentView.viewsCount || 1,
            viewsCount: 0,
            tmpl: template,
            data: data || parentView.data || {},
            // Set additional context on this view (which will modify the context inherited from the parent, and be inherited by child views)
            ctx: context && context === parentContext
			? parentContext
			: (parentContext ? extend(extend({}, parentContext), context) : context || {}),
            // If no jQuery, extend does not support chained copies - so limit to two parameters
            parent: parentView
        };
    }
    extend($, {
        views: viewsNs = {
            templates: {},
            tags: {
                "if": function () {
                    var ifTag = this,
					view = ifTag._view;
                    view.onElse = function (presenter, args) {
                        var i = 0,
						l = args.length;
                        while (l && !args[i++]) {
                            // Only render content if args.length === 0 (i.e. this is an else with no condition) or if a condition argument is truey
                            if (i === l) {
                                return "";
                            }
                        }
                        view.onElse = undefined; // If condition satisfied, so won't run 'else'.
                        return render(view.data, presenter.tmpl, view.ctx, view);
                    };
                    return view.onElse(this, arguments);
                },
                "else": function () {
                    var view = this._view;
                    return view.onElse ? view.onElse(this, arguments) : "";
                },
                each: function () {
                    var i,
					self = this,
					result = "",
					args = arguments,
					l = args.length,
					content = self.tmpl,
					view = self._view;
                    for (i = 0; i < l; i++) {
                        result += args[i] ? render(args[i], content, self.ctx || view.ctx, view, self._path, self._ctor) : "";
                    }
                    return l ? result
                    // If no data parameter, use the current $data from view, and render once
					: result + render(view.data, content, view.ctx, view, self._path, self.tag);
                },
                "=": function (value) {
                    return value;
                },
                "*": function (value) {
                    return value;
                }
            },
            helpers: {
                not: function (value) {
                    return !value;
                }
            },
            allowCode: FALSE,
            debugMode: TRUE,
            err: function (e) {
                return viewsNs.debugMode ? ("<br/><b>Error:</b> <em> " + (e.message || e) + ". </em>") : '""';
            },

            //===============
            // setDelimiters
            //===============

            setDelimiters: function (openTag, closeTag) {
                // Set or modify the delimiter characters for tags: "{{" and "}}"
                var firstCloseChar = closeTag.charAt(0),
				secondCloseChar = closeTag.charAt(1);
                openTag = "\\" + openTag.charAt(0) + "\\" + openTag.charAt(1);
                closeTag = "\\" + firstCloseChar + "\\" + secondCloseChar;

                // Build regex with new delimiters
                //           {{
                rTag = openTag
                //       #      tag    (followed by space,! or })             or equals or  code
				+ "(?:(?:(\\#)?(\\w+(?=[!\\s\\" + firstCloseChar + "]))" + "|(?:(\\=)|(\\*)))"
                //     params
				+ "\\s*((?:[^\\" + firstCloseChar + "]|\\" + firstCloseChar + "(?!\\" + secondCloseChar + "))*?)"
                //   encoding
				+ "(!(\\w*))?"
                //        closeBlock
				+ "|(?:\\/([\\w\\$\\.\\[\\]]+)))"
                //  }}
			+ closeTag;

                // Default rTag:     #    tag              equals code        params         encoding    closeBlock
                //      /\{\{(?:(?:(\#)?(\w+(?=[\s\}!]))|(?:(\=)|(\*)))((?:[^\}]|\}(?!\}))*?)(!(\w*))?|(?:\/([\w\$\.\[\]]+)))\}\}/g;

                rTag = new RegExp(rTag, "g");
            },


            //===============
            // registerTags
            //===============

            // Register declarative tag.
            registerTags: registerTags = function (name, tagFn) {
                var key;
                if (typeof name === "object") {
                    for (key in name) {
                        registerTags(key, name[key]);
                    }
                } else {
                    // Simple single property case.
                    viewsNs.tags[name] = tagFn;
                }
                return this;
            },

            //===============
            // registerHelpers
            //===============

            // Register helper function for use in markup.
            registerHelpers: registerHelpers = function (name, helper) {
                if (typeof name === "object") {
                    // Object representation where property name is path and property value is value.
                    // TODO: We've discussed an "objectchange" event to capture all N property updates here. See TODO note above about propertyChanges.
                    var key;
                    for (key in name) {
                        registerHelpers(key, name[key]);
                    }
                } else {
                    // Simple single property case.
                    viewsNs.helpers[name] = helper;
                }
                return this;
            },

            //===============
            // tmpl.encode
            //===============

            encode: function (encoding, text) {
                return text
				? (tmplEncode[encoding || "html"] || tmplEncode.html)(text) // HTML encoding is the default
				: "";
            },

            encoders: tmplEncode = {
                "none": function (text) {
                    return text;
                },
                "html": function (text) {
                    // HTML encoding helper: Replace < > & and ' and " by corresponding entities.
                    // Implementation, from Mike Samuel <msamuel@google.com>
                    return String(text).replace(htmlSpecialChar, replacerForHtml);
                }
                //TODO add URL encoding, and perhaps other encoding helpers...
            },

            //===============
            // renderTag
            //===============

            renderTag: function (tag, view, encode, content, tagProperties) {
                // This is a tag call, with arguments: "tag", view, encode, content, presenter [, params...]
                var ret, ctx, name,
				args = arguments,
				presenters = viewsNs.presenters;
                hash = tagProperties._hash,
				tagFn = viewsNs.tags[tag];

                if (!tagFn) {
                    return "";
                }

                content = content && view.tmpl.nested[content - 1];
                tagProperties.tmpl = tagProperties.tmpl || content || undefined;
                // Set the tmpl property to the content of the block tag, unless set as an override property on the tag

                if (presenters && presenters[tag]) {
                    ctx = extend(extend({}, tagProperties.ctx), tagProperties);
                    delete ctx.ctx;
                    delete ctx._path;
                    delete ctx.tmpl;
                    tagProperties.ctx = ctx;
                    tagProperties._ctor = tag + (hash ? "=" + hash.slice(0, -1) : "");

                    tagProperties = extend(extend({}, tagFn), tagProperties);
                    tagFn = viewsNs.tags.each; // Use each to render the layout template against the data
                }

                tagProperties._encode = encode;
                tagProperties._view = view;
                ret = tagFn.apply(tagProperties, args.length > 5 ? slice.call(args, 5) : [view.data]);
                return ret || (ret === undefined ? "" : ret.toString()); // (If ret is the value 0 or false or null, will render to string) 
            }
        },

        //===============
        // render
        //===============

        render: render = function (data, tmpl, context, parentView, path, tagName) {
            // Render template against data as a tree of subviews (nested template), or as a string (top-level template).
            // tagName parameter for internal use only. Used for rendering templates registered as tags (which may have associated presenter objects)
            var i, l, dataItem, arrayView, content, result = "";

            if (arguments.length === 2 && data.jsViews) {
                parentView = data;
                context = parentView.ctx;
                data = parentView.data;
            }
            tmpl = $.template(tmpl);
            if (!tmpl) {
                return ""; // Could throw...
            }

            if ($.isArray(data)) {
                // Create a view item for the array, whose child views correspond to each data item.
                arrayView = new View(context, path, parentView, data);
                l = data.length;
                for (i = 0, l = data.length; i < l; i++) {
                    dataItem = data[i];
                    content = dataItem ? tmpl(dataItem, new View(context, path, arrayView, dataItem, tmpl, this)) : "";
                    result += viewsNs.activeViews ? "<!--item-->" + content + "<!--/item-->" : content;
                }
            } else {
                result += tmpl(data, new View(context, path, parentView, data, tmpl));
            }

            return viewsNs.activeViews
            // If in activeView mode, include annotations
			? "<!--tmpl(" + (path || "") + ") " + (tagName ? "tag=" + tagName : tmpl._name) + "-->" + result + "<!--/tmpl-->"
            // else return just the string result
			: result;
        },

        //===============
        // template
        //===============

        template: function (name, tmpl) {
            // Set:
            // Use $.template( name, tmpl ) to cache a named template,
            // where tmpl is a template string, a script element or a jQuery instance wrapping a script element, etc.
            // Use $( "selector" ).template( name ) to provide access by name to a script block template declaration.

            // Get:
            // Use $.template( name ) to access a cached template.
            // Also $( selectorToScriptBlock ).template(), or $.template( null, templateString )
            // will return the compiled template, without adding a name reference.
            // If templateString is not a selector, $.template( templateString ) is equivalent
            // to $.template( null, templateString ). To ensure a string is treated as a template,
            // include an HTML element, an HTML comment, or a template comment tag.

            if (tmpl) {
                // Compile template and associate with name
                if ("" + tmpl === tmpl) { // type string
                    // This is an HTML string being passed directly in.
                    tmpl = compile(tmpl);
                } else if (jQuery && tmpl instanceof $) {
                    tmpl = tmpl[0];
                }
                if (tmpl) {
                    if (jQuery && tmpl.nodeType) {
                        // If this is a template block, use cached copy, or generate tmpl function and cache.
                        tmpl = $.data(tmpl, "tmpl") || $.data(tmpl, "tmpl", compile(tmpl.innerHTML));
                    }
                    viewsNs.templates[tmpl._name = tmpl._name || name || "_" + autoName++] = tmpl;
                }
                return tmpl;
            }
            // Return named compiled template
            return name
			? "" + name !== name // not type string
				? (name._name
					? name // already compiled
					: $.template(null, name))
				: viewsNs.templates[name] ||
            // If not in map, treat as a selector. (If integrated with core, use quickExpr.exec)
					$.template(null, htmlExpr.test(name) ? name : try$(name))
			: null;
        }
    });

    viewsNs.setDelimiters("{{", "}}");

    //=================
    // compile template
    //=================

    // Generate a reusable function that will serve to render a template against data
    // (Compile AST then build template function)

    function parsePath(all, comp, object, viewDataCtx, viewProperty, path, string, quot) {
        return object
		? ((viewDataCtx
			? viewProperty
				? ("$view." + viewProperty)
				: object
			: ("$data." + object)
		) + (path || ""))
		: string || (comp || "");
    }

    function compile(markup) {
        var newNode,
		loc = 0,
		stack = [],
		topNode = [],
		content = topNode,
		current = [, , topNode];

        function pushPreceedingContent(shift) {
            shift -= loc;
            if (shift) {
                content.push(markup.substr(loc, shift).replace(rNewLine, "\\n"));
            }
        }

        function parseTag(all, isBlock, tagName, equals, code, params, useEncode, encode, closeBlock, index) {
            // rTag    :    #    tagName          equals code        params         encode      closeBlock
            // /\{\{(?:(?:(\#)?(\w+(?=[\s\}!]))|(?:(\=)|(\*)))((?:[^\}]|\}(?!\}))*?)(!(\w*))?|(?:\/([\w\$\.\[\]]+)))\}\}/g;

            // Build abstract syntax tree: [ tagName, params, content, encode ]
            var named,
			hash = "",
			parenDepth = 0,
			quoted = FALSE, // boolean for string content in double qoutes
			aposed = FALSE; // or in single qoutes

            function parseParams(all, path, paren, comp, eq, comma, apos, quot, rightParen, space, index) {
                //      path          paren eq      comma   apos   quot  rtPrn  space
                // /(\$?[\w\.\[\]]+)(?:(\()|(===)|(\=))?|(\,\s*)|\\?(\')|\\?(\")|(\))|(\s+)/g

                return aposed
                // within single-quoted string
				? (aposed = !apos, (aposed ? all : '"'))
				: quoted
                // within double-quoted string
					? (quoted = !quot, (quoted ? all : '"'))
					: comp
                // comparison
						? (path.replace(rPath, parsePath) + comp)
						: eq
                // named param
							? parenDepth ? "" : (named = TRUE, '\b' + path + ':')
							: paren
                // function
								? (parenDepth++, path.replace(rPath, parsePath) + '(')
								: rightParen
                // function
									? (parenDepth--, ")")
									: path
                // path
										? path.replace(rPath, parsePath)
										: comma
											? ","
											: space
												? (parenDepth
													? ""
													: named
														? (named = FALSE, "\b")
														: ","
												)
												: (aposed = apos, quoted = quot, '"');
            }

            tagName = tagName || equals;
            pushPreceedingContent(index);
            if (code) {
                if (viewsNs.allowCode) {
                    content.push(["*", params.replace(rUnescapeQuotes, "$1")]);
                }
            } else if (tagName) {
                if (tagName === "else") {
                    current = stack.pop();
                    content = current[2];
                    isBlock = TRUE;
                }
                params = (params
				? (params + " ")
					.replace(rParams, parseParams)
					.replace(rBuildHash, function (all, keyValue, index) {
					    hash += keyValue + ",";
					    return "";
					})
				: "");
                params = params.slice(0, -1);
                newNode = [
				tagName,
				useEncode ? encode || "none" : "",
				isBlock && [],
				"{" + hash + "_hash:'" + hash + "',_path:'" + params + "'}",
				params
			];

                if (isBlock) {
                    stack.push(current);
                    current = newNode;
                }
                content.push(newNode);
            } else if (closeBlock) {
                current = stack.pop();
            }
            loc = index + all.length; // location marker - parsed up to here
            if (!current) {
                throw "Expected block tag";
            }
            content = current[2];
        }
        markup = markup.replace(rEscapeQuotes, "\\$1");
        markup.replace(rTag, parseTag);
        pushPreceedingContent(markup.length);
        return buildTmplFunction(topNode);
    }

    // Build javascript compiled template function, from AST
    function buildTmplFunction(nodes) {
        var ret, node, i,
		nested = [],
		l = nodes.length,
		code = "try{var views="
			+ (jQuery ? "jQuery" : "JsViews")
			+ '.views,tag=views.renderTag,enc=views.encode,html=views.encoders.html,$ctx=$view && $view.ctx,result=""+\n\n';

        for (i = 0; i < l; i++) {
            node = nodes[i];
            if (node[0] === "*") {
                code = code.slice(0, i ? -1 : -3) + ";" + node[1] + (i + 1 < l ? "result+=" : "");
            } else if ("" + node === node) { // type string
                code += '"' + node + '"+';
            } else {
                var tag = node[0],
				encode = node[1],
				content = node[2],
				obj = node[3],
				params = node[4],
				paramsOrEmptyString = params + '||"")+';

                if (content) {
                    nested.push(buildTmplFunction(content));
                }
                code += tag === "="
				? (!encode || encode === "html"
					? "html(" + paramsOrEmptyString
					: encode === "none"
						? ("(" + paramsOrEmptyString)
						: ('enc("' + encode + '",' + paramsOrEmptyString)
				)
				: 'tag("' + tag + '",$view,"' + (encode || "") + '",'
					+ (content ? nested.length : '""') // For block tags, pass in the key (nested.length) to the nested content template
					+ "," + obj + (params ? "," : "") + params + ")+";
            }
        }
        ret = new Function("$data, $view", code.slice(0, -1) + ";return result;\n\n}catch(e){return views.err(e);}");
        ret.nested = nested;
        return ret;
    }

    //========================== Private helper functions, used by code above ==========================

    function replacerForHtml(ch) {
        // Original code from Mike Samuel <msamuel@google.com>
        return escapeMapForHtml[ch]
        // Intentional assignment that caches the result of encoding ch.
		|| (escapeMapForHtml[ch] = "&#" + ch.charCodeAt(0) + ";");
    }

    function try$(selector) {
        // If selector is valid, return jQuery object, otherwise return (invalid) selector string
        try {
            return $(selector);
        } catch (e) { }
        return selector;
    }
})(window);