1var obj = require("./object"), misc = require("./misc"), string = require("./string"), isString = string.isString, number = require("./number.js");
 
 
1var argsToArray = misc.argsToArray;
 
1var isArray = exports.isArray = function (obj) {
318    return Array.isArray(obj);
 };
 
1var cross = function (num, cross) {
7    var ret = cross.reduceRight(function (a, b) {
38        if (!isArray(b)) b = [b];
19        b.unshift(num)
19        a.unshift(b);
19        return a;
     }, []);
7    return ret;
 };
 
1var permute = function (num, cross, length) {
6    var ret = [];
6    for (var i = 0; i < cross.length; i++) {
12        ret.push([num].concat(array.rotate(cross, i)).slice(0, length));
     }
6    return ret;
 };
 
 
1var intersection = function (a, b) {
45    var ret = [];
45    if (isArray(a) && isArray(b)) {
45        if (a.length && b.length) {
35            var aOne = a[0];
35            if (b.indexOf(aOne) != -1) {
28                ret = [aOne].concat(intersection(a.slice(1), b));
             } else {
7                ret = intersection(a.slice(1), b);
             }
         }
     }
 
45    return ret;
 };
 
1var _sort = (function () {
 
1    var isAll = function (arr, test) {
12        return arr.every(test);
     };
 
1    var defaultCmp = function (a, b) {
39        return a - b;
     };
 
1    return function _sort(arr, property) {
22        var ret = [];
22        if (isArray(arr)) {
22            ret = arr.slice();
22            if (property) {
10                if (typeof property == "function") {
1                    ret.sort(property);
                 } else {
9                    ret.sort(function (a, b) {
27                        var aProp = a[property], bProp = b[property];
27                        if (isString(aProp) && isString(bProp)) {
9                            return aProp > bProp ? 1 : aProp < bProp ? -1 : 0;
                         } else {
18                            return aProp - bProp;
                         }
                     });
                 }
             } else {
12                if (isAll(ret, isString)) {
3                    ret.sort();
                 } else {
9                    ret.sort(defaultCmp);
                 }
             }
         }
22        return ret;
     };
 
 })();
 
1var comb = exports, array;
 /**
  * @namespace Utilities for Arrays
  */
1comb.array = {
     /**@lends comb.array*/
 
 
     /**
      * 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"]];
      */
     toArray:function (o) {
21        var ret = [];
21        if (o != null) {
20            var args = argsToArray(arguments);
20            if (args.length == 1) {
19                if (isArray(o)) {
12                    ret = o;
7                } else if (obj.isHash(o)) {
2                    for (var i in o) {
3                        if (o.hasOwnProperty(i)) {
3                            ret.push([i, o[i]]);
                         }
                     }
                 } else {
5                    ret.push(o);
                 }
             } else {
1                args.forEach(function (a) {
2                    ret = ret.concat(array.toArray(a));
                 })
             }
         }
21        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
      */
     sum:function (array) {
10        array = array || [];
10        if (array.length) {
8            return array.reduce(function (a, b) {
16                return a + b;
             });
         } else {
2            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.
      */
     avg:function (arr) {
6        arr = arr || [];
6        if (arr.length) {
4            var sum = array.sum(arr);
4            if (number.isNumber(sum)) {
1                return  sum / arr.length;
             } else {
3                throw new Error("Cannot average an array of non numbers.");
             }
         } else {
2            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.
      */
     sort:function (arr, cmp) {
8        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 {*}
      */
     min:function (arr, cmp) {
7        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.
      */
     max:function (arr, cmp) {
7        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.
      */
     difference:function (arr1, arr2) {
5        var ret = arr1, args = array.flatten(misc.argsToArray(arguments).slice(1));
5        if (isArray(arr1)) {
5            ret = arr1.filter(function (a) {
14                return args.indexOf(a) === -1;
             });
         }
5        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
      */
     removeDuplicates:function (arr) {
11        if (isArray(arr)) {
11            var ret = arr.reduce(function (a, b) {
47                if (a.indexOf(b) === -1) {
32                    return a.concat(b);
                 } else {
15                    return a;
                 }
             }, []);
11            return ret;
         }
     },
 
     unique:function (arr) {
2        return array.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
      */
     rotate:function (arr, numberOfTimes) {
58        var ret = arr.slice();
58        if (typeof numberOfTimes != "number") {
1            numberOfTimes = 1;
         }
58        if (numberOfTimes && isArray(arr)) {
32            if (numberOfTimes > 0) {
22                ret.push(ret.shift());
22                numberOfTimes--;
             } else {
10                ret.unshift(ret.pop());
10                numberOfTimes++;
             }
32            return array.rotate(ret, numberOfTimes);
         } else {
26            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.
      */
     permutations:function (arr, length) {
5        var ret = [];
5        if (isArray(arr)) {
5            var copy = arr.slice(0);
5            if (typeof length != "number") {
1                length = arr.length;
             }
5            if (!length) {
1                ret = [
                     []
                 ];
4            } else if (length <= arr.length) {
3                ret = arr.reduce(function (a, b, i) {
9                    if (length > 1) {
6                        var ret = permute(b, array.rotate(copy, i).slice(1), length);
                     } else {
3                        ret = [
                             [b]
                         ];
                     }
9                    return a.concat(ret);
                 }, [])
             }
         }
5        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
      */
     zip:function () {
5        var ret = [];
5        var arrs = argsToArray(arguments);
5        if (arrs.length > 1) {
5            var arr1 = arrs.shift();
5            if (isArray(arr1)) {
5                ret = arr1.reduce(function (a, b, i) {
11                    var curr = [b];
11                    for (var j = 0; j < arrs.length; j++) {
22                        var currArr = arrs[j];
22                        if (isArray(currArr) && !misc.isUndefined(currArr[i])) {
17                            curr.push(currArr[i]);
                         } else {
5                            curr.push(null);
                         }
                     }
11                    a.push(curr)
11                    return a;
                 }, []);
             }
         }
5        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
      */
     transpose:function (arr) {
3        var ret = [];
3        if (isArray(arr) && arr.length) {
3            var last;
3            arr.forEach(function (a) {
8                if (isArray(a) && (!last || a.length == last.length)) {
6                    a.forEach(function (b, i) {
13                        !ret[i] && (ret[i] = []);
13                        ret[i].push(b);
                     });
6                    last = a;
                 }
             });
         }
3        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
      *   @index {Number} index variable number of indexes to retrieve
      */
     valuesAt:function (arr, indexes) {
3        var ret = [];
3        var indexes = argsToArray(arguments);
3        var arr = indexes.shift(), l = arr.length;
3        if (isArray(arr) && indexes.length) {
3            for (var i = 0; i < indexes.length; i++) {
9                ret.push(arr[indexes[i]] || null);
             }
         }
3        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
      */
     union:function () {
2        var ret = [];
2        var arrs = argsToArray(arguments);
2        if (arrs.length > 1) {
2            ret = array.removeDuplicates(arrs.reduce(function (a, b) {
7                return a.concat(b);
             }, []));
         }
2        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
      */
     intersect:function (a, b) {
5        var collect = [], set;
5        var args = argsToArray(arguments);
5        if (args.length > 1) {
             //assume we are intersections all the lists in the array
4            set = args;
         } else {
1            set = args[0];
         }
5        if (isArray(set)) {
5            var x = set.shift();
5            var collect = set.reduce(function (a, b) {
10                return intersection(a, b);
             }, x);
         }
5        return array.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
      */
     powerSet:function (arr) {
3        var ret = [];
3        if (isArray(arr) && arr.length) {
3            var ret = arr.reduce(function (a, b) {
9                var ret = a.map(function (c) {
25                    return c.concat(b);
                 })
9                return a.concat(ret);
             }, [
                 []
             ]);
         }
3        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
      */
     cartesian:function (a, b) {
10        var ret = [];
10        if (isArray(a) && isArray(b) && a.length && b.length)
7            ret = cross(a[0], b).concat(array.cartesian(a.slice(1), b));
10        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
      */
     compact:function (arr) {
2        var ret = [];
2        if (isArray(arr) && arr.length) {
2            ret = arr.filter(function (item) {
7                return !misc.isUndefinedOrNull(item);
             })
         }
2        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.
      */
     multiply:function (arr, times) {
4        times = number.isNumber(times) ? times : 1;
4        if (!times) {
             //make sure times is greater than zero if it is zero then dont multiply it
1            times = 1;
         }
4        arr = array.toArray(arr || []);
4        var ret = [], i = 0;
4        while (++i <= times) {
5            ret = ret.concat(arr);
         }
4        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
      */
     flatten:function (arr) {
10        var set;
10        var args = argsToArray(arguments);
10        if (args.length > 1) {
             //assume we are intersections all the lists in the array
3            set = args;
         } else {
7            set = array.toArray(arr);
         }
10        return set.reduce(function (a, b) {
19            return a.concat(b);
         }, []);
     }
 
 }
 ;
 
1array = comb.array;

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) {
36    var undef;
36    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) {
28    return pattern.replace(/([a-z])\1*/ig,
         function (match) {
             // Build a simple regexp.  Avoid captures, which would ruin the tokens list
100            var s,
                 c = match.charAt(0),
                 l = match.length,
                 p2 = '', p3 = '';
100            p2 = '0?';
100            p3 = '0{0,2}';
100            switch (c) {
                 case 'y':
17                    s = '\\d{2,4}';
17                    break;
                 case 'M':
17                    s = (l > 2) ? '\\S+?' : '1[0-2]|' + p2 + '[1-9]';
17                    break;
                 case 'D':
2                    s = '[12][0-9][0-9]|3[0-5][0-9]|36[0-6]|' + p3 + '[1-9][0-9]|' + p2 + '[1-9]';
2                    break;
                 case 'd':
16                    s = '3[01]|[12]\\d|' + p2 + '[1-9]';
16                    break;
                 case 'w':
2                    s = '[1-4][0-9]|5[0-3]|' + p2 + '[1-9]';
2                    break;
                 case 'E':
6                    s = '\\S+';
6                    break;
                 case 'h': //hour (1-12)
5                    s = '1[0-2]|' + p2 + '[1-9]';
5                    break;
                 case 'K': //hour (1-24)
2                    s = '1[01]|' + p2 + '\\d';
2                    break;
                 case 'H': //hour (0-23)
1                    s = '1\\d|2[0-3]|' + p2 + '\\d';
1                    break;
                 case 'k': //hour (1-24)
1                    s = '1\\d|2[0-4]|' + p2 + '[1-9]';
1                    break;
                 case 'm':
                 case 's':
15                    s = '[0-5]\\d';
15                    break;
                 case 'S':
5                    s = '\\d{' + l + '}';
5                    break;
                 case 'a':
3                    var am = 'AM', pm = 'PM';
 
3                    s = am + '|' + pm;
3                    if (am != am.toLowerCase()) {
3                        s += '|' + am.toLowerCase();
                     }
3                    if (pm != pm.toLowerCase()) {
3                        s += '|' + pm.toLowerCase();
                     }
3                    s = s.replace(/\./g, "\\.");
3                    break;
                 case 'v':
                 case 'z':
                 case 'Z':
                 case 'G':
                 case 'q':
                 case 'Q':
6                    s = ".*";
6                    break;
                 default:
2                    s = c == " " ? "\\s*" : c + "*";
 //				console.log("parse of date format, pattern=" + pattern);
             }
 
100            if (tokens) {
100                tokens.push(match);
             }
 
100            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
18        var month = dateObject.getMonth();
18        var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
18        if (month == 1 && date.isLeapYear(dateObject)) {
3            return 29;
         } // Number
15        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) {
14        var year = dateObject[utc ? "getUTCFullYear" : "getFullYear"]();
14        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) {
33        var str = dateObject.toString();
33        var tz = '';
33        var pos = str.indexOf('(');
33        if (pos > -1) {
29            tz = str.substring(++pos, str.indexOf(')'));
         }
33        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) {
5        date1 = new Date(date1);
5        date2 = new Date((date2 || new Date()));
 
5        if (portion == "date") {
             // Ignore times and compare dates.
2            date1.setHours(0, 0, 0, 0);
2            date2.setHours(0, 0, 0, 0);
3        } else if (portion == "time") {
             // Ignore dates and compare times.
1            date1.setFullYear(0, 0, 0);
1            date2.setFullYear(0, 0, 0);
         }
5        var ret = 0;
5        date1 > date2 && (ret = 1);
5        date1 < date2 && (ret = -1);
5        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) {
126        amount = amount | 0
126        var sum = new Date(date);
126        var fixOvershoot = false;
126        var property = "Date";
 
         //noinspection FallthroughInSwitchStatementJS
126        switch (interval) {
             case "day":
             case "days" :
33                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
16                var days, weeks, mod = amount % 5, strt = date.getDay(), adj = 0;
16                if (!mod) {
6                    days = (amount > 0) ? 5 : -5;
6                    weeks = (amount > 0) ? ((amount - 5) / 5) : ((amount + 5) / 5);
                 } else {
10                    days = mod;
10                    weeks = parseInt(amount / 5);
                 }
16                if (strt == 6 && amount > 0) {
2                    adj = 1;
14                } else if (strt == 0 && amount < 0) {
                     // Orig date is Sun / negative increment
                     // Jump back over Sat
4                    adj = -1;
                 }
                 // Get weekday val for the new date
16                var trgt = strt + days;
                 // New date is on Sat or Sun
16                if (trgt == 0 || trgt == 6) {
2                    adj = (amount > 0) ? 2 : -2;
                 }
                 // Increment by number of weeks plus leftover days plus
                 // weekend adjustments
16                amount = (7 * weeks) + days + adj;
16                break;
             case "year":
             case "years":
20                property = "FullYear";
20                fixOvershoot = true;
20                break;
             case "week":
             case "weeks":
3                amount *= 7;
3                break;
             case "quarter":
             case "quarters" :
                 // Naive quarter is just three months
9                amount *= 3;
             case "month":
             case "months":
                 // Reset to last day of month if you overshoot
22                fixOvershoot = true;
22                property = "Month";
22                break;
             default:
32                interval = interval.replace(/s$/, "");
32                property = "UTC" + interval.charAt(0).toUpperCase() + interval.substring(1) + "s";
         }
 
126        if (property) {
126            sum["set" + property](sum["get" + property]() + amount);
         }
 
126        if (fixOvershoot && (sum.getDate() < date.getDate())) {
13            sum.setDate(0);
         }
 
126        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) {
172        date2 = date2 || new Date();
172        interval = interval || "day";
172        var yearDiff = date2.getFullYear() - date1.getFullYear();
172        var delta = 1; // Integer return value
 
172        switch (interval) {
             case "quarter":
             case "quarters":
5                var m1 = date1[utc ? "getUTCMonth" : "getMonth"]();
5                var m2 = date2[utc ? "getUTCMonth" : "getMonth"]();
                 // Figure out which quarter the months are in
5                var q1 = floor(m1 / 3) + 1;
5                var q2 = floor(m2 / 3) + 1;
                 // Add quarters for any year difference between the dates
5                q2 += (yearDiff * 4);
5                delta = q2 - q1;
5                break;
             case "weekday":
             case "weekdays":
28                var days = round(date.difference(date1, date2, "day", utc));
28                var weeks = parseInt(date.difference(date1, date2, "week", utc));
28                var mod = days % 7;
 
                 // Even number of weeks
28                if (mod == 0) {
7                    days = weeks * 5;
                 } else {
                     // Weeks plus spare change (< 7 days)
21                    var adj = 0;
21                    var aDay = date1[utc ? "getUTCDay" : "getDay"]();
21                    var bDay = date2[utc ? "getUTCDay" : "getDay"]();
 
21                    weeks = parseInt(days / 7);
21                    mod = days % 7;
                     // Mark the date advanced by the number of
                     // round weeks (may be zero)
21                    var dtMark = new Date(date1);
21                    dtMark.setDate(dtMark[utc ? "getUTCDate" : "getDate"]() + (weeks * 7));
21                    var dayMark = dtMark[utc ? "getUTCDay" : "getDay"]();
 
                     // Spare change days -- 6 or less
21                    if (days > 0) {
12                        switch (true) {
                             // Range starts on Sat
                             case (aDay == 6 || bDay == 6):
3                                adj = -1;
3                                break;
                             // Range starts on Sun
                             case aDay == 0:
4                                adj = 0;
4                                break;
                             // Range ends on Sun
                             case bDay == 0:
1                                adj = -2;
1                                break;
                             // Range contains weekend
                             case (dayMark + mod) > 5:
1                                adj = -2;
                         }
9                    } else if (days < 0) {
9                        switch (true) {
                             // Range starts on Sat
                             case aDay == 6:
1                                adj = 0;
1                                break;
                             // Range starts on Sun
                             case aDay == 0:
3                                adj = 1;
3                                break;
                             // Range ends on Sat
                             case bDay == 6:
1                                adj = 2;
1                                break;
                             // Range ends on Sun
                             case bDay == 0:
1                                adj = 1;
1                                break;
                             // Range contains weekend
                             case (dayMark + mod) < 0:
1                                adj = 2;
                         }
                     }
21                    days += adj;
21                    days -= (weeks * 2);
                 }
28                delta = days;
28                break;
             case "year":
             case "years":
8                delta = yearDiff;
8                break;
             case "month":
             case "months":
5                var m1 = date1[utc ? "getUTCMonth" : "getMonth"]();
5                var m2 = date2[utc ? "getUTCMonth" : "getMonth"]();
5                delta = (m2 - m1) + (yearDiff * 12);
5                break;
             case "week":
             case "weeks":
32                delta = parseInt(date.difference(date1, date2, "day", utc) / 7);
32                break;
             case "day":
             case "days":
77                delta /= 24;
             case "hour":
             case "hours":
83                delta /= 60;
             case "minute":
             case "minutes":
87                delta /= 60;
             case "second":
             case "seconds":
90                delta /= 1000;
             case "millisecond":
             case "milliseconds":
94                delta *= date2.getTime() - date1.getTime();
         }
 
         // Round for fractional values and DST leaps
172        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) {
28        if (!format) throw new Error('format required when calling comb.date.parse');
28        var tokens = [], regexp = buildDateEXP(format, tokens),
             re = new RegExp("^" + regexp + "$", "i"),
             match = re.exec(dateStr);
28        if (!match) {
4            return null;
         } // null
24        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) {
106                if (!i) {
24                    return true;
                 }
82                var token = tokens[i - 1];
82                var l = token.length;
82                switch (token.charAt(0)) {
                     case 'y':
13                        if (v < 100) {
3                            v = parseInt(v, 10);
                             //choose century to apply, according to a sliding window
                             //of 80 years before and 20 years after present year
3                            var year = '' + new Date().getFullYear(),
                                 century = year.substring(0, 2) * 100,
                                 cutoff = min(year.substring(2, 4) + 20, 99);
3                            result[0] = (v < cutoff) ? century + v : century - 100 + v;
                         } else {
10                            result[0] = v;
                         }
13                        break;
                     case 'M':
14                        if (l > 2) {
10                            var months = monthNames;
10                            if (l === 3) {
4                                months = monthAbbr;
                             }
                             //Tolerate abbreviating period in month part
                             //Case-insensitive comparison
10                            v = v.replace(".", "").toLowerCase();
10                            months = months.map(function (s) {
120                                return s.replace(".", "").toLowerCase();
                             });
10                            if ((v = months.indexOf(v)) == -1) {
1                                return false;
                             }
                         } else {
4                            v--;
                         }
13                        result[1] = v;
13                        break;
                     case 'E':
                     case 'e':
6                        var days = dayNames;
6                        if (l == 3) {
2                            days = dayAbbr;
                         }
                         //Case-insensitive comparison
6                        v = v.toLowerCase();
6                        days = days.map(function (d) {
42                            return d.toLowerCase();
                         });
6                        var d = days.indexOf(v);
6                        if (d == -1) {
2                            v = parseInt(v);
2                            if (isNaN(v) || v > days.length) {
1                                return false;
                             }
                         } else {
4                            v = d;
                         }
5                        break;
                     case 'D':
2                        result[1] = 0;
                     case 'd':
15                        result[2] = v;
15                        break;
                     case 'a': //am/pm
2                        var am = "am";
2                        var pm = "pm";
2                        var period = /\./g;
2                        v = v.replace(period, '').toLowerCase();
                         // we might not have seen the hours field yet, so store the state and apply hour change later
2                        amPm = (v == pm) ? 'p' : (v == am) ? 'a' : '';
2                        break;
                     case 'k': //hour (0-11)
1                        if (v == 24) {
1                            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
7                        result[3] = v;
7                        break;
                     case 'm': //minutes
7                        result[4] = v;
7                        break;
                     case 's': //seconds
5                        result[5] = v;
5                        break;
                     case 'S': //milliseconds
4                        result[6] = v;
4                        break;
                 }
80                return true;
             });
24        if (valid) {
22            var hours = +result[3];
             //account for am/pm
22            if (amPm === 'p' && hours < 12) {
1                result[3] = hours + 12; //e.g., 3pm -> 15
21            } else if (amPm === 'a' && hours == 12) {
1                result[3] = 0; //12am -> 0
             }
22            var dateObject = new Date(result[0], result[1], result[2], result[3], result[4], result[5], result[6]); // Date
22            var dateToken = (tokens.indexOf('d') != -1),
                 monthToken = (tokens.indexOf('M') != -1),
                 month = result[1],
                 day = result[2],
                 dateMonth = dateObject.getMonth(),
                 dateDay = dateObject.getDate();
22            if ((monthToken && dateMonth > month) || (dateToken && dateDay > day)) {
1                return null;
             }
21            return dateObject; // Date
         } else {
2            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) {
70        utc = utc || false;
70        var fullYear, month, day, d, hour, minute, second, millisecond;
70        if (utc) {
22            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 {
48            fullYear = date.getFullYear(),
                 month = date.getMonth(),
                 d = date.getDate(),
                 day = date.getDay(),
                 hour = date.getHours(),
                 minute = date.getMinutes(),
                 second = date.getSeconds(),
                 millisecond = date.getMilliseconds();
         }
70        return format.replace(/([a-z])\1*/ig, function (match, options) {
356            var s, pad, h,
                 c = match.charAt(0),
                 l = match.length;
 
356            switch (c) {
                 case 'd':
39                    s = "" + d;
                 case 'H':
68                    !s && (s = "" + hour);
                 case 'm':
107                    !s && (s = "" + minute);
                 case 's':
144                    !s && (s = "" + second);
144                    pad = true;
144                    break;
                 case 'G':
4                    s = ((l < 4) ? eraAbbr : eraNames)[fullYear < 0 ? 0 : 1];
4                    break;
                 case 'y':
42                    s = fullYear;
42                    if (l > 1) {
42                        l == 2 ? s = string.truncate("" + s, 2, true) : pad = true;
                     }
42                    break;
                 case 'Q':
                 case 'q':
6                    s = ceil((month + 1) / 3);
6                    pad = true;
6                    break;
                 case 'M':
39                    if (l < 3) {
31                        s = month + 1;
31                        pad = true;
                     } else {
8                        s = (l == 3 ? monthAbbr : monthNames)[month];
                     }
39                    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':
10                    if (l < 3) {
2                        s = day + 1;
2                        pad = true;
                     } else {
8                        s = (l == 3 ? dayAbbr : dayNames)[day];
                     }
10                    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':
35                    s = round(millisecond * pow(10, l - 3)), pad = true;
35                    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);
             }
356            if (pad) {
272                s = string.pad(s, l, '0');
             }
356            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) {
14    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);
 };

1var comb = exports;
 
 /**
  * Determines if something is a function
  * @param {Anything} obj the thing to test if it is a function
  *
  * @returns {Boolean} true if the obj is a function false otherwise
  */
1comb.isFunction = function (obj) {
885    return typeof obj == "function";
 };
 
 /**
  * Binds a method to a particular scope
  *
  * @param {Object} scope the scope to bind the callback to
  * @param {String|Function} method the method to callback
  * @param [args] optional args to pass to the callback
  *
  * @returns {Function} the hitched function
  */
1comb.hitch = function (scope, method, args) {
447    var args = Array.prototype.slice.call(arguments).slice(2);
447    if (typeof method == "string") {
187        method = scope[method];
     }
447    if (method) {
445        return function () {
621            var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
621            return method.apply(scope, scopeArgs);
         };
     } else {
2        throw new Error(method + "Method not defined");
     }
 };
 
 
 /**
  * @function
  * Binds a method to a particular scope
  *
  * @param {Object} scope the scope to bind the callback to
  * @param {String|Function} method the method to callback
  * @param [args] optional args to pass to the callback
  *
  * @returns {Function} the hitched function
  */
1comb.bind = comb.hitch;
 
 /**
  * Binds a method to a particular scope ignoring any new arguments passed
  * into the function. This is useful if you want to force particular arguments and
  * ignore any new ones
  *
  * @param {Object} scope the scope to bind the callback to
  * @param {String|Function} method the method to callback
  * @param [args] optional args to pass to the callback
  *
  * @returns {Function} the hitched function
  */
1comb.hitchIgnore = function (scope, method, args) {
16    var args = Array.prototype.slice.call(arguments).slice(2);
16    if (typeof method == "string") {
14        method = scope[method];
     }
16    if (method) {
14        return function () {
14            return method.apply(scope, args);
         };
     } else {
2        throw new Error(method + "Method not defined");
     }
 };
 
 /**
  * @function
  * Binds a method to a particular scope ignoring any new arguments passed
  * into the function. This is useful if you want to force particular arguments and
  * ignore any new ones
  *
  * @param {Object} scope the scope to bind the callback to
  * @param {String|Function} method the method to callback
  * @param [args] optional args to pass to the callback
  *
  * @returns {Function} the hitched function
  */
1comb.bindIgnore = comb.hitchIgnore;
 
 
 /**
  * Allows the passing of additional arguments to a function when it is called
  * especially useful for callbacks that you want to provide additional parameters to
  *
  * @param {String|Function} method the method to callback
  * @param {Anything} [args] variable number of arguments to pass
  *
  * @returns {Function} partially hitched function
  */
1comb.partial = function (method, args) {
103    var args = Array.prototype.slice.call(arguments).slice(1);
103    if (typeof method == "function") {
102        return function () {
81            var scopeArgs = args.concat(Array.prototype.slice.call(arguments));
81            return method.apply(this, scopeArgs);
         };
     } else {
1        throw new Error(method + "Method not defined");
     }
 };
 
1var curry = function (f, execute) {
8    return function (arg) {
8        var args = Array.prototype.slice.call(arguments);
8        return execute ? f.apply(this, arguments) : function (arg) {
6            return f.apply(this, args.concat(Array.prototype.slice.call(arguments)));
         };
     }
 };
 
 /**
  * Curries a function
  * @example
  * var curried = comb.curry(4, function(a,b,c,d){
  *     return [a,b,c,d].join(",");
  * }
  *  curried("a");
  *  curried("b");
  *  curried("c");
  *  curried("d") => "a,b,c,d"
  *
  *  //OR
  *
  *  curried("a")("b")("c")("d") => "a,b,c,d"
  *
  *
  * @param {Number} depth the number of args you expect
  * @param {Function} cb the function to call once all args are gathered
  * @param {Object} [scope] what scope to call the function in
  *
  * @returns {Function} the curried version of the function
  * */
1comb.curry = function (depth, cb, scope) {
2    var f;
2    if (scope) {
1        f = comb.hitch(scope, cb);
     } else {
1        f = cb;
     }
2    if (depth) {
2        var len = depth - 1;
2        for (var i = len; i >= 0; i--) {
8            f = curry(f, i == len);
         }
     }
2    return f;
 };
 

1var objectBase = require("./object");
 
1objectBase.merge(exports, objectBase,
         require("./broadcast"),
         require("./functions"),
         require("./string"),
         require("./number"),
         require("./misc"),
         require("./date"),
         require("./array"),
         require("./regexp"),
         require("./inflections"));

 /*
  * A port of the Rails/Sequel inflections class
  * http://sequel.rubyforge.org/rdoc/classes/Sequel/Inflections.html
  */
 
1var array = require("./array").array, misc = require("./misc");
 
1var comb = exports;
 
1var CAMELIZE_CONVERT_REGEXP = /_(.)/g;
1var DASH = '-';
1var UNDERSCORE = '_';
1var UNDERSCORE_CONVERT_REGEXP1 = /([A-Z]+)(\d+|[A-Z][a-z])/g;
1var UNDERSCORE_CONVERT_REGEXP2 = /(\d+|[a-z])(\d+|[A-Z])/g;
1var UNDERSCORE_CONVERT_REPLACE = '$1_$2';
 
1var PLURALS = [], SINGULARS = [], UNCOUNTABLES = [];
 
 
1var _plural = function (rule, replacement) {
20    PLURALS.unshift([rule, replacement])
 };
1var _singular = function (rule, replacement) {
23    SINGULARS.unshift([rule, replacement])
 };
 
 /**
  * Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
  # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
  #
  # Examples:
  #   irregular 'octopus', 'octopi'
  #   irregular 'person', 'people'
  * @param singular the singular version
  * @param plural  the plural version
  */
1var _irregular = function (singular, plural) {
7    _plural(new RegExp("(" + singular.substr(0, 1) + ")" + singular.substr(1) + "$"), "$1" + plural.substr(1));
7    _singular(new RegExp("(" + plural.substr(0, 1) + ")" + plural.substr(1) + "$"), "$1" + singular.substr(1));
 };
1var _uncountable = function (words) {
1    UNCOUNTABLES.push(misc.argsToArray(arguments))
1    UNCOUNTABLES = array.flatten(UNCOUNTABLES);
 };
 
1_plural(/$/, 's');
1_plural(/s$/i, 's');
1_plural(/(alias|(?:stat|octop|vir|b)us)$/i, '$1es');
1_plural(/(buffal|tomat)o$/i, '$1oes');
1_plural(/([ti])um$/i, '$1a');
1_plural(/sis$/i, 'ses');
1_plural(/(?:([^f])fe|([lr])f)$/i, '$1$2ves');
1_plural(/(hive)$/i, '$1s');
1_plural(/([^aeiouy]|qu)y$/i, '$1ies');
1_plural(/(x|ch|ss|sh)$/i, '$1es');
1_plural(/(matr|vert|ind)ix|ex$/i, '$1ices');
1_plural(/([m|l])ouse$/i, '$1ice');
1_plural(/^(ox)$/i, "$1en");
 
1_singular(/s$/i, '');
1_singular(/([ti])a$/i, '$1um');
1_singular(/(analy|ba|cri|diagno|parenthe|progno|synop|the)ses$/i, '$1sis');
1_singular(/([^f])ves$/i, '$1fe');
1_singular(/([h|t]ive)s$/i, '$1');
1_singular(/([lr])ves$/i, '$1f');
1_singular(/([^aeiouy]|qu)ies$/i, '$1y');
1_singular(/(m)ovies$/i, '$1ovie');
1_singular(/(x|ch|ss|sh)es$/i, '$1');
1_singular(/([m|l])ice$/i, '$1ouse');
1_singular(/buses$/i, 'bus');
1_singular(/oes$/i, 'o');
1_singular(/shoes$/i, 'shoe');
1_singular(/(alias|(?:stat|octop|vir|b)us)es$/i, '$1');
1_singular(/(vert|ind)ices$/i, '$1ex');
1_singular(/matrices$/i, 'matrix');
 
1_irregular('person', 'people');
1_irregular('man', 'men');
1_irregular('child', 'children');
1_irregular('sex', 'sexes');
1_irregular('move', 'moves');
1_irregular('quiz', 'quizzes');
1_irregular('testis', 'testes');
 
1_uncountable("equipment", "information", "rice", "money", "species", "series", "fish", "sheep", "news");
 
1exports.singular = _singular;
1exports.plural = _plural;
1exports.uncountable = _uncountable;
 
 /**
  * Converts a string to camelcase
  *
  * @example
  *  comb.camelize('hello_world') => helloWorld
  *  comb.camelize('column_name') => columnName
  *  comb.camelize('columnName') => columnName
  *  comb.camelize(null) => null
  *  comb.camelize() => undefined
  *
  * @param {String} str the string to camelize
  * @memberOf comb
  * @returns {String} the camelized version of the string
  */
1comb.camelize = function (str) {
8    var ret = str;
8    if (!misc.isUndefinedOrNull(str)) {
6        ret = str.replace(CAMELIZE_CONVERT_REGEXP, function (a, b) {
4            return b.toUpperCase();
         });
     }
8    return ret;
 };
 
 /**
  * The reverse of camelize. Makes an underscored form from the expression in the string.
  *
  * @example
  *  comb.underscore('helloWorld') => hello_world
  *  comb.underscore('column_name') => column_name
  *  comb.underscore('columnName') => column_name
  *  comb.underscore(null) => null
  *  comb.underscore() => undefined
  * @param {String} str The string to underscore
  * @memberOf comb
  * @returns {String} the underscored version of the string
  *   */
1comb.underscore = function (str) {
7    var ret = str;
7    if (!misc.isUndefinedOrNull(str)) {
5        ret = str.replace(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE)
             .replace(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE)
             .replace(DASH, UNDERSCORE).toLowerCase();
     }
7    return ret;
 };
 
 /**
  * Singularizes and camelizes the string.  Also strips out all characters preceding
  * and including a period (".").
  *
  * @example
  *   comb.classify('egg_and_hams') => "eggAndHam"
  *   comb.classify('post') => "post"
  *   comb.classify('schema.post') => "post"
  *
  * @param {String} str the string to classify
  * @memberOf comb
  * @returns {String} the classified version of the string
  **/
1comb.classify = function (str) {
5    var ret = str;
5    if (!misc.isUndefinedOrNull(str)) {
3        ret = comb.camelize(comb.singularize(str.replace(/.*\./g, '')));
     }
5    return ret;
 };
 /**
  * Returns the plural form of the word in the string.
  *
  * @example
  *  comb.pluralize("post") => "posts"
  *  comb.pluralize("octopus") => "octopi"
  *  comb.pluralize("sheep") => "sheep"
  *  comb.pluralize("words") => "words"
  *  comb.pluralize("the blue mailman") => "the blue mailmen"
  *  comb.pluralize("CamelOctopus") => "CamelOctopi"
  *
  * @param {String} str the string to pluralize
  * @memberOf comb
  * @returns {String} the pluralized version of the string
  **/
1comb.pluralize = function (str) {
51    var ret = str;
51    if (!misc.isUndefinedOrNull(str)) {
49        if (UNCOUNTABLES.indexOf(str) == -1) {
48            for (var i in PLURALS) {
641                var s = PLURALS[i], rule = s[0], replacement = s[1];
641                if ((ret = ret.replace(rule, replacement)) != str) {
48                    break;
                 }
             }
         }
     }
51    return ret;
 };
 /**
  * The reverse of pluralize, returns the singular form of a word in a string.
  *
  * @example
  *   comb.singularize("posts") => "post"
  *   comb.singularize("octopi")=> "octopus"
  *   comb.singularize("sheep") => "sheep"
  *   comb.singularize("word") => "word"
  *   comb.singularize("the blue mailmen") => "the blue mailman"
  *   comb.singularize("CamelOctopi") => "CamelOctopus"
  *
  * @param {String} str the string to singularize
  * @memberOf comb
  * @returns {String} the singularized version of the string
  * */
1comb.singularize = function (str) {
54    var ret = str;
54    if (!misc.isUndefinedOrNull(str)) {
52        if (UNCOUNTABLES.indexOf(str) == -1) {
51            for (var i in SINGULARS) {
785                var s = SINGULARS[i], rule = s[0], replacement = s[1];
785                if ((ret = ret.replace(rule, replacement)) != str) {
49                    break;
                 }
             }
         }
     }
54    return ret;
 };

1var comb = exports,
     arraySlice = Array.prototype.slice;
 
 /**
  *
  * Converts an arguments object to an array
  *
  * @example
  *
  * function test(){
  *     return comb.argsToArray(arguments);
  * }
  *
  * function testSlice(){
  *     return comb.argsToArray(arguments, 3);
  * }
  *
  * console.log(test(1,2,3)); //[1,2,3]
  * console.log(test(1,2,3,4,5,6)); //[4,5,6]
  *
  * @function
  * @param {Arguments} args the arguments object to convert
  * @param {Number} [slice=0] the number of arguments to slice.
  * @memberOf comb
  * @static
  * @returns {Array} array version of the arguments object
  */
1function argsToArray(args, slice) {
1688    slice = slice || 0;
1688    return arraySlice.call(args, slice);
 }
 
 /**
  * Determines if obj is a boolean
  *
  * @param {Anything} obj the thing to test if it is a boolean
  *
  * @returns {Boolean} true if it is a boolean false otherwise
  * @memberOf comb
  * @static
  */
1function isBoolean(obj) {
24    var undef, type = typeof obj;
24    return obj != undef && type == "boolean" || type == "Boolean";
 }
 
 /**
  * Determines if obj is undefined
  *
  * @param {Anything} obj the thing to test if it is undefined
  * @returns {Boolean} true if it is undefined false otherwise
  * @memberOf comb
  * @static
  */
1function isUndefined(obj) {
1254    var undef;
1254    return obj !== null && obj === undef;
 }
 
 
 /**
  * Determins if the obj is not undefined
  *
  * @param obj the thing to test if it is not undefined
  *
  * @return {Boolean} true if it is defined false otherwise
  * @memberOf comb
  * @static
  */
1function isDefined(obj) {
8    return !isUndefined(obj);
 }
 
 /**
  * Determines if obj is undefined or null
  *
  * @param {Anything} obj the thing to test if it is undefined or null
  * @returns {Boolean} true if it is undefined or null false otherwise
  * @memberOf comb
  * @static
  */
1function isUndefinedOrNull(obj) {
1044    return isUndefined(obj) || isNull(obj);
 }
 
 /**
  * Determines if obj is null
  *
  * @param {Anything} obj the thing to test if it is null
  *
  * @returns {Boolean} true if it is null false otherwise
  * @memberOf comb
  * @static
  */
1function isNull(obj) {
1042    var undef;
1042    return obj !== undef && obj == null;
 }
 
 /**
  * Determines if obj is an Arguments object;
  *
  * @param {Anything} obj the thing to test if it is null
  *
  * @returns {Boolean} true if it is an Arguments Object false otherwise
  * @memberOf comb
  * @static
  */
1function isArguments(object) {
23    return !isUndefinedOrNull(object) && Object.prototype.toString.call(object) == '[object Arguments]';
 }
 
 
1function isInstance(obj, clazz) {
693    if (typeof clazz == "function") {
692        return obj instanceof clazz;
     } else {
1        return false;
     }
 }
 
 /**
  * Determines if obj is an instance of a particular class
  *
  * @param {Anything} obj the thing to test if it and instance of a class
  * @param {Object} Clazz used to determine if the object is an instance of
  *
  * @returns {Boolean} true if it is an instance of the clazz false otherwise
  * @memberOf comb
  * @static
  */
1function isInstanceOf(obj, clazz) {
693    return argsToArray(arguments, 1).some(function (c) {
693        return isInstance(obj, c);
     });
 }
 
1(function () {
 
1    var listeners = [];
1    var setup = false;
 
1    function setupListener() {
13        if (!setup) {
1            var orig = process.emit;
1            process.emit = function (event) {
680                try {
680                    if (event === 'exit') {
1                        listeners.forEach(function (cb) {
13                            cb();
                         });
                     }
                 } finally {
680                    orig.apply(this, arguments);
                 }
             };
1            setup = true;
         }
     }
 
     /**
      * Adds listeners to process.exit without having to change setMaxListeners useful if you
      * are writing a library and do not want to change core setting.
      *
      * @param {Funciton} cb funciton to call when process is exiting
      * @memberOf comb
      * @static
      */
1    function listenForExit(cb) {
13        setupListener();
13        listeners.push(cb);
     }
 
1    comb.listenForExit = listenForExit;
 })();
 
1comb.argsToArray = argsToArray;
1comb.isBoolean = isBoolean;
1comb.isUndefined = isUndefined;
1comb.isDefined = isDefined;
1comb.isUndefinedOrNull = isUndefinedOrNull;
1comb.isNull = isNull;
1comb.isArguments = isArguments;
1comb.isInstanceOf = isInstanceOf;
 
 
 

1var comb = exports;
 
 /**
  * Determines if obj is a number
  *
  * @param {Anything} obj the thing to test if it is a Number
  *
  * @returns {Boolean} true if it is a number false otherwise
  */
1comb.isNumber = function(obj) {
729    var undef;
729    return obj !== undef && obj != null && (typeof obj == "number" || obj instanceof Number);
 };
 
 /**
  * @private
  */
1var round = Math.round, pow = Math.pow;
 
 /**
  * @namespace Utilities for numbers
  */
1comb.number = {
     /**@lends comb.number*/
 
 
     /**
      * Rounds a number to the specified places.
      *
      * @example
      *
      * comb.number.round(10.000009, 2); //10
      * comb.number.round(10.000009, 5); //10.00001
      * comb.number.round(10.0009, 3); //10.001
      * comb.number.round(10.0009, 2); //10
      * comb.number.round(10.0009, 3); //10.001
      *
      * @param {Number} num the number to round.
      * @param {Number} places the number of places to round to.
      */
     round : function(number, places, increment) {
6        increment = increment || 1e-20;
6        var factor = 10 / (10 * (increment || 10));
6        return (Math.ceil(factor * +number) / factor).toFixed(places) * 1; // Number
     },
 
 
     /**
      * Rounds a number to the specified places, rounding up.
      *
      * @example
      *
      * comb.number.roundCeil(10.000001, 2); //10.01
      * comb.number.roundCeil(10.000002, 5); //10.00001
      * comb.number.roundCeil(10.0003, 3); //10.001
      * comb.number.roundCeil(10.0004, 2); //10.01
      * comb.number.roundCeil(10.0005, 3); //10.001
      * comb.number.roundCeil(10.0002, 2); //10.01
      *
      * @param {Number} num the number to round.
      * @param {Number} places the number of places to round to.
      */
     roundCeil : function(number, places){
6         return Math.ceil(number * Math.pow(10, places))/Math.pow(10, places);
     }
 };

1var comb = exports,
     misc = require("./misc.js"),
     isUndefinedOrNull = misc.isUndefined,
     isArguments = misc.isArguments,
     pSlice = Array.prototype.slice;
 
 //taken from node js assert.js
 //https://github.com/joyent/node/blob/master/lib/assert.js
1var _deepEqual = function (actual, expected) {
     // 7.1. All identical values are equivalent, as determined by ===.
43    if (actual === expected) {
3        return true;
 
40    } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
1        if (actual.length != expected.length) return false;
 
1        for (var i = 0; i < actual.length; i++) {
3            if (actual[i] !== expected[i]) return false;
         }
 
1        return true;
 
         // 7.2. If the expected value is a Date object, the actual value is
         // equivalent if it is also a Date object that refers to the same time.
39    } else if (actual instanceof Date && expected instanceof Date) {
2        return actual.getTime() === expected.getTime();
 
         // 7.3 If the expected value is a RegExp object, the actual value is
         // equivalent if it is also a RegExp object with the same source and
         // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
37    } else if (actual instanceof RegExp && expected instanceof RegExp) {
2        return actual.source === expected.source &&
             actual.global === expected.global &&
             actual.multiline === expected.multiline &&
             actual.lastIndex === expected.lastIndex &&
             actual.ignoreCase === expected.ignoreCase;
 
         // 7.4. Other pairs that do not both pass typeof value == 'object',
         // equivalence is determined by ==.
35    } else if (typeof actual != 'object' && typeof expected != 'object') {
13        return actual == expected;
 
         // 7.5 For all other Object pairs, including Array objects, equivalence is
         // determined by having the same number of owned properties (as verified
         // with Object.prototype.hasOwnProperty.call), the same set of keys
         // (although not necessarily the same order), equivalent values for every
         // corresponding key, and an identical 'prototype' property. Note: this
         // accounts for both named and indexed properties on Arrays.
     } else {
22        return objEquiv(actual, expected);
     }
 };
 
 
1var objEquiv = function (a, b) {
22    if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
7        return false;
     // an identical 'prototype' property.
15    if (a.prototype !== b.prototype) return false;
     //~~~I've managed to break Object.keys through screwy arguments passing.
     //   Converting to array solves the problem.
15    if (isArguments(a)) {
2        if (!isArguments(b)) {
1            return false;
         }
1        a = pSlice.call(a);
1        b = pSlice.call(b);
1        return _deepEqual(a, b);
     }
13    try {
13        var ka = Object.keys(a),
             kb = Object.keys(b),
             key, i;
     } catch (e) {//happens when one is a string literal and the other isn't
1        return false;
     }
     // having the same number of owned properties (keys incorporates
     // hasOwnProperty)
12    if (ka.length != kb.length)
2        return false;
     //the same set of keys (although not necessarily the same order),
10    ka.sort();
10    kb.sort();
     //~~~cheap key test
10    for (i = ka.length - 1; i >= 0; i--) {
10        if (ka[i] != kb[i])
2            return false;
     }
     //equivalent values for every corresponding key, and
     //~~~possibly expensive deep test
8    for (i = ka.length - 1; i >= 0; i--) {
8        key = ka[i];
11        if (!_deepEqual(a[key], b[key])) return false;
     }
5    return true;
 }
 
1var merge = function (target, source) {
49    var name, s;
49    for (name in source) {
207        s = source[name];
207        if (!(name in target) || (target[name] !== s)) {
206            target[name] = s;
         }
     }
49    return target;
 };
 
1var deepMerge = function (target, source) {
16    var name, s, t;
16    for (name in source) {
22        s = source[name], t = target[name];
22        if (!_deepEqual(t, s)) {
22            if (comb.isHash(t) && comb.isHash(s)) {
4                target[name] = deepMerge(t, s);
18            } else if (comb.isHash(s)) {
5                target[name] = deepMerge({}, s);
             } else {
13                target[name] = s;
             }
         }
     }
16    return target;
 };
 
 /**
  * Merges objects together
  * NOTE: this function takes a variable number of objects to merge
  *
  * @example
  *
  * var myObj = {};
  * comb.merge(myObj, {test : true});
  *
  * myObj.test => true
  *
  * comb.merge(myObj, {test : false}, {test2 : false}, {test3 : "hello", test4 : "world"});
  * myObj.test => false
  * myObj.test2 => false
  * myObj.test3 => "hello"
  * myObj.test4 => "world"
  *
  *
  * @param {Object} obj the object to merge into
  * @param {Object} props variable number of objects to merge into the obj
  *
  * @returns {Object} the merged object
  */
1comb.merge = function (obj, props) {
31    if (!obj) {
1        obj = {};
     }
31    for (var i = 1, l = arguments.length; i < l; i++) {
49        merge(obj, arguments[i]);
     }
31    return obj; // Object
 };
 
 /**
  * Merges objects together only overriding properties that are different.
  * NOTE: this function takes a variable number of objects to merge
  *
  * @example
  *
  * var myObj = {my : {cool : {property1 : 1, property2 : 2}}};
  * comb.deepMerge(myObj, {my : {cool : {property3 : 3}}});
  *
  * myObj.my.cool.property1 => 1
  * myObj.my.cool.property2 => 2
  * myObj.my.cool.property3 => 3
  *
  *
  * @param {Object} obj the object to merge into
  * @param {Object} props variable number of objects to merge into the obj
  *
  * @returns {Object} the merged object
  */
1comb.deepMerge = function (obj, props) {
4    if (!obj) {
1        obj = {};
     }
4    for (var i = 1, l = arguments.length; i < l; i++) {
7        deepMerge(obj, arguments[i]);
     }
4    return obj; // Object
 };
 
 /**
  * Extends the prototype of an object if it exists otherwise it extends the object.
  *
  * @example
  *
  *  var MyObj = function(){};
  *  MyObj.prototype.test = true;
  *  comb.extend(MyObj, {test2 : false, test3 : "hello", test4 : "world"});
  *
  *  var myObj = new MyObj();
  *
  *  myObj.test => true
  *  myObj.test2 => false
  *  myObj.test3 => "hello"
  *  myObj.test4 => "world"
  *
  *  var myObj2 = {};
  *  myObj2.test = true;
  *  comb.extend(myObj2, {test2 : false, test3 : "hello", test4 : "world"});
  *
  *  myObj2.test => true
  *  myObj2.test2 => false
  *  myObj2.test3 => "hello"
  *  myObj2.test4 => "world"
  *
  *
  * @param {Object} parent the parent object to extend
  * @param {Object} extend the extension object to mixin to the parent
  *
  * @returns {Object} returns the extended object
  */
1comb.extend = function (parent, extend) {
2    var proto = parent.prototype || parent;
2    return exports.merge(proto, extend);
 };
 
 /**
  * Determines if obj is an object
  *
  * @param {Anything} obj the thing to test if it is an object
  *
  * @returns {Boolean} true if it is an object false otherwise
  */
1comb.isObject = function (obj) {
87    var undef;
87    return obj != null && obj != undef && typeof obj == "object";
 };
 
 /**
  * Determines if an object is just a hash and not a qualified Object such as Number
  *
  * @example
  *    comb.isHash({}) => true
  *    comb.isHash({1 : 2, a : "b"}) => true
  *    comb.isHash(new Date()) => false
  *    comb.isHash(new String()) => false
  *    comb.isHash(new Number()) => false
  *    comb.isHash(new Boolean()) => false
  *    comb.isHash() => false
  *    comb.isHash("") => false
  *    comb.isHash(1) => false
  *    comb.isHash(false) => false
  *    comb.isHash(true) => false
  * @param {Anything} obj the thing to test if it is a hash
  *
  * @returns {Boolean} true if it is a hash false otherwise
  */
1comb.isHash = function (obj) {
72    var ret = comb.isObject(obj);
72    return ret && obj.constructor === Object;
 }
 
 /**
  * Determines if an object is empty
  *
  * @example
  *
  * comb.isEmpty({}) => true
  * comb.isEmpty({a : 1}) => false
  *
  * @param object the object to test
  * @returns {Boolean} true if the object is empty;
  */
1comb.isEmpty = function (object) {
5    if (comb.isObject(object)) {
4        for (var i in object) {
2            if (object.hasOwnProperty(i)) {
2                return false;
             }
         }
     }
3    return true;
 };
 
 /**
  * Determines if two things are deep equal.
  *
  * @example
  *
  * comb.deepEqual({a : 1, b : 2}, {a : 1, b : 2}) => true
  * comb.deepEqual({a : 1}, {a : 1, b : 2}) => false
  *
  * @param o1 the first thing to compare
  * @param o3 the second thing to compare
  * @return {Boolean}
  */
1comb.deepEqual = function (o1, o2) {
12    return  _deepEqual(o1, o2);
 }