(function(){
	// TODO: refactor methods, use MaskNode Serialization instead Model Serialization
	custom_Tags['var'] = class_create(customTag_Base, {
		renderStart: function(model, ctx){
			set(this, this.attr, true, model, ctx);
		},
		onRenderStartClient: function(){
			set(this, this.model, false)
		}
	});

	function set(self, source, doEval, model?, ctx?) {
		// set data also to model, so that it will be serialized in NodeJS
		self.model = {};

		var parent = self.parent;
		var scope  = parent.scope;
		if (scope == null) {
			scope = parent.scope = {};
		}
		for(var key in source){
			self.model[key] = scope[key] = doEval === false
				? source[key]
				: expression_eval(source[key], model, ctx, parent);
		}
	}
}());

export function m_registerModuleType(baseModuleType, newType, mix) {
    _typeMappings[newType] = baseModuleType;
    m_Types[newType] = class_create(
        m_Types[baseModuleType],
        mix
    );
}

(function () {
    manager_get = function (ctx, el) {
        if (ctx == null || is_DOM) {
            return manager || (manager = new Manager(document.body));
        }
        var KEY = '__contentManager';
        return ctx[KEY] || (ctx[KEY] = new Manager(el));
    };
    var manager;
    var Manager = class_create({
        constructor: function (el) {
            this.container = el.ownerDocument.body;
            this.ids = {};
        },
        append: function (tagName, node) {
            var id = node.id;
            var el = this.ids[id];
            if (el !== void 0) {
                return el;
            }
            el = render(tagName
                , node.attr
                , node.body
                , node.id
                , this.container
            );
            this.ids[id] = el;
        }
    });
}());

function _createHandlerForNodes(nodes, module) {
    return class_create({
        scope: module.scope,
        location: module.location,
        nodes: nodes,
        getHandler: _module_getHandlerDelegate(module)
    });
}

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(){
		SyncMapper = class_create({
			map: function(node, fn) {
				var mapper = getMapper(node);
				return mapper(node, fn);
			}
		});
		function getMapper (node) {
			/* not strict */
			if (node.compoName) {
				return mapCompo;
			}
			return mapNode;
		}
		function mapNode(node, fn, parent?, index?) {
			if (node == null)
				return null;

			var nextNode = isFragment(node) 
				? new Dom.Fragment 
				: fn(node);
			if (nextNode == null) {
				return null;
			}
			var nodes = safe_getNodes(node);
			if (nodes == null) {
				return nextNode;
			}
			nextNode.nodes = coll_map(nodes, function (x) { 
				return mapNode(x, fn, node) 
			});
			return nextNode;
		}
		function mapCompo(compo, fn, parent?) {
			if (compo == null)
				return null;

			var next = fn(compo);
			if (next == null || compo.components == null) {
				return next;
			}
			next.components = coll_map(compo.components, function (x) { 
				return mapCompo(x, fn, compo)
			});
			return next;
		}
	}());

(function () {
    function parse (def) {
        var rgx    = /^\s*([\w]+)[:\$]+([\w]+)\s*$/,
            parts  = rgx.exec(def),
            name   = parts && parts[1],
            signal = parts && parts[2];
        if (parts == null || name == null || signal == null) {
            log_error('PipeCompo. Invalid name.', def, 'Expect', rgx.toString());
            return null;
        }
        return [name, signal];
    }
    function attach(node, ctr) {
        var pipes = ctr.pipes;
        if (pipes == null) {
            pipes = ctr.pipes = {};
        }
        var signal = parse(node.name);
        if (signal == null) {
            return;
        }
        var name = signal[0],
            type = signal[1],
            pipe = ctr.pipes[name];
        if (pipe == null) {
            pipe = pipes[name] = {};
        }
        pipe[type] = node.fn;
    }
    custom_Tags['pipe'] = class_create(Method, {
        renderEnd: function(){
            attach(this, this.parent);
        }
    });
    custom_Tags.pipe.attach = attach;
}());

import { class_create } from '@utils/class'
import { _appendChild } from './utils';
import { dom_TEXTNODE } from './NodeType';

/**
 * @name TextNode
 * @type {class}
 * @property {type} [type=2]
 * @property {(string|function)} content
 * @property {IMaskNode} parent
 * @memberOf mask.Dom
 */
export const TextNode = class_create({
	constructor: function(text, parent) {
		this.content = text;
		this.parent = parent;
	},
	type: dom_TEXTNODE,
	content: null,
	parent: null,
	sourceIndex: -1
});

import { class_create } from '@utils/class';
import { obj_extend } from '@utils/obj';
import { class_Dfr } from '@utils/class/Dfr';


	export const builder_Ctx = class_create(class_Dfr as any, {
		constructor: function(data){
			obj_extend(this, data);
		},
		// Is true, if some of the components in a ctx is async
		async: false,
		// List of busy components
		defers: null /*Array*/,

		// NodeJS
		// Track components ID
		_id: null,
		// ModelsBuilder for HTML serialization
		_models: null,

		// ModulesBuilder fot HTML serialization
		_modules: null,

		_redirect: null,
		_rewrite: null
	});

	(builder_Ctx as any).clone = function(ctx){
		var data = {};
		for(var key in ctx) {
			if (builder_Ctx.prototype[key] === void 0) {

import { class_create } from '@utils/class';
import { log_error } from '@core/util/reporters';
import { IBinder } from './IBinder';
import { expression_evalStatements } from '@project/expression/src/exports';

/*
 *	"expression, ...args"
 *	expression: to get the IEventEmitter
 */
export const EventEmitterBinder = class_create(IBinder, {
		on: function(exp, model, ctx, ctr, cb){
			call('on', exp, model, ctr, cb);
		},
		off: function(exp, model, ctr, cb){
			call('off', exp, model, ctr, cb);
		},
	});

	function call (method, expr, model, ctr, cb) {
		var arr = expression_evalStatements(expr, model, null, ctr);
		var observable = arr.shift();
		if (observable == null || observable[method] == null) {
			log_error('Method is undefined on observable: ' + method);
			return;
		}
		arr.push(cb);
		observable[method].apply(observable, arr);
	}