getExport: function(property) {
		var obj = this.exports;
		return property !== '*'
			? obj_getProperty(obj, property)
			: obj
			;
	}

export function mask_config (a?, b?, c?) {
	var args = arguments,
		length = args.length
	if (length === 0) {
		return __cfg;
	}
	if (length === 1) {
		let x = args[0]
		if (is_Object(x)) {
			obj_extend(__cfg, x);
			listeners_emit('config', x);
			return;
		}
		if (is_String(x)) {
			return obj_getProperty(__cfg, x);
		}
	}
	if (length === 2) {
		var prop = args[0];
		if (obj_hasProperty(__cfg, prop) === false) {
			log_warn('Unknown configuration property', prop);
		}
		let x = {};
		obj_setProperty(x    , prop, args[1]);
		obj_setProperty(__cfg, prop, args[1]);
		listeners_emit('config', x);
		return;
	}
}

function interpolate_(path, placeholders, node) {
    var index = path.indexOf('.');
    if (index === -1) {
        log_warn('Merge templates. Accessing node', path);
        return null;
    }
    var tagName = path.substring(0, index),
        id = tagName.substring(1),
        property = path.substring(index + 1),
        obj = null;

    if (node != null) {
        if (tagName === '@attr') {
            return interpolate_getAttr_(node, placeholders, property);
        }
        else if (tagName === '@counter') {
            return interpolate_getCounter_(property);
        }
        else if (tagName === node.tagName)
            obj = node;
    }

    if (obj == null)
        obj = placeholders.$getNode(id);

    if (obj == null) {
        //- log_error('Merge templates. Node not found', tagName);
        return null;
    }
    return obj_getProperty(obj, property);
}

export function obj_sub_notifyListeners(obj, path, oldVal) {
    var obs = obj[prop_OBS];
    if (obs == null) return;
    for (var prop in obs) {
        if (prop.indexOf(path + '.') !== 0) continue;

        var cbs = obs[prop].slice(0),
            imax = cbs.length,
            i = 0,
            oldProp,
            cb;
        if (imax === 0) continue;

        var val = obj_getProperty(obj, prop);
        for (i = 0; i < imax; i++) {
            cb = cbs[i];
            obj_removeObserver(obj, prop, cb);

            if (oldVal != null && typeof oldVal === 'object') {
                oldProp = prop.substring(path.length + 1);
                obj_removeObserver(oldVal, oldProp, cb);
            }
        }
        for (i = 0; i < imax; i++) {
            cbs[i](val);
        }
        for (i = 0; i < imax; i++) {
            obj_addObserver(obj, prop, cbs[i]);
        }
    }
}

function obj_crumbRebind(obj, path, oldValue) {
    var obs = obj[prop_OBS];
    if (obs == null) return;

    for (var prop in obs) {
        if (prop.indexOf(path) !== 0) continue;

        var cbs = obs[prop].slice(0),
            imax = cbs.length,
            i = 0;

        if (imax === 0) continue;

        var val = obj_getProperty(obj, prop),
            oldProp = prop.substring(path.length),
            oldVal = obj_getProperty(oldValue, oldProp);

        for (i = 0; i < imax; i++) {
            var cb = cbs[i];
            obj_removeObserver(obj, prop, cb);

            if (oldValue != null && typeof oldValue === 'object') {
                obj_removeObserver(oldValue, oldProp, cb);
            }
        }
        if (oldVal !== val) {
            for (i = 0; i < imax; i++) {
                cbs[i](val);
            }
        }

        for (i = 0; i < imax; i++) {
            obj_addObserver(obj, prop, cbs[i]);
        }
    }
}

export function m_cfg(mix, val){
    if (arguments.length === 1) {
        if (is_String(mix)) {
            return obj_getProperty(_opts, mix);
        }
        if (is_Object(mix)) {
            for (var key in mix) {
                u_setOption(_opts, key, mix[key]);
            }
        }
        return this;
    }
    u_setOption(_opts, mix, val);
    return this;
};

export function compo_attach (compo: Component, name: string, fn: Function) {
    var current = obj_getProperty(compo, name);		
    if (is_Function(current)) {
        var wrapper = function(){
            var args = _Array_slice.call(arguments);
            fn.apply(compo, args);
            current.apply(compo, args);
        };
        obj_setProperty(compo, name, wrapper);
        return;
    }
    if (current == null) {
        obj_setProperty(compo, name, fn);
        return;
    }
    throw Error('Cann`t attach ' + name + ' to not a Function');
}

		validate: function(val, el, oncancel) {
			var element = el == null ? this.element : el,
				value   = val;
			if (arguments.length === 0) {
				value = obj_getProperty(this.model, this.attr.value);
			}
			if (this.validators.length === 0) {
				this.initValidators();
			}
			var fns = this.validators,
				type = this.attr.silent ? 'validate' : 'validateUi'
				;
			
			return ValidatorProvider[type](
				fns, value, this, element, oncancel
			);
		},

export function obj_unlockObservers(obj) {
    var obs = obj[prop_OBS],
        dirties = obs == null ? null : obs[prop_DIRTY];
    if (dirties == null) return;

    obs[prop_DIRTY] = null;

    var prop, cbs, val, imax, i;
    for (prop in dirties) {
        cbs = obj[prop_OBS][prop];
        imax = cbs == null ? 0 : cbs.length;
        if (imax === 0) continue;

        i = -1;
        val = prop === prop_MUTATORS ? obj : obj_getProperty(obj, prop);
        while (++i < imax) {
            cbs[i](val);
        }
    }
}

export function u_setOption (options, key, val) {
    if (key === 'base' || key === 'nsBase') {
        var path = path_normalize(val);
        if (path[path.length - 1] !== '/') {
            path += '/';
        }
        // Do not resolve root, as it will be resolved by base later
        // @NextIteration: remove also path_resolveRoot, use instead resolveCurrent
        // if (path[0] === '/') {
        // 	path = path_combine(path_resolveRoot(), path);
        // }
        options[key] = path;
        return this;
    }
    var current = obj_getProperty(options, key);
    if (is_Object(current) && is_Object(val)) {
        obj_extend(current, val);
        return this;
    }
    obj_setProperty(options, key, val);
};