function _modelArgsBinding(args: any[], expr, model, ctx, ctr) {
    var arr = null;
    if (expr == null) {
        var i = args.length;
        arr = new Array(i);
        while (--i > -1) {
            arr[i] = expression_eval(args[i].name, model, ctx, ctr);
        }
    } else {
        arr = expression_evalStatements(expr, model, ctx, ctr);
    }
    var out = {},
        arrMax = arr.length,
        argsMax = args.length,
        i = -1;
    while (++i < arrMax && i < argsMax) {
        var val = arr[i];
        if (val == null) {
            var type = args[i].type;
            if (type != null) {
                var Type = type;
                if (typeof type === 'string') {
                    Type = expression_eval(type, model, ctx, ctr);
                    if (Type == null) {
                        error_withCompo(type + ' was not resolved', ctr);
                    } else {
                        val = Di.resolve(Type);
                    }
                }
            }
        }
        out[args[i].name] = val;
    }
    return out;
}

    constructor: function(compo, expression) {
        this.error = null;
        this.exports = [];
        this.onResolve = this.onResolve.bind(this);
        this.onReject = this.onReject.bind(this);
                
        var arr = expression_evalStatements(expression, compo.model, null, compo);
        var imax = arr.length,
            i = -1;

        this.await_ = imax;
        while(++i < imax) {
            var x = arr[i];
            if (x == null || is_Function(x.then) === false) {
                this.await_--;
                this.exports.push(x);
                continue;
            }

            x.then(this.onResolve, this.onReject);				
        }
        if (this.await_ === 0) {
            this.resolve(this.exports);
        }
    },

	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);
	}

 return function(event) {
     var args;
     if (arguments.length > 1) {
         args = _Array_slice.call(arguments, 1); 
     }
     if (expr != null) {
         var arr = expression_evalStatements(expr, ctr.model, null, ctr);
         args = args == null ? arr : args.concat(arr);
     }
     _fire(ctr, slot, event, args, -1);
 };

	on: function call (expr, model, ctr, cb) {
		var arr = expression_evalStatements(expr, model, null, ctr);

		var stream = arr.shift();
		if (stream == null || stream.subscribe == null) {
			error_withCompo('Subscribe method is undefined on RxObservable', ctr);
			return;
		}
		arr.push(cb);
		this.stream = stream.subscribe.apply(stream, arr);
	},

		var Wrapped = function (node, model, ctx, el, parent) {
			var args;
			if (node.expression != null) {
				args = expression_evalStatements(node.expression, model, ctx, parent, node);
			}
			if (types != null) {
				if (args == null) args = new Array(types.length);
				for (var i = 0; i < types.length; i++) {
					if (types[i] === null || args[i] != null) continue;
					args[i] = _di.resolve(types[i]);
				}
			}
			Ctor.apply(this, args);
		};

import { custom_Statements } from '@core/custom/exports';
import { expression_evalStatements } from '@project/expression/src/exports';
import { customTag_register } from '@core/custom/exports';


custom_Statements['log'] = {
    render (node, model, ctx, container, controller) {
        var arr = expression_evalStatements(node.expression, model, ctx, controller);
        arr.unshift('Mask::Log');
        console.log.apply(console, arr);
    }
};
customTag_register('debugger', {
    render (model, ctx, container, compo) {
        debugger;
    }
});
customTag_register(':utest', class {
    $: JQuery
    render (model, ctx, container) {
        if (container.nodeType === Node.DOCUMENT_FRAGMENT_NODE)
            container = container.childNodes;
        this.$ = $(container);
    }
});

	custom_Tags['import:cfg'] = function(node, model, ctx, el, ctr){
		var args = expression_evalStatements(node.expression, model, ctx, ctr);
		m_cfg.apply(null, args);
	};