Namespace comb

var args = Array.prototype.slice.call(arguments);
var topic = args.splice(0, 1)[0];
if (topic) {
	var list = listeners[topic];
	if (list) {
		for (var i = list.length - 1; i >= 0; i--) {
			var han = list[i], cb = han.cb;
			if (cb) {
				cb.apply(this, args);
			}
		}
	}
}
			

var ret = str;
if (!misc.isUndefinedOrNull(str)) {
    ret = str.replace(CAMELIZE_CONVERT_REGEXP, function (a, b) {
        return b.toUpperCase();
    });
}
return ret;

var ret = str;
if (!misc.isUndefinedOrNull(str)) {
    ret = comb.camelize(comb.singularize(str.replace(/.*\./g, '')));
}
return ret;

var index;
if (typeof method != "string") throw new Error("When calling connect the method must be string");
if (!func.isFunction(cb)) throw new Error("When calling connect callback must be a string");
var scope = obj || global, listeners, newMethod;
if (typeof scope[method] == "function") {
	listeners = scope[method].__listeners;
	if (!listeners) {
		newMethod = wrapper();
		newMethod.func = obj[method];
		listeners = (newMethod.__listeners = []);
		scope[method] = newMethod;
	}
	index = listeners.push(cb);
} else {
	throw new Error("unknow method " + method + " in object " + obj);
}
return [obj, method, index];
			

var args = misc.argsToArray(arguments), ret;
if (args.length != 4) {
    opts = object.isHash(args[args.length - 1]) ? args.pop() : null;
    constructTrap = functions.isFunction(args[args.length - 1]) ? args.pop() : null;
    handler = functions.isFunction(args[args.length - 1]) ? args.pop() : null;
}
if (misc.isUndefined(obj)) throw new Error("obj required when using create function wrapper");
if (functions.isFunction(constructTrap) && !functions.isFunction(handler)) {
    ret = Proxy.createFunction(handlerMaker(obj), constructTrap);
} else {
    ret = Proxy.createFunction(handlerMaker(obj), handler, constructTrap);
}


if (opts) {
    Proxy.setPrototype(ret, object.isHash(opts) ? opts : opts.prototype);
}
return ret;

var f;
if (scope) {
    f = comb.hitch(scope, cb);
} else {
    f = cb;
}
if (depth) {
    var len = depth - 1;
    for (var i = len; i >= 0; i--) {
        f = curry(f, i == len);
    }
}
return f;

var child = function () {
    
    
    var instance = this.__meta.proto.instance;
    if (instance && instance.constructor && instance.constructor._unique) {
        instance.constructor.apply(this, arguments);
    } else {
        var supers = this.__meta.supers, l = supers.length;
        for (var i = 0; i < l; i++) {
            var protoInstance = supers[i].__meta.proto.instance;
            if (protoInstance && protoInstance.hasOwnProperty("constructor")) {
                protoInstance.constructor.apply(this, arguments);
                break;
            }
        }
    }

};
var ret = __define(child, sup, proto);
if (typeof ret.init === "function") {
    ret.init();
}
return ret;
    

if (handle && handle.length == 3) {
	var obj = handle[0], method = handle[1], cb = handle[2];
	if (typeof method != "string") throw "comb.disconnect : When calling disconnect the method must be string";
	var scope = obj || global, ls;
	if (typeof scope[method] == "function") {
		ls = scope[method].__listeners;
		if (ls && cb-- > 0) {
			
			ls[cb] = null;
		}
	} else {
		throw new Error("unknown method " + method + " in object " + obj);
	}
} else {
	throw "comb.disconnect : invalid handle"
}
			

args = base.argsToArray(arguments);
cb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
var ret = new Promise();
if (cb) {
    var stack = [];
    var newArgs = args.map(function(a){
        return [a, getHandler(a, stack)];
    });
    var cbRet = cb.apply(null, newArgs.map(function(h){
        return h[1];
    }));
    executeStack(stack, newArgs).then(function(results, pMap){
        if (base.isUndefined(cbRet)) {
            ret.callback(results);
        }
        else {
            var cbResults;
            if (base.isArray(cbRet)) {
                cbResults = cbRet.map(
                    function(arg){
                        return getValueFromArrayMap(arg, pMap, newArgs);
                    }).filter(function(r){
                        return !base.isUndefined(r)
                    });
            } else if (base.isHash(cbRet)) {
                cbResults = {};
                for (var i in cbRet) {
                    cbResults[i] = getValueFromArrayMap(cbRet[i], pMap, newArgs);
                }
            } else if (base.isProxy(cbRet)) {
                cbResults = getValueFromArrayMap(cbRet, pMap, newArgs);
            } else {
                cbResults = cbRet;
            }
            ret.callback(cbResults);
        }
    }, hitch(ret, "errback"));

} else {
    ret.callback();
}
return ret;
    

var proto = parent.prototype || parent;
return exports.merge(proto, extend);

opts = opts || {};
return  Proxy.create(merge(handlerMaker(obj), opts));

var args = Array.prototype.slice.call(arguments).slice(2);
if (typeof method == "string") {
    method = scope[method];
}
if (method) {
    return function() {
        var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
        return method.apply(scope, scopeArgs);
    };
} else {
    throw new Error(method + "Method not defined");
}

var undef, type = typeof obj;
return obj != undef && type == "boolean" || type == "Boolean";

var undef;
return (obj !== undef && typeof obj === "object" && obj instanceof Date);

if (object) {
    for (var i in object) {
        if (object.hasOwnProperty(i)) {
            return false;
        }
    }
}
return true;

return typeof obj == "function";

var ret = comb.isObject(obj);
return ret && obj.constructor === Object;

return argsToArray(arguments).slice(1).some(function(c) {
    return isInstance(obj, c);
});

var undef;
return obj !== undef && obj == null;

var undef;
return obj !== undef && obj != null && (typeof obj == "number" || obj instanceof Number);

var undef;
return obj != null && obj != undef && typeof obj == "object";

return !base.isUndefinedOrNull(obj) && (base.isInstanceOf(obj, Promise) || (base.isFunction(obj.then) && base.isFunction(obj.addCallback) && base.isFunction(obj.addErrback)));
    

var undef;
return obj !== undef && obj !== null && Proxy.isProxy(obj);

var undef;
return obj !== null && obj === undef;

return comb.isUndefined(obj) || comb.isNull(obj);

if (!func.isFunction(callback)) throw new Error("callback must be a function");
var handle = {
	topic : topic,
	cb : callback,
	pos : null
};
var list = listeners[topic];
if (!list) {
	list = (listeners[topic] = []);
}
list.push(handle);
handle.pos = list.length - 1;
return handle;
			

if (!obj) {
    obj = {};
}
for (var i = 1, l = arguments.length; i < l; i++) {
    merge(obj, arguments[i]);
}
return obj; 

proto = proto || {};
return  Proxy.create(merge(handlerMaker(obj), noSuchMethodHandler(obj, handler)), object.isHash(proto) ? proto : proto.prototype);

var args = Array.prototype.slice.call(arguments).slice(1);
if (typeof method == "function") {
    return function() {
        var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
        return method.apply(null, scopeArgs);
    };
} else {
    throw new Error(method + "Method not defined");
}

var ret = str;
if (!misc.isUndefinedOrNull(str)) {
    if (UNCOUNTABLES.indexOf(str) == -1) {
        for (var i in PLURALS) {
            var s = PLURALS[i], rule = s[0], replacement = s[1];
            if ((ret = ret.replace(rule, replacement)) != str) {
                break;
            }
        }
    }
}
return ret;

var retInstance;
var child = function () {
    if (!retInstance) {
        
        
        var instance = this.__meta.proto.instance;
        if (instance && instance.constructor._unique) {
            instance.constructor.apply(this, arguments);
        } else {
            var supers = this.__meta.supers, l = supers.length;
            for (var i = 0; i < l; i++) {
                var protoInstance = supers[i].__meta.proto.instance;
                if (protoInstance && protoInstance.hasOwnProperty("constructor")) {
                    protoInstance.constructor.apply(this, arguments);
                    break;
                }
            }
        }
        retInstance = this;
    }
    return retInstance;
};
var ret = __define(child, sup, proto);
if (typeof ret.init === "function") {
    ret.init();
}
return ret;
    

var ret = str;
if (!misc.isUndefinedOrNull(str)) {
    if (UNCOUNTABLES.indexOf(str) == -1) {
        for (var i in SINGULARS) {
            var s = SINGULARS[i], rule = s[0], replacement = s[1];
            if ((ret = ret.replace(rule, replacement)) != str) {
                break;
            }
        }
    }
}
return ret;

var ret = str;
if (!misc.isUndefinedOrNull(str)) {
    ret = str.replace(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE)
        .replace(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE)
        .replace(DASH, UNDERSCORE).toLowerCase();
}
return ret;

if (handle) {
	var topic = handle.topic, list = listeners[topic];
	if (list) {
		for (var i = list.length - 1; i >= 0; i--) {
			if (list[i] == handle) {
				list.splice(i, 1);
			}
		}
		if (!list.length) {
			delete listeners[topic];
		}
	}
}
			

var args = base.argsToArray(arguments), p;
eb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
cb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
if (eb && !cb) {
    cb = eb;
    eb = null;
}
if (!args.length) {
    p = new Promise().callback(args);
} else if (args.length == 1) {
    args = args.pop();
    p = exports.isPromiseLike(args) ? args : new Promise().callback(args);
} else {
    var p = new PromiseList(args.map(function(a){
        return exports.isPromiseLike(a) ? a : new Promise().callback(a);
    }), true);
}
if (cb) {
    p.addCallback(cb);
}
if (eb) {
    p.addErrback(eb);
}
return p;