/**
  * @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;
 
1function asyncLoop(promise, cb, scope, limit) {
52    return when(promise).chain(function (results) {
52        return serial(map((isArray(results) ? results : [results]), function () {
211            var args = arguments;
211            return function () {
211                try {
211                    return when(cb.apply(scope || null, args));
                 } catch (e) {
5                    throw e;
                 }
             };
         })).chain(function (loopResults) {
42                return {loopResults:loopResults || [], arr:results};
             });
     });
 }
 
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) {
11    return asyncArray(asyncLoop(promise, iterator, scope).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) {
15    return asyncArray(asyncLoop(promise, iterator, scope).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) {
7    return asyncArray(asyncLoop(promise, iterator, scope).chain(function (results) {
5        var loopResults = results.loopResults, resultArr = results.arr;
5        return (isArray(resultArr) ? resultArr : [resultArr]).filter(function (res, i) {
21            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) {
9    return asyncArray(asyncLoop(promise, iterator, scope).chain(function (results) {
7        return results.loopResults.every(function (res) {
19            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) {
10    return asyncArray(asyncLoop(promise, iterator, scope).chain(function (results) {
8        return results.loopResults.some(function (res) {
20            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];
             }).chain(function (res) {
8                    result = res;
                 });
         }).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                process.nextTick(function () {
143                    func.apply(null, [ret].concat(args)).then(mRet);
                 });
143                return asyncArray(mRet);
             };
         });
410        ret.__isArrayAsync__ = true;
     } else {
216        ret = p;
     }
626    return ret;
 }
 
 
 
 
 

1var obj = require("./object"),
     merge = obj.merge,
     misc = require("./misc"),
     argsToArray = misc.argsToArray,
     string = require("./string"),
     isString = string.isString,
     number = require("./number.js"),
     floor = Math.floor,
     abs = Math.abs,
     mathMax = Math.max,
     mathMin = Math.min;
 
 
1var isArray = exports.isArray = function isArray(obj) {
15301    return Object.prototype.toString.call(obj) === "[object Array]";
 };
 
1function isDate(obj) {
126    var undef;
126    return (obj !== undef && typeof obj === "object" && obj instanceof Date);
 }
 
1function cross(num, cros) {
21    var ret = reduceRight(cros, function (a, b) {
57        if (!isArray(b)) {
57            b = [b];
         }
57        b.unshift(num);
57        a.unshift(b);
57        return a;
     }, []);
21    return ret;
 }
 
1function permute(num, cross, length) {
18    var ret = [];
18    for (var i = 0; i < cross.length; i++) {
36        ret.push([num].concat(rotate(cross, i)).slice(0, length));
     }
18    return ret;
 }
 
 
1function intersection(a, b) {
135    var ret = [];
135    if (isArray(a) && isArray(b)) {
135        if (a.length && b.length) {
105            var aOne = a[0];
105            if (indexOf(b, aOne) !== -1) {
84                ret = [aOne].concat(intersection(a.slice(1), b));
             } else {
21                ret = intersection(a.slice(1), b);
             }
         }
     }
 
135    return ret;
 }
 
 
1var _sort = (function () {
 
1    var isAll = function (arr, test) {
63        return every(arr, test);
     };
 
1    var defaultCmp = function (a, b) {
90        return a - b;
     };
 
1    var dateSort = function (a, b) {
27        return a.getTime() - b.getTime();
     };
 
1    return function _sort(arr, property) {
66        var ret = [];
66        if (isArray(arr)) {
66            ret = arr.slice();
66            if (property) {
30                if (typeof property === "function") {
3                    ret.sort(property);
                 } else {
27                    ret.sort(function (a, b) {
81                        var aProp = a[property], bProp = b[property];
81                        if (isString(aProp) && isString(bProp)) {
27                            return aProp > bProp ? 1 : aProp < bProp ? -1 : 0;
54                        } else if (isDate(aProp) && isDate(bProp)) {
27                            return aProp.getTime() - bProp.getTime()
                         } else {
27                            return aProp - bProp;
                         }
                     });
                 }
             } else {
36                if (isAll(ret, isString)) {
9                    ret.sort();
27                } else if (isAll(ret, isDate)) {
9                    ret.sort(dateSort);
                 } else {
18                    ret.sort(defaultCmp);
                 }
             }
         }
66        return ret;
     };
 
 })();
 
1function indexOf(arr, searchElement, fromIndex) {
299    if (!isArray(arr)) {
1        throw new TypeError();
     }
298    var t = Object(arr);
298    var len = t.length >>> 0;
298    if (len === 0) {
33        return -1;
     }
265    var n = 0;
265    if (arguments.length > 2) {
8        n = Number(arguments[2]);
8        if (n !== n) { // shortcut for verifying if it's NaN
2            n = 0;
6        } else if (n !== 0 && n !== Infinity && n !== -Infinity) {
2            n = (n > 0 || -1) * floor(abs(n));
         }
     }
265    if (n >= len) {
2        return -1;
     }
263    var k = n >= 0 ? n : mathMax(len - abs(n), 0);
263    for (; k < len; k++) {
568        if (k in t && t[k] === searchElement) {
158            return k;
         }
     }
105    return -1;
 }
 
1function lastIndexOf(arr, searchElement, fromIndex) {
12    if (!isArray(arr)) {
1        throw new TypeError();
     }
 
11    var t = Object(arr);
11    var len = t.length >>> 0;
11    if (len === 0) {
1        return -1;
     }
 
10    var n = len;
10    if (arguments.length > 2) {
8        n = Number(arguments[2]);
8        if (n !== n) {
2            n = 0;
6        } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) {
2            n = (n > 0 || -1) * floor(abs(n));
         }
     }
 
10    var k = n >= 0 ? mathMin(n, len - 1) : len - abs(n);
 
10    for (; k >= 0; k--) {
18        if (k in t && t[k] === searchElement) {
6            return k;
         }
     }
4    return -1;
 }
 
1function filter(arr, iterator, scope) {
27    if (!isArray(arr) || typeof iterator !== "function") {
1        throw new TypeError();
     }
 
26    var t = Object(arr);
26    var len = t.length >>> 0;
26    var res = [];
26    for (var i = 0; i < len; i++) {
88        if (i in t) {
88            var val = t[i]; // in case fun mutates this
88            if (iterator.call(scope, val, i, t)) {
48                res.push(val);
             }
         }
     }
26    return res;
 }
 
1function forEach(arr, iterator, scope) {
11431    if (!isArray(arr) || typeof iterator !== "function") {
1        throw new TypeError();
     }
11430    for (var i = 0, len = arr.length; i < len; ++i) {
83362        iterator.call(scope || arr, arr[i], i, arr);
     }
11430    return arr;
 }
 
1function every(arr, iterator, scope) {
331    if (!isArray(arr) || typeof iterator !== "function") {
1        throw new TypeError();
     }
330    var t = Object(arr);
330    var len = t.length >>> 0;
330    for (var i = 0; i < len; i++) {
383        if (i in t && !iterator.call(scope, t[i], i, t)) {
300            return false;
         }
     }
30    return true;
 }
 
1function some(arr, iterator, scope) {
7    if (!isArray(arr) || typeof iterator !== "function") {
1        throw new TypeError();
     }
6    var t = Object(arr);
6    var len = t.length >>> 0;
6    for (var i = 0; i < len; i++) {
30        if (i in t && iterator.call(scope, t[i], i, t)) {
2            return true;
         }
     }
4    return false;
 }
 
1function map(arr, iterator, scope) {
105    if (!isArray(arr) || typeof iterator !== "function") {
1        throw new TypeError();
     }
 
104    var t = Object(arr);
104    var len = t.length >>> 0;
104    var res = [];
104    for (var i = 0; i < len; i++) {
388        if (i in t) {
388            res.push(iterator.call(scope, t[i], i, t));
         }
     }
104    return res;
 }
 
1function reduce(arr, accumulator, curr) {
139    if (!isArray(arr) || typeof accumulator !== "function") {
1        throw new TypeError();
     }
138    var i = 0, l = arr.length >> 0;
138    if (arguments.length < 3) {
24        if (l === 0) {
1            throw new TypeError("Array length is 0 and no second argument");
         }
23        curr = arr[0];
23        i = 1; // start accumulating at the second element
     } else {
114        curr = arguments[2];
     }
137    while (i < l) {
393        if (i in arr) {
393            curr = accumulator.call(undefined, curr, arr[i], i, arr);
         }
393        ++i;
     }
137    return curr;
 }
 
1function reduceRight(arr, accumulator, curr) {
27    if (!isArray(arr) || typeof accumulator !== "function") {
1        throw new TypeError();
     }
 
26    var t = Object(arr);
26    var len = t.length >>> 0;
 
     // no value to return if no initial value, empty array
26    if (len === 0 && arguments.length === 2) {
1        throw new TypeError();
     }
 
25    var k = len - 1;
25    if (arguments.length >= 3) {
23        curr = arguments[2];
     } else {
2        do {
2            if (k in arr) {
2                curr = arr[k--];
2                break;
             }
         }
         while (true);
     }
25    while (k >= 0) {
75        if (k in t) {
75            curr = accumulator.call(undefined, curr, t[k], k, t);
         }
75        k--;
     }
25    return curr;
 }
 
 
 /**
  * converts anything to an array
  *
  * @example
  *  comb.array.toArray({a : "b", b : "c"}) => [["a","b"], ["b","c"]];
  *  comb.array.toArray("a") => ["a"]
  *  comb.array.toArray(["a"]) =>  ["a"];
  *  comb.array.toArray() => [];
  *  comb.array.toArray("a", {a : "b"}) => ["a", ["a", "b"]];
  *
  * @static
  * @memberOf comb.array
  */
1function toArray(o) {
49    var ret = [];
49    if (o != null) {
48        var args = argsToArray(arguments);
48        if (args.length === 1) {
46            if (isArray(o)) {
33                ret = o;
13            } else if (obj.isHash(o)) {
4                for (var i in o) {
6                    if (o.hasOwnProperty(i)) {
6                        ret.push([i, o[i]]);
                     }
                 }
             } else {
9                ret.push(o);
             }
         } else {
2            forEach(args, function (a) {
4                ret = ret.concat(toArray(a));
             });
         }
     }
49    return ret;
 }
 
 /**
  * Sums all items in an array
  *
  * @example
  *
  *  comb.array.sum([1,2,3]) => 6
  *  comb.array.sum(["A","B","C"]) => "ABC";
  *  var d1 = new Date(1999), d2 = new Date(2000), d3 = new Date(3000);
  *  comb.array.sum([d1,d2,d3]) => "Wed Dec 31 1969 18:00:01 GMT-0600 (CST)"
  *                              + "Wed Dec 31 1969"  18:00:02 GMT-0600 (CST)"
  *                              + "Wed Dec 31 1969 18:00:03 GMT-0600 (CST)"
  *  comb.array.sum([{},{},{}]) => "[object Object][object Object][object Object]";
  *
  * @param {Number[]} array the array of numbers to sum
  * @static
  * @memberOf comb.array
  */
1function sum(array) {
27    array = array || [];
27    if (array.length) {
21        return reduce(array, function (a, b) {
44            return a + b;
         });
     } else {
6        return 0;
     }
 }
 
 /**
  * Averages an array of numbers.
  * @example
  *
  * comb.array.avg([1,2,3]); //2
  *
  * @param {Number[]} array - an array of numbers
  * @return {Number} the average of all the numbers in the array.
  * @throws {Error} if the array is not all numbers.
  * @static
  * @memberOf comb.array
  */
1function avg(arr) {
13    arr = arr || [];
13    if (arr.length) {
8        var total = sum(arr);
8        if (number.isNumber(total)) {
4            return  total / arr.length;
         } else {
4            throw new Error("Cannot average an array of non numbers.");
         }
     } else {
5        return 0;
     }
 }
 
 /**
  * Allows the sorting of an array based on a property name instead. This can also
  * act as a sort that does not change the original array.
  *
  * <b>NOTE:</b> this does not change the original array!
  *
  * @example
  * comb.array.sort([{a : 1}, {a : 2}, {a : -2}], "a"); //[{a : -2}, {a : 1}, {a : 2}];
  * @param {Array} arr the array to sort
  * @param {String|Function} cmp the property to sort on. Or a function used to compare.
  * @return {Array} a copy of the original array that is sorted.
  *
  * @static
  * @memberOf comb.array
  */
1function sort(arr, cmp) {
24    return _sort(arr, cmp);
 }
 
 /**
  * Finds that min value of an array. If a second argument is provided and it is a function
  * it will be used as a comparator function. If the second argument is a string then it will be used
  * as a property look up on each item.
  *
  * @example
  * comb.array.min([{a : 1}, {a : 2}, {a : -2}], "a"); //{a : -2}
  * comb.array.min([{a : 1}, {a : 2}, {a : -2}], function(a,b){
  *      return a.a - b.a
  * }); //{a : -2}
  *
  * @param {Array} arr the array to find the min value on
  * @param {String|Function} cmp the property to sort on. Or a function used to compare.
  * @return {*}
  *
  * @static
  * @memberOf comb.array
  */
1function min(arr, cmp) {
21    return _sort(arr, cmp)[0];
 }
 
 /**
  * Finds that max value of an array. If a second argument is provided and it is a function
  * it will be used as a comparator function. If the second argument is a string then it will be used
  * as a property look up on each item.
  *
  * @example
  * comb.array.max([{a : 1}, {a : 2}, {a : -2}], "a"); //{a : 2}
  * comb.array.max([{a : 1}, {a : 2}, {a : -2}], function(a,b){
  *      return a.a - b.a
  * }); //{a : 2}
  *
  * @param arr the array to find the max value on
  * @param {String|Function} cmp the property to sort on. Or a function used to compare.
  * @return {*} the maximum value of the array based on the provided cmp.
  *
  * @static
  * @memberOf comb.array
  */
1function max(arr, cmp) {
21    return _sort(arr, cmp)[arr.length - 1];
 }
 
 /**
  * Finds the difference of the two arrays.
  *
  * @example
  *
  * comb.array.difference([1,2,3], [2,3]); //[1]
  * comb.array.difference(["a","b",3], [3]); //["a","b"]
  *
  * @param {Array} arr1 the array we are subtracting from
  * @param {Array} arr2 the array we are subtracting from arr1
  * @return {*} the difference of the arrays.
  *
  * @static
  * @memberOf comb.array
  */
1function difference(arr1, arr2) {
15    var ret = arr1, args = flatten(argsToArray(arguments, 1));
15    if (isArray(arr1)) {
15        ret = filter(arr1, function (a) {
42            return indexOf(args, a) === -1;
         });
     }
15    return ret;
 }
 
 
 /**
  * Removes duplicates from an array
  *
  * @example
  *
  * comb.array.removeDuplicates([1,1,1]) => [1]
  * comb.array.removeDuplicates([1,2,3,2]) => [1,2,3]
  *
  * @param {Aray} array the array of elements to remove duplicates from
  *
  * @static
  * @memberOf comb.array
  */
1function removeDuplicates(arr) {
33    if (isArray(arr)) {
33        return reduce(arr, function (a, b) {
141            if (indexOf(a, b) === -1) {
96                return a.concat(b);
             } else {
45                return a;
             }
         }, []);
     }
 }
 
 /**
  *
  * See {@link comb.array.removeDuplicates}
  *
  * @static
  * @memberOf comb.array
  */
1function unique(arr) {
4    return removeDuplicates(arr);
 }
 
 /**
  * Rotates an array the number of specified positions
  *
  * @example
  * var arr = ["a", "b", "c", "d"];
  * comb.array.rotate(arr)     => ["b", "c", "d", "a"]
  * comb.array.rotate(arr, 2)  => ["c", "d", "a", "b"]);
  * comb.array.rotate(arr, 3)  => ["d", "a", "b", "c"]);
  * comb.array.rotate(arr, 4)  => ["a", "b", "c", "d"]);
  * comb.array.rotate(arr, -1) => ["d", "a", "b", "c"]);
  * comb.array.rotate(arr, -2) => ["c", "d", "a", "b"]);
  * comb.array.rotate(arr, -3) => ["b", "c", "d", "a"]);
  * comb.array.rotate(arr, -4) => ["a", "b", "c", "d"]);
  *
  * @param {Array} array the array of elements to remove duplicates from
  * @param {Number} numberOfTimes the number of times to rotate the array
  *
  * @static
  * @memberOf comb.array
  */
1function rotate(arr, numberOfTimes) {
174    var ret = arr.slice();
174    if (typeof numberOfTimes !== "number") {
3        numberOfTimes = 1;
     }
174    if (numberOfTimes && isArray(arr)) {
96        if (numberOfTimes > 0) {
66            ret.push(ret.shift());
66            numberOfTimes--;
         } else {
30            ret.unshift(ret.pop());
30            numberOfTimes++;
         }
96        return rotate(ret, numberOfTimes);
     } else {
78        return ret;
     }
 }
 
 /**
  * Finds all permutations of an array
  *
  * @example
  * var arr = [1,2,3];
  * comb.array.permutations(arr)    => [[ 1, 2, 3 ],[ 1, 3, 2 ],[ 2, 3, 1 ],
  *                                     [ 2, 1, 3 ],[ 3, 1, 2 ],[ 3, 2, 1 ]]
  * comb.array.permutations(arr, 2) => [[ 1, 2],[ 1, 3],[ 2, 3],[ 2, 1],[ 3, 1],[ 3, 2]]
  * comb.array.permutations(arr, 1) => [[1],[2],[3]]
  * comb.array.permutations(arr, 0) => [[]]
  * comb.array.permutations(arr, 4) => []
  *
  * @param {Array} arr the array to permute.
  * @param {Number} length the number of elements to permute.
  * @static
  * @memberOf comb.array
  */
1function permutations(arr, length) {
15    var ret = [];
15    if (isArray(arr)) {
15        var copy = arr.slice(0);
15        if (typeof length !== "number") {
3            length = arr.length;
         }
15        if (!length) {
3            ret = [
                 []
             ];
12        } else if (length <= arr.length) {
9            ret = reduce(arr, function (a, b, i) {
27                var ret;
27                if (length > 1) {
18                    ret = permute(b, rotate(copy, i).slice(1), length);
                 } else {
9                    ret = [
                         [b]
                     ];
                 }
27                return a.concat(ret);
             }, []);
         }
     }
15    return ret;
 }
 
 /**
  * Zips to arrays together
  *
  * @example
  *  var a = [ 4, 5, 6 ], b = [ 7, 8, 9 ]
  *  comb.array.zip([1], [2], [3]) => [[ 1, 2, 3 ]]);
  *  comb.array.zip([1,2], [2], [3]) => [[ 1, 2, 3 ],[2, null, null]]
  *  comb.array.zip([1,2,3], a, b) => [[1, 4, 7],[2, 5, 8],[3, 6, 9]]
  *  comb.array.zip([1,2], a, b) => [[1, 4, 7],[2, 5, 8]]
  *  comb.array.zip(a, [1,2], [8]) => [[4,1,8],[5,2,null],[6,null,null]]
  *
  * @param arrays variable number of arrays to zip together
  *
  * @static
  * @memberOf comb.array
  */
1function zip() {
11    var ret = [];
11    var arrs = argsToArray(arguments);
11    if (arrs.length > 1) {
11        var arr1 = arrs.shift();
11        if (isArray(arr1)) {
11            ret = reduce(arr1, function (a, b, i) {
27                var curr = [b];
27                for (var j = 0; j < arrs.length; j++) {
54                    var currArr = arrs[j];
54                    if (isArray(currArr) && !misc.isUndefined(currArr[i])) {
44                        curr.push(currArr[i]);
                     } else {
10                        curr.push(null);
                     }
                 }
27                a.push(curr);
27                return a;
             }, []);
         }
     }
11    return ret;
 }
 
 /**
  * Transposes an array of arrays
  * @example
  *
  * comb.array.transpose([[1,2,3], [4,5,6]]) => [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]
  * comb.array.transpose([[1,2], [3,4], [5,6]]) => [ [ 1, 3, 5 ], [ 2, 4, 6 ] ]
  * comb.array.transpose([[1], [3,4], [5,6]]) => [[1]])
  *
  * @param [Array[Array[]]] arr Array of arrays
  *
  * @static
  * @memberOf comb.array
  */
1function transpose(arr) {
9    var ret = [];
9    if (isArray(arr) && arr.length) {
9        var last;
9        forEach(arr, function (a) {
24            if (isArray(a) && (!last || a.length === last.length)) {
18                forEach(a, function (b, i) {
39                    if (!ret[i]) {
18                        ret[i] = [];
                     }
39                    ret[i].push(b);
                 });
18                last = a;
             }
         });
     }
9    return ret;
 }
 
 
 /**
  * Retrieves values at specified indexes in the array
  *
  * @example
  *
  *  var arr =["a", "b", "c", "d"]
  *   comb.array.valuesAt(arr, 1,2,3) => ["b", "c", "d"];
  *   comb.array.valuesAt(arr, 1,2,3, 4) => ["b", "c", "d", null];
  *   comb.array.valuesAt(arr, 0,3) => ["a", "d"];
  *
  * @param {Array} arr the array to retrieve values from
  * @param {Number} indexes variable number of indexes to retrieve
  *
  * @static
  * @memberOf comb.array
  */
1function valuesAt(arr, indexes) {
9    var ret = [];
9    indexes = argsToArray(arguments);
9    arr = indexes.shift();
9    var l = arr.length;
9    if (isArray(arr) && indexes.length) {
9        for (var i = 0; i < indexes.length; i++) {
27            ret.push(arr[indexes[i]] || null);
         }
     }
9    return ret;
 }
 
 /**
  * Union a variable number of arrays together
  *
  * @example
  *
  * comb.array.union(['a','b','c'], ['b','c', 'd']) => ["a", "b", "c", "d"]
  * comb.array.union(["a"], ["b"], ["c"], ["d"], ["c"]) => ["a", "b", "c", "d"]
  *
  * @param arrs variable number of arrays to union
  *
  * @static
  * @memberOf comb.array
  */
1function union() {
6    var ret = [];
6    var arrs = argsToArray(arguments);
6    if (arrs.length > 1) {
6        ret = removeDuplicates(reduce(arrs, function (a, b) {
21            return a.concat(b);
         }, []));
     }
6    return ret;
 }
 
 /**
  * Finds the intersection of arrays
  * NOTE : this function accepts an arbitrary number of arrays
  *
  * @example
  * comb.array.intersect([1,2], [2,3], [2,3,5]) => [2]
  * comb.array.intersect([1,2,3], [2,3,4,5], [2,3,5]) => [2,3]
  * comb.array.intersect([1,2,3,4], [2,3,4,5], [2,3,4,5]) => [2,3,4]
  * comb.array.intersect([1,2,3,4,5], [1,2,3,4,5], [1,2,3]) => [1,2,3]
  * comb.array.intersect([[1,2,3,4,5],[1,2,3,4,5],[1,2,3]]) => [1,2,3]
  *
  * @param {Array} a
  * @param {Array} b
  *
  * @static
  * @memberOf comb.array
  */
1function intersect(a, b) {
15    var collect = [], set;
15    var args = argsToArray(arguments);
15    if (args.length > 1) {
         //assume we are intersections all the lists in the array
13        set = args;
     } else {
2        set = args[0];
     }
15    if (isArray(set)) {
15        var x = set.shift();
15        collect = reduce(set, function (a, b) {
30            return intersection(a, b);
         }, x);
     }
15    return removeDuplicates(collect);
 }
 
 /**
  * Finds the powerset of an array
  *
  * @example
  *
  *  comb.array.powerSet([1,2]) => [
  *           [],
  *           [ 1 ],
  *           [ 2 ],
  *           [ 1, 2 ]
  *   ]
  *   comb.array.powerSet([1,2,3]) => [
  *           [],
  *           [ 1 ],
  *           [ 2 ],
  *           [ 1, 2 ],
  *           [ 3 ],
  *           [ 1, 3 ],
  *           [ 2, 3 ],
  *           [ 1, 2, 3 ]
  *       ]
  *   comb.array.powerSet([1,2,3,4]) => [
  *           [],
  *           [ 1 ],
  *           [ 2 ],
  *           [ 1, 2 ],
  *           [ 3 ],
  *           [ 1, 3 ],
  *           [ 2, 3 ],
  *           [ 1, 2, 3 ],
  *           [ 4 ],
  *           [ 1, 4 ],
  *           [ 2, 4 ],
  *           [ 1, 2, 4 ],
  *           [ 3, 4 ],
  *           [ 1, 3, 4 ],
  *           [ 2, 3, 4 ],
  *           [ 1, 2, 3, 4 ]
  *       ]
  *
  * @param {Array} arr the array to find the powerset of
  *
  * @static
  * @memberOf comb.array
  */
1function powerSet(arr) {
9    var ret = [];
9    if (isArray(arr) && arr.length) {
9        ret = reduce(arr, function (a, b) {
27            var ret = map(a, function (c) {
75                return c.concat(b);
             });
27            return a.concat(ret);
         }, [
             []
         ]);
     }
9    return ret;
 }
 
 /**
  * Find the cartesian product of two arrays
  *
  * @example
  *
  * comb.array.cartesian([1,2], [2,3]) => [
  *           [1,2],
  *           [1,3],
  *           [2,2],
  *           [2,3]
  *       ]
  * comb.array.cartesian([1,2], [2,3,4]) => [
  *           [1,2],
  *           [1,3],
  *           [1,4] ,
  *           [2,2],
  *           [2,3],
  *           [2,4]
  *       ]
  * comb.array.cartesian([1,2,3], [2,3,4]) => [
  *           [1,2],
  *           [1,3],
  *           [1,4] ,
  *           [2,2],
  *           [2,3],
  *           [2,4] ,
  *           [3,2],
  *           [3,3],
  *           [3,4]
  *       ]
  *
  * @param {Array} a
  * @param {Array} b
  *
  * @static
  * @memberOf comb.array
  */
1function cartesian(a, b) {
30    var ret = [];
30    if (isArray(a) && isArray(b) && a.length && b.length) {
21        ret = cross(a[0], b).concat(cartesian(a.slice(1), b));
     }
30    return ret;
 }
 
 /**
  * Compacts an array removing null or undefined objects from the array.
  *
  * @example
  *
  * var x;
  * comb.array.compact([1,null,null,x,2]) => [1,2]
  * comb.array.compact([1,2]) => [1,2]
  *
  * @param {Array} arr
  * @static
  * @memberOf comb.array
  */
1function compact(arr) {
6    var ret = [];
6    if (isArray(arr) && arr.length) {
6        ret = filter(arr, function (item) {
21            return !misc.isUndefinedOrNull(item);
         });
     }
6    return ret;
 }
 
 /**
  * Creates a new array that is the result of the array concated the number of
  * times. If times is not specified or it equals 0 then it defaults to 1.
  * @param {Array} arr the array to multiply.
  * @param {Number} [times=1] the number of times to multiple the array.
  * @return {Array} a new array that is the result of the array multiplied the number of times specified.
  *
  * @static
  * @memberOf comb.array
  */
1function multiply(arr, times) {
12    times = number.isNumber(times) ? times : 1;
12    if (!times) {
         //make sure times is greater than zero if it is zero then dont multiply it
3        times = 1;
     }
12    arr = toArray(arr || []);
12    var ret = [], i = 0;
12    while (++i <= times) {
15        ret = ret.concat(arr);
     }
12    return ret;
 }
 
 /**
  * Flatten multiple arrays into a single array
  *
  * @example
  *
  * comb.array.flatten([1,2], [2,3], [3,4]) => [1,2,2,3,3,4]
  * comb.array.flatten([1,"A"], [2,"B"], [3,"C"]) => [1,"A",2,"B",3,"C"]
  *
  * @param array
  *
  * @static
  * @memberOf comb.array
  */
1function flatten(arr) {
29    var set;
29    var args = argsToArray(arguments);
29    if (args.length > 1) {
         //assume we are intersections all the lists in the array
10        set = args;
     } else {
19        set = toArray(arr);
     }
29    return reduce(set, function (a, b) {
58        return a.concat(b);
     }, []);
 }
 
 
 /**
  * Plucks values from an array. Effectevily the same as using a array.map implementation. However the porperty specified supports
  * a "dot" notation to access nested properties.
  *
  * @example
  *
  *   var arr = [
  *                  {name:{first:"Fred", last:"Jones"}, age:50, roles:["a", "b", "c"]},
  *                  {name:{first:"Bob", last:"Yukon"}, age:40, roles:["b", "c"]},
  *                  {name:{first:"Alice", last:"Palace"}, age:35, roles:["c"]},
  *                  {name:{first:"Johnny", last:"P."}, age:56, roles:[]}
  *             ];
  * console.log(comb.array.pluck(arr, "name.first")); //["Fred", "Bob", "Alice", "Johnny"]
  * console.log(comb.array.pluck(arr, "age")); //[50, 40, 35, 56]
  * console.log(comb.array.pluck(arr, "roles.length")); //[3, 2, 1, 0]
  * console.log(comb.array.pluck(arr, "roles.0")); //["a", "b", "c", undefined]
  *
  * @param {Array} arr the array to pluck values from
  * @param {String} prop the property to retrieve from each item in the array
  * @return {Array} an array containing the plucked properties.
  *
  * @static
  * @memberOf comb.array
  */
1function pluck(arr, prop) {
7    prop = prop.split(".");
7    var result = arr.slice(0);
7    forEach(prop, function (prop) {
13        var exec = prop.match(/(\w+)\(\)$/);
13        result = map(result, function (item) {
52            return exec ? item[exec[1]]() : item[prop];
         });
     });
7    return result;
 }
 
 /**
  * Invokes the method specified in the scope of each item in the array. If you supply addional arguments they will
  * be applied to the function.
  *
  * ```
  *
  * function person(name, age){
  *     return {
  *         getName : function(){
  *             return name;
  *         },
  *         setName : function(newName){
  *             name = newName;
  *         },
  *
  *         getOlder : function(){
  *             age++;
  *             return this;
  *         },
  *
  *         getAge : function(){
  *             return age;
  *         }
  *     };
  * }
  *
  * var arr = [person("Bob", 40), person("Alice", 35), person("Fred", 50), person("Johnny", 56)];
  *
  * console.log(comb.array.invoke(arr, "getName")); //["Bob", "Alice", "Fred", "Johnny"]
  *
  * console.log(comb.array(arr).invoke("getOlder").invoke("getAge")); //[41, 36, 51, 57];
  *
  * ```
  *
  * @param {Array} arr the array to iterate and invoke the functions on
  * @param {String|Function} func the function to invoke, if it is a string then the function will be looked up on the
  * each item in the array and invoked
  * @param [args=null] variable number of arguments to apply to the function
  * @return {Array} the return values of the functions invoked.
  *
  * @static
  * @memberOf comb.array
  */
1function invoke(arr, func, args) {
8    args = argsToArray(arguments, 2);
8    return map(arr, function (item) {
32        var exec = isString(func) ? item[func] : func;
32        return exec.apply(item, args);
     });
 }
 
 
1var comb = exports;
 
 /**
  * @namespace Utilities for working with arrays.
  *
  * The `comb.array` namespace can be used to decorate arrays with additional chainable funcitonality.
  *
  * ```
  *
  * var arr = comb.array([1,3,2,5,4,6]);
  * console.log(arr.sum()) //21
  * console.log(arr.sort()) //[1,2,3,4,5,6]
  * console.log(arr.min()) //[1]
  * console.log(arr.max()) [6]
  *
  * ```
  *
  * @function
  * @ignoreCode
  */
 
1comb.array = {
     toArray:toArray,
     sum:sum,
     avg:avg,
     sort:sort,
     min:min,
     max:max,
     difference:difference,
     removeDuplicates:removeDuplicates,
     unique:unique,
     rotate:rotate,
     permutations:permutations,
     zip:zip,
     transpose:transpose,
     valuesAt:valuesAt,
     union:union,
     intersect:intersect,
     powerSet:powerSet,
     cartesian:cartesian,
     compact:compact,
     multiply:multiply,
     flatten:flatten,
     pluck:pluck,
     invoke:invoke,
     forEach:forEach,
     map:map,
     filter:filter,
     reduce:reduce,
     reduceRight:reduceRight,
     some:some,
     every:every,
     indexOf:indexOf,
     lastIndexOf:lastIndexOf
 };
 
 
 
 
 
 
 

1var func = require("./functions"),
 		obj = require("./object");
 
1var comb = exports;
 
 
1var wrapper = function() {
8	return function() {
31		var c = arguments.callee, listeners = c.__listeners, func = c.func, r;
31		if (func) {
31			r = func.apply(this, arguments);
 		}
31		for (var i = 0; i < listeners.length; i++) {
39			var lis = listeners[i];
39			if (lis) {
30				lis.apply(this, arguments);
 			}
 		}
31		return r;
 
 	}
 };
 
 
1var listeners = {};
1obj.merge(comb, {
             /**@lends comb*/
 			/**
 			 * Disconnects a listener to a function
 			 * @param {handle} A handle returned from comb.connect
 			 */
 			disconnect : function(handle) {
10				if (handle && handle.length == 3) {
9					var obj = handle[0], method = handle[1], cb = handle[2];
9					if (typeof method != "string") throw "comb.disconnect : When calling disconnect the method must be string";
9					var scope = obj || global, ls;
9					if (typeof scope[method] == "function") {
8						ls = scope[method].__listeners;
8						if (ls && cb-- > 0) {
 							//we dont want to splice it because our indexing will get off
8							ls[cb] = null;
 						}
 					} else {
1						throw new Error("unknown method " + method + " in object " + obj);
 					}
 				} else {
1					throw "comb.disconnect : invalid handle"
 				}
 			},
 
 			/**
 			 * Function to listen when other functions are called
 			 *
 			 * @example
 			 *
 			 *  comb.connect(obj, "event", myfunc);
 			 *  comb.connect(obj, "event", "log", console);
 			 *
 			 * @param {Object} obj the object in which the method you are connecting to resides
 			 * @param {String} method the name of the method to connect to
 			 * @param {Function} cb the function to callback
 			 * @param {Object} [scope] the scope to call the specified cb in
 			 *
 			 * @returns {Array} handle to pass to {@link comb.disconnect}
 			 */
 			connect : function(obj, method, cb, scope) {
14				var index;
14				if (typeof method != "string") throw new Error("When calling connect the method must be string");
14				if (!func.isFunction(cb)) throw new Error("When calling connect callback must be a string");
14				var scope = obj || global, listeners, newMethod;
14				if (typeof scope[method] == "function") {
13					listeners = scope[method].__listeners;
13					if (!listeners) {
8						newMethod = wrapper();
8						newMethod.func = obj[method];
8						listeners = (newMethod.__listeners = []);
8						scope[method] = newMethod;
 					}
13					index = listeners.push(cb);
 				} else {
1					throw new Error("unknow method " + method + " in object " + obj);
 				}
13				return [obj, method, index];
 			},
 
 
 			/**
 			 * Broadcasts an event to all listeners
 			 * NOTE : the function takes a variable number of arguments
 			 *        i.e. all arguments after the topic will be passed to the listeners
 			 *
 			 * @example
 			 *
 			 *
 			 * comb.broadcast("hello", "hello world");
 			 * //the args "hello" and "world" will be passed to any listener of the topic
 			 * //"hello"
 			 * comb.broadcast("hello", "hello", "world");
 			 *
 			 * @param  {String} topic the topic to brodcast
 			 * @param params the information to bradcast
 			 */
 			broadcast : function() {
4				var args = Array.prototype.slice.call(arguments);
4				var topic = args.splice(0, 1)[0];
4				if (topic) {
4					var list = listeners[topic];
4					if (list) {
4						for (var i = list.length - 1; i >= 0; i--) {
4							var han = list[i], cb = han.cb;
4							if (cb) {
4								cb.apply(this, args);
 							}
 						}
 					}
 				}
 			},
 
 			/**
 			 * Listen for the broadcast of certain events
 			 *
 			 * @example
 			 *  comb.listen("hello", function(arg1, arg2){
 			 *     console.log(arg1);
 			 *     console.log(arg2);
 			 *  });
 			 *
 			 * @param {String} topic the topic to listen for
 			 * @param {Function} callback the funciton to call when the topic is published
 			 *
 			 * @returns a handle to pass to {@link comb.unListen}
 			 */
 			listen : function(topic, callback) {
3				if (!func.isFunction(callback)) throw new Error("callback must be a function");
3				var handle = {
 					topic : topic,
 					cb : callback,
 					pos : null
 				};
3				var list = listeners[topic];
3				if (!list) {
3					list = (listeners[topic] = []);
 				}
3				list.push(handle);
3				handle.pos = list.length - 1;
3				return handle;
 			},
 
 			/**
 			 * Disconnects a listener
 			 *
 			 * @param handle a handle returned from {@link comb.listen}
 			 */
 			unListen : function(handle) {
2				if (handle) {
2					var topic = handle.topic, list = listeners[topic];
2					if (list) {
2						for (var i = list.length - 1; i >= 0; i--) {
2							if (list[i] == handle) {
2								list.splice(i, 1);
 							}
 						}
2						if (!list.length) {
2							delete listeners[topic];
 						}
 					}
 				}
 			}
 
 		});
 

1var string = require("./string").string;
 
 /**
  * @ignore
  * Based on DOJO Date Implementation
  *
  * Dojo is available under *either* the terms of the modified BSD license *or* the
  * Academic Free License version 2.1. As a recipient of Dojo, you may choose which
  * license to receive this code under (except as noted in per-module LICENSE
  * files). Some modules may not be the copyright of the Dojo Foundation. These
  * modules contain explicit declarations of copyright in both the LICENSE files in
  * the directories in which they reside and in the code itself. No external
  * contributions are allowed under licenses which are fundamentally incompatible
  * with the AFL or BSD licenses that Dojo is distributed under.
  *
  */
 
1var floor = Math.floor, round = Math.round, min = Math.min, pow = Math.pow, ceil = Math.ceil, abs = Math.abs;
1var monthNames = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
1var monthAbbr = ["Jan.", "Feb.", "Mar.", "Apr.", "May.", "Jun.", "Jul.", "Aug.", "Sep.", "Oct.", "Nov.", "Dec."];
1var monthLetter = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"];
1var dayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
1var dayAbbr = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
1var dayLetter = ["S", "M", "T", "W", "T", "F", "S"];
1var eraNames = ["Before Christ", "Anno Domini"];
1var eraAbbr = ["BC", "AD"];
1var eraLetter = ["B", "A"];
 
 
1var comb = exports, date;
 /**
  * Determines if obj is a Date
  *
  * @param {Anything} obj the thing to test if it is a Date
  * @memberOf comb
  * @returns {Boolean} true if it is a Date false otherwise
  */
1comb.isDate = function (obj) {
1233    var undef;
1233    return (obj !== undef && typeof obj === "object" && obj instanceof Date);
 };
 
1function getDayOfYear(/*Date*/dateObject, utc) {
     // summary: gets the day of the year as represented by dateObject
6    return date.difference(new Date(dateObject.getFullYear(), 0, 1, dateObject.getHours()), dateObject, null, utc) + 1; // Number
 }
 
1function getWeekOfYear(/*Date*/dateObject, /*Number*/firstDayOfWeek, utc) {
4    firstDayOfWeek = firstDayOfWeek || 0;
4    var fullYear = dateObject[utc ? "getUTCFullYear" : "getFullYear"]();
4    var firstDayOfYear = new Date(fullYear, 0, 1).getDay(),
         adj = (firstDayOfYear - firstDayOfWeek + 7) % 7,
         week = floor((getDayOfYear(dateObject) + adj - 1) / 7);
 
     // if year starts on the specified day, start counting weeks at 1
4    if (firstDayOfYear == firstDayOfWeek) {
4        week++;
     }
 
4    return week; // Number
 }
 
1function buildDateEXP(pattern, tokens) {
55    return pattern.replace(/([a-z])\1*/ig,
         function (match) {
             // Build a simple regexp.  Avoid captures, which would ruin the tokens list
197            var s,
                 c = match.charAt(0),
                 l = match.length,
                 p2 = '', p3 = '';
197            p2 = '0?';
197            p3 = '0{0,2}';
197            switch (c) {
                 case 'y':
33                    s = '\\d{2,4}';
33                    break;
                 case 'M':
33                    s = (l > 2) ? '\\S+?' : '1[0-2]|' + p2 + '[1-9]';
33                    break;
                 case 'D':
4                    s = '[12][0-9][0-9]|3[0-5][0-9]|36[0-6]|' + p3 + '[1-9][0-9]|' + p2 + '[1-9]';
4                    break;
                 case 'd':
31                    s = '3[01]|[12]\\d|' + p2 + '[1-9]';
31                    break;
                 case 'w':
4                    s = '[1-4][0-9]|5[0-3]|' + p2 + '[1-9]';
4                    break;
                 case 'E':
12                    s = '\\S+';
12                    break;
                 case 'h': //hour (1-12)
10                    s = '1[0-2]|' + p2 + '[1-9]';
10                    break;
                 case 'K': //hour (1-24)
4                    s = '1[01]|' + p2 + '\\d';
4                    break;
                 case 'H': //hour (0-23)
2                    s = '1\\d|2[0-3]|' + p2 + '\\d';
2                    break;
                 case 'k': //hour (1-24)
2                    s = '1\\d|2[0-4]|' + p2 + '[1-9]';
2                    break;
                 case 'm':
                 case 's':
30                    s = '[0-5]\\d';
30                    break;
                 case 'S':
10                    s = '\\d{' + l + '}';
10                    break;
                 case 'a':
6                    var am = 'AM', pm = 'PM';
 
6                    s = am + '|' + pm;
6                    if (am != am.toLowerCase()) {
6                        s += '|' + am.toLowerCase();
                     }
6                    if (pm != pm.toLowerCase()) {
6                        s += '|' + pm.toLowerCase();
                     }
6                    s = s.replace(/\./g, "\\.");
6                    break;
                 case 'v':
                 case 'z':
                 case 'Z':
                 case 'G':
                 case 'q':
                 case 'Q':
12                    s = ".*";
12                    break;
                 default:
4                    s = c == " " ? "\\s*" : c + "*";
 //				console.log("parse of date format, pattern=" + pattern);
             }
 
197            if (tokens) {
197                tokens.push(match);
             }
 
197            return "(" + s + ")"; // add capture
         }).replace(/[\xa0 ]/g, "[\\s\\xa0]"); // normalize whitespace.  Need explicit handling of \xa0 for IE.
 }
 
 
 /**
  * @namespace Utilities for Dates
  */
1comb.date = {
 
     /**@lends comb.date*/
 
     /**
      * Returns the number of days in the month of a date
      *
      * @example
      *
      *  comb.date.getDaysInMonth(new Date(2006, 1, 1)); //28
      *  comb.date.getDaysInMonth(new Date(2004, 1, 1)); //29
      *  comb.date.getDaysInMonth(new Date(2006, 2, 1)); //31
      *  comb.date.getDaysInMonth(new Date(2006, 3, 1)); //30
      *  comb.date.getDaysInMonth(new Date(2006, 4, 1)); //31
      *  comb.date.getDaysInMonth(new Date(2006, 5, 1)); //30
      *  comb.date.getDaysInMonth(new Date(2006, 6, 1)); //31
      * @param {Date} dateObject the date containing the month
      * @return {Number} the number of days in the month
      */
     getDaysInMonth:function (/*Date*/dateObject) {
         //	summary:
         //		Returns the number of days in the month used by dateObject
36        var month = dateObject.getMonth();
36        var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
36        if (month == 1 && date.isLeapYear(dateObject)) {
6            return 29;
         } // Number
30        return days[month]; // Number
     },
 
     /**
      * Determines if a date is a leap year
      *
      * @example
      *
      *  comb.date.isLeapYear(new Date(1600, 0, 1)); //true
      *  comb.date.isLeapYear(new Date(2004, 0, 1)); //true
      *  comb.date.isLeapYear(new Date(2000, 0, 1)); //true
      *  comb.date.isLeapYear(new Date(2006, 0, 1)); //false
      *  comb.date.isLeapYear(new Date(1900, 0, 1)); //false
      *  comb.date.isLeapYear(new Date(1800, 0, 1)); //false
      *  comb.date.isLeapYear(new Date(1700, 0, 1)); //false
      *
      * @param {Date} dateObject
      * @returns {Boolean} true if it is a leap year false otherwise
      */
     isLeapYear:function (/*Date*/dateObject, utc) {
28        var year = dateObject[utc ? "getUTCFullYear" : "getFullYear"]();
28        return !(year % 400) || (!(year % 4) && !!(year % 100)); // Boolean
     },
 
     /**
      * Determines if a date is on a weekend
      *
      * @example
      *
      * var thursday = new Date(2006, 8, 21);
      * var saturday = new Date(2006, 8, 23);
      * var sunday = new Date(2006, 8, 24);
      * var monday = new Date(2006, 8, 25);
      * comb.date.isWeekend(thursday)); //false
      * comb.date.isWeekend(saturday); //true
      * comb.date.isWeekend(sunday); //true
      * comb.date.isWeekend(monday)); //false
      *
      * @param {Date} dateObject the date to test
      *
      * @returns {Boolean} true if the date is a weekend
      */
     isWeekend:function (/*Date?*/dateObject, utc) {
         // summary:
         //	Determines if the date falls on a weekend, according to local custom.
4        var day = (dateObject || new Date())[utc ? "getUTCDay" : "getDay"]();
4        return day == 0 || day == 6;
     },
 
     /**
      * Get the timezone of a date
      *
      * @example
      *  //just setting the strLocal to simulate the toString() of a date
      *  dt.str = 'Sun Sep 17 2006 22:25:51 GMT-0500 (CDT)';
      *  //just setting the strLocal to simulate the locale
      *  dt.strLocale = 'Sun 17 Sep 2006 10:25:51 PM CDT';
      *  comb.date.getTimezoneName(dt); //'CDT'
      *  dt.str = 'Sun Sep 17 2006 22:57:18 GMT-0500 (CDT)';
      *  dt.strLocale = 'Sun Sep 17 22:57:18 2006';
      *  comb.date.getTimezoneName(dt); //'CDT'
      * @param dateObject the date to get the timezone from
      *
      * @returns {String} the timezone of the date
      */
     getTimezoneName:function (/*Date*/dateObject) {
35        var str = dateObject.toString();
35        var tz = '';
35        var pos = str.indexOf('(');
35        if (pos > -1) {
31            tz = str.substring(++pos, str.indexOf(')'));
         }
35        return tz; // String
     },
 
 
     /**
      * Compares two dates
      *
      * @example
      *
      * var d1 = new Date();
      * d1.setHours(0);
      * comb.date.compare(d1, d1); // 0
      *
      *  var d1 = new Date();
      *  d1.setHours(0);
      *  var d2 = new Date();
      *  d2.setFullYear(2005);
      *  d2.setHours(12);
      *  comb.date.compare(d1, d2, "date"); // 1
      *  comb.date.compare(d1, d2, "datetime"); // 1
      *
      *  var d1 = new Date();
      *  d1.setHours(0);
      *  var d2 = new Date();
      *  d2.setFullYear(2005);
      *  d2.setHours(12);
      *  comb.date.compare(d2, d1, "date"); // -1
      *  comb.date.compare(d1, d2, "time"); //-1
      *
      * @param {Date|String} date1 the date to comapare
      * @param {Date|String} [date2=new Date()] the date to compare date1 againse
      * @param {"date"|"time"|"datetime"} portion compares the portion specified
      *
      * @returns -1 if date1 is < date2 0 if date1 === date2  1 if date1 > date2
      */
     compare:function (/*Date*/date1, /*Date*/date2, /*String*/portion) {
10        date1 = new Date(date1);
10        date2 = new Date((date2 || new Date()));
 
10        if (portion == "date") {
             // Ignore times and compare dates.
4            date1.setHours(0, 0, 0, 0);
4            date2.setHours(0, 0, 0, 0);
6        } else if (portion == "time") {
             // Ignore dates and compare times.
2            date1.setFullYear(0, 0, 0);
2            date2.setFullYear(0, 0, 0);
         }
10        var ret = 0;
10        date1 > date2 && (ret = 1);
10        date1 < date2 && (ret = -1);
10        return ret; // int
     },
 
 
     /**
      * Adds a specified interval and amount to a date
      *
      * @example
      *  var dtA = new Date(2005, 11, 27);
      *  comb.date.add(dtA, "year", 1); //new Date(2006, 11, 27);
      *  comb.date.add(dtA, "years", 1); //new Date(2006, 11, 27);
      *
      *  dtA = new Date(2000, 0, 1);
      *  comb.date.add(dtA, "quarter", 1); //new Date(2000, 3, 1);
      *  comb.date.add(dtA, "quarters", 1); //new Date(2000, 3, 1);
      *
      *  dtA = new Date(2000, 0, 1);
      *  comb.date.add(dtA, "month", 1); //new Date(2000, 1, 1);
      *  comb.date.add(dtA, "months", 1); //new Date(2000, 1, 1);
      *
      *  dtA = new Date(2000, 0, 31);
      *  comb.date.add(dtA, "month", 1); //new Date(2000, 1, 29);
      *  comb.date.add(dtA, "months", 1); //new Date(2000, 1, 29);
      *
      *  dtA = new Date(2000, 0, 1);
      *  comb.date.add(dtA, "week", 1); //new Date(2000, 0, 8);
      *  comb.date.add(dtA, "weeks", 1); //new Date(2000, 0, 8);
      *
      *  dtA = new Date(2000, 0, 1);
      *  comb.date.add(dtA, "day", 1); //new Date(2000, 0, 2);
      *
      *  dtA = new Date(2000, 0, 1);
      *  comb.date.add(dtA, "weekday", 1); //new Date(2000, 0, 3);
      *
      *  dtA = new Date(2000, 0, 1, 11);
      *  comb.date.add(dtA, "hour", 1); //new Date(2000, 0, 1, 12);
      *
      *  dtA = new Date(2000, 11, 31, 23, 59);
      *  comb.date.add(dtA, "minute", 1); //new Date(2001, 0, 1, 0, 0);
      *
      *  dtA = new Date(2000, 11, 31, 23, 59, 59);
      *  comb.date.add(dtA, "second", 1); //new Date(2001, 0, 1, 0, 0, 0);
      *
      *  dtA = new Date(2000, 11, 31, 23, 59, 59, 999);
      *  comb.date.add(dtA, "millisecond", 1); //new Date(2001, 0, 1, 0, 0, 0, 0);
      *
      * @param {Date} date
      * @param {String} interval the interval to add
      *  <ul>
      *      <li>day | days</li>
      *      <li>weekday | weekdays</li>
      *      <li>year | years</li>
      *      <li>week | weeks</li>
      *      <li>quarter | quarters</li>
      *      <li>months | months</li>
      *      <li>hour | hours</li>
      *      <li>minute | minutes</li>
      *      <li>second | seconds</li>
      *      <li>millisecond | milliseconds</li>
      *  </ul>
      * @param {Number} [amount=0] the amount to add
      */
     add:function (/*Date*/date, /*String*/interval, /*int*/amount) {
216        amount = amount | 0
216        var sum = new Date(date);
216        var fixOvershoot = false;
216        var property = "Date";
 
         //noinspection FallthroughInSwitchStatementJS
216        switch (interval) {
             case "day":
             case "days" :
60                break;
             case "weekday":
             case "weekdays":
                 // Divide the increment time span into weekspans plus leftover days
                 // e.g., 8 days is one 5-day weekspan / and two leftover days
                 // Can't have zero leftover days, so numbers divisible by 5 get
                 // a days value of 5, and the remaining days make up the number of weeks
32                var days, weeks, mod = amount % 5, strt = date.getDay(), adj = 0;
32                if (!mod) {
12                    days = (amount > 0) ? 5 : -5;
12                    weeks = (amount > 0) ? ((amount - 5) / 5) : ((amount + 5) / 5);
                 } else {
20                    days = mod;
20                    weeks = parseInt(amount / 5);
                 }
32                if (strt == 6 && amount > 0) {
4                    adj = 1;
28                } else if (strt == 0 && amount < 0) {
                     // Orig date is Sun / negative increment
                     // Jump back over Sat
8                    adj = -1;
                 }
                 // Get weekday val for the new date
32                var trgt = strt + days;
                 // New date is on Sat or Sun
32                if (trgt == 0 || trgt == 6) {
4                    adj = (amount > 0) ? 2 : -2;
                 }
                 // Increment by number of weeks plus leftover days plus
                 // weekend adjustments
32                amount = (7 * weeks) + days + adj;
32                break;
             case "year":
             case "years":
34                property = "FullYear";
34                fixOvershoot = true;
34                break;
             case "week":
             case "weeks":
6                amount *= 7;
6                break;
             case "quarter":
             case "quarters" :
                 // Naive quarter is just three months
18                amount *= 3;
             case "month":
             case "months":
                 // Reset to last day of month if you overshoot
38                fixOvershoot = true;
38                property = "Month";
38                break;
             default:
46                interval = interval.replace(/s$/, "");
46                property = "UTC" + interval.charAt(0).toUpperCase() + interval.substring(1) + "s";
         }
 
216        if (property) {
216            sum["set" + property](sum["get" + property]() + amount);
         }
 
216        if (fixOvershoot && (sum.getDate() < date.getDate())) {
26            sum.setDate(0);
         }
 
216        return sum; // Date
     },
 
     /**
      * Finds the difference between two dates based on the specified interval
      *
      * @example
      *
      * var dtA, dtB;
      *
      * dtA = new Date(2005, 11, 27);
      * dtB = new Date(2006, 11, 27);
      * comb.date.difference(dtA, dtB, "year"); //1
      *
      * dtA = new Date(2000, 1, 29);
      * dtB = new Date(2001, 2, 1);
      * comb.date.difference(dtA, dtB, "quarter"); //4
      * comb.date.difference(dtA, dtB, "month"); //13
      *
      * dtA = new Date(2000, 1, 1);
      * dtB = new Date(2000, 1, 8);
      * comb.date.difference(dtA, dtB, "week"); //1
      *
      * dtA = new Date(2000, 1, 29);
      * dtB = new Date(2000, 2, 1);
      * comb.date.difference(dtA, dtB, "day"); //1
      *
      * dtA = new Date(2006, 7, 3);
      * dtB = new Date(2006, 7, 11);
      * comb.date.difference(dtA, dtB, "weekday"); //6
      *
      * dtA = new Date(2000, 11, 31, 23);
      * dtB = new Date(2001, 0, 1, 0);
      * comb.date.difference(dtA, dtB, "hour"); //1
      *
      * dtA = new Date(2000, 11, 31, 23, 59);
      * dtB = new Date(2001, 0, 1, 0, 0);
      * comb.date.difference(dtA, dtB, "minute"); //1
      *
      * dtA = new Date(2000, 11, 31, 23, 59, 59);
      * dtB = new Date(2001, 0, 1, 0, 0, 0);
      * comb.date.difference(dtA, dtB, "second"); //1
      *
      * dtA = new Date(2000, 11, 31, 23, 59, 59, 999);
      * dtB = new Date(2001, 0, 1, 0, 0, 0, 0);
      * comb.date.difference(dtA, dtB, "millisecond"); //1
      *
      *
      * @param {Date} date1
      * @param {Date} [date2 = new Date()]
      * @param {String} [interval = "day"] the intercal to find the difference of.
      *   <ul>
      *      <li>day | days</li>
      *      <li>weekday | weekdays</li>
      *      <li>year | years</li>
      *      <li>week | weeks</li>
      *      <li>quarter | quarters</li>
      *      <li>months | months</li>
      *      <li>hour | hours</li>
      *      <li>minute | minutes</li>
      *      <li>second | seconds</li>
      *      <li>millisecond | milliseconds</li>
      *  </ul>
      */
     difference:function (/*Date*/date1, /*Date?*/date2, /*String*/interval, utc) {
338        date2 = date2 || new Date();
338        interval = interval || "day";
338        var yearDiff = date2.getFullYear() - date1.getFullYear();
338        var delta = 1; // Integer return value
 
338        switch (interval) {
             case "quarter":
             case "quarters":
10                var m1 = date1[utc ? "getUTCMonth" : "getMonth"]();
10                var m2 = date2[utc ? "getUTCMonth" : "getMonth"]();
                 // Figure out which quarter the months are in
10                var q1 = floor(m1 / 3) + 1;
10                var q2 = floor(m2 / 3) + 1;
                 // Add quarters for any year difference between the dates
10                q2 += (yearDiff * 4);
10                delta = q2 - q1;
10                break;
             case "weekday":
             case "weekdays":
56                var days = round(date.difference(date1, date2, "day", utc));
56                var weeks = parseInt(date.difference(date1, date2, "week", utc));
56                var mod = days % 7;
 
                 // Even number of weeks
56                if (mod == 0) {
14                    days = weeks * 5;
                 } else {
                     // Weeks plus spare change (< 7 days)
42                    var adj = 0;
42                    var aDay = date1[utc ? "getUTCDay" : "getDay"]();
42                    var bDay = date2[utc ? "getUTCDay" : "getDay"]();
 
42                    weeks = parseInt(days / 7);
42                    mod = days % 7;
                     // Mark the date advanced by the number of
                     // round weeks (may be zero)
42                    var dtMark = new Date(date1);
42                    dtMark.setDate(dtMark[utc ? "getUTCDate" : "getDate"]() + (weeks * 7));
42                    var dayMark = dtMark[utc ? "getUTCDay" : "getDay"]();
 
                     // Spare change days -- 6 or less
42                    if (days > 0) {
24                        switch (true) {
                             // Range starts on Sat
                             case (aDay == 6 || bDay == 6):
6                                adj = -1;
6                                break;
                             // Range starts on Sun
                             case aDay == 0:
8                                adj = 0;
8                                break;
                             // Range ends on Sun
                             case bDay == 0:
2                                adj = -2;
2                                break;
                             // Range contains weekend
                             case (dayMark + mod) > 5:
2                                adj = -2;
                         }
18                    } else if (days < 0) {
18                        switch (true) {
                             // Range starts on Sat
                             case aDay == 6:
2                                adj = 0;
2                                break;
                             // Range starts on Sun
                             case aDay == 0:
6                                adj = 1;
6                                break;
                             // Range ends on Sat
                             case bDay == 6:
2                                adj = 2;
2                                break;
                             // Range ends on Sun
                             case bDay == 0:
2                                adj = 1;
2                                break;
                             // Range contains weekend
                             case (dayMark + mod) < 0:
2                                adj = 2;
                         }
                     }
42                    days += adj;
42                    days -= (weeks * 2);
                 }
56                delta = days;
56                break;
             case "year":
             case "years":
16                delta = yearDiff;
16                break;
             case "month":
             case "months":
10                var m1 = date1[utc ? "getUTCMonth" : "getMonth"]();
10                var m2 = date2[utc ? "getUTCMonth" : "getMonth"]();
10                delta = (m2 - m1) + (yearDiff * 12);
10                break;
             case "week":
             case "weeks":
64                delta = parseInt(date.difference(date1, date2, "day", utc) / 7);
64                break;
             case "day":
             case "days":
148                delta /= 24;
             case "hour":
             case "hours":
160                delta /= 60;
             case "minute":
             case "minutes":
168                delta /= 60;
             case "second":
             case "seconds":
174                delta /= 1000;
             case "millisecond":
             case "milliseconds":
182                delta *= date2.getTime() - date1.getTime();
         }
 
         // Round for fractional values and DST leaps
338        return round(delta); // Number (integer)
     },
 
 
     /**
      * Parses a date string into a date object
      *
      * @example
      *  var aug_11_2006 = new Date(2006, 7, 11, 0);
      *  comb.date.parse("08/11/06", "MM/dd/yy"); //aug_11_2006
      *  comb.date.parse("11Aug2006", 'ddMMMyyyy'); //aug_11_2006
      *  comb.date.parse("Aug2006", 'MMMyyyy'); //new Date(2006, 7, 1)
      *  comb.date.parse("Aug 11, 2006", "MMM dd, yyyy"); //aug_11_2006
      *  comb.date.parse("August 11, 2006", "MMMM dd, yyyy"); //aug_11_2006
      *  comb.date.parse("Friday, August 11, 2006", "EEEE, MMMM dd, yyyy"); //aug_11_2006
      *
      * @param {String} dateStr The string to parse
      * @param {String} format the format of the date composed of the following options
      * <ul>
      *                  <li> G    Era designator    Text    AD</li>
      *                  <li> y    Year    Year    1996; 96</li>
      *                  <li> M    Month in year    Month    July; Jul; 07</li>
      *                  <li> w    Week in year    Number    27</li>
      *                  <li> W    Week in month    Number    2</li>
      *                  <li> D    Day in year    Number    189</li>
      *                  <li> d    Day in month    Number    10</li>
      *                  <li> E    Day in week    Text    Tuesday; Tue</li>
      *                  <li> a    Am/pm marker    Text    PM</li>
      *                  <li> H    Hour in day (0-23)    Number    0</li>
      *                  <li> k    Hour in day (1-24)    Number    24</li>
      *                  <li> K    Hour in am/pm (0-11)    Number    0</li>
      *                  <li> h    Hour in am/pm (1-12)    Number    12</li>
      *                  <li> m    Minute in hour    Number    30</li>
      *                  <li> s    Second in minute    Number    55</li>
      *                  <li> S    Millisecond    Number    978</li>
      *                  <li> z    Time zone    General time zone    Pacific Standard Time; PST; GMT-08:00</li>
      *                  <li> Z    Time zone    RFC 822 time zone    -0800 </li>
      * </ul>
      *
      * @returns {Date} the parsed date
      *
      *
      */
     parse:function (dateStr, format) {
55        if (!format) throw new Error('format required when calling comb.date.parse');
55        var tokens = [], regexp = buildDateEXP(format, tokens),
             re = new RegExp("^" + regexp + "$", "i"),
             match = re.exec(dateStr);
55        if (!match) {
7            return null;
         } // null
48        var result = [1970, 0, 1, 0, 0, 0, 0], // will get converted to a Date at the end
             amPm = "",
             valid = match.every(function (v, i) {
212                if (!i) {
48                    return true;
                 }
164                var token = tokens[i - 1];
164                var l = token.length;
164                switch (token.charAt(0)) {
                     case 'y':
26                        if (v < 100) {
6                            v = parseInt(v, 10);
                             //choose century to apply, according to a sliding window
                             //of 80 years before and 20 years after present year
6                            var year = '' + new Date().getFullYear(),
                                 century = year.substring(0, 2) * 100,
                                 cutoff = min(year.substring(2, 4) + 20, 99);
6                            result[0] = (v < cutoff) ? century + v : century - 100 + v;
                         } else {
20                            result[0] = v;
                         }
26                        break;
                     case 'M':
28                        if (l > 2) {
20                            var months = monthNames;
20                            if (l === 3) {
8                                months = monthAbbr;
                             }
                             //Tolerate abbreviating period in month part
                             //Case-insensitive comparison
20                            v = v.replace(".", "").toLowerCase();
20                            months = months.map(function (s) {
240                                return s.replace(".", "").toLowerCase();
                             });
20                            if ((v = months.indexOf(v)) == -1) {
2                                return false;
                             }
                         } else {
8                            v--;
                         }
26                        result[1] = v;
26                        break;
                     case 'E':
                     case 'e':
12                        var days = dayNames;
12                        if (l == 3) {
4                            days = dayAbbr;
                         }
                         //Case-insensitive comparison
12                        v = v.toLowerCase();
12                        days = days.map(function (d) {
84                            return d.toLowerCase();
                         });
12                        var d = days.indexOf(v);
12                        if (d == -1) {
4                            v = parseInt(v);
4                            if (isNaN(v) || v > days.length) {
2                                return false;
                             }
                         } else {
8                            v = d;
                         }
10                        break;
                     case 'D':
4                        result[1] = 0;
                     case 'd':
30                        result[2] = v;
30                        break;
                     case 'a': //am/pm
4                        var am = "am";
4                        var pm = "pm";
4                        var period = /\./g;
4                        v = v.replace(period, '').toLowerCase();
                         // we might not have seen the hours field yet, so store the state and apply hour change later
4                        amPm = (v == pm) ? 'p' : (v == am) ? 'a' : '';
4                        break;
                     case 'k': //hour (0-11)
2                        if (v == 24) {
2                            v = 0;
                         }
                     // fallthrough...
                     case 'h': //hour (1-12)
                     case 'H': //hour (0-23)
                     case 'K': //hour (0-11)
                         //in the 12-hour case, adjusting for am/pm requires the 'a' part
                         //which could come before or after the hour, so we will adjust later
14                        result[3] = v;
14                        break;
                     case 'm': //minutes
14                        result[4] = v;
14                        break;
                     case 's': //seconds
10                        result[5] = v;
10                        break;
                     case 'S': //milliseconds
8                        result[6] = v;
8                        break;
                 }
160                return true;
             });
48        if (valid) {
44            var hours = +result[3];
             //account for am/pm
44            if (amPm === 'p' && hours < 12) {
2                result[3] = hours + 12; //e.g., 3pm -> 15
42            } else if (amPm === 'a' && hours == 12) {
2                result[3] = 0; //12am -> 0
             }
44            var dateObject = new Date(result[0], result[1], result[2], result[3], result[4], result[5], result[6]); // Date
44            var dateToken = (tokens.indexOf('d') != -1),
                 monthToken = (tokens.indexOf('M') != -1),
                 month = result[1],
                 day = result[2],
                 dateMonth = dateObject.getMonth(),
                 dateDay = dateObject.getDate();
44            if ((monthToken && dateMonth > month) || (dateToken && dateDay > day)) {
2                return null;
             }
42            return dateObject; // Date
         } else {
4            return null;
         }
     },
 
     /**
      * Formats a date to the specidifed format string
      *
      * @example
      *
      * var date = new Date(2006, 7, 11, 0, 55, 12, 345);
      * comb.date.format(date, "EEEE, MMMM dd, yyyy"); //"Friday, August 11, 2006"
      * comb.date.format(date, "M/dd/yy"); //"8/11/06"
      * comb.date.format(date, "E"); //"6"
      * comb.date.format(date, "h:m a"); //"12:55 AM"
      * comb.date.format(date, 'h:m:s'); //"12:55:12"
      * comb.date.format(date, 'h:m:s.SS'); //"12:55:12.35"
      * comb.date.format(date, 'k:m:s.SS'); //"24:55:12.35"
      * comb.date.format(date, 'H:m:s.SS'); //"0:55:12.35"
      * comb.date.format(date, "ddMMyyyy"); //"11082006"
      *
      * @param date the date to format
      * @param {String} format the format of the date composed of the following options
      * <ul>
      *                  <li> G    Era designator    Text    AD</li>
      *                  <li> y    Year    Year    1996; 96</li>
      *                  <li> M    Month in year    Month    July; Jul; 07</li>
      *                  <li> w    Week in year    Number    27</li>
      *                  <li> W    Week in month    Number    2</li>
      *                  <li> D    Day in year    Number    189</li>
      *                  <li> d    Day in month    Number    10</li>
      *                  <li> E    Day in week    Text    Tuesday; Tue</li>
      *                  <li> a    Am/pm marker    Text    PM</li>
      *                  <li> H    Hour in day (0-23)    Number    0</li>
      *                  <li> k    Hour in day (1-24)    Number    24</li>
      *                  <li> K    Hour in am/pm (0-11)    Number    0</li>
      *                  <li> h    Hour in am/pm (1-12)    Number    12</li>
      *                  <li> m    Minute in hour    Number    30</li>
      *                  <li> s    Second in minute    Number    55</li>
      *                  <li> S    Millisecond    Number    978</li>
      *                  <li> z    Time zone    General time zone    Pacific Standard Time; PST; GMT-08:00</li>
      *                  <li> Z    Time zone    RFC 822 time zone    -0800 </li>
      * </ul>
      */
     format:function (date, format, utc) {
79        utc = utc || false;
79        var fullYear, month, day, d, hour, minute, second, millisecond;
79        if (utc) {
26            fullYear = date.getUTCFullYear(),
                 month = date.getUTCMonth(),
                 day = date.getUTCDay(),
                 d = date.getUTCDate(),
                 hour = date.getUTCHours(),
                 minute = date.getUTCMinutes(),
                 second = date.getUTCSeconds(),
                 millisecond = date.getUTCMilliseconds();
         } else {
53            fullYear = date.getFullYear(),
                 month = date.getMonth(),
                 d = date.getDate(),
                 day = date.getDay(),
                 hour = date.getHours(),
                 minute = date.getMinutes(),
                 second = date.getSeconds(),
                 millisecond = date.getMilliseconds();
         }
79        return format.replace(/([a-z])\1*/ig, function (match, options) {
381            var s, pad, h,
                 c = match.charAt(0),
                 l = match.length;
 
381            switch (c) {
                 case 'd':
43                    s = "" + d;
                 case 'H':
74                    !s && (s = "" + hour);
                 case 'm':
115                    !s && (s = "" + minute);
                 case 's':
154                    !s && (s = "" + second);
154                    pad = true;
154                    break;
                 case 'G':
4                    s = ((l < 4) ? eraAbbr : eraNames)[fullYear < 0 ? 0 : 1];
4                    break;
                 case 'y':
49                    s = fullYear;
49                    if (l > 1) {
49                        l == 2 ? s = string.truncate("" + s, 2, true) : pad = true;
                     }
49                    break;
                 case 'Q':
                 case 'q':
6                    s = ceil((month + 1) / 3);
6                    pad = true;
6                    break;
                 case 'M':
43                    if (l < 3) {
33                        s = month + 1;
33                        pad = true;
                     } else {
10                        s = (l == 3 ? monthAbbr : monthNames)[month];
                     }
43                    break;
                 case 'w':
4                    s = getWeekOfYear(date, 0, utc), pad = true;
4                    break;
                 case 'D':
2                    s = getDayOfYear(date, utc), pad = true;
2                    break;
                 case 'E':
12                    if (l < 3) {
2                        s = day + 1;
2                        pad = true;
                     } else {
10                        s = (l == 3 ? dayAbbr : dayNames)[day];
                     }
12                    break;
                 case 'a':
2                    s = (hour < 12) ? 'AM' : 'PM';
2                    break;
                 case 'h':
6                    s = (hour % 12) || 12, pad = true;
6                    break;
                 case 'K':
2                    s = (hour % 12), pad = true;
2                    break;
                 case 'k':
2                    s = hour || 24, pad = true;
2                    break;
                 case 'S':
37                    s = round(millisecond * pow(10, l - 3)), pad = true;
37                    break;
                 case 'v':
                 case 'z':
31                    s = comb.date.getTimezoneName(date);
31                    if (s) {
27                        break;
                     }
4                    l = 4;
                 // fallthrough... use GMT if tz not available
                 case 'Z':
4                    var offset = date.getTimezoneOffset();
4                    var tz = [
                         (offset >= 0 ? "-" : "+"),
                         string.pad(floor(abs(offset) / 60), 2, "0"),
                         string.pad(abs(offset) % 60, 2, "0")
                     ];
4                    if (l == 4) {
4                        tz.splice(0, 0, "GMT");
4                        tz.splice(3, 0, ":");
                     }
4                    s = tz.join("");
4                    break;
 //				case 'Y': case 'u': case 'W': case 'F': case 'g': case 'A': case 'e':
 //					console.log(match+" modifier unimplemented");
                 default:
27                    s = match;
                 //  throw new Error("comb.date.format: invalid pattern char: " + match);
             }
381            if (pad) {
291                s = string.pad(s, l, '0');
             }
381            return s;
         });
     }
 
 };
 
1date = comb.date;
 
 /**
  * Adds the specified year/s to the current date.
  *
  * @example
  *
  * //assuming that current year is 2012
  * comb.yearsFromNow(1); //2013-mm-dd hh:MM:ss
  *
  * @param {Number} val the number of years to add
  *
  * @return {Date} a date with the number of years added
  */
1comb.yearsFromNow = function (val) {
1    return date.add(new Date(), "years", val);
 };
 
 /**
  * Subtracts the specified year/s from the current date.
  *
  * @param {Number} val the number of years to subtract
  *
  * @return {Date} a date with the number of years subtracted
  */
1comb.yearsAgo = function (val) {
1    return date.add(new Date(), "years", -val);
 };
 
 
 /**
  * Adds the specified month/s to the current date.
  *
  * @example
  *
  * //assuming that current month is february
  * comb.yearsFromNow(2); //yyyy-04-dd hh:MM:ss
  *
  * @param {Number} val the number of months to add
  *
  * @return {Date} a date with the number of years added
  */
1comb.monthsFromNow = function (val) {
1    return date.add(new Date(), "months", val);
 };
 
 
 /**
  * Subtracts the specified month/s from the current date.
  *
  * @param {Number} val the number of months to subtract
  *
  * @return {Date} a date with the number of months subtracted
  */
1comb.monthsAgo = function (val) {
1    return date.add(new Date(), "months", -val);
 };
 
 /**
  * Adds the specified day/s to the current date.
  *
  * @param {Number} val the number of days to add
  *
  * @return {Date} a date with the number of days added
  */
1comb.daysFromNow = function (val) {
27    return date.add(new Date(), "days", val);
 };
 
 /**
  * Subtracts the specified day/s from the current date.
  *
  * @param {Number} val the number of days to subtract
  *
  * @return {Date} a date with the number of days subtracted
  */
1comb.daysAgo = function (val) {
1    return date.add(new Date(), "days", -val);
 };
 
 /**
  * Adds the specified hour/s to the current date.
  *
  * @param {Number} val the number of hours to add
  *
  * @return {Date} a date with the number of hours added
  */
1comb.hoursFromNow = function (val) {
1    return date.add(new Date(), "hours", val);
 };
 
 
 /**
  * Subtracts the specified hour/s from the current date.
  *
  * @param {Number} val the number of hours to subtract
  *
  * @return {Date} a date with the number of hours subtracted
  */
1comb.hoursAgo = function (val) {
1    return date.add(new Date(), "hours", -val);
 };
 
 
 /**
  * Adds the specified minute/s to the current date.
  *
  * @param {Number} val the number of minutes to add
  *
  * @return {Date} a date with the number of minutes added
  */
1comb.minutesFromNow = function (val) {
1    return date.add(new Date(), "minutes", val);
 };
 
 
 /**
  * Subtracts the specified minute/s from the current date.
  *
  * @param {Number} val the number of minutes to subtract
  *
  * @return {Date} a date with the number of minutes subtracted
  */
1comb.minutesAgo = function (val) {
1    return date.add(new Date(), "minutes", -val);
 };
 
 
 /**
  * Adds the specified second/s to the current date.
  *
  * @param {Number} val the number of seconds to add
  *
  * @return {Date} a date with the number of seconds added
  */
1comb.secondsFromNow = function (val) {
1    return date.add(new Date(), "seconds", val);
 };
 
 
 /**
  * Subtracts the specified second/s from the current date.
  *
  * @param {Number} val the number of seconds to subtract
  *
  * @return {Date} a date with the number of seconds subtracted
  */
1comb.secondsAgo = function (val) {
1    return date.add(new Date(), "seconds", -val);
 };