(function() {

	function Bind() {}

	customTag_register(':bind', Bind);
	customTag_register( 'bind', Bind);

	Bind.prototype = {
		constructor: Bind,
		renderStart: function(model, ctx, container){
			
			this.provider = BindingProvider.create(model, container, this, 'single');
			this.provider.objectChanged();
		}
	};


}());

function _createExports(nodes, model, module) {
    var exports = module.exports,
        items = module.importItems,
        getHandler = _module_getHandlerDelegate(module);

    var i = -1,
        imax = items.length;
    while (++i < imax) {
        var x = items[i];
        if (x.registerScope) {
            x.registerScope(module);
        }
    }

    var i = -1,
        imax = nodes.length;
    while (++i < imax) {
        var node = nodes[i];
        var name = node.tagName;
        if (name === 'define' || name === 'let') {
            var Base = {
                getHandler: _fn_wrap(customTag_Compo_getHandler, getHandler),
                getModule: _module_getModuleDelegate(module),
                location: module.location
            };
            var Ctor = Define.create(node, model, module, Base);
            var Proto = Ctor.prototype;
            if (Proto.scope != null || module.scope != null) {
                Proto.scope = obj_extend(Proto.scope, module.scope);
            }

            var compoName = node.name;
            if (name === 'define') {
                exports[compoName] = Ctor;
                customTag_register(compoName, Ctor);
            }
            if (name === 'let') {
                customTag_registerResolver(compoName);
            }
            exports.__handlers__[compoName] = Ctor;
        }
    }
    exports['*'] = class_create(customTag_Base, {
        getHandler: getHandler,
        location: module.location,
        nodes: exports.__nodes__,
        scope: module.scope
    });

    return exports;
}

(function() {

	function Bind() {}

	customTag_register(':bind', Bind);
	customTag_register( 'bind', Bind);

	Bind.prototype = {
		constructor: Bind,
		renderEnd: function(els, model, cntx, container){
			
			this.provider = BindingProvider.create(model, container, this, 'single');
			
			BindingProvider.bind(this.provider);
		},
		dispose: function(){
			if (this.provider && typeof this.provider.dispose === 'function') {
				this.provider.dispose();
			}
		}
	};


}());

            log_warn('Template was not found', id);
            return null;
        },
        register: function(id, nodes){
            if (id == null) {
                log_warn('`:template` must define the `id` attr');
                return;
            }
            cache_[id] = nodes;
        }
    };


customTag_register(':template', {
    render: function() {
        Templates.register(this.attr.id, this.nodes);
    }
});

customTag_register(':import', {
    renderStart: function() {
        var id = this.attr.id;
        if (id == null) {
            log_error('`:import` shoud reference the template via id attr')
            return;
        }
        this.nodes = Templates.resolve(this, id);
    }
});

custom_Statements['include'] = {

customTag_register('+for', {
    meta: {
        serializeNodes: true
    },
    serializeNodes: function(node){
        return mask_stringify(node);
    },
    render: function(model, ctx, container, ctr, children){
        var directive = For.parseFor(this.expression),
            attr = this.attr;
        
        attr[attr_PROP_1] = directive[0];
        attr[attr_PROP_2] = directive[1];
        attr[attr_TYPE] = directive[2];
        attr[attr_EXPR] = directive[3];
        
        var value = expression_eval(directive[3], model, ctx, ctr);
        if (value == null) 
            return;
        
        if (is_Array(value)) 
            arr_createRefs(value);
        
        For.build(
            value,
            directive,
            this.nodes,
            model,
            ctx,
            container,
            this,
            children
        );
    },
    
    renderEnd: function(els, model, ctx, container, ctr){
        
        var compo = new ForStatement(this, this.attr);
        _renderPlaceholder(this, compo, container);			
        _compo_initAndBind(compo, this, model, ctx, container, ctr);
        return compo;
    },
    
    getHandler: function(name, model){
        
        return For.getHandler(name, model);
    }
    
});

import { customTag_register } from '@core/custom/exports';

function ValidateGroup() {}

customTag_register(':validate:group', ValidateGroup);


ValidateGroup.prototype = {
	constructor: ValidateGroup,
	validate: function() {
		var validations = getValidations(this);


		for (var i = 0, x, length = validations.length; i < length; i++) {
			x = validations[i];
			if (!x.validate()) {
				return false;
			}
		}
		return true;
	}
};

function getValidations(component, out = []){
	
	if (component.components == null){
		return out;
	}
	var compos = component.components;
	for(var i = 0, x, length = compos.length; i < length; i++){
		x = compos[i];

(function(){
	var $Visible = customStatement_get('visible');
		
	customTag_register('+visible', {
		meta: {
			serializeNodes: true
		},
		render: function(model, ctx, container, ctr, childs){
			return build(this.nodes, model, ctx, container, ctr);
		},
		renderEnd: function(els, model, ctx, container, ctr){
			
			var compo = new VisibleStatement(this);
			compo.elements = els;
			compo.model = model;
			compo.parent = ctr;
			compo.refresh = fn_proxy(compo.refresh, compo);
			compo.binder = expression_createBinder(
				compo.expr,
				model,
				ctx,
				ctr,
				compo.refresh
			);
			
			expression_bind(compo.expr, model, ctx, ctr, compo.binder);
			compo.refresh();
			return compo;
		}
	});
	
	
	function VisibleStatement(node){
		this.expr = node.expression;
		this.nodes = node.nodes;
	}
	
	VisibleStatement.prototype = {
		compoName: '+visible',
		elements: null,
		binder: null,
		model: null,
		parent: null,
		refresh: function(){
			var isVisible = expression_eval_safe(
				this.expr, this.model, this.ctx, this
			);
			$Visible.toggle(this.elements, isVisible);
		},
		dispose: function(){
			expression_unbind(
				this.expr,
				this.model,
				this.parent,
				this.binder
			);
		
			this.parent = null;
			this.model = null;
			this.ctx = null;
		}
		
	};
	
	function build(nodes, model, ctx, container, ctr){
		var els = [];
		builder_build(nodes, model, ctx, container, ctr, els);
		return els;
	}
}());

import { _global } from '@utils/refs'
import { customTag_register } from '@core/custom/exports';
import { expression_eval } from '@project/expression/src/exports';

function SlotHandler() {}

customTag_register(':slot', SlotHandler);

SlotHandler.prototype = {
	constructor: SlotHandler,
	renderEnd: function(element, model, cntx, container){
		this.slots = {};

		this.expression = this.attr.on;

		this.slots[this.attr.signal] = this.handle;
	},
	handle: function(){
		var expr = this.expression;

		expression_eval(expr, this.model, _global, this);
	}
};

				if (x.compoName === ':validate') {
					this.provider.addValidation(x.validations);
				}
			}
		}
		if (this.attr['no-validation'] == null) {
			var fn = ValidatorProvider.getFnFromModel(model, this.provider.value);
			if (fn != null) {
				this.provider.addValidation(fn);
			}
		}
		BindingProvider.bind(this.provider);
	},
	dispose: function() {
		var dispose = this.provider && this.provider.dispose;
		if (dispose != null) {
			dispose.call(this.provider);
		}
	},	
	validate: function(){
		return this.provider && this.provider.validate();
	},	
	handlers: {
		attr: {
			'x-signal': function() {}
		}
	}
});

customTag_register(':dualbind', DualbindCompo);
customTag_register( 'dualbind', DualbindCompo);

var Compo = {
    meta: {
        mode: 'server:all'
    },
    render: function(model, ctx, container) {
        this.html = jMask(this.nodes).text(model, ctx, this);

        if (container.insertAdjacentHTML) {
            container.insertAdjacentHTML('beforeend', this.html);
            return;
        }
        if (container.ownerDocument) {
            var div = document.createElement('div'),
                child;
            div.innerHTML = this.html;
            child = div.firstChild;
            while (child != null) {
                container.appendChild(child);
                child = child.nextSibling;
            }
        }
    },
    toHtml: function(){
        return this.html || '';
    },
    html: null
};
customTag_register(':html', Compo);