{"version":3,"sources":["jsdelivr-header.js","/npm/metaphorjs-promise@1.2.0/dist/metaphorjs.promise.npm.js"],"names":[],"mappings":"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","file":"/npm/metaphorjs-promise@1.2.0/dist/metaphorjs.promise.npm.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/metaphorjs-promise@1.2.0/dist/metaphorjs.promise.npm.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/* BUNDLE START 004 */\n\"use strict\";\n\nvar MetaphorJsPrebuilt = {\"templates\":{},\"templateOptions\":{},\"expressionOpts\":{}}\nMetaphorJsPrebuilt['funcs'] = {\n\n};\n\n/**\n * Check if given value is a function\n * @function isFunction\n * @param {*} value \n * @returns {boolean}\n */\nfunction isFunction(value) {\n    return typeof value == 'function';\n};\n\n\n\n/**\n * Checks if given value is a thenable (a Promise)\n * @function isThenable\n * @param {*} any\n * @returns {boolean|function}\n */\nfunction isThenable(any) {\n\n    // any.then must only be accessed once\n    // this is a promise/a+ requirement\n\n    if (!any) { //  || !any.then\n        return false;\n    }\n    \n    var t;\n\n    //if (!any || (!isObject(any) && !isFunction(any))) {\n    if (((t = typeof any) != \"object\" && t != \"function\")) {\n        return false;\n    }\n\n    var then = any.then;\n\n    return isFunction(then) ? then : false;\n};\n\n/**\n * Bind function to context (Function.bind wrapper)\n * @function bind\n * @param {function} fn\n * @param {*} context\n * @returns {function}\n */\nfunction bind(fn, context){\n    return fn.bind(context);\n};\n\nvar strUndef = \"undefined\";\n\n\n\n/**\n * Log thrown error to console (in debug mode) and \n * call all error listeners\n * @function error\n * @param {Error} e \n */\nvar error = (function(){\n\n    var listeners = [];\n\n    var error = function error(e) {\n\n        var i, l;\n\n        for (i = 0, l = listeners.length; i < l; i++) {\n            listeners[i][0].call(listeners[i][1], e)\n        }\n\n        /*DEBUG-START*/\n        if (typeof console != strUndef && console.error) {\n            console.error(e);\n        }\n        /*DEBUG-END*/\n    };\n\n    /**\n     * Subscribe to all errors\n     * @method on\n     * @param {function} fn \n     * @param {object} context \n     */\n    error.on = function(fn, context) {\n        error.un(fn, context);\n        listeners.push([fn, context]);\n    };\n\n    /**\n     * Unsubscribe from all errors\n     * @method un\n     * @param {function} fn \n     * @param {object} context \n     */\n    error.un = function(fn, context) {\n        var i, l;\n        for (i = 0, l = listeners.length; i < l; i++) {\n            if (listeners[i][0] === fn && listeners[i][1] === context) {\n                listeners.splice(i, 1);\n                break;\n            }\n        }\n    };\n\n    return error;\n}());\n\n\n\n\nvar MetaphorJs = {\n    plugin: {},\n    mixin: {},\n    lib: {},\n    dom: {},\n    regexp: {},\n    browser: {},\n    app: {},\n    prebuilt: typeof MetaphorJsPrebuilt !== \"undefined\" ? MetaphorJsPrebuilt : null\n};\n\n\nvar undf = undefined;\n\n\n\n/**\n * Transform anything into array\n * @function toArray\n * @param {*} list\n * @returns {array}\n */\nfunction toArray(list) {\n    if (list && !list.length != undf && list !== \"\"+list) {\n        for(var a = [], i =- 1, l = list.length>>>0; ++i !== l; a[i] = list[i]){}\n        return a;\n    }\n    else if (list) {\n        return [list];\n    }\n    else {\n        return [];\n    }\n};\n\n/**\n * Convert anything to string\n * @function toString\n * @param {*} value\n * @returns {string}\n */\nvar toString = Object.prototype.toString;\n\n\n\n\nvar _varType = function(){\n\n    var types = {\n        '[object String]': 0,\n        '[object Number]': 1,\n        '[object Boolean]': 2,\n        '[object Object]': 3,\n        '[object Function]': 4,\n        '[object Array]': 5,\n        '[object RegExp]': 9,\n        '[object Date]': 10\n    };\n\n\n    /*\n     * 'string': 0,\n     * 'number': 1,\n     * 'boolean': 2,\n     * 'object': 3,\n     * 'function': 4,\n     * 'array': 5,\n     * 'null': 6,\n     * 'undefined': 7,\n     * 'NaN': 8,\n     * 'regexp': 9,\n     * 'date': 10,\n     * unknown: -1\n     * @param {*} value\n     * @returns {number}\n     */\n\n\n\n    return function _varType(val) {\n\n        if (!val) {\n            if (val === null) {\n                return 6;\n            }\n            if (val === undf) {\n                return 7;\n            }\n        }\n\n        var num = types[toString.call(val)];\n\n        if (num === undf) {\n            return -1;\n        }\n\n        if (num === 1 && isNaN(val)) {\n            return 8;\n        }\n\n        return num;\n    };\n\n}();\n\n\n\n/**\n * Check if given value is plain object\n * @function isPlainObject\n * @param {*} value \n * @returns {boolean}\n */\nfunction isPlainObject(value) {\n    // IE < 9 returns [object Object] from toString(htmlElement)\n    return typeof value == \"object\" &&\n           _varType(value) === 3 &&\n            !value.nodeType &&\n            value.constructor === Object;\n};\n\n/**\n * Check if given value is a boolean value\n * @function isBool\n * @param {*} value \n * @returns {boolean}\n */\nfunction isBool(value) {\n    return value === true || value === false;\n};\n\n\n/**\n * Copy properties from one object to another\n * @function extend\n * @param {Object} dst\n * @param {Object} src\n * @param {Object} src2 ... srcN\n * @param {boolean} override {\n *  Override already existing keys \n *  @default false\n * }\n * @param {boolean} deep {\n *  Do not copy objects by link, deep copy by value\n *  @default false\n * }\n * @returns {object}\n */\nfunction extend() {\n\n    var override    = false,\n        deep        = false,\n        args        = toArray(arguments),\n        dst         = args.shift(),\n        src,\n        k,\n        value;\n\n    if (isBool(args[args.length - 1])) {\n        override    = args.pop();\n    }\n    if (isBool(args[args.length - 1])) {\n        deep        = override;\n        override    = args.pop();\n    }\n\n    while (args.length) {\n        \n        // src can be empty\n        src = args.shift();\n        \n        if (!src) {\n            continue;\n        }\n\n        for (k in src) {\n\n            if (src.hasOwnProperty(k) && (value = src[k]) !== undf) {\n\n                if (deep) {\n                    if (dst[k] && isPlainObject(dst[k]) && isPlainObject(value)) {\n                        extend(dst[k], value, override, deep);\n                    }\n                    else {\n                        if (override === true || dst[k] == undf) { // == checks for null and undefined\n                            if (isPlainObject(value)) {\n                                dst[k] = {};\n                                extend(dst[k], value, override, true);\n                            }\n                            else {\n                                dst[k] = value;\n                            }\n                        }\n                    }\n                }\n                else {\n                    if (override === true || dst[k] == undf) {\n                        dst[k] = value;\n                    }\n                }\n            }\n        }\n    }\n\n    return dst;\n};\n\n\n\n\n\nMetaphorJs.lib.Promise = function(){\n\n    var PENDING     = 0,\n        FULFILLED   = 1,\n        REJECTED    = 2,\n        CANCELLED   = 3,\n\n        queue       = [],\n        qRunning    = false,\n\n        nextTick    = typeof process !== strUndef ?\n                        process.nextTick :\n                        function(fn) {\n                            setTimeout(fn, 0);\n                        },\n\n        // synchronous queue of asynchronous functions:\n        // callbacks must be called in \"platform stack\"\n        // which means setTimeout/nextTick;\n        // also, they must be called in a strict order.\n        nextInQueue = function() {\n            qRunning    = true;\n            var next    = queue.shift();\n            nextTick(function(){\n                next[0].apply(next[1], next[2]);\n                if (queue.length) {\n                    nextInQueue();\n                }\n                else {\n                    qRunning = false;\n                }\n            }, 0);\n        },\n\n        /**\n         * add to execution queue\n         * @function\n         * @param {Function} fn\n         * @param {Object} scope\n         * @param {[]} args\n         * @ignore\n         */\n        next        = function(fn, scope, args) {\n            args = args || [];\n            queue.push([fn, scope, args]);\n            if (!qRunning) {\n                nextInQueue();\n            }\n        },\n\n        /**\n         * returns function which receives value from previous promise\n         * and tries to resolve next promise with new value returned from given function(prev value)\n         * or reject on error.\n         * promise1.then(success, failure) -> promise2\n         * wrapper(success, promise2) -> fn\n         * fn(promise1 resolve value) -> new value\n         * promise2.resolve(new value)\n         *\n         * @function\n         * @param {Function} fn\n         * @param {Promise} promise\n         * @returns {Function}\n         * @ignore\n         */\n        resolveWrapper     = function(fn, promise) {\n            return function(value) {\n                try {\n                    promise.resolve(fn(value));\n                }\n                catch (thrownError) {\n                    promise.reject(thrownError);\n                }\n            };\n        };\n\n\n    /**\n     * @class MetaphorJs.lib.Promise\n     */\n\n    /**\n     * @constructor \n     * @method Promise\n     * @param {Function} fn {\n     *  @description Constructor accepts two parameters: resolve and reject functions.\n     *  @param {function} resolve {\n     *      @param {*} value\n     *  }\n     *  @param {function} reject {\n     *      @param {*} reason\n     *  }\n     * }\n     * @param {Object} context\n     * @returns {Promise}\n     */\n\n    /**\n     * @constructor \n     * @method Promise \n     * @param {Thenable} thenable\n     * @returns {Promise}\n     */\n\n    /**\n     * @constructor \n     * @method Promise \n     * @param {*} value Value to resolve promise with\n     * @returns {Promise}\n     */\n\n    /**\n     * @constructor \n     * @method Promise \n     * @returns {Promise}\n     */\n    var Promise = function(fn, context) {\n\n        if (fn instanceof Promise) {\n            return fn;\n        }\n\n        if (!(this instanceof Promise)) {\n            return new Promise(fn, context);\n        }\n\n        var self = this,\n            then;\n\n        self._fulfills   = [];\n        self._rejects    = [];\n        self._dones      = [];\n        self._fails      = [];\n\n        if (arguments.length > 0) {\n\n            if (then = isThenable(fn)) {\n                if (fn instanceof Promise) {\n                    fn.then(\n                        bind(self.resolve, self),\n                        bind(self.reject, self));\n                }\n                else {\n                    (new Promise(then, fn)).then(\n                        bind(self.resolve, self),\n                        bind(self.reject, self));\n                }\n            }\n            else if (isFunction(fn)) {\n                try {\n                    fn.call(context,\n                            bind(self.resolve, self),\n                            bind(self.reject, self));\n                }\n                catch (thrownError) {\n                    self.reject(thrownError);\n                }\n            }\n            else {\n                self.resolve(fn);\n            }\n        }\n    };\n\n    extend(Promise.prototype, {\n\n        _state: PENDING,\n\n        _fulfills: null,\n        _rejects: null,\n        _dones: null,\n        _fails: null,\n\n        _wait: 0,\n\n        _value: null,\n        _reason: null,\n\n        _triggered: false,\n\n        /**\n         * Is promise still pending (as opposed to resolved or rejected)\n         * @method\n         * @returns {boolean}\n         */\n        isPending: function() {\n            return this._state === PENDING;\n        },\n\n        /**\n         * Is the promise fulfilled. Same as isResolved()\n         * @method\n         * @returns {boolean}\n         */\n        isFulfilled: function() {\n            return this._state === FULFILLED;\n        },\n\n        /**\n         * Is the promise resolved. Same as isFulfilled()\n         * @method\n         * @returns {boolean}\n         */\n        isResolved: function() {\n            return this._state === FULFILLED;\n        },\n\n        /**\n         * Is the promise rejected\n         * @method\n         * @returns {boolean}\n         */\n        isRejected: function() {\n            return this._state === REJECTED;\n        },\n\n        /**\n         * Is the promise was destroyed before resolving or rejecting\n         * @method\n         * @returns {boolean}\n         */\n        isCancelled: function() {\n            return this._state === CANCELLED;\n        },\n\n        /**\n         * Did someone subscribed to this promise\n         * @method\n         * @returns {boolean}\n         */\n        hasListeners: function() {\n            var self = this,\n                ls  = [self._fulfills, self._rejects, self._dones, self._fails],\n                i, l;\n\n            for (i = 0, l = ls.length; i < l; i++) {\n                if (ls[i] && ls[i].length) {\n                    return true;\n                }\n            }\n\n            return false;\n        },\n\n        _cleanup: function() {\n            var self    = this;\n\n            self._fulfills = null;\n            self._rejects = null;\n            self._dones = null;\n            self._fails = null;\n        },\n\n        _processValue: function(value, cb, allowThenanle) {\n\n            var self    = this,\n                then;\n\n            if (self._state !== PENDING) {\n                return;\n            }\n\n            if (value === self) {\n                self._doReject(new TypeError(\"cannot resolve promise with itself\"));\n                return;\n            }\n\n            if (allowThenanle) {\n                try {\n                    if (then = isThenable(value)) {\n                        if (value instanceof Promise) {\n                            value.then(\n                                bind(self._processResolveValue, self),\n                                bind(self._processRejectReason, self)\n                            );\n                        }\n                        else {\n                            (new Promise(then, value)).then(\n                                bind(self._processResolveValue, self),\n                                bind(self._processRejectReason, self)\n                            );\n                        }\n                        return;\n                    }\n                }\n                catch (thrownError) {\n                    if (self._state === PENDING) {\n                        self._doReject(thrownError);\n                    }\n                    return;\n                }\n            }\n\n            cb.call(self, value);\n        },\n\n\n        _callResolveHandlers: function() {\n\n            var self    = this;\n\n            self._done();\n\n            var cbs  = self._fulfills,\n                cb;\n\n            while (cb = cbs.shift()) {\n                next(cb[0], cb[1], [self._value]);\n            }\n\n            self._cleanup();\n        },\n\n\n        _doResolve: function(value) {\n            var self    = this;\n\n            self._value = value;\n            self._state = FULFILLED;\n\n            if (self._wait === 0) {\n                self._callResolveHandlers();\n            }\n        },\n\n        _processResolveValue: function(value) {\n            this._processValue(value, this._doResolve, true);\n        },\n\n        /**\n         * Resolve the promise\n         * @method\n         * @param {*} value\n         */\n        resolve: function(value) {\n\n            var self    = this;\n\n            if (self._triggered) {\n                return self;\n            }\n\n            self._triggered = true;\n            self._processResolveValue(value);\n\n            return self;\n        },\n\n\n        _callRejectHandlers: function() {\n\n            var self    = this;\n\n            self._fail();\n\n            var cbs  = self._rejects,\n                cb;\n\n            while (cb = cbs.shift()) {\n                next(cb[0], cb[1], [self._reason]);\n            }\n\n            self._cleanup();\n        },\n\n        _doReject: function(reason) {\n\n            var self        = this;\n\n            self._state     = REJECTED;\n            self._reason    = reason;\n\n            if (self._wait === 0) {\n                self._callRejectHandlers();\n            }\n        },\n\n\n        _processRejectReason: function(reason) {\n            this._processValue(reason, this._doReject, false);\n        },\n\n        /**\n         * Reject the promise\n         * @method\n         * @param {*} reason\n         */\n        reject: function(reason) {\n\n            var self    = this;\n\n            if (self._triggered) {\n                return self;\n            }\n\n            self._triggered = true;\n\n            self._processRejectReason(reason);\n\n            return self;\n        },\n\n        /**\n         * @method\n         * @async\n         * @param {Function} resolve -- called when this promise is resolved; \n         *  returns new resolve value or promise\n         * @param {Function} reject -- called when this promise is rejected; \n         *  returns new reject reason\n         * @param {object} context -- resolve's and reject's functions \"this\" object\n         * @returns {Promise} new promise\n         */\n        then: function(resolve, reject, context) {\n\n            var self            = this,\n                promise         = new Promise,\n                state           = self._state;\n\n            if (context) {\n                if (resolve) {\n                    resolve = bind(resolve, context);\n                }\n                if (reject) {\n                    reject = bind(reject, context);\n                }\n            }\n\n            if (state === PENDING || self._wait !== 0) {\n\n                if (resolve && isFunction(resolve)) {\n                    self._fulfills.push([resolveWrapper(resolve, promise), null]);\n                }\n                else {\n                    self._fulfills.push([promise.resolve, promise])\n                }\n\n                if (reject && isFunction(reject)) {\n                    self._rejects.push([resolveWrapper(reject, promise), null]);\n                }\n                else {\n                    self._rejects.push([promise.reject, promise]);\n                }\n            }\n            else if (state === FULFILLED) {\n\n                if (resolve && isFunction(resolve)) {\n                    next(resolveWrapper(resolve, promise), null, [self._value]);\n                }\n                else {\n                    promise.resolve(self._value);\n                }\n            }\n            else if (state === REJECTED) {\n                if (reject && isFunction(reject)) {\n                    next(resolveWrapper(reject, promise), null, [self._reason]);\n                }\n                else {\n                    promise.reject(self._reason);\n                }\n            }\n\n            return promise;\n        },\n\n        /**\n         * Add reject listener.\n         * @method\n         * @async\n         * @param {Function} reject -- same as then(null, reject)\n         * @returns {Promise} new promise\n         */\n        \"catch\": function(reject) {\n            return this.then(null, reject);\n        },\n\n        _done: function() {\n\n            var self    = this,\n                cbs     = self._dones,\n                cb;\n\n            while (cb = cbs.shift()) {\n                try {\n                    cb[0].call(cb[1] || null, self._value);\n                }\n                catch (thrown) {\n                    error(thrown);\n                }\n            }\n        },\n\n        /**\n         * Add resolve listener\n         * @method\n         * @sync\n         * @param {Function} fn -- function to call when promise is resolved\n         * @param {Object} context -- function's \"this\" object\n         * @returns {Promise} same promise\n         */\n        done: function(fn, context) {\n            var self    = this,\n                state   = self._state;\n\n            if (state === FULFILLED && self._wait === 0) {\n                try {\n                    fn.call(context || null, self._value);\n                }\n                catch (thrown) {\n                    error(thrown);\n                }\n            }\n            else if (state === PENDING) {\n                self._dones.push([fn, context]);\n            }\n\n            return self;\n        },\n\n        _fail: function() {\n\n            var self    = this,\n                cbs     = self._fails,\n                cb;\n\n            while (cb = cbs.shift()) {\n                try {\n                    cb[0].call(cb[1] || null, self._reason);\n                }\n                catch (thrown) {\n                    error(thrown);\n                }\n            }\n        },\n\n        /**\n         * Add reject listener\n         * @method\n         * @sync\n         * @param {Function} fn -- function to call when promise is rejected.\n         * @param {Object} context -- function's \"this\" object\n         * @returns {Promise} same promise\n         */\n        fail: function(fn, context) {\n\n            var self    = this,\n                state   = self._state;\n\n            if (state === REJECTED && self._wait === 0) {\n                try {\n                    fn.call(context || null, self._reason);\n                }\n                catch (thrown) {\n                    error(thrown);\n                }\n            }\n            else if (state === PENDING) {\n                self._fails.push([fn, context]);\n            }\n\n            return self;\n        },\n\n        /**\n         * Add both resolve and reject listener\n         * @method\n         * @sync\n         * @param {Function} fn -- function to call when promise resolved or rejected\n         * @param {Object} context -- function's \"this\" object\n         * @return {Promise} same promise\n         */\n        always: function(fn, context) {\n            this.done(fn, context);\n            this.fail(fn, context);\n            return this;\n        },\n\n        /**\n         * Get a thenable object\n         * @method\n         * @returns {object} then: function, done: function, fail: function, always: function\n         */\n        promise: function() {\n            var self = this;\n            return {\n                then: bind(self.then, self),\n                done: bind(self.done, self),\n                fail: bind(self.fail, self),\n                always: bind(self.always, self),\n                \"catch\": bind(self['catch'], self)\n            };\n        },\n\n        /**\n         * Resolve this promise after <code>value</code> promise is resolved.\n         * @method\n         * @param {*|Promise} value\n         * @returns {Promise} self\n         */\n        after: function(value) {\n\n            var self = this;\n\n            if (isThenable(value)) {\n\n                self._wait++;\n\n                var done = function() {\n                    self._wait--;\n                    if (self._wait === 0 && self._state !== PENDING) {\n                        self._state === FULFILLED ?\n                            self._callResolveHandlers() :\n                            self._callRejectHandlers();\n                    }\n                };\n\n                if (isFunction(value.done)) {\n                    value.done(done);\n                }\n                else {\n                    value.then(done);\n                }\n            }\n\n            return self;\n        },\n\n        $destroy: function() {\n            this._cleanup();\n            this._state === PENDING && (this._state = CANCELLED);\n        }\n    }, true, false);\n\n\n    /**\n     * Call function <code>fn</code> with given args in given context\n     * and use its return value as resolve value for a new promise.\n     * Then return this promise.\n     * @static\n     * @method\n     * @param {function} fn\n     * @param {object} context\n     * @param {[]} args\n     * @returns {Promise}\n     */\n    Promise.fcall = function(fn, context, args) {\n        return Promise.resolve(fn.apply(context, args || []));\n    };\n\n    /**\n     * Create new promise and resolve it with given value\n     * @static\n     * @method\n     * @param {*} value\n     * @returns {Promise}\n     */\n    Promise.resolve = function(value) {\n        var p = new Promise;\n        p.resolve(value);\n        return p;\n    };\n\n\n    /**\n     * Create new promise and reject it with given reason\n     * @static\n     * @method\n     * @param {*} reason\n     * @returns {Promise}\n     */\n    Promise.reject = function(reason) {\n        var p = new Promise;\n        p.reject(reason);\n        return p;\n    };\n\n\n    /**\n     * Take a list of promises or values and once all promises are resolved,\n     * create a new promise and resolve it with a list of final values.<br>\n     * If one of the promises is rejected, it will reject the returned promise.\n     * @static\n     * @method\n     * @param {[]} promises -- array of promises or resolve values\n     * @returns {Promise}\n     */\n    Promise.all = function(promises) {\n\n        if (!promises.length) {\n            return Promise.resolve(null);\n        }\n\n        var p       = new Promise,\n            len     = promises.length,\n            values  = new Array(len),\n            cnt     = len,\n            i,\n            item,\n            done    = function(value, inx) {\n                values[inx] = value;\n                cnt--;\n\n                if (cnt === 0) {\n                    p.resolve(values);\n                }\n            };\n\n        for (i = 0; i < len; i++) {\n\n            (function(inx){\n                item = promises[i];\n\n                if (item instanceof Promise) {\n                    item.done(function(value){\n                        done(value, inx);\n                    })\n                        .fail(p.reject, p);\n                }\n                else if (isThenable(item) || isFunction(item)) {\n                    (new Promise(item))\n                        .done(function(value){\n                            done(value, inx);\n                        })\n                        .fail(p.reject, p);\n                }\n                else {\n                    done(item, inx);\n                }\n            })(i);\n        }\n\n        return p;\n    };\n\n    /**\n     * Same as <code>all()</code> but it treats arguments as list of values.\n     * @static\n     * @method\n     * @param {Promise|*} promise1\n     * @param {Promise|*} promise2\n     * @param {Promise|*} promiseN\n     * @returns {Promise}\n     */\n    Promise.when = function() {\n        return Promise.all(arguments);\n    };\n\n    /**\n     * Same as <code>all()</code> but the resulting promise\n     * will not be rejected if ones of the passed promises is rejected.\n     * @static\n     * @method\n     * @param {[]} promises -- array of promises or resolve values\n     * @returns {Promise}\n     */\n    Promise.allResolved = function(promises) {\n\n        if (!promises.length) {\n            return Promise.resolve(null);\n        }\n\n        var p       = new Promise,\n            len     = promises.length,\n            values  = [],\n            cnt     = len,\n            i,\n            item,\n            settle  = function(value) {\n                values.push(value);\n                proceed();\n            },\n            proceed = function() {\n                cnt--;\n                if (cnt === 0) {\n                    p.resolve(values);\n                }\n            };\n\n        for (i = 0; i < len; i++) {\n            item = promises[i];\n\n            if (item instanceof Promise) {\n                item.done(settle).fail(proceed);\n            }\n            else if (isThenable(item) || isFunction(item)) {\n                (new Promise(item)).done(settle).fail(proceed);\n            }\n            else {\n                settle(item);\n            }\n        }\n\n        return p;\n    };\n\n    /**\n     * Given the list of promises or values it will return a new promise\n     * and resolve it with the first resolved value.\n     * @static\n     * @method\n     * @param {[]} promises -- array of promises or resolve values\n     * @returns {Promise}\n     */\n    Promise.race = function(promises) {\n\n        if (!promises.length) {\n            return Promise.resolve(null);\n        }\n\n        var p   = new Promise,\n            len = promises.length,\n            i,\n            item;\n\n        for (i = 0; i < len; i++) {\n            item = promises[i];\n\n            if (item instanceof Promise) {\n                item.done(p.resolve, p).fail(p.reject, p);\n            }\n            else if (isThenable(item) || isFunction(item)) {\n                (new Promise(item)).done(p.resolve, p).fail(p.reject, p);\n            }\n            else {\n                p.resolve(item);\n            }\n\n            if (!p.isPending()) {\n                break;\n            }\n        }\n\n        return p;\n    };\n\n    /**\n     * Takes a list of async functions and executes \n     * them in given order consequentially\n     * @static\n     * @method\n     * @param {[]} functions -- array of promises or resolve values or functions\n     * @returns {Promise}\n     */\n    Promise.waterfall = function(functions) {\n\n        if (!functions.length) {\n            return Promise.resolve(null);\n        }\n\n        var first   = functions.shift(),\n            promise = isFunction(first) ? Promise.fcall(first) : Promise.resolve(fn),\n            fn;\n\n        while (fn = functions.shift()) {\n            if (isThenable(fn)) {\n                promise = promise.then(function(fn){\n                    return function(){\n                        return fn;\n                    };\n                }(fn));\n            }\n            else if (isFunction(fn)) {\n                promise = promise.then(fn);\n            }\n            else {\n                promise.resolve(fn);\n            }\n        }\n\n        return promise;\n    };\n\n    /**\n     * Works like Array.forEach but it expects passed function to \n     * return a Promise.\n     * @static\n     * @method \n     * @param {array} items \n     * @param {function} fn {\n     *  @param {*} value\n     *  @param {int} index\n     *  @returns {Promise|*}\n     * }\n     * @param {object} context \n     * @param {boolean} allResolved if true, the resulting promise\n     * will fail if one of the returned promises fails.\n     */\n    Promise.forEach = function(items, fn, context, allResolved) {\n\n        var left = items.slice(),\n            p = new Promise,\n            values = [],\n            i = 0;\n\n        var next = function() {\n\n            if (!left.length) {\n                p.resolve(values);\n                return;\n            }\n\n            var item = left.shift(),\n                index = i;\n\n            i++;\n\n            Promise.fcall(fn, context, [item, index])\n                .done(function(result){\n                    values.push(result);\n                    next();\n                })\n                .fail(function(reason){\n                    if (allResolved) {\n                        p.reject(reason);\n                    }\n                    else {\n                        values.push(null);\n                        next();\n                    }\n                });\n        };\n\n        next();\n\n        return p;\n    };\n\n    /**\n     * Returns a promise with additional <code>countdown</code>\n     * method. Call this method <code>cnt</code> times and\n     * the promise will get resolved.\n     * @static\n     * @method\n     * @param {int} cnt \n     * @returns {Promise}\n     */\n    Promise.counter = function(cnt) {\n\n        var promise     = new Promise;\n\n        promise.countdown = function() {\n            cnt--;\n            if (cnt === 0) {\n                promise.resolve();\n            }\n        };\n\n        return promise;\n    };\n\n    return Promise;\n}();\n\n\nmodule.exports = MetaphorJs.lib.Promise;\n/* BUNDLE END 004 */"]}