/**
* jTemplates 0.8.4 (http://jtemplates.tpython.com)
* Copyright (c) 2007-2013 Tomasz Gloc (http://www.tpython.com)
* 
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and/or GPL (GPL-LICENSE.txt) licenses.
*
* Id: $Id: jquery-jtemplates_uncompressed.js 203 2013-02-03 13:28:34Z tom $
*/

/**
* @fileOverview Template engine in JavaScript.
* @name jTemplates
* @author Tomasz Gloc
* @date $Date: 2013-02-03 14:28:34 +0100 (N, 03 lut 2013) $
*/

if (window.jQuery && !window.jQuery.createTemplate) {
    (function (jQuery) {

        /**
        * [abstract]
        * @name BaseNode
        * @class Abstract node. [abstract]
        */

        /**
        * Process node and get the html string. [abstract]
        * @name get
        * @function
        * @param {object} d data
        * @param {object} param parameters
        * @param {Element} element a HTML element
        * @param {Number} deep
        * @return {String}
        * @memberOf BaseNode
        */

        /**
        * [abstract]
        * @name BaseArray
        * @augments BaseNode
        * @class Abstract array/collection. [abstract]
        */

        /**
        * Add node 'e' to array.
        * @name push
        * @function
        * @param {BaseNode} e a node
        * @memberOf BaseArray
        */

        /**
        * See (http://jquery.com/).
        * @name jQuery
        * @class jQuery Library (http://jquery.com/)
        */

        /**
        * See (http://jquery.com/)
        * @name fn
        * @class jQuery Library (http://jquery.com/)
        * @memberOf jQuery
        */

        /**
        * Create new template from string s.
        * @name Template
        * @class A template or multitemplate.
        * @param {string} s A template string (like: "Text: {$T.txt}.").
        * @param {array} [includes] Array of included templates.
        * @param {object} [settings] Settings.
        * @config {boolean} [disallow_functions] Do not allow use function in data (default: true).
        * @config {boolean} [filter_data] Enable filter data using escapeHTML (default: true).
        * @config {boolean} [filter_params] Enable filter parameters using escapeHTML (default: false).
        * @config {boolean} [runnable_functions] Automatically run function (from data) inside {} [default: false].
        * @config {boolean} [clone_data] Clone input data [default: true]
        * @config {boolean} [clone_params] Clone input parameters [default: true]
        * @config {Function} [f_cloneData] Function used to data cloning
        * @config {Function} [f_escapeString] Function used to escape strings
        * @config {Function} [f_parseJSON] Function used to parse JSON
        * @augments BaseNode
        */
        var Template = function (s, includes, settings) {
            this._tree = [];
            this._param = {};
            this._includes = null;
            this._templates = {};
            this._templates_code = {};

            //default parameters
            this.settings = jQuery.extend({
                disallow_functions: false,
                filter_data: true,
                filter_params: false,
                runnable_functions: false,
                clone_data: true,
                clone_params: true
            }, settings);

            //set handlers
            this.f_cloneData = (this.settings.f_cloneData !== undefined) ? (this.settings.f_cloneData) : (TemplateUtils.cloneData);
            this.f_escapeString = (this.settings.f_escapeString !== undefined) ? (this.settings.f_escapeString) : (TemplateUtils.escapeHTML);
            this.f_parseJSON = (this.settings.f_parseJSON !== undefined) ? (this.settings.f_parseJSON) : ((this.settings.disallow_functions) ? (jQuery.parseJSON) : (TemplateUtils.parseJSON));

            if (s == null) {
                return;
            }

            //split multiteplate
            this.splitTemplates(s, includes);

            if (s) {
                //set main template
                this.setTemplate(this._templates_code['MAIN'], includes, this.settings);
            }

            this._templates_code = null;
        };

        /**
        * jTemplates version
        * @type string
        */
        Template.version = '0.8.4';

        /**
        * Debug mode (all errors are on), default: off
        * @type Boolean
        */
        Template.DEBUG_MODE = false;

        /**
        * Foreach loop limit (enable only when DEBUG_MODE = true)
        * @type integer
        */
        Template.FOREACH_LOOP_LIMIT = 10000;

        /**
        * Global guid
        * @type integer
        */
        Template.guid = 0;

        /**
        * Split multitemplate into multiple templates.
        * @param {string} s A template string (like: "Text: {$T.txt}.").
        * @param {array} includes Array of included templates.
        */
        Template.prototype.splitTemplates = function (s, includes) {
            var reg = /\{#template *(\w+) *(.*?) *\}/g, //split multitemplate into subtemplates
			iter, tname, se, lastIndex = null, _template_settings = [], i;

            //while find new subtemplate
            while ((iter = reg.exec(s)) !== null) {
                lastIndex = reg.lastIndex;
                tname = iter[1];
                se = s.indexOf('{#/template ' + tname + '}', lastIndex);
                if (se === -1) {
                    throw new Error('jTemplates: Template "' + tname + '" is not closed.');
                }
                //save a subtemplate and parse options
                this._templates_code[tname] = s.substring(lastIndex, se);
                _template_settings[tname] = TemplateUtils.optionToObject(iter[2]);
            }
            //when no subtemplates, use all as main template
            if (lastIndex === null) {
                this._templates_code['MAIN'] = s;
                return;
            }

            //create a new object for every subtemplates
            for (i in this._templates_code) {
                if (i !== 'MAIN') {
                    this._templates[i] = new Template();
                }
            }
            for (i in this._templates_code) {
                if (i !== 'MAIN') {
                    this._templates[i].setTemplate(this._templates_code[i],
					jQuery.extend({}, includes || {}, this._templates || {}),
					jQuery.extend({}, this.settings, _template_settings[i]));
                    this._templates_code[i] = null;
                }
            }
        };

        /**
        * Parse template. (should be template, not multitemplate).
        * @param {string} s A template string (like: "Text: {$T.txt}.").
        * @param {array} includes Array of included templates.
        * @param {object} [settings] Settings.
        */
        Template.prototype.setTemplate = function (s, includes, settings) {
            if (s == undefined) {
                this._tree.push(new TextNode('', 1, this));
                return;
            }
            s = s.replace(/[\n\r]/g, ''); //remove endlines
            s = s.replace(/\{\*.*?\*\}/g, ''); //remove comments
            this._includes = jQuery.extend({}, this._templates || {}, includes || {});
            this.settings = new Object(settings);
            var node = this._tree,
			op = s.match(/\{#.*?\}/g), //find operators
			ss = 0, se = 0, e, literalMode = 0, i, l;

            //loop operators
            for (i = 0, l = (op) ? (op.length) : (0); i < l; ++i) {
                var this_op = op[i];

                //when literal mode is on, treat operator like a text
                if (literalMode) {
                    se = s.indexOf('{#/literal}', ss); //find end of block
                    if (se === -1) {
                        throw new Error("jTemplates: No end of literal.");
                    }
                    if (se > ss) {
                        node.push(new TextNode(s.substring(ss, se), 1, this));
                    }
                    ss = se + 11; //strlen '{#/literal}'
                    literalMode = 0;
                    while (i < l && op[i] !== '{#/literal}') { //skip all operators until literal end
                        i++;
                    }
                    continue;
                }

                se = s.indexOf(this_op, ss);
                if (se > ss) {
                    node.push(new TextNode(s.substring(ss, se), literalMode, this));
                }
                this_op.match(/\{#([\w\/]+).*?\}/); //find operator name
                var op_ = RegExp.$1;
                switch (op_) {
                    case 'elseif':
                        node.addCond(this_op);
                        break;
                    case 'if':
                        e = new opIF(node, this);
                        e.addCond(this_op);
                        node.push(e);
                        node = e;
                        break;
                    case 'else':
                        node.switchToElse();
                        break;
                    case '/if':
                    case '/for':
                    case '/foreach':
                        node = node.getParent();
                        break;
                    case 'foreach':
                        e = new opFOREACH(this_op, node, this);
                        node.push(e);
                        node = e;
                        break;
                    case 'for':
                        e = opFORFactory(this_op, node, this);
                        node.push(e);
                        node = e;
                        break;
                    case 'continue':
                    case 'break':
                        node.push(new JTException(op_));
                        break;
                    case 'include':
                        node.push(new Include(this_op, this._includes, this));
                        break;
                    case 'param':
                        node.push(new UserParam(this_op, this));
                        break;
                    case 'var':
                        node.push(new UserVariable(this_op, this));
                        break;
                    case 'cycle':
                        node.push(new Cycle(this_op));
                        break;
                    case 'ldelim':
                        node.push(new TextNode('{', 1, this));
                        break;
                    case 'rdelim':
                        node.push(new TextNode('}', 1, this));
                        break;
                    case 'literal':
                        literalMode = 1;
                        break;
                    case '/literal':
                        if (Template.DEBUG_MODE) {
                            throw new Error("jTemplates: Missing begin of literal.");
                        }
                        break;
                    default:
                        if (Template.DEBUG_MODE) {
                            throw new Error('jTemplates: unknown tag: ' + op_ + '.');
                        }
                }

                ss = se + this_op.length;
            }

            if (s.length > ss) {
                node.push(new TextNode(s.substr(ss), literalMode, this));
            }
        };

        /**
        * Process template and get the html string.
        * @param {object} d data
        * @param {object} param parameters
        * @param {Element} element a HTML element
        * @param {Number} deep
        * @return {String}
        */
        Template.prototype.get = function (d, param, element, deep) {
            ++deep;

            if (deep == 1 && element != undefined) {
                jQuery.removeData(element, "jTemplatesRef");
            }

            var $T = d, $P, ret = '';

            //create clone of data
            if (this.settings.clone_data) {
                $T = this.f_cloneData(d, { escapeData: (this.settings.filter_data && deep == 1), noFunc: this.settings.disallow_functions }, this.f_escapeString);
            }

            //create clone of parameters
            if (!this.settings.clone_params) {
                $P = jQuery.extend({}, this._param, param);
            } else {
                $P = jQuery.extend({},
				this.f_cloneData(this._param, { escapeData: (this.settings.filter_params), noFunc: false }, this.f_escapeString),
				this.f_cloneData(param, { escapeData: (this.settings.filter_params && deep == 1), noFunc: false }, this.f_escapeString));
            }

            for (var i = 0, l = this._tree.length; i < l; ++i) {
                ret += this._tree[i].get($T, $P, element, deep);
            }

            this.EvalObj = null;

            --deep;
            return ret;
        };

        /**
        * Create and return EvalClass object
        * @return {EvalClass}
        */
        Template.prototype.getBin = function () {
            if (this.EvalObj == null) {
                this.EvalObj = new EvalClass(this);
            }
            return this.EvalObj;
        };

        /**
        * Set to parameter 'name' value 'value'.
        * @param {string} name
        * @param {object} value
        */
        Template.prototype.setParam = function (name, value) {
            this._param[name] = value;
        };


        /**
        * Template utilities.
        * @namespace Template utilities.
        */
        TemplateUtils = function () {
        };

        /**
        * Replace chars &, >, <, ", ' with html entities.
        * To disable function set settings: filter_data=false, filter_params=false
        * @param {string} string
        * @return {string}
        * @static
        * @memberOf TemplateUtils
        */
        TemplateUtils.escapeHTML = function (txt) {
            return txt.replace(/&/g, '&amp;').replace(/>/g, '&gt;').replace(/</g, '&lt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
        };

        /**
        * Make a copy od data 'd'. It also filters data (depend on 'filter').
        * @param {object} d input data
        * @param {object} filter a filters
        * @config {boolean} [escapeData] Use escapeHTML on every string.
        * @config {boolean} [noFunc] Do not allow to use function (throws exception).
        * @param {Function} f_escapeString function using to filter string (usually: TemplateUtils.escapeHTML)
        * @return {object} output data (filtered)
        * @static
        * @memberOf TemplateUtils
        */
        TemplateUtils.cloneData = function (d, filter, f_escapeString) {
            if (d == null) {
                return d;
            }
            switch (d.constructor) {
                case Object:
                    var o = {};
                    for (var i in d) {
                        o[i] = TemplateUtils.cloneData(d[i], filter, f_escapeString);
                    }
                    if (!filter.noFunc) {
                        if (d.hasOwnProperty("toString")) {
                            o.toString = d.toString;
                        }
                    }
                    return o;
                case Array:
                    var a = [];
                    for (var i = 0, l = d.length; i < l; ++i) {
                        a[i] = TemplateUtils.cloneData(d[i], filter, f_escapeString);
                    }
                    return a;
                case String:
                    return (filter.escapeData) ? (f_escapeString(d)) : (d);
                case Function:
                    if (filter.noFunc) {
                        if (Template.DEBUG_MODE) {
                            throw new Error("jTemplates: Functions are not allowed.");
                        }
                        else {
                            return undefined;
                        }
                    }
            }
            return d;
        };

        /**
        * Convert text-based option string to Object
        * @param {string} optionText text-based option string
        * @return {Object}
        * @static
        * @memberOf TemplateUtils
        */
        TemplateUtils.optionToObject = function (optionText) {
            if (optionText === null || optionText === undefined) {
                return {};
            }

            var o = optionText.split(/[= ]/);
            if (o[0] === '') {
                o.shift();
            }

            var obj = {};
            for (var i = 0, l = o.length; i < l; i += 2) {
                obj[o[i]] = o[i + 1];
            }

            return obj;
        };

        /**
        * Parse JSON string into object
        * @param {string} data Text JSON
        * @return {Object}
        * @static
        */
        TemplateUtils.parseJSON = function (data) {
            if (typeof data !== "string" || !data) {
                return null;
            }
            try {
                return (new Function("return " + jQuery.trim(data)))();
            } catch (e) {
                if (Template.DEBUG_MODE) {
                    throw new Error("jTemplates: Invalid JSON");
                }
                return {};
            }
        };

        /**
        * Find parents nodes for a reference value and return it
        * @param {Element} el html element
        * @param {int} guid template process unique identificator
        * @param {int} id index
        * @return {object}
        * @static
        */
        TemplateUtils.ReturnRefValue = function (el, guid, id) {
            //search element with stored data
            while (el != null) {
                var d = jQuery.data(el, 'jTemplatesRef');
                if (d != undefined && d.guid == guid && d.d[id] != undefined) {
                    return d.d[id];
                }
                el = el.parentNode;
            }
            return null;
        };

        /**
        * Create a new text node.
        * @name TextNode
        * @class All text (block {..}) between control's block "{#..}".
        * @param {string} val text string
        * @param {boolean} literalMode When enable (true) template does not process blocks {..}.
        * @param {Template} Template object
        * @augments BaseNode
        */
        var TextNode = function (val, literalMode, template) {
            this._value = val;
            this._literalMode = literalMode;
            this._template = template;
        };

        /**
        * Get the html string for a text node.
        * @param {object} d data
        * @param {object} param parameters
        * @param {Element} element a HTML element
        * @param {Number} deep
        * @return {String}
        */
        TextNode.prototype.get = function (d, param, element, deep) {
            if (this._literalMode) {
                return this._value;
            }
            var s = this._value;
            var result = "";
            var i = -1;
            var nested = 0;
            var sText = -1;
            var sExpr = 0;
            while (true) {
                var lm = s.indexOf("{", i + 1);
                var rm = s.indexOf("}", i + 1);
                if (lm < 0 && rm < 0) {
                    break;
                }
                if ((lm != -1 && lm < rm) || (rm == -1)) {
                    i = lm;
                    if (++nested == 1) {
                        sText = lm;
                        result += s.substring(sExpr, i);
                        sExpr = -1;
                    }
                } else {
                    i = rm;
                    if (--nested === 0) {
                        if (sText >= 0) {
                            result += this._template.getBin().evaluateContent(d, param, element, s.substring(sText, rm + 1));
                            sText = -1;
                            sExpr = i + 1;
                        }
                    } else if (nested < 0) {
                        nested = 0;
                    }
                }
            }
            if (sExpr > -1) {
                result += s.substr(sExpr);
            }
            return result;
        };

        /**
        * Virtual context for eval() (internal class)
        * @name EvalClass
        * @class Virtual bin for eval() evaluation
        * @param {Template} t template
        * @private
        */
        EvalClass = function (t) {
            this.__templ = t;
        };

        /**
        * Evaluate expression (template content)
        * @param {object} $T data
        * @param {object} $P parameters
        * @param {object} $Q element
        * @param {String} __value Template content
        * @return {String}
        */
        EvalClass.prototype.evaluateContent = function ($T, $P, $Q, __value) {
            try {
                var result = eval(__value);

                if (jQuery.isFunction(result)) {
                    if (this.__templ.settings.disallow_functions || !this.__templ.settings.runnable_functions) {
                        return '';
                    }
                    result = result($T, $P, $Q);
                }
                return (result === undefined) ? ("") : (String(result));
            } catch (e) {
                if (Template.DEBUG_MODE) {
                    if (e instanceof JTException) {
                        e.type = "subtemplate";
                    }
                    throw e;
                }
                return "";
            }
        };

        /**
        * Evaluate expression (simple eval)
        * @param {object} $T data
        * @param {object} $P parameters
        * @param {object} $Q element
        * @param {String} __value content to evaluate
        * @return {String}
        */
        EvalClass.prototype.evaluate = function ($T, $P, $Q, __value) {
            return eval(__value);
        };

        /**
        * Create a new conditional node.
        * @name opIF
        * @class A class represent: {#if}.
        * @param {object} par parent node
        * @param {Template} templ template
        * @augments BaseArray
        */
        var opIF = function (par, templ) {
            this._parent = par;
            this._templ = templ;
            this._cond = []; //conditions
            this._tree = []; //conditions subtree
            this._curr = null; //current subtree
        };

        /**
        * Add node 'e' to array.
        * @param {BaseNode} e a node
        */
        opIF.prototype.push = function (e) {
            this._curr.push(e);
        };

        /**
        * Get a parent node.
        * @return {BaseNode}
        */
        opIF.prototype.getParent = function () {
            return this._parent;
        };

        /**
        * Add condition
        * @param {string} oper content of operator {#..}
        */
        opIF.prototype.addCond = function (oper) {
            oper.match(/\{#(?:else)*if (.*?)\}/);
            this._cond.push(RegExp.$1);
            this._curr = [];
            this._tree.push(this._curr);
        };

        /**
        * Switch to else
        */
        opIF.prototype.switchToElse = function () {
            this._cond.push(true); //else is the last condition and its always true
            this._curr = [];
            this._tree.push(this._curr);
        };

        /**
        * Process node depend on conditional and get the html string.
        * @param {object} d data
        * @param {object} param parameters
        * @param {Element} element a HTML element
        * @param {Number} deep
        * @return {String}
        */
        opIF.prototype.get = function (d, param, element, deep) {
            var ret = ''; //result

            try {
                //foreach condition
                for (var ci = 0, cl = this._cond.length; ci < cl; ++ci) {
                    //if condition is true
                    if (this._templ.getBin().evaluate(d, param, element, this._cond[ci])) {
                        //execute and exit
                        var t = this._tree[ci];
                        for (var i = 0, l = t.length; i < l; ++i) {
                            ret += t[i].get(d, param, element, deep);
                        }
                        return ret;
                    }
                }
            } catch (e) {
                if (Template.DEBUG_MODE || (e instanceof JTException)) {
                    throw e;
                }
            }
            return ret;
        };

        /**
        * Handler for a tag 'FOR'. Create new and return relative opFOREACH object.
        * @name opFORFactory
        * @class Handler for a tag 'FOR'. Create new and return relative opFOREACH object.
        * @param {string} oper content of operator {#..}
        * @param {object} par parent node
        * @param {Template} template a pointer to Template object
        * @return {opFOREACH}
        */
        opFORFactory = function (oper, par, template) {
            //create operator FOREACH with function as iterator
            if (oper.match(/\{#for (\w+?) *= *(\S+?) +to +(\S+?) *(?:step=(\S+?))*\}/)) {
                var f = new opFOREACH(null, par, template);
                f._name = RegExp.$1;
                f._option = { 'begin': (RegExp.$2 || 0), 'end': (RegExp.$3 || -1), 'step': (RegExp.$4 || 1), 'extData': '$T' };
                f._runFunc = (function (i) { return i; });
                return f;
            } else {
                throw new Error('jTemplates: Operator failed "find": ' + oper);
            }
        };

        /**
        * Create a new loop node.
        * @name opFOREACH
        * @class A class represent: {#foreach}.
        * @param {string} oper content of operator {#..}
        * @param {object} par parent node
        * @param {Template} template a pointer to Template object
        * @augments BaseArray
        */
        var opFOREACH = function (oper, par, template) {
            this._parent = par;
            this._template = template;
            if (oper != null) {
                oper.match(/\{#foreach +(.+?) +as +(\w+?)( .+)*\}/);
                this._arg = RegExp.$1;
                this._name = RegExp.$2;
                this._option = RegExp.$3 || null;
                this._option = TemplateUtils.optionToObject(this._option);
            }

            this._onTrue = [];
            this._onFalse = [];
            this._currentState = this._onTrue;
            //this._runFunc = null;
        };

        /**
        * Add node 'e' to array.
        * @param {BaseNode} e
        */
        opFOREACH.prototype.push = function (e) {
            this._currentState.push(e);
        };

        /**
        * Get a parent node.
        * @return {BaseNode}
        */
        opFOREACH.prototype.getParent = function () {
            return this._parent;
        };

        /**
        * Switch from collection onTrue to onFalse.
        */
        opFOREACH.prototype.switchToElse = function () {
            this._currentState = this._onFalse;
        };

        /**
        * Process loop and get the html string.
        * @param {object} d data
        * @param {object} param parameters
        * @param {Element} element a HTML element
        * @param {Number} deep
        * @return {String}
        */
        opFOREACH.prototype.get = function (d, param, element, deep) {
            try {
                //array of elements in foreach (or function)
                var fcount = (this._runFunc === undefined) ? (this._template.getBin().evaluate(d, param, element, this._arg)) : (this._runFunc);
                if (fcount === $) {
                    throw new Error("jTemplate: Variable '$' cannot be used as loop-function");
                }
                var key = []; //only for objects
                var mode = typeof fcount;
                if (mode == 'object') {
                    //transform object to array
                    var arr = [];
                    jQuery.each(fcount, function (k, v) {
                        key.push(k);
                        arr.push(v);
                    });
                    fcount = arr;
                }
                //setup primary iterator, iterator can get data from options (using by operator FOR) or from data "$T"
                var extData = (this._option.extData !== undefined) ? (this._template.getBin().evaluate(d, param, element, this._option.extData)) : ((d != null) ? (d) : ({}));
                if (extData == null) {
                    extData = {};
                }
                //start, end and step
                var s = Number(this._template.getBin().evaluate(d, param, element, this._option.begin) || 0), e; //start, end
                var step = Number(this._template.getBin().evaluate(d, param, element, this._option.step) || 1);
                if (mode != 'function') {
                    e = fcount.length;
                } else {
                    if (this._option.end === undefined || this._option.end === null) {
                        e = Number.MAX_VALUE;
                    } else {
                        e = Number(this._template.getBin().evaluate(d, param, element, this._option.end)) + ((step > 0) ? (1) : (-1));
                    }
                }
                var ret = ''; //result string
                var i, l; //local iterators

                if (this._option.count) {
                    //limit number of loops
                    var tmp = s + Number(this._template.getBin().evaluate(d, param, element, this._option.count));
                    e = (tmp > e) ? (e) : (tmp);
                }

                if ((e > s && step > 0) || (e < s && step < 0)) {
                    var iteration = 0;
                    var _total = (mode != 'function') ? (Math.ceil((e - s) / step)) : undefined;
                    var ckey, cval; //current key, current value
                    var loopCounter = 0;
                    for (; ((step > 0) ? (s < e) : (s > e)); s += step, ++iteration, ++loopCounter) {
                        if (Template.DEBUG_MODE && loopCounter > Template.FOREACH_LOOP_LIMIT) {
                            throw new Error("jTemplate: Foreach loop limit was exceed");
                        }
                        ckey = key[s];
                        if (mode != 'function') {
                            cval = fcount[s];  //get value from array
                        } else {
                            cval = fcount(s);  //calc function
                            //if no result from function then stop foreach
                            if (cval === undefined || cval === null) {
                                break;
                            }
                        }
                        if ((typeof cval == 'function') && (this._template.settings.disallow_functions || !this._template.settings.runnable_functions)) {
                            continue;
                        }
                        if ((mode == 'object') && (ckey in Object) && (cval === Object[ckey])) {
                            continue;
                        }
                        //backup on value
                        var prevValue = extData[this._name];
                        //set iterator properties
                        extData[this._name] = cval;
                        extData[this._name + '$index'] = s;
                        extData[this._name + '$iteration'] = iteration;
                        extData[this._name + '$first'] = (iteration === 0);
                        extData[this._name + '$last'] = (s + step >= e);
                        extData[this._name + '$total'] = _total;
                        extData[this._name + '$key'] = (ckey !== undefined && ckey.constructor == String) ? (this._template.f_escapeString(ckey)) : (ckey);
                        extData[this._name + '$typeof'] = typeof cval;
                        for (i = 0, l = this._onTrue.length; i < l; ++i) {
                            try {
                                ret += this._onTrue[i].get(extData, param, element, deep);
                            } catch (ex) {
                                if (ex instanceof JTException) {
                                    switch (ex.type) {
                                        case 'continue':
                                            i = l; //force skip to next node
                                            break;
                                        case 'break':
                                            i = l;  //force skip to next node
                                            s = e;  //force skip outsite foreach
                                            break;
                                        default:
                                            throw ex;
                                    }
                                } else {
                                    throw ex;
                                }
                            }
                        }
                        //restore values
                        delete extData[this._name + '$index'];
                        delete extData[this._name + '$iteration'];
                        delete extData[this._name + '$first'];
                        delete extData[this._name + '$last'];
                        delete extData[this._name + '$total'];
                        delete extData[this._name + '$key'];
                        delete extData[this._name + '$typeof'];
                        delete extData[this._name];
                        extData[this._name] = prevValue;
                    }
                } else {
                    //no items to loop ("foreach->else")
                    for (i = 0, l = this._onFalse.length; i < l; ++i) {
                        ret += this._onFalse[i].get(d, param, element, deep);
                    }
                }
                return ret;
            } catch (e) {
                if (Template.DEBUG_MODE || (e instanceof JTException)) {
                    throw e;
                }
                return "";
            }
        };

        /**
        * Template-control exceptions
        * @name JTException
        * @class A class used internals for a template-control exceptions
        * @param type {string} Type of exception
        * @augments Error
        * @augments BaseNode
        */
        var JTException = function (type) {
            this.type = type;
        };
        JTException.prototype = Error;

        /**
        * Throw a template-control exception
        * @throws It throws itself
        */
        JTException.prototype.get = function (d) {
            throw this;
        };

        /**
        * Create a new entry for included template.
        * @name Include
        * @class A class represent: {#include}.
        * @param {string} oper content of operator {#..}
        * @param {array} includes
        * @param {Template} templ template
        * @augments BaseNode
        */
        var Include = function (oper, includes, templ) {
            oper.match(/\{#include (.*?)(?: root=(.*?))?\}/);
            this._template = includes[RegExp.$1];
            if (this._template == undefined) {
                if (Template.DEBUG_MODE) {
                    throw new Error('jTemplates: Cannot find include: ' + RegExp.$1);
                }
            }
            this._root = RegExp.$2;
            this._mainTempl = templ;
        };

        /**
        * Run method get on included template.
        * @param {object} d data
        * @param {object} param parameters
        * @param {Element} element a HTML element
        * @param {Number} deep
        * @return {String}
        */
        Include.prototype.get = function (d, param, element, deep) {
            try {
                //run a subtemplates with a new root node
                return this._template.get(this._mainTempl.getBin().evaluate(d, param, element, this._root), param, element, deep);
            } catch (e) {
                if (Template.DEBUG_MODE || (e instanceof JTException)) {
                    throw e;
                }
            }
            return '';
        };

        /**
        * Create new node for {#param}.
        * @name UserParam
        * @class A class represent: {#param}.
        * @param {string} oper content of operator {#..}
        * @param {Template} templ template
        * @augments BaseNode
        */
        var UserParam = function (oper, templ) {
            oper.match(/\{#param name=(\w*?) value=(.*?)\}/);
            this._name = RegExp.$1;
            this._value = RegExp.$2;
            this._templ = templ;
        };

        /**
        * Return value of selected parameter.
        * @param {object} d data
        * @param {object} param parameters
        * @param {Element} element a HTML element
        * @param {Number} deep
        * @return {String} empty string
        */
        UserParam.prototype.get = function (d, param, element, deep) {
            try {
                param[this._name] = this._templ.getBin().evaluate(d, param, element, this._value);
            } catch (e) {
                if (Template.DEBUG_MODE || (e instanceof JTException)) {
                    throw e;
                }
                param[this._name] = undefined;
            }
            return '';
        };

        /**
        * Create new node for {#var}.
        * @name UserVariable
        * @class A class represent: {#var}.
        * @param {string} oper content of operator {#..}
        * @param {Template} templ template
        * @augments BaseNode
        */
        var UserVariable = function (oper, templ) {
            oper.match(/\{#var (.*?)\}/);
            this._id = RegExp.$1;
            this._templ = templ;
        };

        /**
        * Return value of selected variable.
        * @param {object} d data
        * @param {object} param parameters
        * @param {Element} element a HTML element
        * @param {Number} deep
        * @return {String} calling of function ReturnRefValue (as text string)
        */
        UserVariable.prototype.get = function (d, param, element, deep) {
            try {
                if (element == undefined) {
                    return "";
                }
                var obj = this._templ.getBin().evaluate(d, param, element, this._id);
                var refobj = jQuery.data(element, "jTemplatesRef");
                if (refobj == undefined) {
                    refobj = { guid: (++Template.guid), d: [] };
                }
                var i = refobj.d.push(obj);
                jQuery.data(element, "jTemplatesRef", refobj);
                return "(TemplateUtils.ReturnRefValue(this," + refobj.guid + "," + (i - 1) + "))";
            } catch (e) {
                if (Template.DEBUG_MODE || (e instanceof JTException)) {
                    throw e;
                }
                return '';
            }
        };

        /**
        * Create a new cycle node.
        * @name Cycle
        * @class A class represent: {#cycle}.
        * @param {string} oper content of operator {#..}
        * @augments BaseNode
        */
        var Cycle = function (oper) {
            oper.match(/\{#cycle values=(.*?)\}/);
            this._values = eval(RegExp.$1);
            this._length = this._values.length;
            if (this._length <= 0) {
                throw new Error('jTemplates: no elements for cycle');
            }
            this._index = 0;
            this._lastSessionID = -1;
        };

        /**
        * Do a step on cycle and return value.
        * @param {object} d data
        * @param {object} param parameters
        * @param {Element} element a HTML element
        * @param {Number} deep
        * @return {String}
        */
        Cycle.prototype.get = function (d, param, element, deep) {
            var sid = jQuery.data(element, 'jTemplateSID');
            if (sid != this._lastSessionID) {
                this._lastSessionID = sid;
                this._index = 0;
            }
            var i = this._index++ % this._length;
            return this._values[i];
        };


        /**
        * Add a Template to HTML Elements.
        * @param {Template/string} s a Template or a template string
        * @param {array} [includes] Array of included templates.
        * @param {object} [settings] Settings (see Template)
        * @return {jQuery} chainable jQuery class
        * @memberOf jQuery.fn
        */
        jQuery.fn.setTemplate = function (s, includes, settings) {
            return jQuery(this).each(function () {
                var t = (s && s.constructor == Template) ? s : new Template(s, includes, settings);
                jQuery.data(this, 'jTemplate', t);
                jQuery.data(this, 'jTemplateSID', 0);
            });
        };

        /**
        * Add a Template (from URL) to HTML Elements.
        * @param {string} url_ URL to template
        * @param {array} [includes] Array of included templates.
        * @param {object} [settings] Settings (see Template)
        * @return {jQuery} chainable jQuery class
        * @memberOf jQuery.fn
        */
        jQuery.fn.setTemplateURL = function (url_, includes, settings) {
            var s = jQuery.ajax({
                url: url_,
                dataType: 'text',
                async: false,
                type: 'GET'
            }).responseText;

            return jQuery(this).setTemplate(s, includes, settings);
        };

        /**
        * Create a Template from element's content.
        * @param {string} elementName an ID of element
        * @param {array} [includes] Array of included templates.
        * @param {object} [settings] Settings (see Template)
        * @return {jQuery} chainable jQuery class
        * @memberOf jQuery.fn
        */
        jQuery.fn.setTemplateElement = function (elementName, includes, settings) {
            var s = jQuery('#' + elementName).val();
            if (s == null) {
                s = jQuery('#' + elementName).html();
                s = s.replace(/&lt;/g, "<").replace(/&gt;/g, ">");
            }

            s = jQuery.trim(s);
            s = s.replace(/^<\!\[CDATA\[([\s\S]*)\]\]>$/im, '$1');
            s = s.replace(/^<\!--([\s\S]*)-->$/im, '$1');

            return jQuery(this).setTemplate(s, includes, settings);
        };

        /**
        * Check it HTML Elements have a template. Return count of templates.
        * @return {number} Number of templates.
        * @memberOf jQuery.fn
        */
        jQuery.fn.hasTemplate = function () {
            var count = 0;
            jQuery(this).each(function () {
                if (jQuery.getTemplate(this)) {
                    ++count;
                }
            });
            return count;
        };

        /**
        * Remote Template from HTML Element(s)
        * @return {jQuery} chainable jQuery class
        */
        jQuery.fn.removeTemplate = function () {
            jQuery(this).processTemplateStop();
            return jQuery(this).each(function () {
                jQuery.removeData(this, 'jTemplate');
            });
        };

        /**
        * Set to parameter 'name' value 'value'.
        * @param {string} name
        * @param {object} value
        * @return {jQuery} chainable jQuery class
        * @memberOf jQuery.fn
        */
        jQuery.fn.setParam = function (name, value) {
            return jQuery(this).each(function () {
                var t = jQuery.getTemplate(this);
                if (t != null) {
                    t.setParam(name, value);
                } else if (Template.DEBUG_MODE) {
                    throw new Error('jTemplates: Template is not defined.');
                }
            });
        };

        /**
        * Process template using data 'd' and parameters 'param'. Update HTML code.
        * @param {object} d data 
        * @param {object} [param] parameters
        * @option {object} [options] internal use only
        * @return {jQuery} chainable jQuery class
        * @memberOf jQuery.fn
        */
        jQuery.fn.processTemplate = function (d, param, options) {
            return jQuery(this).each(function () {
                var t = jQuery.getTemplate(this);
                if (t != null) {
                    if (options != undefined && options.StrToJSON) {
                        d = t.f_parseJSON(d);
                    }
                    jQuery.data(this, 'jTemplateSID', jQuery.data(this, 'jTemplateSID') + 1);
                    jQuery(this).html(t.get(d, param, this, 0));
                } else if (Template.DEBUG_MODE) {
                    throw new Error('jTemplates: Template is not defined.');
                }
            });
        };

        /**
        * Process template using data from URL 'url_' (only format JSON) and parameters 'param'. Update HTML code.
        * @param {string} url_ URL to data (in JSON)
        * @param {object} [param] parameters
        * @param {object} options options (over ajaxSettings) and callbacks
        * @return {jQuery} chainable jQuery class
        * @memberOf jQuery.fn
        */
        jQuery.fn.processTemplateURL = function (url_, param, options) {
            var that = this;

            var o = jQuery.extend({ cache: false }, jQuery.ajaxSettings);
            o = jQuery.extend(o, options);

            jQuery.ajax({
                url: url_,
                type: o.type,
                data: o.data,
                dataFilter: o.dataFilter,
                async: o.async,
                headers: o.headers,
                cache: o.cache,
                timeout: o.timeout,
                dataType: 'text',
                success: function (d) {
                    var r = jQuery(that).processTemplate(d, param, { StrToJSON: true });
                    if (o.on_success) {
                        o.on_success(r);
                    }
                },
                error: o.on_error,
                complete: o.on_complete
            });
            return this;
        };

        /**
        * Create new Updater.
        * @name Updater
        * @class This class is used for 'Live Refresh!'.
        * @param {string} url A destination URL
        * @param {object} param Parameters (for template)
        * @param {number} interval Time refresh interval
        * @param {object} args Additional URL parameters (in URL alter ?) as assoc array.
        * @param {array} objs An array of HTMLElement which will be modified by Updater.
        * @param {object} options options and callbacks
        */
        var Updater = function (url, param, interval, args, objs, options) {
            this._url = url;
            this._param = param;
            this._interval = interval;
            this._args = args;
            this.objs = objs;
            this.timer = null;
            this._options = options || {};

            var that = this;
            jQuery(objs).each(function () {
                jQuery.data(this, 'jTemplateUpdater', that);
            });
            this.run();
        };

        /**
        * Create new HTTP request to server, get data (as JSON) and send it to templates. Also check does HTMLElements still exists in Document.
        */
        Updater.prototype.run = function () {
            //remove deleted node
            this.objs = jQuery.grep(this.objs, function (elem) {
                return (jQuery.contains(document.body, elem.jquery ? elem[0] : elem));
            });
            //if no node then do nothing
            if (this.objs.length === 0) {
                return;
            }
            //ajax call
            var that = this;
            jQuery.ajax({
                url: this._url,
                dataType: 'text',
                data: this._args,
                cache: false,
                headers: that._options.headers,
                success: function (d) {
                    try {
                        var r = jQuery(that.objs).processTemplate(d, that._param, { StrToJSON: true });
                        if (that._options.on_success) {
                            that._options.on_success(r); //callback
                        }
                    } catch (ex) { }
                }
            });
            //schedule next run
            this.timer = setTimeout(function () { that.run(); }, this._interval);
        };

        /**
        * Start 'Live Refresh!'.
        * @param {string} url A destination URL
        * @param {object} param Parameters (for template)
        * @param {number} interval Time refresh interval
        * @param {object} args Additional URL parameters (in URL alter ?) as assoc array.
        * @param {object} options options and callbacks
        * @return {Updater} an Updater object
        * @memberOf jQuery.fn
        */
        jQuery.fn.processTemplateStart = function (url, param, interval, args, options) {
            return new Updater(url, param, interval, args, this, options);
        };

        /**
        * Stop 'Live Refresh!'.
        * @return {jQuery} chainable jQuery class
        * @memberOf jQuery.fn
        */
        jQuery.fn.processTemplateStop = function () {
            return jQuery(this).each(function () {
                var updater = jQuery.data(this, 'jTemplateUpdater');
                if (updater == null) {
                    return;
                }
                var that = this;
                updater.objs = jQuery.grep(updater.objs, function (o) {
                    return o != that;
                });
                jQuery.removeData(this, 'jTemplateUpdater');
            });
        };

        jQuery.extend(/** @scope jQuery.prototype */{
        /**
        * Create new Template.
        * @param {string} s A template string (like: "Text: {$T.txt}.").
        * @param {array} includes Array of included templates.
        * @param {object} settings Settings. (see Template)
        * @return {Template}
        */
        createTemplate: function (s, includes, settings) {
            return new Template(s, includes, settings);
        },

        /**
        * Create new Template from URL.
        * @param {string} url_ URL to template
        * @param {array} includes Array of included templates.
        * @param {object} settings Settings. (see Template)
        * @return {Template}
        */
        createTemplateURL: function (url_, includes, settings) {
            var s = jQuery.ajax({
                url: url_,
                dataType: 'text',
                async: false,
                type: 'GET'
            }).responseText;

            return new Template(s, includes, settings);
        },

        /**
        * Get a Template for HTML node
        * @param {Element} HTML node
        * @return {Template} a Template or "undefined"
        */
        getTemplate: function (element) {
            return jQuery.data(element, 'jTemplate');
        },

        /**
        * Process template and return text content.
        * @param {Template} template A Template
        * @param {object} data data
        * @param {object} param parameters
        * @return {string} Content of template
        */
        processTemplateToText: function (template, data, parameter) {
            return template.get(data, parameter, undefined, 0);
        },

        /**
        * Set Debug Mode
        * @param {Boolean} value
        */
        jTemplatesDebugMode: function (value) {
            Template.DEBUG_MODE = value;
        }
    });

})(jQuery);
};