1var string = require("./string"),
     object = require("./object"),
     isArray = Array.isArray,
     isObject = object.isObject,
     isString = string.isString;
 
 /**
  * Determines if something is a function
  * @param {Anything} obj the thing to test if it is a function
  *
  * @returns {Boolean} true if the obj is a function false otherwise
  * @static
  * @memberOf comb
  */
1function isFunction(obj) {
30832    return typeof obj === "function";
 }
 
 /**
  * Binds a method to a particular scope
  *
  * @static
  * @memberOf comb
  *
  * @param {Object} scope the scope to bind the callback to
  * @param {String|Function} method the method to callback
  * @param [args] optional args to pass to the callback
  *
  * @returns {Function} the hitched function
  */
1function hitch(scope, method, args) {
5486    args = Array.prototype.slice.call(arguments).slice(2);
5486    if ((isString(method) && !(method in scope))) {
2        throw new Error(method + " property not defined in scope");
5484    } else if (!isString(method) && !isFunction(method)) {
1        throw new Error(method + " is not a function");
     }
5483    if (isString(method)) {
452        return function () {
541            var func = scope[method];
541            if (isFunction(func)) {
538                var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
538                return func.apply(scope, scopeArgs);
             } else {
3                return func;
             }
         };
     } else {
5031        return function () {
4290            var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
4290            return method.apply(scope, scopeArgs);
         };
     }
 }
 
 /**
  * Binds a method to the scope of the first argument.
  *
  * This is useful if you have async actions and you just want to run a method or retrieve a property on the object.
  *
  * ```
  *  var arr = [], push = comb.applyFirst("push"), length = comb.applyFirst("length");
  *  push(arr, 1, 2,3,4);
  *  console.log(length(arr)); //4
  *  console.log(arr); //1,2,3,4
  *
  * ```
  * @static
  * @memberOf comb
  * @param {String|Function} method the method to invoke in the scope of the first arument.
  * @param [args] optional args to pass to the callback
  *
  * @returns {Function} a function that will execute the method in the scope of the first argument.
  */
1function applyFirst(method, args) {
10    args = Array.prototype.slice.call(arguments).slice(1);
10    if (!isString(method) && !isFunction(method)) {
2        throw new Error(method + " must be the name of a property or function to execute");
     }
8    if (isString(method)) {
4        return function () {
12            var scopeArgs = Array.prototype.slice.call(arguments), scope = scopeArgs.shift();
12            var func = scope[method];
12            if (isFunction(func)) {
6                scopeArgs = args.concat(scopeArgs);
6                return func.apply(scope, scopeArgs);
             } else {
6                return func;
             }
         };
     } else {
4        return function () {
4            var scopeArgs = Array.prototype.slice.call(arguments), scope = scopeArgs.shift();
4            scopeArgs = args.concat(scopeArgs);
4            return method.apply(scope, scopeArgs);
         };
     }
 }
1;
 
 
 /**
  * @function
  * Binds a method to a particular scope
  * @static
  * @memberOf comb
  * @param {Object} scope the scope to bind the callback to
  * @param {String|Function} method the method to callback
  * @param [args] optional args to pass to the callback
  *
  * @returns {Function} the hitched function
  */
1exports.bind = hitch;
 
 /**
  * Binds a method to a particular scope ignoring any new arguments passed
  * into the function. This is useful if you want to force particular arguments and
  * ignore any new ones
  * @static
  * @memberOf comb
  * @param {Object} scope the scope to bind the callback to
  * @param {String|Function} method the method to callback
  * @param [args] optional args to pass to the callback
  *
  * @returns {Function} the hitched function
  */
1function hitchIgnore(scope, method, args) {
136    args = Array.prototype.slice.call(arguments).slice(2);
136    if ((isString(method) && !(method in scope))) {
2        throw new Error(method + " property not defined in scope");
134    } else if (!isString(method) && !isFunction(method)) {
1        throw new Error(method + " is not a function");
     }
133    if (isString(method)) {
15        return function () {
15            var func = scope[method];
15            if (isFunction(func)) {
12                return func.apply(scope, args);
             } else {
3                return func;
             }
         };
     } else {
118        return function () {
107            return method.apply(scope, args);
         };
     }
 }
 
 /**
  * @function
  * Binds a method to a particular scope ignoring any new arguments passed
  * into the function. This is useful if you want to force particular arguments and
  * ignore any new ones
  * @static
  * @memberOf comb
  * @param {Object} scope the scope to bind the callback to
  * @param {String|Function} method the method to callback
  * @param [args] optional args to pass to the callback
  *
  * @returns {Function} the hitched function
  */
1exports.bindIgnore = hitchIgnore;
 
 
1function hitchAll(scope, methods) {
3    var funcs = Array.prototype.slice.call(arguments).slice(1);
3    if (!isObject(scope)) {
0        throw new TypeError("scope must be an object");
     }
3    if (funcs.length === 1 && isArray(funcs[0])) {
1        funcs = funcs[0];
     }
3    if (!funcs.length) {
1        funcs = Object.keys(scope).filter(function (k) {
6            return isFunction(scope[k]);
         });
     }
3    for (var i = 0, l = funcs.length; i < l; i++) {
6        scope[funcs[i]] = hitch(scope, scope[funcs[i]]);
     }
3    return object;
 }
 
1exports.hitchAll = hitchAll;
1exports.bindAll = hitchAll;
 
 
 /**
  * Allows the passing of additional arguments to a function when it is called
  * especially useful for callbacks that you want to provide additional parameters to
  *
  * @static
  * @memberOf comb
  * @param {String|Function} method the method to callback
  * @param {Anything} [args] variable number of arguments to pass
  *
  * @returns {Function} partially hitched function
  */
1function partial(method, args) {
8416    args = Array.prototype.slice.call(arguments).slice(1);
8416    if (!isString(method) && !isFunction(method)) {
2        throw new Error(method + " must be the name of a property or function to execute");
     }
8414    if (isString(method)) {
4        return function () {
4            var func = this[method];
4            if (isFunction(func)) {
2                var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
2                return func.apply(this, scopeArgs);
             } else {
2                return func;
             }
         };
     } else {
8410        return function () {
1697            var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
1697            return method.apply(this, scopeArgs);
         };
     }
 }
1;
 
1function curryFunc(f, execute) {
28    return function (arg) {
28        var args = Array.prototype.slice.call(arguments);
28        return execute ? f.apply(this, arguments) : function (arg) {
21            return f.apply(this, args.concat(Array.prototype.slice.call(arguments)));
         };
     };
 }
 
 /**
  * Curries a function
  * @example
  * var curried = comb.curry(4, function(a,b,c,d){
  *     return [a,b,c,d].join(",");
  * }
  *  curried("a");
  *  curried("b");
  *  curried("c");
  *  curried("d") => "a,b,c,d"
  *
  *  //OR
  *
  *  curried("a")("b")("c")("d") => "a,b,c,d"
  *
  * @static
  * @memberOf comb
  * @param {Number} depth the number of args you expect
  * @param {Function} cb the function to call once all args are gathered
  * @param {Object} [scope] what scope to call the function in
  *
  * @returns {Function} the curried version of the function
  * */
1function curry(depth, cb, scope) {
7    var f;
7    if (scope) {
5        f = hitch(scope, cb);
     } else {
2        f = cb;
     }
7    if (depth) {
7        var len = depth - 1;
7        for (var i = len; i >= 0; i--) {
28            f = curryFunc(f, i === len);
         }
     }
7    return f;
 }
 
1exports.isFunction = isFunction;
1exports.hitch = hitch;
1exports.hitchIgnore = hitchIgnore;
1exports.partial = partial;
1exports.applyFirst = applyFirst;
1exports.bindFirst = applyFirst;
1exports.curry = curry;
 

1var os = require("os"),
     define = require("../define.js"),
     base = require("../base"),
     isString = base.isString,
     merge = base.merge,
     isUndefinedOrNull = base.isUndefinedOrNull,
     isHash = base.isHash,
     isInstanceOf = base.isInstanceOf,
     argsToArray = base.argsToArray,
     format = base.string.format,
     Level = require("./level"),
     appenders = require("./appenders"),
     Appender = appenders.Appender,
     configurators = require("./config");
1var rootTree;
1var LoggerTree = define.define(null, {
     instance: {
 
         constructor: function (root) {
14            this.__root = root;
14            this.__name = root.name;
14            this.__level = root.level;
14            this.__parent = root._parent;
14            this.__map = {};
         },
 
         __getSubLoggers: function () {
6            var map = this.__map, ret = [], n;
6            for (var i in map) {
2                n = map[i];
2                if (n) {
2                    ret = ret.concat(n.tree.getCurrentLoggers());
                 }
             }
6            return ret;
         },
 
         __getLoggers: function () {
4            return [this.__root].concat(this.__getSubLoggers())
         },
 
         getCurrentLoggers: function () {
4            return this.__getLoggers();
         },
 
         getSubLoggers: function () {
2            return this.__getSubLoggers();
         },
 
         getLogger: function (name) {
31            var ret;
31            if (name) {
29                var parts = name.split(".");
29                if (parts.length) {
29                    var category = parts.shift();
29                    var lNode = this.__map[category];
29                    if (!lNode) {
13                        lNode = this.__map[category] = new Logger(category, this);
13                        lNode.addAppenders(this.__root.appenders);
                     }
29                    ret = lNode;
29                    if (parts.length) {
                         //keep searching
10                        name = parts.join(".");
10                        ret = lNode.tree.getLogger(name);
                     }
                 }
             } else {
2                ret = this.__root;
             }
31            return ret;
         },
 
         getRootLogger: function () {
11            return this.__root;
         },
 
         isDisabled: function (level) {
         },
 
         resetConfiguration: function () {
         },
 
         /**
          * level = string|Level
          */
 
         addAppender: function (appender) {
63            var map = this.__map;
63            for (var i in map) {
41                map[i].addAppender(appender);
             }
         },
 
         removeAppender: function (name) {
46            var map = this.__map;
46            for (var i in map) {
39                map[i].removeAppender(name);
             }
         },
 
         setters: {
             level: function (level) {
45                this.__level = level;
45                if (level && level instanceof Level) {
45                    var map = this.__map;
45                    for (var i in map) {
2                        map[i].level = level;
                     }
 
                 }
             }
 
         },
 
         getters: {
             categories: function () {
2                return this.getCurrentLoggers().map(function (l) {
3                    return l.fullName;
                 });
             },
 
             name: function () {
35                var ret = this.__name;
35                if (this.__parent) {
21                    var pName = this.__parent.name;
21                    if (pName) {
8                        ret = pName + "." + ret;
                     }
                 }
35                return ret;
             },
 
             level: function () {
13                return this.__level;
             },
 
             additive: function () {
13                return this.__root.additive;
             }
         }
     }
 });
 
1var comb = exports;
 /**
  * @ignore
  * @namespace logging package*/
1comb.logging = merge({
     Level: Level
 }, configurators);
 /**
  * @ignore
  * @namespace appenders for logging*/
1comb.logging.appenders = appenders;
 
1var logging = comb.logging, hasGetGid = process.hasOwnProperty("getgid");
 
 /**
  * @class This class is the entry point for all logging actions in comb.
  * <p><b>Logger should be retrieved by calling Logger.getLogger() NOT through the new keyword</b><p>
  * <p>
  *     All loggers in comb follow a heirarchy of inheritance based on a dot notation.
  *     <pre class="code">
  *                          rootLogger - ""
  *                                  /         \
  *                               "my"      "myOther"
  *                               /               \
  *                         "my.logger"       "myOther.logger"
  *                            /                     \
  *                       "my.logger.Log"        "myOther.logger.Log"
  *
  *     </pre>
  *     In the above Tree the rootLogger is the base for all logger. my and myOther inherit from rootLogger
  *     my.logger inherits from my, and myOther.logger inherits from myOther. The logs do not have to be retrieved in
  *     order. If I set rootLogger to ERROR level and added a console appender to it the appender and level will be
  *     added to all logs. However if I set my to INFO level and add a fileAppender to it the level and appender will
  *     only be added to logs in "my" subtree. If you set my.logger to not be additive then levels, and appenders will not
  *     propogate down to the rest of the tree.
  *
  * </p>
  *
  * <p>For information on levels see {@link comb.logging.Level}.</p>
  * <p>For information on appenders see
  *          <ul>
  *              <li>{@link comb.logging.appenders.Appender}</li>
  *              <li>{@link comb.logging.appenders.ConsoleAppender}</li>
  *              <li>{@link comb.logging.appenders.FileAppender}</li>
  *              <li>{@link comb.logging.appenders.JSONAppender}</li>
  *              <li>{@link comb.logging.appenders.RollingFileAppender}</li>
  *          </ul>
  * </p>
  * <p>For information on configurators see {@link comb.logging.BasicConfigurator} or {@link comb.logging.PropertyConfigurator}.</p>
  *
  * @example
  *
  * var logger = comb.logger;
  *
  * //configure you logging environement
  * logger.configure();
  *
  * //add a file appender to all loggers
  * logger.configure(logger.appender("FileAppender", {file : "/var/log/myLog.log"});
  *
  * //Retreiving a logger.
  * var combLogger = logger("comb");
  * var combCollectionLogger = logger("comb.collections");
  * var treeLogger = logger("comb.collections.Tree")
  *                      //add a JSON appender to tree logger just for fun!
  *                      .addAppender("JSONAppender", {file : "/var/log/myTreeLogger.json"})
  *
  * //set my treeLogger to DEBUG Level
  * treeLogger.level = "DEBUG";
  *
  *
  * @name Logger
  * @memberOf comb.logging
  *
  * @property {Array<comb.logging.Logger>} subLoggers all loggers this logger is the parent of.
  * @property {comb.logging.Level} level the level of this Logger
  * @property {Boolean} additive set to false to prevent changes to this logger from propogating down.
  * @property {Boolean} isDebug true if this Loggers level is DEBUG
  * @property {Boolean} isTrace true if this Loggers level is TRACE
  * @property {Boolean} isInfo true if this Loggers level is INFO
  * @property {Boolean} isWarn true if this Loggers level is WARN
  * @property {Boolean} isError true if this Loggers level is ERROR
  * @property {Boolean} isFatal true if this Loggers level is FATAL
  * @property {Boolean} isOff true if this Loggers level is OFF
  * @property {String} name the name of this logger this <b>does not</b> include the dot notated name
  * @property {String} fullName the full path name of this Logger.
  * @property {comb.logging.appenders.Appender} appenders list of appenders this logger currently contains.
  * @ignoreCode
  */
1var Logger = (logging.Logger = define.define(null, {
 
     instance: {
         /**@lends comb.logging.Logger.prototype*/
 
         constructor: function (name, parent) {
14            this.__additive = true;
14            this.__name = name;
14            this._parent = parent;
14            this._tree = new LoggerTree(this);
14            this.fullName = this._tree.name;
14            if (!parent || !parent.additive) {
1                this.level = Level.ALL;
             } else {
13                this.level = parent.level;
             }
14            this.__appenders = {};
         },
 
         /**
          * Log an info level message
          *
          * @param {String} message the message to log.
          *
          * @return {comb.logging.Logger} for chaining.
          */
         info: function (message) {
17            return this.log.apply(this, [Level.INFO].concat(argsToArray(arguments)));
         },
 
         /**
          * Log an debug level message
          *
          * @param {String} message the message to log.
          *
          * @return {comb.logging.Logger} for chaining.
          */
         debug: function (message) {
14            return this.log.apply(this, [Level.DEBUG].concat(argsToArray(arguments)));
         },
 
         /**
          * Log an error level message
          *
          * @param {String} message the message to log.
          *
          * @return {comb.logging.Logger} for chaining.
          */
         error: function (message) {
14            return this.log.apply(this, [Level.ERROR].concat(argsToArray(arguments)));
         },
 
         /**
          * Log an warn level message
          *
          * @param {String} message the message to log.
          *
          * @return {comb.logging.Logger} for chaining.
          */
         warn: function (message) {
14            return this.log.apply(this, [Level.WARN].concat(argsToArray(arguments)));
         },
 
         /**
          * Log an trace level message
          *
          * @param {String} message the message to log.
          *
          * @return {comb.logging.Logger} for chaining.
          */
         trace: function (message) {
14            return this.log.apply(this, [Level.TRACE].concat(argsToArray(arguments)));
         },
 
         /**
          * Log an fatal level message
          *
          * @param {String} message the message to log.
          *
          * @return {comb.logging.Logger} for chaining.
          */
         fatal: function (message) {
14            return this.log.apply(this, [Level.FATAL].concat(argsToArray(arguments)));
         },
 
         /**
          * Creates a log event to be passed to appenders
          *
          * @param {comb.logging.Level} level the level of the logging event
          * @param {String} message the message to be logged
          * @return {Object} the logging event
          */
         getLogEvent: function getLogEvent(level, message) {
64            return {
                 hostname: os.hostname(),
                 pid: process.pid,
                 gid: hasGetGid ? process.getgid() : null,
                 processTitle: process.title,
                 level: level,
                 levelName: level.name,
                 message: message,
                 timeStamp: new Date(),
                 name: this.fullName
             };
         },
 
         /**
          * Log a message
          *
          * @param {comb.logging.Level} level the level the message is
          * @param {String} message the message to log.
          *
          * @return {comb.logging.Logger} for chaining.
          */
         log: function (level, message) {
93            var args = argsToArray(arguments, 1);
93            level = Level.toLevel(level);
93            if (args.length > 1) {
18                message = format.apply(null, args);
             }
93            if (level.isGreaterOrEqualToo(this.level)) {
63                if (Level.TRACE.equals(level)) {
10                    var err = new Error;
10                    err.name = "Trace";
10                    err.message = message || '';
10                    Error.captureStackTrace(err, arguments.callee);
10                    message = err.stack;
53                } else if (Level.ERROR.equals(level) && isInstanceOf(message, Error)) {
0                    message = message.stack;
                 }
63                var type = level.name.toLowerCase(), appenders = this.__appenders;
63                var event = this.getLogEvent(level, message);
63                Object.keys(appenders).forEach(function (i) {
63                    appenders[i].append(event);
                 });
             }
93            return this;
         },
 
         /**
          * Add an appender to this logger. If this is additive then the appender is added to all subloggers.
          *
          * @example
          * comb.logger("my.logger")
          *  .addAppender("ConsoleAppender")
          *  .addAppender("FileAppender", {file:'/var/log/my.log'})
          *  .addAppender("RollingFileAppender", {file:'/var/log/myRolling.log'})
          *  .addAppender("JSONAppender", {file:'/var/log/myJson.log'});
          *
          * @param {comb.logging.Appender|String} If the appender is an {@link comb.logging.appenders.Appender} then it is added.
          * If the appender is a string then {@link comb.logging.appenders.Appender.createAppender} will be called to create it.
          *
          * @param {Object} [opts = null] If the first argument is a string then the opts will be used as constructor arguments for
          * creating the appender.
          *
          * @return {comb.logging.Logger} for chaining.
          */
         addAppender: function (appender, opts) {
82            var args = argsToArray(arguments);
82            if (isString(appender)) {
12                this.addAppender(Appender.createAppender(appender, opts));
             } else {
70                if (!isUndefinedOrNull(appender)) {
 
70                    var name = appender.name;
70                    if (!(name in this.__appenders)) {
63                        this.__appenders[name] = appender;
63                        if (!appender.level) {
15                            appender.level = this.level;
                         }
63                        this._tree.addAppender(appender);
                     }
                 }
             }
82            return this;
         },
 
         /**
          * Short cut to add a list of appenders to this Logger
          * @param {Array<comb.logging.Appender>} appenders
          *
          * @return {comb.logging.Logger} for chaining.
          */
         addAppenders: function (appenders) {
14            appenders.forEach(this.addAppender.bind(this));
14            return this;
         },
 
         /**
          * Removes and appender from this logger.
          * @param {String} name the name of the appender
          * @return {comb.logging.Logger} for chaining.
          */
         removeAppender: function (name) {
46            if (name in this.__appenders) {
46                delete this.__appenders[name];
46                this._tree.removeAppender(name);
             }
46            return this;
         },
 
         /**
          * Removes a list of appenders from this logger.
          *
          * @param {String[]} appenders a list of names of appenders to remove
          * @return {comb.logging.Logger} for chaining.
          */
         removeAppenders: function (appenders) {
1            appenders.forEach(this.removeAppender, this);
1            return this;
         },
 
         /**
          * Removes all appenders from this logger and sub loggers if this Logger is additive.
          *
          * @return {comb.logging.Logger} for chaining.
          */
         removeAllAppenders: function () {
13            Object.keys(this.__appenders).forEach(this.removeAppender.bind(this));
13            return this;
         },
 
         /**
          * Determines if an appender is attached.
          *
          * @param {String} name the name of the appender.
          */
         isAppenderAttached: function (name) {
38            return (name in this.__appenders);
         },
 
         /**
          * Gets an appender from this logger
          *
          * @param {String} name the name of the appender.
          *
          * @return {comb.logging.Appender|undefined} returns the appender with the specified name or
          *                                          undefined if it is not found.
          */
         getAppender: function (name) {
8            var ret;
8            if (name in this.__appenders) {
8                ret = this.__appenders[name];
             }
8            return ret;
         },
 
         /**
          * @ignore
          * */
         setters: {
 
             level: function (level) {
46                level = Level.toLevel(level);
46                if (this.__additive) {
45                    this.__level = level;
45                    var appenders = this.__appenders;
45                    for (var i in appenders) {
35                        appenders[i].level = level;
                     }
45                    this._tree.level = level;
                 } else {
1                    this.__level = level;
                 }
             },
 
             additive: function (additive) {
2                this.__additive = additive;
             }
         },
 
         /**@ignore*/
         getters: {
             /**@ignore*/
 
             /**@ignore*/
             subLoggers: function () {
2                return this._tree.getSubLoggers();
             },
 
             /**@ignore*/
             level: function () {
199                return this.__level;
             },
 
             /**@ignore*/
             additive: function () {
15                return this.__additive;
             },
 
             isAll: function () {
8                return Level.ALL.isGreaterOrEqualToo(this.level);
             },
 
             /**@ignore*/
             isDebug: function () {
8                return Level.DEBUG.isGreaterOrEqualToo(this.level);
             },
 
             /**@ignore*/
             isTrace: function () {
8                return Level.TRACE.isGreaterOrEqualToo(this.level);
             },
 
             /**@ignore*/
             isInfo: function () {
8                return Level.INFO.isGreaterOrEqualToo(this.level);
             },
 
             /**@ignore*/
             isWarn: function () {
8                return Level.WARN.isGreaterOrEqualToo(this.level);
             },
 
             /**@ignore*/
             isError: function () {
8                return Level.ERROR.isGreaterOrEqualToo(this.level);
             },
 
             /**@ignore*/
             isFatal: function () {
8                return Level.FATAL.isGreaterOrEqualToo(this.level);
             },
 
             /**@ignore*/
             isOff: function () {
9                return Level.OFF.equals(this.level);
             },
 
             /**@ignore*/
             name: function () {
14                return this.__name;
             },
 
             /**@ignore*/
             tree: function () {
13                return this._tree;
             },
 
             /**@ignore*/
             appenders: function () {
18                var ret = [];
18                for (var i in this.__appenders) {
8                    ret.push(this.__appenders[i]);
                 }
18                return ret;
             },
 
             categories: function () {
2                return this._tree.categories;
             }
         }
     },
 
     static: {
         /**@lends comb.logging.Logger*/
 
         /**
          * Return the root of all loggers
          */
         getRootLogger: function () {
11            return rootTree.getRootLogger();
         },
 
         /**
          * Retrieves/Creates a logger based on the name passed in
          *
          * @param {String} name the name of the logger
          */
         getLogger: function (name) {
21            return rootTree.getLogger(name);
         }
     }
 }));
 
 /**
  *
  * @function
  * @description Alias to {@link comb.logging.Logger.getLogger}.  See {@link comb.logging.Logger} for more information.
  *
  * @example
  *
  * comb.logger("my.logger");
  *
  * @memberOf comb
  * @namespace
  */
1exports.logger = Logger.getLogger.bind(Logger);
 
 /**
  * @function
  * @description Shortcut to configure loggers.
  *
  * @example
  *
  * //same as new comb.logging.BasicConfigurator().configure();
  * comb.logger.configure();
  *
  * //new comb.logging.PropertyConfigurator().configure("/location/to/logger/configuration.json");
  * comb.logger.configure("/location/to/logger/configuration.json");
  *
  * @memberOf comb.logger
  */
1exports.logger.configure = function configure() {
4    var args = argsToArray(arguments), configurator;
4    if (!args.length) {
1        configurator = new configurators.BasicConfigurator();
     } else {
3        var first = args[0];
3        if (isHash(first) || isString(first)) {
2            configurator = new configurators.PropertyConfigurator();
         } else {
1            configurator = new configurators.BasicConfigurator();
         }
     }
4    configurator.configure.apply(configurator, args);
4    return this;
 };
 
 /**
  * @function
  * @description Factory method for creating appenders. See {@link comb.logging.appenders.Appender.createAppender} for
  * arguments.
  *
  * @example
  *
  * var appender = comb.logger.appender("ConsoleAppender");
  * comb.logger("my.logger").addAppender(appender);
  *
  * @memberOf comb.logger
  *
  */
1exports.logger.appender = Appender.createAppender.bind(Appender);
 
1var rootLogger = new Logger("");
1rootTree = rootLogger._tree;
 
 /**
  * The root for all loggers.
  * @memberOf comb.logger
  * @type comb.logging.Logger
  */
1exports.logger.rootLogger = rootLogger;
 
 

1var hitch = require("./base/functions").hitch,
     define = require("./define").define,
     base = require("./base"),
     argsToArray = base.argsToArray,
     array = base.array,
     forEach = array.forEach,
     zip = array.zip,
     flatten = array.flatten,
     isUndefinedOrNull = base.isUndefinedOrNull,
     isArray = base.isArray,
     isFunction = base.isFunction,
     bindIgnore = base.bindIgnore,
     isInstanceOf = base.isInstanceOf,
     nextTick = setImmediate;
 
 
1var Promise = define(null, {
     instance: {
         /** @lends comb.Promise.prototype */
         __fired: false,
 
         __results: null,
 
         __error: null,
 
         __errorCbs: null,
 
         __cbs: null,
 
         /**
          * Promise object used to provide seperation of success and error resolution paths for async operations.
          *
          * @example
          * var myFunc = function(){
          *     var promise = new Promise();
          *     //callback the promise after 10 Secs
          *     setTimeout(hitch(promise, "callback"), 10000);
          *     return promise.promise();
          * }
          * var myFunc2 = function(){
          *     var promises =[];
          *     for(var i = 0; i < 10; i++){
          *         promises.push(myFunc);
          *     }
          *     //create a new promise list with all 10 promises
          *     return new PromiseList(promises).promise();
          * }
          *
          * myFunc.then(function(success){}, function(error){})
          * //chain promise operations
          * myFunc.chain(myfunc).then(function(success){}, function(error){})
          *
          * myFunc2.then(function(success){}, function(error){})
          * //chain promise operations
          * myFunc2.chain(myfunc).then(function(success){}, function(error){})
          * @constructs
          */
         constructor: function () {
2821            this.__errorCbs = [];
2821            this.__cbs = [];
         },
         /**
          * @private
          */
         __resolve: function () {
2667            if (!this.__fired) {
2667                this.__fired = true;
2667                var cbs = this.__error ? this.__errorCbs : this.__cbs,
                     len = cbs.length, i,
                     results = this.__error || this.__results;
2667                for (i = 0; i < len; i++) {
2245                    this.__callNextTick(cbs[i], results);
                 }
             }
         },
 
         __callNextTick: function (cb, results) {
3318            nextTick(hitch(this, function () {
3318                cb.apply(this, results);
3318                results = null;
             }));
         },
 
         /**
          * Add a callback to the callback chain of the promise
          *
          *
          * @param {Function|comb.Promise} cb the function or promise to callback when the promise is resolved.
          *
          * @return {comb.Promise} this promise for chaining
          */
         addCallback: function (cb) {
3339            if (cb) {
3339                if (exports.isPromiseLike(cb)) {
159                    cb = hitch(cb, "callback");
                 }
3339                if (this.__fired && this.__results) {
1059                    this.__callNextTick(cb, this.__results);
                 } else {
2280                    this.__cbs.push(cb);
                 }
             }
3339            return this;
         },
 
 
         /**
          * Add a callback to the errback chain of the promise
          *
          * @param {Function|comb.Promise} cb the function or promise to callback when the promise errors
          *
          * @return {comb.Promise} this promise for chaining
          */
         addErrback: function (cb) {
3221            if (cb) {
3215                if (exports.isPromiseLike(cb)) {
157                    cb = hitch(cb, "errback");
                 }
3215                if (this.__fired && this.__error) {
14                    this.__callNextTick(cb, this.__error);
                 } else {
3201                    this.__errorCbs.push(cb);
                 }
             }
3221            return this;
         },
 
         /**
          *
          * Adds a callback or promise to be resolved for both success
          * and error.
          *
          * @param {Function|comb.Promise} cb callback or promise to be resolved for both success
          * and error.
          * @return {comb.Promise} this promise for chaining
          */
         both: function (cb) {
580            this.addCallback(cb);
580            if (exports.isPromiseLike(cb)) {
2                this.addErrback(hitch(cb, "callback"));
             } else {
578                this.addErrback(cb);
             }
 
580            return this;
         },
 
         /**
          * When called all functions registered as callbacks are called with the passed in results.
          *
          * @param {*} args variable number of results to pass back to listeners of the promise
          */
         callback: function (args) {
2514            args = argsToArray(arguments);
2514            if (this.__fired) {
1                throw new Error("Already fired!");
             }
2513            this.__results = args;
2513            this.__resolve();
2513            return this.promise();
         },
 
 
         /**
          * When called all functions registered as errbacks are called with the passed in error(s)
          *
          * @param {*} args  number of errors to pass back to listeners of the promise
          */
         errback: function (args) {
155            if (this.__fired) {
1                throw args || new Error("Already fired");
             }
154            this.__error = argsToArray(arguments);
154            this.__resolve();
154            return this.promise();
         },
 
         /**
          * Resolved a promise using the node style callback.
          *
          * @example
          *
          * var promise = new Promise();
          * fs.readFile("file.txt", "utf8", promise.resolve.bind(promise));
          * promise.then(function(file){
          *     console.log(file);
          * });
          *
          * @param {Error} [err=null] If specified then the promise will error out
          * @param {...} [args] if err is null then the aruments will be used to resolve the promise.
          *
          * @return {comb.Promise} for chaining.
          */
         resolve: function (err, args) {
4            if (err) {
1                this.errback(err);
             } else {
3                this.callback.apply(this, argsToArray(arguments, 1));
             }
4            return this;
         },
 
         /**
          * Call to specify action to take after promise completes or errors
          *
          * @param {Function} [callback=null] function to call after the promise completes successfully
          * @param {Function} [errback=null] function to call if the promise errors
          *
          * @return {comb.Promise} this promise for chaining
          */
         then: function (callback, errback) {
1415            if (exports.isPromiseLike(callback)) {
157                this.addCallback(callback);
157                this.addErrback(callback);
             } else {
1258                this.addCallback(callback);
1258                this.addErrback(errback);
             }
1415            return this;
         },
 
         /**
          * Call this function as a classic node callback where the first argument
          * will be an error, or null if no error occured. The other arugments will
          * be the result from the promise.
          *
          * @example
          *
          * promise.classic(function(err, res){
          *      if(err){
          *          console.log(err);
          *      }else{
          *          console.log(res);
          *      }
          * });
          *
          * @param cb callback where the first argument
          * will be an error, or null if no error occured. The other arugments will
          * be the result from the promise.
          * @return {comb.Promise} the promise to chain
          */
         classic: function (cb) {
5            if ("function" === typeof cb) {
5                this.addErrback(function (err) {
1                    cb(err);
                 });
5                this.addCallback(function () {
4                    cb.apply(this, [null].concat(argsToArray(arguments)));
                 });
             }
5            return this;
         },
 
         /**
          * Call to chaining of promises
          *
          * ```
          * new Promise()
          *  .callback("hello")
          *  .chain(function(previousPromiseResults){
          *      return previousPromiseResults + " world";
          * }, errorHandler)
          *  .chain(function(previousPromiseResults){
          *    return when(dbCall());
          *  }).classic(function(err, results){
          *      //all promises are done
          *  });
          *
          *  ```
          *
          *  You can also use static values
          *
          *  ```
          * new Promise().callback()
          *     .chain("hello")
          *     .chain(function(prev){
          *         return prev + " world!"
          *     }).then(function(str){
          *         console.log(str); //"hello world!"
          *     });
          * ```
          *
          * If you do not provide an `errback` for each chain then it will be propogated to the final promise
          *
          *
          * ```
          * new Promise()
          *     .chain(function(){
          *         return new comb.Promise().errback(new Error("error"));
          *     })
          *     .chain(function(){
          *         return prev + " world!"
          *     })
          *     .classic(function(err, str){
          *         console.log(err.message); //"error"
          *     });
          * ```
          *
          *
          * @param callback method to call this one completes. If you return a promise the execution will delay until the returned promise has resolved.
          * @param [errback=null] method to call if this promise errors. If errback is not specified then the returned promises
          * errback method will be used.
          *
          * @return {comb.Promise} A new that wraps the promise for chaining
          */
         chain: function (callback, errback) {
 
582            var promise = new Promise();
 
582            function errorHandler() {
84                var args = arguments;
84                if (errback) {
5                    nextTick(function () {
5                        try {
5                            when(isFunction(errback) ? errback.apply(this, args) : errback).then(promise);
                         } catch (e) {
1                            promise.errback(e);
                         }
5                        promise = args = null;
                     });
                 } else {
79                    promise.errback.apply(promise, args);
79                    promise = args = null;
                 }
             }
 
582            this.addCallback(function () {
531                var args = arguments;
531                nextTick(function () {
531                    try {
531                        when(isFunction(callback) ? callback.apply(this, args) : callback).then(function () {
498                            promise.callback.apply(promise, arguments);
498                            promise = args = null;
                         }, errorHandler);
                     } catch (e) {
4                        errorHandler(e);
                     }
                 });
             });
 
             // If no errback passed, then invoke our promise's errback to pass
             // on to next link in the chain.
582            this.addErrback(errorHandler);
582            return promise.promise();
         },
 
         /**
          * Applies the same function that returns a promise to both the callback and errback.
          *
          * @param {Function} callback function to call. This function must return a Promise
          *
          * @return {comb.Promise} a promise to continue chaining or to resolve with.
          *
          */
         chainBoth: function (callback) {
10            var promise = new Promise();
10            this.addCallback(function () {
5                try {
5                    when(isFunction(callback) ? callback.apply(this, arguments) : callback).then(promise);
                 } catch (e) {
1                    promise.errback(e);
                 }
             });
 
10            this.addErrback(function () {
5                try {
5                    when(isFunction(callback) ? callback.apply(this, arguments) : callback).then(promise);
                 } catch (e) {
1                    promise.errback(e);
                 }
             });
10            return promise.promise();
         },
 
         /**
          * Creates an object to that contains methods to listen to resolution but not the "callback" or "errback" methods.
          *
          * @example
          *
          * var asyncMethod = function(){
          *     var ret = new comb.Promise();
          *     process.nextTick(ret.callback.bind(ret, "hello"));
          *     return ret.promise();
          * }
          *
          * asyncMethod().callback() //throws error
          *
          * @return {Object} an object containing "chain", "chainBoth", "promise", "addCallback", "addErrback", "then", "both".
          */
         promise: function () {
4577            var ret = {
                 chain: this.chain.bind(this),
                 chainBoth: this.chainBoth.bind(this),
                 promise: function () {
1173                    return ret;
                 }
             };
4577            forEach(["addCallback", "addErrback", "then", "both", "classic"], function (action) {
22885                ret[action] = function () {
1830                    this[action].apply(this, arguments);
1830                    return ret;
                 }.bind(this);
             }, this);
 
4577            return ret;
         }
 
 
     }
 });
 
 
1var PromiseList = define(Promise, {
     instance: {
         /** @lends comb.PromiseList.prototype */
 
         /*@private*/
         __results: null,
 
         /*@private*/
         __errors: null,
 
         /*@private*/
         __promiseLength: 0,
 
         /*@private*/
         __defLength: 0,
 
         /*@private*/
         __firedLength: 0,
 
         normalizeResults: false,
 
         /**
          * PromiseList object used for handling a list of Promises
          *
          * @example
          * var myFunc = function(){
          *     var promise = new Promise();
          *     //callback the promise after 10 Secs
          *     setTimeout(hitch(promise, "callback"), 10000);
          *     return promise.promise();
          * }
          * var myFunc2 = function(){
          *     var promises =[];
          *     for(var i = 0; i < 10; i++){
          *         promises.push(myFunc);
          *     }
          *     //create a new promise list with all 10 promises
          *     return new PromiseList(promises).promise();
          * }
          *
          * myFunc.then(function(success){}, function(error){})
          * //chain promise operations
          * myFunc.chain(myfunc).then(function(success){}, function(error){})
          *
          * myFunc2.then(function(success){}, function(error){})
          * //chain promise operations
          * myFunc2.chain(myfunc).then(function(success){}, function(error){})
          *
          *  @param {comb.Promise[]} [defs=[]] the list of promises
          * @constructs
          * @augments comb.Promise
          * @memberOf comb
          * */
         constructor: function (defs, normalizeResults) {
142            this.__errors = [];
142            this.__results = [];
142            this.normalizeResults = base.isBoolean(normalizeResults) ? normalizeResults : false;
142            this._super(arguments);
142            if (defs && defs.length) {
135                this.__defLength = defs.length;
135                forEach(defs, this.__addPromise, this);
             } else {
7                this.__resolve();
             }
         },
 
         /**
          * Add a promise to our chain
          * @private
          * @param promise the promise to add to our chain
          * @param i the index of the promise in our chain
          */
         __addPromise: function (promise, i) {
757            promise.addCallback(hitch(this, function () {
742                var args = argsToArray(arguments);
742                args.unshift(i);
742                this.callback.apply(this, args);
             }));
757            promise.addErrback(hitch(this, function () {
15                var args = argsToArray(arguments);
15                args.unshift(i);
15                this.errback.apply(this, args);
             }));
         },
 
         /**
          * Resolves the promise
          * @private
          */
         __resolve: function () {
142            if (!this.__fired) {
142                this.__fired = true;
142                var cbs = this.__errors.length ? this.__errorCbs : this.__cbs,
                     len = cbs.length, i,
                     results = this.__errors.length ? this.__errors : this.__results;
142                for (i = 0; i < len; i++) {
136                    this.__callNextTick(cbs[i], results);
                 }
             }
         },
 
         __callNextTick: function (cb, results) {
145            nextTick(hitch(this, function () {
145                cb.apply(this, [results]);
             }));
         },
 
         addCallback: function (cb) {
145            if (cb) {
145                if (exports.isPromiseLike(cb)) {
1                    cb = hitch(cb, "callback");
                 }
145                if (this.__fired && !this.__errors.length) {
9                    this.__callNextTick(cb, this.__results);
                 } else {
136                    this.__cbs.push(cb);
                 }
             }
145            return this;
         },
 
         addErrback: function (cb) {
143            if (cb) {
143                if (exports.isPromiseLike(cb)) {
1                    cb = hitch(cb, "errback");
                 }
143                if (this.__fired && this.__errors.length) {
0                    this.__callNextTick(cb, this.__errors);
                 } else {
143                    this.__errorCbs.push(cb);
                 }
             }
143            return this;
         },
 
 
         callback: function (i) {
743            if (this.__fired) {
1                throw new Error("Already fired!");
             }
742            var args = argsToArray(arguments);
742            if (this.normalizeResults) {
725                args = args.slice(1);
725                args = args.length == 1 ? args.pop() : args;
             }
742            this.__results[i] = args;
742            this.__firedLength++;
742            if (this.__firedLength == this.__defLength) {
130                this.__resolve();
             }
742            return this.promise();
         },
 
 
         errback: function (i) {
16            if (this.__fired) {
1                throw new Error("Already fired!");
             }
15            var args = argsToArray(arguments);
15            if (this.normalizeResults) {
14                args = args.slice(1);
14                args = args.length == 1 ? args.pop() : args;
             }
15            this.__errors[i] = args;
15            this.__firedLength++;
15            if (this.__firedLength == this.__defLength) {
5                this.__resolve();
             }
15            return this.promise();
         }
 
     }
 });
 
 
 /**
  * Creates the promise chain
  * @ignore
  * @private
  */
1function callNext(list, results, propogate) {
59    var ret = new Promise().callback();
59    forEach(list, function (listItem) {
156        ret = ret.chain(propogate ? listItem : bindIgnore(null, listItem));
156        if (!propogate) {
112            ret.addCallback(function (res) {
89                results.push(res);
89                res = null;
             });
         }
     });
59    return propogate ? ret.promise() : ret.chain(results);
 }
 
 /**
  * Tests if an object is like a promise (i.e. it contains then, addCallback, addErrback)
  * @param obj object to test
  * @function
  * @static
  * @memberOf comb
  */
1function isPromiseLike(obj) {
11670    return !isUndefinedOrNull(obj) && (isInstanceOf(obj, Promise) || (isFunction(obj.then)
         && isFunction(obj.addCallback) && isFunction(obj.addErrback)));
 }
 
 /**
  * Waits for promise and non promise values to resolve and fires callback or errback appropriately. If you pass in an array of promises
  * then it will wait for all promises in the list to resolve.
  *
  * @example
  *  var a = "hello";
  *  var b = new comb.Promise().callback(world);
  *  comb.when(a, b) => called back with ["hello", "world"];
  *
  * @param {Anything...} args variable number of arguments to wait for.
  * @param {Function} cb the callback function
  * @param {Function} eb the errback function
  * @returns {comb.Promise} a promise that is fired when all values have resolved
  * @static
  * @memberOf comb
  */
1function when(args, cb, eb) {
1895    var args = argsToArray(arguments), p;
1895    eb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
1895    cb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
1895    if (eb && !cb) {
9        cb = eb;
9        eb = null;
     }
1895    if (!args.length) {
7        p = new Promise().callback(args);
1888    } else if (args.length == 1) {
1848        args = args.pop();
1848        if (isPromiseLike(args)) {
848            p = args;
1000        } else if (isArray(args) && array.every(args, isPromiseLike)) {
91            p = new PromiseList(args, true);
         } else {
909            p = new Promise().callback(args);
         }
     } else {
40        p = new PromiseList(args.map(function (a) {
135            return exports.isPromiseLike(a) ? a : new Promise().callback(a);
         }), true);
     }
1895    if (cb) {
15        p.addCallback(cb);
     }
1895    if (eb) {
6        p.addErrback(eb);
     }
1895    return p.promise();
 
 }
 
 /**
  * Wraps traditional node style functions with a promise.
  * @example
  *
  * var fs = require("fs");
  * var readFile = comb.wrap(fs.readFile, fs);
  * readFile(__dirname + "/test.json").then(
  *      function(buffer){
  *          console.log(contents);
  *      },
  *      funciton(err){
  *
  *      }  console.error(err);
  * );
  *
  *
  * @param {Function} fn function to wrap
  * @param {Object} scope scope to call the function in
  *
  * @return {Funciton} a wrapped function
  * @static
  * @memberOf comb
  */
1function wrap(fn, scope) {
2    return function () {
2        var ret = new Promise();
2        var args = argsToArray(arguments);
2        args.push(ret.resolve.bind(ret));
2        fn.apply(scope || this, args);
2        return ret.promise();
     }
 }
 
 /**
  * Executes a list of items in a serial manner. If the list contains promises then each promise
  * will be executed in a serial manner, if the list contains non async items then the next item in the list
  * is called.
  *
  * @example
  *
  * var asyncAction = function(item, timeout){
  *    var ret = new comb.Promise();
  *    setTimeout(comb.hitchIgnore(ret, "callback", item), timeout);
  *    return ret.promise();
  * };
  *
  * comb.serial([
  *     comb.partial(asyncAction, 1, 1000),
  *     comb.partial(asyncAction, 2, 900),
  *     comb.partial(asyncAction, 3, 800),
  *     comb.partial(asyncAction, 4, 700),
  *     comb.partial(asyncAction, 5, 600),
  *     comb.partial(asyncAction, 6, 500)
  * ]).then(function(results){
  *     console.log(results); // [1,2,3,4,5,6];
  * });
  *
  *
  *
  * @param list
  * @param callback
  * @param errback
  * @static
  * @memberOf comb
  */
1function serial(list, callback, errback) {
56    if (base.isArray(list)) {
55        return callNext(list, [], false);
     } else {
1        throw new Error("When calling comb.serial the first argument must be an array");
     }
 }
 
 
 /**
  * Works just like {@link comb.Promise#chain} method, allowing you to propogate results from one funciton to another.
  * This is different than {@link comb.serial} in that it propogates results from one promise to the next, where
  * {@link comb.serial} does not.
  *
  * @example
  *
  * function asyncAction(add, timeout) {
  *      return function (num) {
  *          num = num || 0;
  *          var ret = new comb.Promise();
  *          setTimeout(function () {
  *               ret.callback(num + add);
  *          }, timeout);
  *          return ret;
  *      }
  * }
  *
  * comb.chain([
  *      asyncAction(1, 100),
  *      asyncAction(2, 100),
  *      asyncAction(3, 100),
  *      asyncAction(4, 100),
  *      asyncAction(5, 100),
  * ]).then(function(results){
  *      console.log(results); //15
  * });
  *
  * @param {function[]} list an array of function to call.
  * @return {comb.Promise} a promise that will resolve with the results of the last function in the list.
  * @static
  * @memberOf comb
  */
1function chain(list) {
5    if (base.isArray(list)) {
4        return callNext(list, [], true);
     } else {
1        throw new Error("When calling comb.serial the first argument must be an array");
     }
 }
 
 
 /**
  * Ensures that a promise is resolved before a the function can be run.
  *
  * For example suppose you have to ensure that you are connected to a database before you execute a function.
  *
  * ```
  * var findUser = comb.wait(connect(), function findUser(id){
  *      //this wont execute until we are connected
  *      return User.findById(id);
  * });
  *
  *  comb.when(findUser(1), findUser(2)).then(function(users){
  *      var user1 = users[0], user2 = users[1];
  *  });
  *
  * ```
  *
  * @param args variable number of arguments to wait on. See {@link comb.when}.
  * @param {Function} fn function that will wait.
  * @return {Function} a function that will wait on the args to resolve.
  * @memberOf comb
  * @static
  */
1function wait(args, fn) {
2    var args = argsToArray(arguments), resolved = false;
2    fn = args.pop();
2    var p = when(args);
2    return function waiter() {
3        if (!resolved) {
2            var args = arguments;
2            return p.chain(function () {
2                resolved = true;
2                p = null;
2                return fn.apply(this, args);
             }.bind(this));
         } else {
1            return when(fn.apply(this, arguments));
         }
     }
 }
 
 
1base.merge(exports, {
     isPromiseLike: isPromiseLike,
     when: when,
     wrap: wrap,
     wait: wait,
     serial: serial,
     chain: chain,
     Promise: Promise,
     PromiseList: PromiseList
 });
 
 
 
 
 
 
 
 

 /**
  * @ignoreCode
  * @name async
  * @memberOf comb
  * @namespace utilities for working with promises.
  */
 
 
1var promise = require("./promise.js"),
     when = promise.when,
     serial = promise.serial,
     PromiseList = promise.PromiseList,
     base = require("./base"),
     merge = base.merge,
     isDefined = base.isDefined,
     isNumber = base.isNumber,
     isString = base.isString,
     argsToArray = base.argsToArray,
     array = base.array,
     isArray = base.isArray,
     Promise = promise.Promise,
     isFunction = base.isFunction,
     sum = array.sum,
     avg = array.avg,
     sort = array.sort,
     min = array.min,
     max = array.max,
     map = array.map,
     forEach = array.forEach,
     difference = array.difference,
     removeDuplicates = array.removeDuplicates,
     unique = array.unique,
     rotate = array.rotate,
     permutations = array.permutations,
     zip = array.zip,
     transpose = array.transpose,
     valuesAt = array.valuesAt,
     union = array.union,
     intersect = array.intersect,
     powerSet = array.powerSet,
     cartesian = array.cartesian,
     compact = array.compact,
     multiply = array.multiply,
     flatten = array.flatten,
     invoke = array.invoke,
     nextTick = setImmediate;
 
1function _loopResults(cb, scope, results, index, offset, limit) {
79    return function () {
79        return when(results.slice(offset, limit + offset).map(function (r, i) {
574            var ret = new Promise();
574            nextTick(function () {
574                try {
574                    when(cb.apply(scope || results, [r, i + offset, results])).then(function () {
564                        ret.callback.apply(ret, arguments);
                     }, function () {
5                        ret.errback.apply(ret, arguments);
                     });
                 } catch (e) {
5                    ret.errback(e);
                 }
             });
574            ret.both(function () {
574                cb = scope = results = index = offset = limit = null;
             })
574            return ret;
         }));
     };
 }
 
1function asyncLoop(promise, cb, scope, limit) {
52    if (isNumber(scope)) {
13        limit = scope;
13        scope = null;
     }
52    return when(promise).chain(function (results) {
52        var loopResults = (isArray(results) ? results : [results]);
52        limit = limit || loopResults.length;
 
52        var list = [];
52        for (var offset = 0, i = 0, l = loopResults.length; offset < l; offset += limit, i++) {
79            list.push(_loopResults(cb, scope, loopResults, i, offset, limit));
         }
52        var ret = new Promise();
52        serial(list).then(function (loopResults) {
42            ret.callback({loopResults: flatten(loopResults) || [], arr: results});
 //            loopResults = null;
 //            results = null;
         }, function (error) {
10            error = compact(error);
10            ret.errback(error.length === 1 ? error[0] : error);
 //            loopResults = null;
 //            results = null;
         });
52        return ret;
 
     });
 }
 
1function normalizeResult(result) {
92    return isArray(result) ? result : isDefined(result) ? [result] : result;
 }
 
 
 /**
  * Loops through the results of an promise. The promise can return an array or just a single item.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.forEach(asyncArr(), function(){
  *      //do something with it
  * }).then(function(arr){
  *      console.log(arr); //[1,2,3,4,5];
  * });
  *
  * ```
  *
  * You may also return a promise from the iterator block.
  *
  * ```
  * var myNewArr = [];
  *
  * comb.async.forEach(asyncArr(), function(item, index){
  *     var ret = new comb.Promise();
  *     process.nextTick(function(){
  *         myNewArr.push([item, index]);
  *         ret.callback();
  *     });
  *     return ret.promise();
  * }).then(function(){
  *     console.log(myNewArr) //[[1,0], [2,1], [3,2], [4,3], [5,4]]
  * });
  * ```
  *
  *
  * @param {comb.Promise|Array} promise the promise or array to loop through
  * @param {Function} iterator a function to invoke for each item
  * @param [scope] optional scope to execute the function in.
  * @return {comb.Promise} a promise that is resolved with the original array.
  * @static
  * @memberof comb.async
  * @name forEach
  */
1function asyncForEach(promise, iterator, scope, limit) {
11    return asyncArray(asyncLoop(promise, iterator, scope, limit).chain(function (results) {
9        return results.arr;
     }));
 }
 
 
 /**
  * Loops through the results of an promise resolving with the return value of the iterator function.
  * The promise can return an array or just a single item.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.map(asyncArr(), function(item){
  *      return item * 2;
  * }).then(function(arr){
  *      console.log(arr); //[2,4,6,8,10];
  * });
  *
  * ```
  *
  * You may also return a promise from the iterator block.
  *
  * ```
  * comb.async.map(asyncArr(), function(item, index){
  *     var ret = new comb.Promise();
  *     process.nextTick(function(){
  *         ret.callback(item * 2);
  *     });
  *     return ret.promise();
  * }).then(function(){
  *     console.log(myNewArr) //[2,4,6,8,10];
  * });
  * ```
  *
  *
  * @param {comb.Promise|Array} promise the promise or array to loop through
  * @param {Function} iterator a function to invoke for each item
  * @param [scope] optional scope to execute the function in.
  * @return {comb.Promise} a promise that is resolved with the mapped array.
  * @static
  * @memberof comb.async
  * @name map
  */
1function asyncMap(promise, iterator, scope, limit) {
15    return asyncArray(asyncLoop(promise, iterator, scope, limit).chain(function (results) {
13        return results.loopResults;
     }));
 }
 
 
 /**
  * Loops through the results of an promise resolving with the filtered array.
  * The promise can return an array or just a single item.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.filter(asyncArr(), function(item){
  *      return item % 2;
  * }).then(function(arr){
  *      console.log(arr); //[1,3,5];
  * });
  *
  * ```
  *
  * You may also return a promise from the iterator block.
  *
  * ```
  * comb.async.filter(asyncArr(), function(item, index){
  *     var ret = new comb.Promise();
  *     process.nextTick(function(){
  *         ret.callback(item % 2);
  *     });
  *     return ret.promise();
  * }).then(function(){
  *     console.log(myNewArr) //[1,3,5];
  * })
  * ```
  *
  *
  * @param {comb.Promise|Array} promise the promise or array to loop through
  * @param {Function} iterator a function to invoke for each item
  * @param [scope] optional scope to execute the function in.
  * @return {comb.Promise} a promise that is resolved with the filtered array.
  * @static
  * @memberof comb.async
  * @name filter
  */
1function asyncFilter(promise, iterator, scope, limit) {
7    return asyncArray(asyncLoop(promise, iterator, scope, limit).chain(function (results) {
5        var loopResults = results.loopResults, resultArr = results.arr;
5        return (isArray(resultArr) ? resultArr : [resultArr]).filter(function (res, i) {
65            return loopResults[i];
         });
     }));
 }
 
 
 /**
  * Loops through the results of an promise resolving with true if every item passed, false otherwise.
  * The promise can return an array or just a single item.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.every(asyncArr(), function(item){
  *      return item <= 5;
  * }).then(function(every){
  *      console.log(every); //true
  * });
  *
  * ```
  *
  * You may also return a promise from the iterator block.
  *
  * ```
  * comb.async.every(asyncArr(), function(item, index){
  *     var ret = new comb.Promise();
  *     process.nextTick(function(){
  *         ret.callback(item == 1);
  *     });
  *     return ret.promise();
  * }).then(function(){
  *     console.log(myNewArr) //false;
  * })
  * ```
  *
  *
  * @param {comb.Promise|Array} promise the promise or array to loop through
  * @param {Function} iterator a function to invoke for each item
  * @param [scope] optional scope to execute the function in.
  * @return {comb.Promise} a promise that is resolved true if every item passed false otherwise.
  * @static
  * @memberof comb.async
  * @name every
  */
1function asyncEvery(promise, iterator, scope, limit) {
9    return asyncArray(asyncLoop(promise, iterator, scope, limit).chain(function (results) {
7        return results.loopResults.every(function (res) {
52            return !!res;
         });
     }));
 }
 
 /**
  * Loops through the results of an promise resolving with true if some items passed, false otherwise.
  * The promise can return an array or just a single item.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.some(asyncArr(), function(item){
  *      return item == 1;
  * }).then(function(every){
  *      console.log(every); //true
  * });
  *
  * ```
  *
  * You may also return a promise from the iterator block.
  *
  * ```
  * comb.async.some(asyncArr(), function(item, index){
  *     var ret = new comb.Promise();
  *     process.nextTick(function(){
  *         ret.callback(item > 5);
  *     });
  *     return ret.promise();
  * }).then(function(){
  *     console.log(myNewArr) //false;
  * })
  * ```
  *
  *
  * @param {comb.Promise|Array} promise the promise or array to loop through
  * @param {Function} iterator a function to invoke for each item
  * @param [scope] optional scope to execute the function in.
  * @return {comb.Promise} a promise that is resolved with true if some items passed false otherwise.
  * @static
  * @memberof comb.async
  * @name some
  */
1function asyncSome(promise, iterator, scope, limit) {
10    return asyncArray(asyncLoop(promise, iterator, scope, limit).chain(function (results) {
8        return results.loopResults.some(function (res) {
53            return !!res;
         });
     }));
 }
 
 /**
  * Zips results from promises into an array.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.zip(asyncArr(), asyncArr()).then(function(zipped){
  *      console.log(zipped); //[[1,1],[2,2],[3,3], [4,4], [5,5]]
  * });
  *
  * comb.async.array(asyncArr()).zip(asyncArr()).then(function(zipped){
  *      console.log(zipped); //[[1,1],[2,2],[3,3], [4,4], [5,5]]
  * });
  *
  * ```
  *
  *
  * @return {comb.Promise} an array with all the arrays zipped together.
  * @static
  * @memberof comb.async
  * @name zip
  */
1function asyncZip() {
1    return asyncArray(when.apply(null, argsToArray(arguments)).chain(function (result) {
1        return zip.apply(array, normalizeResult(result).map(function (arg) {
3            return isArray(arg) ? arg : [arg];
         }));
     }));
 }
 
 /**
  * Async version of {@link comb.array.avg}.
  *
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).avg().then(function(avg){
  *     console.log(avg); //3
  * })
  *
  * comb.async.avg(asyncArr()).then(function(avg){
  *     console.log(avg); //3
  * })
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name avg
  */
1function asyncAvg(avgPromise) {
5    return when(avgPromise).chain(function (result) {
5        return avg.call(array, normalizeResult(result));
     });
 }
 
 /**
  * Async version of {@link comb.array.cartesian}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).cartesian([1,2,3]).then(function(avg){
  *     console.log(avg); //[ [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 2 ], [ 2, 3 ] ]
  * })
  *
  *  comb.async.cartesian(asyncArr(), [1,2,3]).then(function(avg){
  *     console.log(avg); //[ [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 2 ], [ 2, 3 ] ]
  * })
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name cartesian
  */
1function asyncCartesian() {
3    return asyncArray(when.apply(null, argsToArray(arguments)).chain(function (result) {
3        return cartesian.apply(array, normalizeResult(result).map(function (arg) {
6            return isArray(arg) ? arg : [arg];
         }));
     }));
 }
 
 
 /**
  * Async version of {@link comb.array.compact}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,null,2,null,3,null,4,null,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).compact().then(function(compacted){
  *     console.log(compacted); //[1,2,3,4,5]
  * })
  *
  * comb.async.compact(asyncArr()).then(function(compacted){
  *     console.log(compacted); //[1,2,3,4,5]
  * })
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name compact
  */
1function asyncCompact(arr) {
2    return asyncArray(when(arr).chain(function (result) {
2        return compact.call(array, normalizeResult(result));
     }));
 }
 
 
 /**
  * Async version of {@link comb.array.difference}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).difference([3,4,5]).then(function(diff){
  *     console.log(diff); //[1,2]
  * })
  *
  * comb.async.difference(asyncArr(), [3,4,5]).then(function(diff){
  *     console.log(diff); //[1,2]
  * })
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name difference
  */
1function asyncDifference() {
5    return asyncArray(when.apply(null, argsToArray(arguments)).chain(function (result) {
5        return difference.apply(array, normalizeResult(result).map(function (arg) {
11            return isArray(arg) ? arg : [arg];
         }));
     }));
 }
 
 /**
  * Async version of {@link comb.array.flatten}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [[1],[2],[3],[4],[5]]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).flatten().then(function(flat){
  *     console.log(flat); //[1,2,3,4,5]
  * });
  *
  * comb.async.flatten(asyncArr()).then(function(flat){
  *     console.log(flat); //[1,2,3,4,5]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name flatten
  */
1function asyncFlatten() {
4    return asyncArray(when.apply(null, argsToArray(arguments)).chain(function (result) {
4        return flatten.apply(array, normalizeResult(result).map(function (arg) {
12            return isArray(arg) ? arg : [arg];
         }));
     }));
 }
 
 
 /**
  * Async version of {@link comb.array.intersect}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).intersect([3,4], [3]).then(function(intersection){
  *     console.log(intersection); //[3]
  * });
  *
  * comb.async.intersect(asyncArr(), [3,4]).then(function(intersection){
  *     console.log(intersection); //[3,4]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name intersect
  */
1function asyncIntersect() {
5    return asyncArray(when.apply(null, argsToArray(arguments)).chain(function (result) {
5        return intersect.apply(array, normalizeResult(result).map(function (arg) {
15            return isArray(arg) ? arg : [arg];
         }));
     }));
 }
 
 /**
  * Async version of {@link comb.array.max}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).max().then(function(max){
  *     console.log(max); //5
  * })
  *
  * comb.async.max(asyncArr()).then(function(max){
  *     console.log(max); //5
  * })
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name max
  */
1function asyncMax() {
7    var args = argsToArray(arguments), last = args.pop(), cmp = null;
7    if (isFunction(last) || isString(last)) {
3        cmp = last;
     } else {
4        args.push(last);
     }
7    return when.apply(null, args).chain(function (result) {
7        return max.call(array, normalizeResult(result), cmp);
     });
 }
 
 
 /**
  * Async version of {@link comb.array.min}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).min().then(function(min){
  *     console.log(min) //3
  * });
  *
  * comb.async.min(asyncArr()).then(function(min){
  *     console.log(min) //3
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name min
  */
1function asyncMin() {
7    var args = argsToArray(arguments), last = args.pop(), cmp = null;
7    if (isFunction(last) || isString(last)) {
3        cmp = last;
     } else {
4        args.push(last);
     }
7    return when.apply(null, args).chain(function (result) {
7        return min.call(array, normalizeResult(result), cmp);
     });
 }
 
 /**
  * Async version of {@link comb.array.sort}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,3,2,5,4]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).sort().then(function(sorted){
  *    console.log(sorted); //[1,2,3,4,5]
  * });
  *
  * comb.async.sort(asyncArr()).then(function(sorted){
  *    console.log(sorted); //[1,2,3,4,5]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name sort
  */
1function asyncSort() {
8    var args = argsToArray(arguments), last = args.pop(), cmp = null;
8    if (isFunction(last) || isString(last)) {
4        cmp = last;
     } else {
4        args.push(last);
     }
8    return asyncArray(when.apply(null, args).chain(function (result) {
8        return sort.call(array, normalizeResult(result), cmp);
     }));
 }
 
 /**
  * Async version of {@link comb.array.multiply}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).multiply(2).then(function(mult){
  *    console.log(mult); //[1,2,3,4,5,1,2,3,4,5]
  * });
  *
  * comb.async.multiply(asyncArr(),2 ).then(function(mult){
  *    console.log(mult); //[1,2,3,4,5,1,2,3,4,5]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name multiply
  */
1function asyncMultiply() {
4    var args = argsToArray(arguments), last = args.pop(), times = null;
4    if (isNumber(last)) {
3        times = last;
     } else {
1        args.push(last);
     }
4    return asyncArray(when.apply(null, args).chain(function (result) {
4        return multiply.call(array, normalizeResult(result), times);
     }));
 }
 
 /**
  * Async version of {@link comb.array.permutations}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).permutations().then(function(permutations){
  *      console.log(permutations) //[ [ 1, 2, 3 ],
  *                                //  [ 1, 3, 2 ],
  *                                //  [ 2, 3, 1 ],
  *                                //  [ 2, 1, 3 ],
  *                                //  [ 3, 1, 2 ],
  *                                //  [ 3, 2, 1 ] ]
  * });
  *
  * comb.async.permutations(asyncArr()).then(function(permutations){
  *      console.log(permutations) //[ [ 1, 2, 3 ],
  *                                //  [ 1, 3, 2 ],
  *                                //  [ 2, 3, 1 ],
  *                                //  [ 2, 1, 3 ],
  *                                //  [ 3, 1, 2 ],
  *                                //  [ 3, 2, 1 ] ]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name permutations
  */
1function asyncPermutations() {
5    var args = argsToArray(arguments), last = args.pop(), times = null;
5    if (isNumber(last)) {
4        times = last;
     } else {
1        args.push(last);
     }
5    return asyncArray(when.apply(null, args).chain(function (result) {
5        return permutations.call(array, normalizeResult(result), times);
     }));
 }
 
 
 /**
  * Async version of {@link comb.array.powerSet}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).powerSet().then(function(set){
  *      console.log(set); //[ [], [ 1 ], [ 2 ], [ 1, 2 ], [ 3 ], [ 1, 3 ], [ 2, 3 ], [ 1, 2, 3 ] ]
  * });
  *
  * comb.async.powerSet(asyncArr()).then(function(set){
  *      console.log(set); //[ [], [ 1 ], [ 2 ], [ 1, 2 ], [ 3 ], [ 1, 3 ], [ 2, 3 ], [ 1, 2, 3 ] ]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name powerSet
  */
1function asyncPowerSet(arr) {
3    return asyncArray(when(arr).chain(function (result) {
3        return powerSet.call(array, normalizeResult(result));
     }));
 }
 
 
 /**
  * Async version of {@link comb.array.removeDuplicates}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,2,3,3,3,4,4,4]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).removeDuplicates().then(function(unique){
  *      console.log(unique); // [1, 2, 3, 4]
  * });
  *
  * comb.async.removeDuplicates(asyncArray()).then(function(unique){
  *      console.log(unique); // [1, 2, 3, 4]
  * });
  * ```
  *
  * @static
  * @memberof comb.async
  * @name removeDuplicates
  */
1function asyncRemoveDuplicates(arr) {
4    return asyncArray(when(arr).chain(function (result) {
4        return removeDuplicates.call(array, normalizeResult(result));
     }));
 }
 
 
 /**
  * Async version of {@link comb.array.rotate}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).rotate(2).then(function(rotated){
  *     console.log(rotated); // [ 3, 4, 5, 1, 2 ]
  * });
  *
  * comb.async.rotate(asyncArr(), 2).then(function(rotated){
  *     console.log(rotated); // [ 3, 4, 5, 1, 2 ]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name rotate
  */
1function asyncRotate() {
8    var args = argsToArray(arguments), last = args.pop(), times = null;
8    if (isNumber(last)) {
7        times = last;
     } else {
1        args.push(last);
     }
8    return asyncArray(when.apply(null, args).chain(function (result) {
8        return rotate.call(array, normalizeResult(result), times);
     }));
 }
 
 
 /**
  * Async version of {@link comb.array.sum}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).sum().then(function(sum){
  *     console.log(sum) //15
  * })
  *
  * comb.async.sum(asyncArr()).then(function(sum){
  *     console.log(sum) //15
  * })
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name sum
  */
1function asyncSum(arr) {
6    return when(arr).chain(function (result) {
6        return sum.call(array, normalizeResult(result));
     });
 }
 
 
 /**
  * Async version of {@link comb.array.transpose}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [[1, 2, 3], [4, 5, 6]]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).transpose().then(function(transposed){
  *     console.log(transposed); //[ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]
  * });
  *
  * comb.async.transpose(asyncArr()).then(function(transposed){
  *     console.log(transposed); //[ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name transpose
  */
1function asyncTranspose(arr) {
3    return asyncArray(when(arr).chain(function (result) {
3        return transpose.call(array, normalizeResult(result));
     }));
 }
 
 
 /**
  * Async version of {@link comb.array.union}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).union([3],[7], [9,10]).then(function(union){
  *      console.log(union); //[1,2,3,4,5,7,9,10]
  * });
  *
  * comb.async.union(asyncArr(), [3],[7], [9,10]).then(function(union){
  *      console.log(union); //[1,2,3,4,5,7,9,10]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name union
  */
1function asyncUnion() {
2    return asyncArray(when.apply(null, argsToArray(arguments)).chain(function (result) {
2        return union.apply(array, (normalizeResult(result)).map(function (arg) {
7            return isArray(arg) ? arg : [arg];
         }));
     }));
 }
 
 
 /**
  * Async version of {@link comb.array.unique}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,2,3,3,4,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).unique().then(function(unique){
  *     console.log(unique); //[1,2,3,4,5]
  * });
  *
  * comb.async.unique(asyncArr()).then(function(unique){
  *     console.log(unique); //[1,2,3,4,5]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name unique
  */
1function asyncUnique() {
2    return asyncRemoveDuplicates.apply(null, arguments);
 }
 
 
 /**
  * Async version of {@link comb.array.valuesAt}.
  *
  * ```
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * comb.async.array(asyncArr()).valuesAt(2,3,4).then(function(values){
  *     console.log(values); //[3,4,5]
  * });
  *
  * comb.async.valuesAt(asyncArr(), 2,3,4).then(function(values){
  *     console.log(values); //[3,4,5]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name valuesAt
  */
1function asyncValuesAt(arrPromise) {
3    var args = argsToArray(arguments, 1);
3    return asyncArray(when(arrPromise).chain(function (result) {
3        return when(valuesAt.apply(array, [normalizeResult(result)].concat(args)));
     }));
 }
 
 /**
  * Async version of {@link comb.array.pluck}.
  *
  * ```
  * var when = comb.when,
  *     array = comb.async.array;
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [
  *                                              {name:{first:when("Fred"), last:"Jones"}, age:when(50), roles:["a", "b", "c"]},
  *                                              {name:{first:"Bob", last:"Yukon"}, age:40, roles:when(["b", "c"])},
  *                                              {name:{first:"Alice", last:"Palace"}, age:when(35), roles:["c"]},
  *                                              {name:{first:when("Johnny"), last:"P."}, age:56, roles:when([])}
  *                                             ]);
  *     return ret.promise;
  * }
  *
  * array(asyncArr()).pluck("name.first").then(function(values){
  *     console.log(values); //["Fred", "Bob", "Alice", "Johnny"]
  * });
  *
  * pluck(asyncArr(), "age").then(function(values){
  *     console.log(values); //[50, 40, 35, 56]
  * });
  *
  * ```
  *
  * @static
  * @memberof comb.async
  * @name pluck
  */
1function asyncPluck(arrPromise, property) {
5    var args = argsToArray(arguments, 1);
5    return asyncArray(when(arrPromise).chain(function (result) {
5        var prop = property.split(".");
5        result = normalizeResult(result);
5        return asyncArray(prop).forEach(function (prop) {
8            var exec = prop.match(/(\w+)\(\)$/);
8            return asyncArray(result).map(function (item) {
32                return exec ? item[exec[1]]() : item[prop];
             }, 1).chain(function (res) {
8                    result = res;
                 });
         }, 1).chain(function () {
5                return result;
             });
     }));
 }
 
 /**
  *
  * Async version of {@link comb.array.invoke}.
  *
  * ```
  * function person(name, age) {
  *      return {
  *          getName:function () {
  *              return when(name);
  *          },
  *          getOlder:function () {
  *              age++;
  *              return when(this);
  *          },
  *          getAge:function () {
  *              return when(age);
  *          }
  *      };
  * }
  *
  * var arr = [when(person("Bob", 40)), when(person("Alice", 35)), when(person("Fred", 50)), when(person("Johnny", 56))];
  * console.log(comb.async.invoke(arr, "getName")); //["Bob", "Alice", "Fred", "Johnny"]
  * console.log(array(arr).invoke("getOlder").pluck("getAge")) //[41, 36, 51, 57]
  * ```
  * @static
  * @memberOf comb.async
  * @name invoke
  */
1function asyncInvoke(arrPromise) {
2    var args = argsToArray(arguments, 1);
2    return asyncArray(when(arrPromise).chain(function (result) {
2        return when(invoke.apply(array, [normalizeResult(result)].concat(args)));
     }));
 }
 
1var asyncExports = (exports.async = {
     array: asyncArray,
     forEach: asyncForEach,
     map: asyncMap,
     filter: asyncFilter,
     every: asyncEvery,
     some: asyncSome,
     zip: asyncZip,
     sum: asyncSum,
     avg: asyncAvg,
     sort: asyncSort,
     min: asyncMin,
     max: asyncMax,
     difference: asyncDifference,
     removeDuplicates: asyncRemoveDuplicates,
     unique: asyncUnique,
     rotate: asyncRotate,
     permutations: asyncPermutations,
     transpose: asyncTranspose,
     valuesAt: asyncValuesAt,
     union: asyncUnion,
     intersect: asyncIntersect,
     powerSet: asyncPowerSet,
     cartesian: asyncCartesian,
     compact: asyncCompact,
     multiply: asyncMultiply,
     flatten: asyncFlatten,
     pluck: asyncPluck,
     invoke: asyncInvoke
 });
 
1var methods = ["forEach", "map", "filter", "some", "every", "zip", "sum", "avg", "sort", "min", "max", "difference", "removeDuplicates", "unique", "rotate",
     "permutations", "transpose", "valuesAt", "union", "intersect", "powerSet", "cartesian", "compact",
     "multiply", "flatten", "pluck", "invoke"];
 
 
 /**
  * Exposes array methods on a {@link comb.Promise}.
  *
  * The methods added are.
  *
  * * forEach : See {@link comb.async.forEach}.
  * * map : See {@link comb.async.map}.
  * * filter : See {@link comb.async.filter}.
  * * some : See {@link comb.async.some}.
  * * every : See {@link comb.async.every}.
  * * zip : See {@link comb.async.zip}.
  * * sum : See {@link comb.async.sum}.
  * * avg : See {@link comb.async.avg}.
  * * sort : See {@link comb.async.sort}.
  * * min : See {@link comb.async.min}.
  * * max : See {@link comb.async.max}.
  * * difference : See {@link comb.async.difference}.
  * * removeDuplicates : See {@link comb.async.removeDuplicates}.
  * * unique : See {@link comb.async.unique}.
  * * rotate : See {@link comb.async.rotate}.
  * * permutations : See {@link comb.async.permutations}.
  * * transpose : See {@link comb.async.transpose}.
  * * valuesAt : See {@link comb.async.valuesAt}.
  * * union : See {@link comb.async.union}.
  * * intersect : See {@link comb.async.intersect}.
  * * powerSet : See {@link comb.async.powerSet}.
  * * cartesian : See {@link comb.async.cartesian}.
  * * compact : See {@link comb.async.compact}.
  * * multiply : See {@link comb.async.multiply}.
  * * flatten : See {@link comb.async.flatten}.
  * * pluck : See {@link comb.async.pluck}.
  * * invoke : See {@link comb.async.invoke}.
  *
  * When using this method each of the methods are chainable so you can combine actions.
  *
  * ```
  * var array = comb.async.array;
  * function asyncArr(){
  *     var ret = new comb.Promise();
  *     process.nextTick(ret.callback.bind(ret, [1,2,3,4,5]);
  *     return ret.promise;
  * }
  *
  * array(asyncArr())
  *      .map(function (num, i) {
  *          return num * (i + 1);
  *      }).filter(function (num) {
  *          return num % 2;
  *      }).avg().then(function(avg){
  *          console.log(avg); //11.666666666666666
  *      });
  * ```
  * @param {comb.Promise|[]} p the promise or array to use.
  *
  * @static
  * @memberof comb.async
  * @name array
  */
1function asyncArray(p) {
626    var ret;
626    if (!p || !p.__isArrayAsync__) {
410        ret = merge(when(p), {
             promise: function () {
216                return asyncArray(this)
             }
         });
410        forEach(methods, function (m) {
11070            var func = asyncExports[m];
11070            ret[m] = function () {
143                var args = argsToArray(arguments), mRet = new Promise();
143                nextTick(function () {
143                    func.apply(null, [ret].concat(args)).then(mRet);
                 });
143                return asyncArray(mRet);
             };
         });
410        ret.__isArrayAsync__ = true;
     } else {
216        ret = p;
     }
626    p = null;
626    return ret;
 }