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

1var func = require("../base/functions"),
     obj = require("../base/object"),
     Promise = require("../promise").Promise,
     define = require("../define").define;
 
1var nextTick;
1if (typeof setImmediate === "function") {
     // In IE10, or use https://github.com/NobleJS/setImmediate
1    nextTick = setImmediate;
 } else {
0    nextTick = function (cb) {
0        process.nextTick(cb);
     };
 }
 
1var Middleware = define(null, {
     instance: {
         /** @lends comb.plugins.Middleware.prototype */
 
 
         __hooks: {pre: {}, post: {}},
 
 
         /**
          * @class Plugin to enable middleware on a class
          *
          * @example
          *
          * var Mammal = define(comb.plugins.Middleware, {
          *  instance : {
          *
          *    constructor: function(options) {
          *        options = options || {};
          *        this.super(arguments);
          *        this._type = options.type || "mammal";
          *    },
          *
          *    speak : function() {
          *        var ret = new comb.Promise();
          *        this._hook("pre", "speak")
          *                .then(comb.hitch(this, "_hook", "post", "speak"), hitch(ret, "errback"))
          *                .then(comb.hitch(ret, "callback"), comb.hitch(ret, "errback"));
          *        return ret;
          *    }
          *  }
          *});
          *
          *  Mammal.pre('speak', function(next){
          *     //do something meaningful
          *     next();
          *  });
          *  var m = new Mammal({color : "gold"});
          *  m.speak();
          *
          * @constructs
          */
         constructor: function () {
6            this.__hooks = obj.merge({}, this.__hooks);
6            this._super(arguments);
         },
 
         /**
          * <p>Protected!</p>
          *
          * <p>Call to initiate middleware for the topic</p>
          * <p><b>NOTE:</b> this function takes a variable number of arguments
          *       whatever comes after the op param will be passed into
          *       the listening function, with the last argument to the listenting
          *       function being the next function</p>
          *
          *
          * @public
          * @param {"pre"|"post"} state the state in which the hook should be called
          * @param {String} op the operation that is being acted upong
          * @param args arguments to be passed into the listening functions.
          * @returns {comb.Promise} a promise to use after middleware chain completes
          *
          */
         _hook: function (state, op, args) {
11            args = args || [];
11            var promise = new Promise();
11            var funcs, length;
11            if (this.__hooks[state] && (funcs = this.__hooks[state][op]) != null && (length = funcs.length) > 0) {
7                var count = 0;
7                var next = func.hitch(this, function (err) {
15                    if (err) {
1                        promise.errback(err);
                     } else {
14                        nextTick(func.hitch(this, function () {
                             //if Ive looped through all of them callback
14                            if (count == length) {
6                                promise.callback();
                             } else {
                                 //call next
8                                var nextArgs = args.slice(0);
8                                nextArgs.unshift(next);
8                                funcs[count++].apply(this, nextArgs);
                             }
                         }));
                     }
                 });
7                next();
             } else {
4                promise.callback();
             }
11            return promise.promise();
         },
 
         /**
          * Use to listen to before an event occurred i.e. pre save
          *
          * <b>NOTE:</b></br>
          * <ul>
          *     <li>You must call next in order for the middleware chain to complete</li>
          *      <li>This connects to events on the instance of an object, not all instances!</li>
          *      <li>Hooks are called in the order they are received!</li>
          *      <li> When connecting your callback will be called in the scope of the class</br>if you want a certain scope use {@link comb.hitch}</li>
          *  </ul>
          *
          * @example
          *      instance.pre("save", function(args,...., next){
          *          //do something...
          *          //you have to call next!!!!!
          *          next();
          *      });
          *
          * */
         pre: function (fun, callback) {
1            var hook = this.__hooks.pre[fun];
1            if (!hook) {
1                hook = this.__hooks.pre[fun] = [];
             }
1            hook.push(callback);
         },
 
         /**
          * <p>Use to listen to after an event has occurred i.e. post save</p>
          * <b>NOTE:</b></br>
          * <ul>
          *     <li>You must call next in order for the middleware chain to complete</li>
          *      <li>This connects to events on the instance of an object, NOT all instances!</li>
          *      <li>Hooks are called in the order they are received!</li>
          *      <li>When connecting your callback will be called in the scope of the class</br>if you want a certain scope use {@link comb.hitch}</li>
          *  </ul>
          * @example
          *
          * instance.post("save", function(next){
          *                //do something...
          *                 //you have to call next!!!!!
          *                 next();
          *          });
          * */
         post: function (fun, callback) {
1            var hook = this.__hooks.post[fun];
             //if I havent initialized it create it;
1            if (hook == undefined) {
1                hook = this.__hooks.post[fun] = [];
             }
1            hook.push(callback);
         }
     },
 
     static: {
         /** @lends comb.plugins.Middleware */
 
         /**
          *<p> Use to listen to after an event has occurred i.e. post save</p>
          *
          * <b>NOTE:</b></br>
          * <ul>
          *     <li>You must call next in order for the middleware chain to complete</li>
          *      <li>This connects to events on ALL instances of an object</li>
          *      <li>Hooks are called in the order they are received!</li>
          *      <li>When connecting your callback will be called in the scope of the class</br>if you want a certain scope use {@link comb.hitch}</li>
          *  </ul>
          *
          * @example
          * Class.pre("save", function(next){
          *               ...
          *               //you must call next
          *          });
          * */
         pre: function (name, cb) {
2            var hooks = this.prototype.__hooks;
2            var hook = hooks.pre[name];
2            if (!hook) {
1                hook = hooks.pre[name] = [];
             }
2            hook.push(cb);
         },
 
         /**
          *<p>Use to listen to after an event has occurred i.e. post save</p>
          *
          *<b>NOTE:</b></br>
          * <ul>
          *     <li>You must call next in order for the middleware chain to complete</li>
          *      <li>This connects to events on ALL instances of an object</li>
          *      <li>Hooks are called in the order they are received!</li>
          *      <li>When connecting your callback will be called in the scope of the class</br>if you want a certain scope use {@link comb.hitch}</li>
          *  </ul>
          *
          * @example
          * Class.post("save", function(next){
          *               ...
          *               //you must call next
          *          });
          * */
         post: function (name, cb) {
1            var hooks = this.prototype.__hooks;
1            var hook = hooks.post[name];
1            if (!hook) {
1                hook = hooks.post[name] = [];
             }
1            hook.push(cb);
         }
     }
 
 });
 
1module.exports = exports = Middleware;

1var define = require("./define").define,
     base = require("./base"),
     isObject = base.isObject,
     hitch = base.hitch,
     hitchAll = base.hitchAll,
     partial = base.partial,
     argsToArray = base.argsToArray,
     array = base.array,
     forEach = array.forEach,
     zip = array.zip,
     flatten = array.flatten,
     isUndefinedOrNull = base.isUndefinedOrNull,
     isArray = base.isArray,
     isFunction = base.isFunction,
     bindIgnore = base.bindIgnore,
     isInstanceOf = base.isInstanceOf,
     spreadArgs = base.__spreadArgs;
 
1var nextTick;
1if (typeof setImmediate === "function") {
     // In IE10, or use https://github.com/NobleJS/setImmediate
1    nextTick = setImmediate;
 } else {
0    nextTick = function (cb) {
0        process.nextTick(cb);
     };
 }
1function reject(e) {
0    return new Promise().errback(e);
 }
 
1function promiseWrapper(wrapper, promise, action) {
0    var m = promise[action];
0    wrapper[action] = hitch(promise, function () {
0        spreadArgs(m, arguments, this);
0        return wrapper;
     });
 }
 
 
1var Promise = define(null, {
     instance: {
         /** @lends comb.Promise.prototype */
         __fired: false,
 
         __results: null,
 
         __error: null,
 
         __errorCbs: null,
 
         __cbs: null,
 
         /**
          * Promise object used to provide seperation of success and error resolution paths for async operations.
          *
          * @example
          * var myFunc = function(){
          *     var promise = new Promise();
          *     //callback the promise after 10 Secs
          *     setTimeout(hitch(promise, "callback"), 10000);
          *     return promise.promise();
          * }
          * var myFunc2 = function(){
          *     var promises =[];
          *     for(var i = 0; i < 10; i++){
          *         promises.push(myFunc);
          *     }
          *     //create a new promise list with all 10 promises
          *     return new PromiseList(promises).promise();
          * }
          *
          * myFunc.then(function(success){}, function(error){})
          * //chain promise operations
          * myFunc.chain(myfunc).then(function(success){}, function(error){})
          *
          * myFunc2.then(function(success){}, function(error){})
          * //chain promise operations
          * myFunc2.chain(myfunc).then(function(success){}, function(error){})
          * @constructs
          */
         constructor: function () {
2526            this.__errorCbs = [];
2526            this.__cbs = [];
2526            this.callback = hitch(this, this.callback);
2526            this.errback = hitch(this, this.errback);
         },
         /**
          * @private
          */
         __resolve: function () {
2374            var self = this;
2374            if (!self.__fired) {
2374                self.__fired = true;
2374                nextTick(function () {
2373                    var cbs = self.__error ? self.__errorCbs : self.__cbs,
                         res = self.__error || self.__results,
                         i = -1, l = cbs.length;
2373                    while (++i < l) {
2264                        spreadArgs(cbs[i], res);
                     }
2373                    self.__errorCbs.length = self.__cbs.length = 0;
2373                    self = null;
                 });
             }
         },
 
         __callNextTick: function (cb, results) {
760            nextTick(function () {
760                spreadArgs(cb, results);
760                cb = results = null;
             });
         },
 
         /**
          * Add a callback to the callback chain of the promise
          *
          *
          * @param {Function|comb.Promise} cb the function or promise to callback when the promise is resolved.
          *
          * @return {comb.Promise} this promise for chaining
          */
         addCallback: function (cb) {
3045            if (cb) {
3045                if (isPromise(cb)) {
2                    cb = cb.callback;
                 }
3045                if (this.__fired && this.__results) {
740                    this.__callNextTick(cb, this.__results);
                 } else {
2305                    this.__cbs.push(cb);
                 }
             }
3045            return this;
         },
 
 
         /**
          * Add a callback to the errback chain of the promise
          *
          * @param {Function|comb.Promise} cb the function or promise to callback when the promise errors
          *
          * @return {comb.Promise} this promise for chaining
          */
         addErrback: function (cb) {
2927            if (cb) {
2921                if (isPromise(cb)) {
0                    cb = cb.errback;
                 }
2921                if (this.__fired && this.__error) {
20                    this.__callNextTick(cb, this.__error);
                 } else {
2901                    this.__errorCbs.push(cb);
                 }
             }
2927            return this;
         },
 
         /**
          *
          * Adds a callback or promise to be resolved for both success
          * and error.
          *
          * @param {Function|comb.Promise} cb callback or promise to be resolved for both success
          * and error.
          * @return {comb.Promise} this promise for chaining
          */
         both: function (cb) {
580            this.addCallback(cb);
580            if (isPromise(cb)) {
2                this.addErrback(cb.callback);
             } else {
578                this.addErrback(cb);
             }
 
580            return this;
         },
 
         /**
          * When called all functions registered as callbacks are called with the passed in results.
          *
          * @param {*} args variable number of results to pass back to listeners of the promise
          */
         callback: function (args) {
2209            args = argsToArray(arguments);
2209            if (this.__fired) {
1                throw new Error("Already fired!");
             }
2208            this.__results = args;
2208            this.__resolve();
2208            return this.promise();
         },
 
 
         /**
          * When called all functions registered as errbacks are called with the passed in error(s)
          *
          * @param {*} args  number of errors to pass back to listeners of the promise
          */
         errback: function (args) {
170            if (this.__fired) {
4                throw args || new Error("Already fired");
             }
166            this.__error = argsToArray(arguments);
166            this.__resolve();
166            return this.promise();
         },
 
         /**
          * Resolved a promise using the node style callback.
          *
          * @example
          *
          * var promise = new Promise();
          * fs.readFile("file.txt", "utf8", promise.resolve.bind(promise));
          * promise.then(function(file){
          *     console.log(file);
          * });
          *
          * @param {Error} [err=null] If specified then the promise will error out
          * @param {...} [args] if err is null then the aruments will be used to resolve the promise.
          *
          * @return {comb.Promise} for chaining.
          */
         resolve: function (err, args) {
4            if (err) {
1                this.errback(err);
             } else {
3                spreadArgs(this.callback, argsToArray(arguments, 1), this);
             }
4            return this;
         },
 
         /**
          * Call to specify action to take after promise completes or errors
          *
          * @param {Function} [callback=null] function to call after the promise completes successfully
          * @param {Function} [errback=null] function to call if the promise errors
          *
          * @return {comb.Promise} this promise for chaining
          */
         then: function (callback, errback) {
1858            if (isPromise(callback)) {
153                errback = callback.errback;
153                callback = callback.callback;
             }
1858            this.addCallback(callback);
1858            this.addErrback(errback);
 
1858            return this;
         },
 
         /**
          * Call this function as a classic node callback where the first argument
          * will be an error, or null if no error occured. The other arugments will
          * be the result from the promise.
          *
          * @example
          *
          * promise.classic(function(err, res){
          *      if(err){
          *          console.log(err);
          *      }else{
          *          console.log(res);
          *      }
          * });
          *
          * @param cb callback where the first argument
          * will be an error, or null if no error occured. The other arugments will
          * be the result from the promise.
          * @return {comb.Promise} the promise to chain
          */
         classic: function (cb) {
5            if ("function" === typeof cb) {
5                this.addErrback(cb);
5                this.addCallback(partial(cb, null));
             }
5            return this;
         },
 
         /**
          * Call to chaining of promises
          *
          * ```
          * new Promise()
          *  .callback("hello")
          *  .chain(function(previousPromiseResults){
          *      return previousPromiseResults + " world";
          * }, errorHandler)
          *  .chain(function(previousPromiseResults){
          *    return when(dbCall());
          *  }).classic(function(err, results){
          *      //all promises are done
          *  });
          *
          *  ```
          *
          *  You can also use static values
          *
          *  ```
          * new Promise().callback()
          *     .chain("hello")
          *     .chain(function(prev){
          *         return prev + " world!"
          *     }).then(function(str){
          *         console.log(str); //"hello world!"
          *     });
          * ```
          *
          * If you do not provide an `errback` for each chain then it will be propogated to the final promise
          *
          *
          * ```
          * new Promise()
          *     .chain(function(){
          *         return new comb.Promise().errback(new Error("error"));
          *     })
          *     .chain(function(){
          *         return prev + " world!"
          *     })
          *     .classic(function(err, str){
          *         console.log(err.message); //"error"
          *     });
          * ```
          *
          *
          * @param callback method to call this one completes. If you return a promise the execution will delay until the returned promise has resolved.
          * @param [errback=null] method to call if this promise errors. If errback is not specified then the returned promises
          * errback method will be used.
          *
          * @return {comb.Promise} A new that wraps the promise for chaining
          */
         chain: function (callback, errback) {
600            var promise = new Promise(),
                 self = this;
 
600            function _errback(e) {
94                if (isFunction(errback)) {
15                    try {
15                        var res = spreadArgs(errback, [e]);
11                        isPromiseLike(res) ? res.then(promise.callback, promise.errback) : promise.callback(res);
                     } catch (e) {
4                        promise.errback(e);
                     }
                 } else {
79                    promise.errback(e);
                 }
             }
 
600            function _callback() {
542                try {
542                    var res = isFunction(callback) ? spreadArgs(callback, arguments) : callback;
538                    if (isPromiseLike(res)) {
206                        res.then(promise.callback, _errback);
                     } else {
332                        promise.callback(res);
332                        promise = null;
                     }
538                    callback = res = null;
                 } catch (e) {
4                    _errback(e);
                 }
             }
 
600            self.addCallback(_callback);
600            self.addErrback(_errback);
600            return promise.promise();
         },
 
         /**
          * Applies the same function that returns a promise to both the callback and errback.
          *
          * @param {Function} callback function to call. This function must return a Promise
          *
          * @return {comb.Promise} a promise to continue chaining or to resolve with.
          *
          */
         chainBoth: function (callback) {
10            var promise = new Promise();
10            this.addCallback(function () {
5                try {
5                    when(isFunction(callback) ? callback.apply(this, arguments) : callback).then(promise);
                 } catch (e) {
1                    promise.errback(e);
                 }
             });
 
10            this.addErrback(function () {
5                try {
5                    when(isFunction(callback) ? callback.apply(this, arguments) : callback).then(promise);
                 } catch (e) {
1                    promise.errback(e);
                 }
             });
10            return promise.promise();
         },
 
         /**
          * Creates an object to that contains methods to listen to resolution but not the "callback" or "errback" methods.
          *
          * @example
          *
          * var asyncMethod = function(){
          *     var ret = new comb.Promise();
          *     process.nextTick(ret.callback.bind(ret, "hello"));
          *     return ret.promise();
          * }
          *
          * asyncMethod().callback() //throws error
          *
          * @return {Object} an object containing "chain", "chainBoth", "promise", "addCallback", "addErrback", "then", "both".
          */
         promise: function () {
4220            var ret = {
                 promise: function () {
765                    return ret;
                 }
             };
4220            var self = this;
4220            ret["chain"] = function () {
590                return spreadArgs(self["chain"], arguments, self);
             };
4220            ret["chainBoth"] = function () {
5                return spreadArgs(self["chainBoth"], arguments, self);
             };
4220            ret["addCallback"] = function () {
120                spreadArgs(self["addCallback"], arguments, self);
120                return ret;
             };
4220            ret["addErrback"] = function () {
7                spreadArgs(self["addErrback"], arguments, self);
7                return ret;
             };
4220            ret["then"] = function () {
1143                spreadArgs(self["then"], arguments, self);
1143                return ret;
             };
4220            ret["both"] = function () {
0                spreadArgs(self["both"], arguments, self);
0                return ret;
             };
4220            ret["classic"] = function () {
3                spreadArgs(self["classic"], arguments, self);
3                return ret;
             };
4220            return ret;
         }
 
 
     }
 });
 
 
1var PromiseList = define(Promise, {
     instance: {
         /** @lends comb.PromiseList.prototype */
 
         /*@private*/
         __results: null,
 
         /*@private*/
         __errors: null,
 
         /*@private*/
         __promiseLength: 0,
 
         /*@private*/
         __defLength: 0,
 
         /*@private*/
         __firedLength: 0,
 
         normalizeResults: false,
 
         /**
          * PromiseList object used for handling a list of Promises
          *
          * @example
          * var myFunc = function(){
          *     var promise = new Promise();
          *     //callback the promise after 10 Secs
          *     setTimeout(hitch(promise, "callback"), 10000);
          *     return promise.promise();
          * }
          * var myFunc2 = function(){
          *     var promises =[];
          *     for(var i = 0; i < 10; i++){
          *         promises.push(myFunc);
          *     }
          *     //create a new promise list with all 10 promises
          *     return new PromiseList(promises).promise();
          * }
          *
          * myFunc.then(function(success){}, function(error){})
          * //chain promise operations
          * myFunc.chain(myfunc).then(function(success){}, function(error){})
          *
          * myFunc2.then(function(success){}, function(error){})
          * //chain promise operations
          * myFunc2.chain(myfunc).then(function(success){}, function(error){})
          *
          *  @param {comb.Promise[]} [defs=[]] the list of promises
          * @constructs
          * @augments comb.Promise
          * @memberOf comb
          * */
         constructor: function (defs, normalizeResults) {
140            this.__errors = [];
140            this.__results = [];
140            this.normalizeResults = base.isBoolean(normalizeResults) ? normalizeResults : false;
140            this._super(arguments);
140            if (defs && defs.length) {
135                this.__defLength = defs.length;
135                forEach(defs, this.__addPromise, this);
             } else {
5                this.__resolve();
             }
         },
 
         /**
          * Add a promise to our chain
          * @private
          * @param promise the promise to add to our chain
          * @param i the index of the promise in our chain
          */
         __addPromise: function (promise, i) {
757            var self = this;
757            promise.then(
                 function () {
742                    var args = argsToArray(arguments);
742                    args.unshift(i);
742                    spreadArgs(self.callback, args, self);
742                    promise = i = self = null;
                 },
                 function () {
15                    var args = argsToArray(arguments);
15                    args.unshift(i);
15                    spreadArgs(self.errback, args, self);
15                    promise = i = self = null;
                 });
         },
 
         /**
          * Resolves the promise
          * @private
          */
         __resolve: function () {
140            if (!this.__fired) {
140                this.__fired = true;
140                var self = this;
140                nextTick(function () {
140                    var cbs = self.__errors.length ? self.__errorCbs : self.__cbs,
                         len = cbs.length, i,
                         results = self.__errors.length ? self.__errors : self.__results;
140                    for (i = 0; i < len; i++) {
136                        spreadArgs(cbs[i], [results]);
                     }
                 });
             }
         },
 
         __callNextTick: function (cb, results) {
7            nextTick(function () {
7                spreadArgs(cb, [results]);
7                cb = results = null;
             });
         },
 
         addCallback: function (cb) {
143            if (cb) {
143                if (isPromise(cb)) {
1                    cb = cb.callback;
                 }
143                if (this.__fired && !this.__errors.length) {
7                    this.__callNextTick(cb, this.__results);
                 } else {
136                    this.__cbs.push(cb);
                 }
             }
143            return this;
         },
 
         addErrback: function (cb) {
141            if (cb) {
141                if (isPromise(cb)) {
1                    cb = cb.errback;
                 }
141                if (this.__fired && this.__errors.length) {
0                    this.__callNextTick(cb, this.__errors);
                 } else {
141                    this.__errorCbs.push(cb);
                 }
             }
141            return this;
         },
 
 
         callback: function (i) {
743            if (this.__fired) {
1                throw new Error("Already fired!");
             }
742            var args = argsToArray(arguments);
742            if (this.normalizeResults) {
725                args = args.slice(1);
725                args = args.length == 1 ? args.pop() : args;
             }
742            this.__results[i] = args;
742            this.__firedLength++;
742            if (this.__firedLength == this.__defLength) {
130                this.__resolve();
             }
742            return this.promise();
         },
 
 
         errback: function (i) {
16            if (this.__fired) {
1                throw new Error("Already fired!");
             }
15            var args = argsToArray(arguments);
15            if (this.normalizeResults) {
14                args = args.slice(1);
14                args = args.length == 1 ? args.pop() : args;
             }
15            this.__errors[i] = args;
15            this.__firedLength++;
15            if (this.__firedLength == this.__defLength) {
5                this.__resolve();
             }
15            return this.promise();
         }
 
     }
 });
 
 
 /**
  * Creates the promise chain
  * @ignore
  * @private
  */
1function callNext(list, results, propogate) {
59    var ret = new Promise().callback();
59    forEach(list, function (listItem) {
156        ret = ret.chain(propogate ? listItem : bindIgnore(null, listItem));
156        if (!propogate) {
112            ret.addCallback(function (res) {
89                results.push(res);
89                res = null;
             });
         }
     });
59    return propogate ? ret.promise() : ret.chain(results);
 }
 
 /**
  * Tests if an object is like a promise (i.e. it contains then, addCallback, addErrback)
  * @param obj object to test
  * @function
  * @static
  * @memberOf comb
  */
1function isPromiseLike(obj) {
2731    return isObject(obj, Promise) && typeof obj.then === "function";
 }
 
1function isPromise(obj) {
8688    return obj instanceof Promise;
 }
 
 /**
  * Waits for promise and non promise values to resolve and fires callback or errback appropriately. If you pass in an array of promises
  * then it will wait for all promises in the list to resolve.
  *
  * @example
  *  var a = "hello";
  *  var b = new comb.Promise().callback(world);
  *  comb.when(a, b) => called back with ["hello", "world"];
  *
  * @param {Anything...} args variable number of arguments to wait for.
  * @param {Function} cb the callback function
  * @param {Function} eb the errback function
  * @returns {comb.Promise} a promise that is fired when all values have resolved
  * @static
  * @memberOf comb
  */
1function when(args, cb, eb) {
1373    var args = argsToArray(arguments), p;
1373    eb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
1373    cb = base.isFunction(args[args.length - 1]) ? args.pop() : null;
1373    if (eb && !cb) {
9        cb = eb;
9        eb = null;
     }
1373    if (!args.length) {
7        p = new Promise().callback(args);
1366    } else if (args.length == 1) {
1326        args = args.pop();
1326        if (isPromiseLike(args)) {
651            p = args;
675        } else if (isArray(args) && array.every(args, isPromiseLike)) {
89            p = new PromiseList(args, true);
         } else {
586            p = new Promise().callback(args);
         }
     } else {
40        p = new PromiseList(args.map(function (a) {
135            return isPromiseLike(a) ? a : new Promise().callback(a);
         }), true);
     }
1373    if (cb) {
15        p.addCallback(cb);
     }
1373    if (eb) {
6        p.addErrback(eb);
     }
1373    return p.promise();
 
 }
 
 /**
  * Wraps traditional node style functions with a promise.
  * @example
  *
  * var fs = require("fs");
  * var readFile = comb.wrap(fs.readFile, fs);
  * readFile(__dirname + "/test.json").then(
  *      function(buffer){
  *          console.log(contents);
  *      },
  *      function(err){
  *
  *      }  console.error(err);
  * );
  *
  *
  * @param {Function} fn function to wrap
  * @param {Object} scope scope to call the function in
  *
  * @return {Funciton} a wrapped function
  * @static
  * @memberOf comb
  */
1function wrap(fn, scope) {
2    return function () {
2        var ret = new Promise();
2        var args = argsToArray(arguments);
2        args.push(ret.resolve.bind(ret));
2        fn.apply(scope || this, args);
2        return ret.promise();
     }
 }
 
 /**
  * Executes a list of items in a serial manner. If the list contains promises then each promise
  * will be executed in a serial manner, if the list contains non async items then the next item in the list
  * is called.
  *
  * @example
  *
  * var asyncAction = function(item, timeout){
  *    var ret = new comb.Promise();
  *    setTimeout(comb.hitchIgnore(ret, "callback", item), timeout);
  *    return ret.promise();
  * };
  *
  * comb.serial([
  *     comb.partial(asyncAction, 1, 1000),
  *     comb.partial(asyncAction, 2, 900),
  *     comb.partial(asyncAction, 3, 800),
  *     comb.partial(asyncAction, 4, 700),
  *     comb.partial(asyncAction, 5, 600),
  *     comb.partial(asyncAction, 6, 500)
  * ]).then(function(results){
  *     console.log(results); // [1,2,3,4,5,6];
  * });
  *
  *
  *
  * @param list
  * @param callback
  * @param errback
  * @static
  * @memberOf comb
  */
1function serial(list, callback, errback) {
56    if (base.isArray(list)) {
55        return callNext(list, [], false);
     } else {
1        throw new Error("When calling comb.serial the first argument must be an array");
     }
 }
 
 
 /**
  * Works just like {@link comb.Promise#chain} method, allowing you to propogate results from one funciton to another.
  * This is different than {@link comb.serial} in that it propogates results from one promise to the next, where
  * {@link comb.serial} does not.
  *
  * @example
  *
  * function asyncAction(add, timeout) {
  *      return function (num) {
  *          num = num || 0;
  *          var ret = new comb.Promise();
  *          setTimeout(function () {
  *               ret.callback(num + add);
  *          }, timeout);
  *          return ret;
  *      }
  * }
  *
  * comb.chain([
  *      asyncAction(1, 100),
  *      asyncAction(2, 100),
  *      asyncAction(3, 100),
  *      asyncAction(4, 100),
  *      asyncAction(5, 100),
  * ]).then(function(results){
  *      console.log(results); //15
  * });
  *
  * @param {function[]} list an array of function to call.
  * @return {comb.Promise} a promise that will resolve with the results of the last function in the list.
  * @static
  * @memberOf comb
  */
1function chain(list) {
5    if (base.isArray(list)) {
4        return callNext(list, [], true);
     } else {
1        throw new Error("When calling comb.serial the first argument must be an array");
     }
 }
 
 
 /**
  * Ensures that a promise is resolved before a the function can be run.
  *
  * For example suppose you have to ensure that you are connected to a database before you execute a function.
  *
  * ```
  * var findUser = comb.wait(connect(), function findUser(id){
  *      //this wont execute until we are connected
  *      return User.findById(id);
  * });
  *
  *  comb.when(findUser(1), findUser(2)).then(function(users){
  *      var user1 = users[0], user2 = users[1];
  *  });
  *
  * ```
  *
  * @param args variable number of arguments to wait on. See {@link comb.when}.
  * @param {Function} fn function that will wait.
  * @return {Function} a function that will wait on the args to resolve.
  * @memberOf comb
  * @static
  */
1function wait(args, fn) {
2    var args = argsToArray(arguments), resolved = false;
2    fn = args.pop();
2    var p = when(args);
2    return function waiter() {
3        if (!resolved) {
2            var args = arguments;
2            return p.chain(function () {
2                resolved = true;
2                p = null;
2                return fn.apply(this, args);
             }.bind(this));
         } else {
1            return when(fn.apply(this, arguments));
         }
     };
 }
 
 
 /**
  * Wraps a stream in a promise waiting for either the `"end"` or `"error"` event to be triggered.
  *
  * ```
  * comb.promisfyStream(fs.createdReadStream("my.file")).chain(function(){
  *      console.log("done reading!");
  * });
  *
  * ```
  *
  * @param stream stream to wrap
  * @return {comb.Promise} a Promise is resolved if `"end"` is triggered before `"error"` or rejected if `"error"` is triggered.
  * @memberOf comb
  * @static
  */
1function promisfyStream(stream) {
2    var ret = new Promise(), called;
 
2    function errorHandler() {
1        if (!called) {
1            called = true;
1            spreadArgs(ret.errback, arguments, ret);
1            stream.removeListener("error", endHandler);
1            stream.removeListener("end", endHandler);
1            stream = ret = null;
         }
     }
 
2    function endHandler() {
1        if (!called) {
1            called = true;
1            spreadArgs(ret.callback, arguments, ret);
1            stream.removeListener("error", endHandler);
1            stream.removeListener("end", endHandler);
1            stream = ret = null;
         }
     }
 
2    stream.on("error", errorHandler).on("end", endHandler);
2    return ret.promise();
 }
 
 /**
  * Creates a new {@link comb.Promise} that is resolved with the given value.
  *
  * ```
  * comb.resolved(1).chain(function(val){
  *      //val === 1
  * });
  * ```
  *
  * If you give it a promise it will wait for the promise to resolve or error.
  *
  * ```
  * comb.resolved(new comb.Promise().callback(1)).chain(function(val){
  *      //val === 1
  * });
  * ```
  *
  * @param val - val to resolve with
  * @returns {comb.Promise} a promisfied version of the value.
  * @memberOf comb
  * @static
  */
1function resolved(val) {
5    var ret = new Promise();
5    when(val).chain(ret.callback, ret.errback);
5    return ret.promise();
 }
 
 /**
  * Creates a new {@link comb.Promise} that is rejected with the given value.
  *
  * ```
  * comb.resolved(new Error("error!")).chain(null, function(err){
  *      console.error(err.stack);
  * });
  * ```
  *
  * If you give it a promise it will wait for the promise to resolve or error but with reject either way.
  *
  * ```
  * comb.resolved(new comb.Promise().callback(1)).chain(null, function(err){
  *      //err === 1
  * });
  * ```
  *
  * @param val - val to reject with
  * @returns {comb.Promise} a rejected promise with the specified value.
  * @memberOf comb
  * @static
  */
1function rejected(val) {
4    var ret = new Promise();
4    when(val).chain(ret.errback, ret.errback);
4    return ret.promise();
 }
 
 
1base.merge(exports, {
     isPromiseLike: isPromiseLike,
     when: when,
     wrap: wrap,
     wait: wait,
     serial: serial,
     chain: chain,
     promisfyStream: promisfyStream,
     resolved: resolved,
     rejected: rejected,
     Promise: Promise,
     PromiseList: PromiseList
 });
 
 
 
 
 
 
 
 

 /**
  * Used to keep track of classes and to create unique ids
  * @ignore
  */
1var classCounter = 0, Base,
     _base = require("./base"),
     isHash = _base.isHash,
     isArray = _base.isArray,
     SUPER_REGEXP = /(super)/ig,
     invoke = _base.__spreadArgs;
 
 
1function callSuper(args, a) {
1243    var meta = this.__meta,
         supers = meta.supers,
         l = supers.length, superMeta = meta.superMeta, pos = superMeta.pos;
1243    if (l > pos) {
1243        a && (args = a);
1243        var name = superMeta.name, f = superMeta.f, m;
1243        do {
1243            m = supers[pos][name];
1243            if ("function" === typeof m && (m = m._f || m) !== f) {
1239                superMeta.pos = 1 + pos;
1239                return invoke(m, args, this);
             }
         } while (l > ++pos);
     }
4    return null;
 }
 
1function getSuper() {
2    var meta = this.__meta,
         supers = meta.supers,
         l = supers.length, superMeta = meta.superMeta, pos = superMeta.pos;
2    if (l > pos) {
2        var name = superMeta.name, f = superMeta.f, m;
2        do {
3            m = supers[pos][name];
3            if ("function" === typeof m && (m = m._f || m) !== f) {
1                superMeta.pos = 1 + pos;
1                return m.bind(this);
             }
         } while (l > ++pos);
     }
1    return null;
 }
 
 
1function defaultFunction() {
287    var meta = this.__meta || {},
         supers = meta.supers,
         l = supers.length, superMeta = meta.superMeta, pos = superMeta.pos;
287    if (l > pos) {
143        var name = superMeta.name, f = superMeta.f, m;
143        do {
223            m = supers[pos][name];
223            if ("function" === typeof m && (m = m._f || m) !== f) {
96                superMeta.pos = 1 + pos;
96                return invoke(m, arguments, this);
             }
         } while (l > ++pos);
     }
191    return null;
 }
 
 
1function functionWrapper(f, name) {
318    if (f.toString().match(SUPER_REGEXP)) {
104        var wrapper = function () {
2128            var ret, meta = this.__meta || {};
2128            var orig = meta.superMeta;
2128            meta.superMeta = {f: f, pos: 0, name: name};
2128            ret = invoke(f, arguments, this);
2128            meta.superMeta = orig;
2128            return ret;
         };
104        wrapper._f = f;
104        return wrapper;
     } else {
214        f._f = f;
214        return f;
     }
 }
 
 
 /**
  * @ignore
  */
1function defineMixinProps(child, proto) {
 
34    var operations = proto.setters || {};
34    for (var i in operations) {
15        if (!child.__lookupSetter__(i)) {  //make sure that the setter isnt already there
15            child.__defineSetter__(i, operations[i]);
         }
     }
34    operations = proto.getters || {};
34    for (i in operations) {
15        if (!child.__lookupGetter__(i)) {
             //define the getter if the child does not already have it
15            child.__defineGetter__(i, operations[i]);
         }
     }
34    for (var j in proto) {
103        if (j != "getters" && j != "setters") {
83            var p = proto[j];
83            if ("function" === typeof p) {
78                if (!child.hasOwnProperty(j)) {
10                    child[j] = functionWrapper(defaultFunction, j);
                 }
             } else {
5                child[j] = p;
             }
         }
     }
 }
 
 
 /**
  * @ignore
  */
1function mixin() {
7    var args = Array.prototype.slice.call(arguments), l = args.length;
7    var child = this.prototype, childMeta = child.__meta, thisMeta = this.__meta, bases = child.__meta.bases, staticBases = bases.slice(),
         staticSupers = thisMeta.supers || [], supers = childMeta.supers || [];
7    for (var i = 0; i < l; i++) {
17        var m = args[i], mProto = m.prototype;
17        var protoMeta = mProto.__meta, meta = m.__meta;
17        if (!protoMeta) {
0            protoMeta = {proto: mProto || {}};
0            Object.defineProperty(mProto, "__meta", {
                 enumerable: false,
                 value: protoMeta
             });
         }
17        if (!meta) {
0            meta = {proto: m["__proto__"] || {}};
0            Object.defineProperty(m, "__meta", {
                 enumerable: false,
                 value: protoMeta
             });
         }
17        defineMixinProps(child, protoMeta.proto || {});
17        defineMixinProps(this, meta.proto || {});
         //copy the bases for static,
 
17        mixinSupers(m.prototype, supers, bases);
17        mixinSupers(m, staticSupers, staticBases);
     }
7    return this;
 }
 
 /**
  * @ignore
  */
1function mixinSupers(sup, arr, bases) {
386    var meta = sup.__meta;
386    if (!meta) {
0        meta = {};
0        Object.defineProperty(sup, "__meta", {
             enumerable: false,
             value: meta
         });
     }
386    var unique = sup.__meta.unique;
386    !unique && (meta.unique = "define" + ++classCounter);
     //check it we already have this super mixed into our prototype chain
     //if true then we have already looped their supers!
386    if (bases.indexOf(unique) == -1) {
         //add their id to our bases
234        bases.push(unique);
234        var supers = sup.__meta.supers || [], i = supers.length - 1 || 0;
234        while (i >= 0) {
258            mixinSupers(supers[i--], arr, bases);
         }
234        arr.unshift(sup);
     }
 }
 
 
 /**
  * @ignore
  */
1function defineProps(child, proto) {
92    var operations = proto.setters;
92    if (operations) {
8        for (var i in operations) {
13            child.__defineSetter__(i, operations[i]);
         }
     }
92    operations = proto.getters || {};
92    if (operations) {
92        for (i in operations) {
47            child.__defineGetter__(i, operations[i]);
         }
     }
92    for (i in proto) {
359        if (i != "getters" && i != "setters") {
338            var f = proto[i];
338            if ("function" === typeof f) {
305                var meta = f.__meta || {};
305                if (!meta.isConstructor) {
304                    child[i] = functionWrapper(f, i);
                 } else {
1                    child[i] = f;
                 }
             } else {
33                child[i] = f;
             }
         }
     }
 
 }
 
1function _export(obj, name) {
11    if (obj && name) {
2        obj[name] = this;
     } else {
9        obj.exports = obj = this;
     }
11    return this;
 }
 
1function extend(proto) {
7    return define(this, proto);
 }
 
 
 /**
  * @ignore
  */
1function __define(child, sup, proto) {
48    var childProto = child.prototype, supers = [];
48    var unique = "define" + ++classCounter, bases = [], staticBases = [];
48    var instanceSupers = [], staticSupers = [];
48    var meta = {
         supers: instanceSupers,
         unique: unique,
         bases: bases,
         superMeta: {
             f: null,
             pos: 0,
             name: null
         }
     };
48    Object.defineProperty(childProto, "__meta", {
         enumerable: false,
         value: meta
     });
48    var childMeta = {
         supers: staticSupers,
         unique: unique,
         bases: staticBases,
         isConstructor: true,
         superMeta: {
             f: null,
             pos: 0,
             name: null
         }
     };
48    Object.defineProperty(child, "__meta", {
         enumerable: false,
         value: childMeta
     });
48    if ((isHash(sup) && !proto)) {
2        proto = sup;
2        sup = Base;
46    } else if ((!sup && isHash(proto))) {
14        sup = Base;
     }
 
48    if ("function" === typeof sup || isArray(sup)) {
47        supers = isArray(sup) ? sup : [sup];
47        sup = supers.shift();
47        child.__proto__ = sup;
47        childProto.__proto__ = sup.prototype;
47        mixinSupers(sup.prototype, instanceSupers, bases),
             mixinSupers(sup, staticSupers, staticBases);
     }
48    if (proto) {
46        var instance = meta.proto = proto.instance || {};
46        !instance.hasOwnProperty("constructor") && (instance.constructor = defaultFunction);
46        var stat = childMeta.proto = proto.static || {};
46        stat.init = stat.init || defaultFunction;
46        defineProps(childProto, instance, false);
46        defineProps(child, stat, true);
     } else {
2        meta.proto = {};
2        childMeta.proto = {};
2        child.init = functionWrapper(defaultFunction, "init");
2        childProto.constructor = functionWrapper(defaultFunction, "constructor");
     }
48    if (supers.length) {
7        invoke(mixin, supers, child);
     }
48    Object.defineProperty(childProto, "_super", {
         enumerable: false,
         value: callSuper
     });
48    Object.defineProperty(child, "_super", {
         enumerable: false,
         value: callSuper
     });
48    Object.defineProperty(child, "_getSuper", {
         enumerable: false,
         value: getSuper
     });
48    Object.defineProperty(childProto, "_getSuper", {
         enumerable: false,
         value: getSuper
     });
48    Object.defineProperty(childProto, "_static", {
         enumerable: false,
         value: child
     });
 }
 
1function define(sup, proto) {
45    function defineConstructor() {
2876        invoke(this.constructor, arguments, this);
2875        sup = proto = null;
     }
 
45    __define(defineConstructor, sup, proto);
45    return defineConstructor.init() || defineConstructor;
 }
 
1function singleton(sup, proto) {
3    var retInstance;
 
3    function singletonConstructor() {
6        if (!retInstance) {
2            invoke(this.constructor, arguments, this);
2            retInstance = this;
         }
6        return retInstance;
     }
 
3    __define(singletonConstructor, sup, proto);
3    return  singletonConstructor.init() || singletonConstructor;
 }
 
1Base = define({
     instance: {},
 
     "static": {
         mixin: mixin,
         extend: extend,
         as: _export
     }
 });
 
 
 /**
  * Defines a new class to be used
  *
  * <p>
  *     Class methods
  *     <ul>
  *         <li>as(module | object, name): exports the object to module or the object with the name</li>
  *         <li>mixin(mixin) : mixes in an object</li>
  *     </ul>
  *     </br>
  *     Instance methods
  *     <ul>
  *         <li>_super(argumnents, [?newargs]): calls the super of the current method</li>
  *     </ul>
  *
  *      </br>
  *     Instance properties
  *     <ul>
  *         <li>_static: use to reference class properties and methods</li>
  *     </ul>
  *
  * </p>
  *
  *
  * @example
  *  //Class without a super class
  * var Mammal = comb.define(null, {
  *      instance : {
  *
  *          constructor: function(options) {
  *              options = options || {};
  *              this._super(arguments);
  *              this._type = options.type || "mammal";
  *          },
  *
  *          speak : function() {
  *              return  "A mammal of type " + this._type + " sounds like";
  *          },
  *
  *          //Define your getters
  *          getters : {
  *              type : function() {
  *                  return this._type;
  *              }
  *          },
  *
  *           //Define your setters
  *          setters : {
  *              type : function(t) {
  *                  this._type = t;
  *              }
  *          }
  *      },
  *
  *      //Define your static methods
  *      static : {
  *          soundOff : function() {
  *              return "Im a mammal!!";
  *          }
  *      }
  * });
  *
  * //Show singular inheritance
  *var Wolf = comb.define(Mammal, {
  *   instance: {
  *       constructor: function(options) {
  *          options = options || {};
  *          //You can call your super constructor, or you may not
  *          //call it to prevent the super initializing parameters
  *          this._super(arguments);
  *          this._sound = "growl";
  *          this._color = options.color || "grey";
  *      },
  *
  *      speak : function() {
  *          //override my super classes speak
  *          //Should return "A mammal of type mammal sounds like a growl"
  *          return this._super(arguments) + " a " + this._sound;
  *      },
  *
  *      //add new getters for sound and color
  *      getters : {
  *
  *          color : function() {
  *              return this._color;
  *          },
  *
  *          sound : function() {
  *              return this._sound;
  *          }
  *      },
  *
  *      setters : {
  *
  *          //NOTE color is read only except on initialization
  *
  *          sound : function(s) {
  *              this._sound = s;
  *          }
  *      }
  *
  *  },
  *
  *  static : {
  *      //override my satic soundOff
  *      soundOff : function() {
  *          //You can even call super in your statics!!!
  *          //should return "I'm a mammal!! that growls"
  *          return this._super(arguments) + " that growls";
  *      }
  *  }
  *});
  *
  *
  * //Typical hierarchical inheritance
  * // Mammal->Wolf->Dog
  * var Dog = comb.define(Wolf, {
  *    instance: {
  *        constructor: function(options) {
  *            options = options || {};
  *            this._super(arguments);
  *            //override Wolfs initialization of sound to woof.
  *            this._sound = "woof";
  *
  *        },
  *
  *        speak : function() {
  *            //Should return "A mammal of type mammal sounds like a growl thats domesticated"
  *            return this._super(arguments) + " thats domesticated";
  *        }
  *    },
  *
  *    static : {
  *        soundOff : function() {
  *            //should return "I'm a mammal!! that growls but now barks"
  *            return this._super(arguments) + " but now barks";
  *        }
  *    }
  *});
  *
  *
  *
  * dog instanceof Wolf => true
  * dog instanceof Mammal => true
  * dog.speak() => "A mammal of type mammal sounds like a woof thats domesticated"
  * dog.type => "mammal"
  * dog.color => "gold"
  * dog.sound => "woof"
  * Dog.soundOff() => "Im a mammal!! that growls but now barks"
  *
  * // Mammal->Wolf->Dog->Breed
  *var Breed = comb.define(Dog, {
  *    instance: {
  *
  *        //initialize outside of constructor
  *        _pitch : "high",
  *
  *        constructor: function(options) {
  *            options = options || {};
  *            this._super(arguments);
  *            this.breed = options.breed || "lab";
  *        },
  *
  *        speak : function() {
  *            //Should return "A mammal of type mammal sounds like a
  *            //growl thats domesticated with a high pitch!"
  *            return this._super(arguments) + " with a " + this._pitch + " pitch!";
  *        },
  *
  *        getters : {
  *            pitch : function() {
  *                return this._pitch;
  *            }
  *        }
  *    },
  *
  *    static : {
  *        soundOff : function() {
  *            //should return "I'M A MAMMAL!! THAT GROWLS BUT NOW BARKS!"
  *            return this._super(arguments).toUpperCase() + "!";
  *        }
  *    }
  * });
  *
  *
  * var breed = new Breed({color : "gold", type : "lab"}),
  *
  *
  *
  * breed instanceof Dog => true
  * breed instanceof Wolf => true
  * breed instanceof Mammal => true
  * breed.speak() => "A mammal of type lab sounds like a woof "
  *                  + "thats domesticated with a high pitch!"
  * breed.type => "lab"
  * breed.color => "gold"
  * breed.sound => "woof"
  * breed.soundOff() => "IM A MAMMAL!! THAT GROWLS BUT NOW BARKS!"
  *
  *
  *  //Example of multiple inheritance
  *  //NOTE proto is optional
  *
  *  //Mammal is super class
  *  //Wolf Dog and Breed inject functionality into the prototype
  * var Lab = comb.define([Mammal, Wolf, Dog, Breed]);
  *
  * var lab = new Lab();
  * lab instanceof Wolf => false
  * lab instanceof Dog => false
  * lab instanceof Breed => false
  * lab instanceof Mammal => true
  * lab.speak() => "A mammal of type mammal sounds like a"
  *                + " woof thats domesticated with a high pitch!"
  * Lab.soundOff() => "IM A MAMMAL!! THAT GROWLS BUT NOW BARKS!"
  *
  * @name define
  * @memberOf comb
  *
  * @param {Array|Class} super the supers of this class
  * @param {Object} [proto] the object used to define this class
  * @param {Object} [proto.instance] the instance methods of the class
  * @param {Object} [proto.instance.getters] the getters for the class
  * @param {Object} [proto.instance.setters] the setters for the class
  * @param {Object} [proto.static] the Class level methods of this class
  * @param {Object} [proto.static.getters] static getters for the object
  * @param {Object} [proto.static.setters] static setters for the object
  *
  * @returns {Object} the constructor of the class to be used with new keyword
  */
1exports.define = define;
 
 /**
  * Defines a singleton instance of a Class. See {@link define}
  * @example
  *  var MyLab = comb.singleton([Mammal, Wolf, Dog, Breed]);
  *  var myLab1 = new MyLab();
  *  myLab1.type = "collie"
  *  var myLab2 = new MyLab();
  *  myLab1 === myLab2 => true
  *  myLab1.type => "collie"
  *  myLab2.type => "collie"
  *
  *
  * @name singleton
  * @memberOf comb
 
  */
1exports.singleton = singleton;
 

1var comb = exports, date,
     misc = require("./misc"),
     object = require("./object"),
     round = require("./number").number.round,
     isHash = object.isHash,
     pSlice = Array.prototype.slice,
     toStr = Object.prototype.toString,
     abs = Math.abs;
 
1function getDate() {
70    return (date || (date = require("./date")));
 }
 
 /**
  * Truncates a string to the specified length.
  * @example
  *
  * //from the beginning
  * comb.string.truncate("abcdefg", 3) => "abc";
  * //from the end
  * comb.string.truncate("abcdefg", 3,true) => "efg"
  * //omit the length
  * comb.string.truncate("abcdefg") => "abcdefg"
  *
  * @param {String} string the string to truncate
  * @param {Number} [length = -1] the max length of the string, if the string is
  *                              shorter than the length then the string is returned.
  * @param {Boolean} [end=false] truncate starting at the end of the string
  *
  * @return {String} the truncated string.
  * @memberOf comb.string
  * @static
  */
1function truncate(string, length, end) {
46    var ret = string;
46    if (comb.isString(ret)) {
44        if (string.length > length) {
27            if (end) {
8                var l = string.length;
8                ret = string.substring(l - length, l);
             } else {
19                ret = string.substring(0, length);
             }
         }
     } else {
2        ret = truncate("" + ret, length);
     }
46    return ret;
 }
 
 /**
  * Escapes an HTML string by replacing <>&" characters.
  *
  * @example
  * comb.string.escapeHtml('<script>alert("test")</script>'); // &lt;script&gt;alert("test")&lt;/script&gt;
  *
  * @param {String} str The string to escape.
  * @memberOf comb.string
  * @static
  */
1function escapeHtml(str) {
1    return String(str)
         .replace(/&/g, '&amp;')
         .replace(/</g, '&lt;')
         .replace(/>/g, '&gt;')
         .replace(/"/g, '&quot;')
         .replace(/'/g, '&#39;');
 }
 
 /**
  * Pads a string
  *
  * @example
  *
  * comb.string.pad("STR", 5, " ", true) => "STR  "
  * comb.string.pad("STR", 5, "$") => "$$STR"
  *
  * @param {String} string the string to pad
  * @param {Number} length the length of the string when padded
  * @param {String} [ch= " "] character to pad the string with
  * @param {Boolean} [end=false] if true then the padding is added to the end
  *
  * @returns {String} the padded string
  * @memberOf comb.string
  * @static
  */
1function pad(string, length, ch, end) {
376    string = "" + string; //check for numbers
376    ch = ch || " ";
376    var strLen = string.length;
376    while (strLen < length) {
306        if (end) {
158            string += ch;
         } else {
148            string = ch + string;
         }
306        strLen++;
     }
376    return string;
 }
 
 /**
  * Tests if something is a string.
  *
  * @example
  *
  * comb.isString("true") //true
  * comb.isString(true) //false
  *
  * @param obj the thing to test
  * @return {Boolean} returns true if the argument is a string.
  * @static
  * @memberOf comb
  */
1function isString(obj) {
36117    return toStr.call(obj) === '[object String]';
 }
 
1comb.isString = isString;
 
1var FORMAT_REGEX = /%((?:-?[\+| ]?.?\d*(?:\.\d+)*)?|(?:\[[^\[|\]]*\]))?([sjdDZ])/g;
1var INTERP_REGEX = /{(?:\[([^\[|\]]*)\])?(\w+)}/g;
1var STR_FORMAT = /(-?)(\+?)([A-Z|a-z|\W]?)([1-9][0-9]*)?$/;
1var NUMBER_FORMAT = /(-?)([\+| ]?)([^\.1-9])?([1-9][0-9]*)?(\.[1-9][0-9]*)?$/;
1var OBJECT_FORMAT = /([1-9][0-9]*)$/g;
 
1function formatString(string, format) {
64    var match = format.match(STR_FORMAT), ret = string;
64    if (match) {
64        var isLeftJustified = match[1], padChar = match[3], width = match[4];
64        if (width) {
64            width = parseInt(width, 10);
64            if (ret.length < width) {
35                ret = pad(ret, width, padChar, isLeftJustified);
             } else {
29                ret = truncate(ret, width);
             }
         }
     }
64    return ret;
 }
 
1function formatNumber(number, format) {
37    var ret = "";
37    if (typeof number === "number") {
35        ret = "" + abs(number);
35        var match = format.match(NUMBER_FORMAT);
35        if (match) {
35            var isLeftJustified = match[1], signed = (number < 0 ? '-' : match[2]), padChar = match[3] || ' ', width = match[4], precision = match[5];
35            if (precision) {
12                precision = parseInt(precision.replace(/^\./, ""), 10);
12                ret = round(abs(number), precision) + "";
                 //check and ensure we have padding zeros
12                var split = ret.split(".");
12                if (split.length === 1) {
12                    ret = [split[0], pad("0", precision, "0", true)].join(".");
0                } else if (split[1].length < precision) {
0                    ret = [split[0], pad(split[1], precision, "0", true)].join(".");
                 }
             }
35            if (padChar === ' ') {
27                ret = signed + ret;
27                signed = false;
             }
35            if (width) {
26                width = parseInt(width, 10);
26                if (signed) {
6                    width--;
                 }
26                if (ret.length < width) {
23                    ret = pad(ret, width, padChar || " ", isLeftJustified);
                 } else {
3                    ret = truncate(ret, width);
                 }
             }
35            if (signed) {
6                ret = signed + ret;
             }
 
         }
     } else {
2        throw new Error("comb.string.format : when using %d the parameter must be a number!");
     }
35    return ret;
 }
 
1function formatObject(object, format) {
8    var ret, match = format.match(OBJECT_FORMAT), spacing = 0;
8    if (match) {
8        spacing = parseInt(match[0], 10);
8        if (isNaN(spacing)) {
0            spacing = 0;
         }
     }
8    try {
8        ret = JSON.stringify(object, null, spacing);
     } catch (e) {
2        throw new Error("comb.string.format : Unable to parse json from ", object);
     }
6    return ret;
 }
 
 /**
  * Formats a string with the specified format
  *
  * Format `String`s
  *
  * ```
  * comb.string.format("%s", "Hello"); // "Hello"
  * comb.string.format("%10s", "Hello"); // "     Hello"
  * comb.string.format("%-10s", "Hello"); // ""Hello     ""
  * comb.string.format('%.10s', "Hello"); //".....Hello"
  * comb.string.format('%-!10s', "Hello"); //"Hello!!!!!"
  * comb.string.format("%-.10s%s!", "Hello", "World"); //"Hello.....World!"
  * ```
  *
  * Formatting Numbers
  *
  * ```
  * comb.string.format('%d', 10); //"10"
  *
  * //setting precision
  * comb.string.format('%.2d', 10); //"10.00"
  *
  * //specifying width
  * comb.string.format('%5d', 10); //"   10"
  *
  * //Signed
  * comb.string.format('%+d', 10);  //"+10"
  * comb.string.format('%+d', -10); //"-10"
  *
  * comb.string.format('% d', 10);  //" 10"
  * comb.string.format('% d', -10); //"-10"
  *
  * //width
  * comb.string.format('%5d', 10); //"   10"
  *
  * //width and precision
  * comb.string.format('%6.2d', 10); //" 10.00"
  *
  * //signed, width and precision
  * comb.string.format('%+ 7.2d', 10);  //" +10.00"
  * comb.string.format('%+ 7.2d', -10); //" -10.00"
  * comb.string.format('%+07.2d', 10);  //"+010.00"
  * comb.string.format('%+07.2d', -10); //"-010.00"
  * comb.string.format('%  7.2d', 10);  //"  10.00"
  * comb.string.format('%  7.2d', -10); //" -10.00"
  * comb.string.format('% 7.2d', 10);   //"  10.00"
  * comb.string.format('% 7.2d', -10);  //" -10.00"
  *
  * //use a 0 as padding
  * comb.string.format('%010d', 10); //"0000000010"
  *
  * //use an ! as padding
  * comb.string.format('%!10d', 10); //"!!!!!!!!10"
  *
  * //left justify signed ! as padding and a width of 10
  * comb.string.format('%-+!10d', 10); //"+10!!!!!!!"
  *
  * ```
  *
  * Formatting dates
  *
  * ```
  * comb.string.format("%[h:mm a]D", new Date(2014, 05, 04, 7,6,1)); // 7:06 AM - local -
  * comb.string.format("%[h:mm a]Z", new Date(2014, 05, 04, 7,6,1)); //12:06 PM - UTC
  * comb.string.format("%[yyyy-MM-dd]D", new Date(2014, 05, 04, 7,6,1)); // 2014-06-04 - local
  * comb.string.format("%[yyyy-MM-dd]Z", new Date(2014, 05, 04, 7,6,1)); // 2014-06-04 - UTC
  * ```
  *
  * Formatting Objects
  *
  * ```
  * //When using object formats they must be in an array otherwise
  * //format will try to interpolate the properties into the string.
  * comb.string.format("%j", [{a : "b"}]) // '{"a":"b"}'
  *
  * //Specifying spacing
  * comb.string.format("%4j", [{a : "b"}]) // '{\n    "a": "b"\n}'
  *
  * ```
  *
  * String interpolation
  *
  * ```
  * comb.string.format("{hello}, {world}", {hello : "Hello", world : "World"); //"Hello, World";
  * comb.string.format("{[.2]min}...{[.2]max}", {min: 1, max: 10}); //"1.00...10.00"
  * ```
  *
  * @param {String} str the string to format, if you want to use a spacing character as padding (other than \\s) then put your format in brackets.
  *  <ol>
  *      <li>String Formats %[options]s</li>
  *          <ul>
  *              <li>- : left justified</li>
  *              <li>Char : padding character <b>Excludes d,j,s</b></li>
  *              <li>Number : width</li>
  *          </ul>
  *      </li>
  *      <li>Number Formats %[options]d</li>
  *          <ul>
  *              <li>`-` : left justified</li>
  *              <li>`+` or `<space>` : signed number if space is used the number will use a extra `<space>` instead of a `+`</li>
  *              <li>`<Char>` : padding character <b>Excludes d,j,s</b></li>
  *              <li>`Number` : width</li>
  *              <li>`.Number`: specify the precision of the number</li>
  *          </ul>
  *      </li>
  *      <li>Object Formats %[options]j</li>
  *          <ul>
  *              <li>Number : spacing for object properties.</li>
  *          </ul>
  *      </li>
  *  </ol>
  *
  *
  * @param {Object|Array|Arguments...} obj the parameters to replace in the string
  *                                    if an array is passed then the array is used sequentially
  *                                    if an object is passed then the object keys are used
  *                                    if a variable number of args are passed then they are used like an array
  *
  * @returns {String} the formatted string
  * @memberOf comb.string
  * @static
  */
1function format(str, obj) {
 
180    if (obj instanceof Array) {
82        var i = 0, len = obj.length;
         //find the matches
82        return str.replace(FORMAT_REGEX, function (m, format, type) {
134            var replacer, ret;
134            if (i < len) {
132                replacer = obj[i++];
             } else {
                 //we are out of things to replace with so
                 //just return the match?
2                return m;
             }
132            if (m === "%s" || m === "%d" || m === "%D") {
                 //fast path!
61                ret = replacer + "";
71            } else if (m === "%Z") {
2                ret = replacer.toUTCString();
69            } else if (m === "%j") {
4                try {
4                    ret = JSON.stringify(replacer);
                 } catch (e) {
2                    throw new Error("comb.string.format : Unable to parse json from ", replacer);
                 }
             } else {
65                format = format.replace(/^\[|\]$/g, "");
65                switch (type) {
                 case "s":
8                    ret = formatString(replacer, format);
8                    break;
                 case "d":
35                    ret = formatNumber(replacer, format);
33                    break;
                 case "j":
6                    ret = formatObject(replacer, format);
4                    break;
                 case "D":
8                    ret = getDate().date.format(replacer, format);
8                    break;
                 case "Z":
8                    ret = getDate().date.format(replacer, format, true);
8                    break;
                 }
             }
126            return ret;
         });
98    } else if (isHash(obj)) {
36        return str.replace(INTERP_REGEX, function (m, format, value) {
142            value = obj[value];
142            if (!misc.isUndefined(value)) {
140                if (format) {
86                    if (comb.isString(value)) {
56                        return formatString(value, format);
30                    } else if (typeof value === "number") {
2                        return formatNumber(value, format);
28                    } else if (getDate().isDate(value)) {
26                        return getDate().date.format(value, format);
2                    } else if (typeof value === "object") {
2                        return formatObject(value, format);
                     }
                 } else {
54                    return "" + value;
                 }
             }
2            return m;
         });
     } else {
62        var args = pSlice.call(arguments).slice(1);
62        return format(str, args);
     }
 }
 
 
1var styles = {
     //styles
     bold: 1,
     bright: 1,
     italic: 3,
     underline: 4,
     blink: 5,
     inverse: 7,
     crossedOut: 9,
 
     red: 31,
     green: 32,
     yellow: 33,
     blue: 34,
     magenta: 35,
     cyan: 36,
     white: 37,
 
     redBackground: 41,
     greenBackground: 42,
     yellowBackground: 43,
     blueBackground: 44,
     magentaBackground: 45,
     cyanBackground: 46,
     whiteBackground: 47,
 
     encircled: 52,
     overlined: 53,
     grey: 90,
     black: 90
 };
 
 /**
  * Styles a string according to the specified styles.
  *
  * @example
  * //style a string red
  * comb.string.style('myStr', 'red');
  * //style a string red and bold
  * comb.string.style('myStr', ['red', bold]);
  *
  * @param {String} str The string to style.
  * @param {String|Array} styles the style or styles to apply to a string.
  *          options include :
  *          <ul>
  *             <li>bold</li>
  *             <li>bright</li>
  *             <li>italic</li>
  *             <li>underline</li>
  *             <li>inverse</li>
  *             <li>crossedOut</li>
  *             <li>blink</li>
  *             <li>red</li>
  *             <li>green</li>
  *             <li>yellow</li>
  *             <li>blue</li>
  *             <li>magenta</li>
  *             <li>cyan</li>
  *             <li>white</li>
  *             <li>redBackground</li>
  *             <li>greenBackground</li>
  *             <li>yellowBackground</li>
  *             <li>blueBackground</li>
  *             <li>magentaBackground</li>
  *             <li>cyanBackground</li>
  *             <li>whiteBackground</li>
  *             <li>grey</li>
  *             <li>black</li>
  *
  *          </ul>
  * @memberOf comb.string
  * @static
  */
1function style(str, options) {
89    var ret = str;
89    if (options) {
89        if (ret instanceof Array) {
2            ret = ret.map(function (s) {
6                return style(s, options);
             });
87        } else if (options instanceof Array) {
8            options.forEach(function (option) {
24                ret = style(ret, option);
             });
79        } else if (options in styles) {
79            ret = '\x1B[' + styles[options] + 'm' + str + '\x1B[0m';
         }
     }
89    return ret;
 }
 
 /**
  * Returns a string duplicated n times;
  *
  * @example
  *
  * comb.string.multiply("HELLO", 5) => "HELLOHELLOHELLOHELLOHELLO"
  *
  * @memberOf comb.string
  * @static
  */
1function multiply(str, times) {
156    var ret = [];
156    if (times) {
150        for (var i = 0; i < times; i++) {
568            ret.push(str);
         }
     }
156    return ret.join("");
 }
 
 /**
  * Converts a string to an array
  *
  * @example
  *
  * comb.string.toArray("a|b|c|d", "|") => ["a","b","c","d"]
  * comb.string.toArray("a", "|") => ["a"]
  * comb.string.toArray("", "|") => []
  *
  * @param {String} str the string to parse
  * @param {String} delimeter the delimeter to use
  * @memberOf comb.string
  * @static
  */
1function toArray(testStr, delim) {
6    var ret = [];
6    if (testStr) {
4        if (testStr.indexOf(delim) > 0) {
2            ret = testStr.replace(/\s+/g, "").split(delim);
         } else {
2            ret = [testStr];
         }
     }
6    return ret;
 }
 
 
 /**@namespace String utilities*/
1comb.string = {
     pad: pad,
     truncate: truncate,
     format: format,
     toArray: toArray,
     multiply: multiply,
     style: style,
     escapeHtml: escapeHtml
 };