twitst4tz

bluebird.core.js (123379B)

---

 /* @preserve
  * The MIT License (MIT)
  * 
  * Copyright (c) 2013-2018 Petka Antonov
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  * 
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  * 
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  * 
  */
 /**
  * bluebird build version 3.7.2
  * Features enabled: core
  * Features disabled: race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each
 */
 !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof _dereq_=="function"&&_dereq_;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
 "use strict";
 var firstLineError;
 try {throw new Error(); } catch (e) {firstLineError = e;}
 var schedule = _dereq_("./schedule");
 var Queue = _dereq_("./queue");
 
 function Async() {
     this._customScheduler = false;
     this._isTickUsed = false;
     this._lateQueue = new Queue(16);
     this._normalQueue = new Queue(16);
     this._haveDrainedQueues = false;
     var self = this;
     this.drainQueues = function () {
         self._drainQueues();
     };
     this._schedule = schedule;
 }
 
 Async.prototype.setScheduler = function(fn) {
     var prev = this._schedule;
     this._schedule = fn;
     this._customScheduler = true;
     return prev;
 };
 
 Async.prototype.hasCustomScheduler = function() {
     return this._customScheduler;
 };
 
 Async.prototype.haveItemsQueued = function () {
     return this._isTickUsed || this._haveDrainedQueues;
 };
 
 
 Async.prototype.fatalError = function(e, isNode) {
     if (isNode) {
         process.stderr.write("Fatal " + (e instanceof Error ? e.stack : e) +
             "\n");
         process.exit(2);
     } else {
         this.throwLater(e);
     }
 };
 
 Async.prototype.throwLater = function(fn, arg) {
     if (arguments.length === 1) {
         arg = fn;
         fn = function () { throw arg; };
     }
     if (typeof setTimeout !== "undefined") {
         setTimeout(function() {
             fn(arg);
         }, 0);
     } else try {
         this._schedule(function() {
             fn(arg);
         });
     } catch (e) {
         throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
     }
 };
 
 function AsyncInvokeLater(fn, receiver, arg) {
     this._lateQueue.push(fn, receiver, arg);
     this._queueTick();
 }
 
 function AsyncInvoke(fn, receiver, arg) {
     this._normalQueue.push(fn, receiver, arg);
     this._queueTick();
 }
 
 function AsyncSettlePromises(promise) {
     this._normalQueue._pushOne(promise);
     this._queueTick();
 }
 
 Async.prototype.invokeLater = AsyncInvokeLater;
 Async.prototype.invoke = AsyncInvoke;
 Async.prototype.settlePromises = AsyncSettlePromises;
 
 
 function _drainQueue(queue) {
     while (queue.length() > 0) {
         _drainQueueStep(queue);
     }
 }
 
 function _drainQueueStep(queue) {
     var fn = queue.shift();
     if (typeof fn !== "function") {
         fn._settlePromises();
     } else {
         var receiver = queue.shift();
         var arg = queue.shift();
         fn.call(receiver, arg);
     }
 }
 
 Async.prototype._drainQueues = function () {
     _drainQueue(this._normalQueue);
     this._reset();
     this._haveDrainedQueues = true;
     _drainQueue(this._lateQueue);
 };
 
 Async.prototype._queueTick = function () {
     if (!this._isTickUsed) {
         this._isTickUsed = true;
         this._schedule(this.drainQueues);
     }
 };
 
 Async.prototype._reset = function () {
     this._isTickUsed = false;
 };
 
 module.exports = Async;
 module.exports.firstLineError = firstLineError;
 
 },{"./queue":17,"./schedule":18}],2:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function(Promise, INTERNAL, tryConvertToPromise, debug) {
 var calledBind = false;
 var rejectThis = function(_, e) {
     this._reject(e);
 };
 
 var targetRejected = function(e, context) {
     context.promiseRejectionQueued = true;
     context.bindingPromise._then(rejectThis, rejectThis, null, this, e);
 };
 
 var bindingResolved = function(thisArg, context) {
     if (((this._bitField & 50397184) === 0)) {
         this._resolveCallback(context.target);
     }
 };
 
 var bindingRejected = function(e, context) {
     if (!context.promiseRejectionQueued) this._reject(e);
 };
 
 Promise.prototype.bind = function (thisArg) {
     if (!calledBind) {
         calledBind = true;
         Promise.prototype._propagateFrom = debug.propagateFromFunction();
         Promise.prototype._boundValue = debug.boundValueFunction();
     }
     var maybePromise = tryConvertToPromise(thisArg);
     var ret = new Promise(INTERNAL);
     ret._propagateFrom(this, 1);
     var target = this._target();
     ret._setBoundTo(maybePromise);
     if (maybePromise instanceof Promise) {
         var context = {
             promiseRejectionQueued: false,
             promise: ret,
             target: target,
             bindingPromise: maybePromise
         };
         target._then(INTERNAL, targetRejected, undefined, ret, context);
         maybePromise._then(
             bindingResolved, bindingRejected, undefined, ret, context);
         ret._setOnCancel(maybePromise);
     } else {
         ret._resolveCallback(target);
     }
     return ret;
 };
 
 Promise.prototype._setBoundTo = function (obj) {
     if (obj !== undefined) {
         this._bitField = this._bitField | 2097152;
         this._boundTo = obj;
     } else {
         this._bitField = this._bitField & (~2097152);
     }
 };
 
 Promise.prototype._isBound = function () {
     return (this._bitField & 2097152) === 2097152;
 };
 
 Promise.bind = function (thisArg, value) {
     return Promise.resolve(value).bind(thisArg);
 };
 };
 
 },{}],3:[function(_dereq_,module,exports){
 "use strict";
 var old;
 if (typeof Promise !== "undefined") old = Promise;
 function noConflict() {
     try { if (Promise === bluebird) Promise = old; }
     catch (e) {}
     return bluebird;
 }
 var bluebird = _dereq_("./promise")();
 bluebird.noConflict = noConflict;
 module.exports = bluebird;
 
 },{"./promise":15}],4:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function(Promise, PromiseArray, apiRejection, debug) {
 var util = _dereq_("./util");
 var tryCatch = util.tryCatch;
 var errorObj = util.errorObj;
 var async = Promise._async;
 
 Promise.prototype["break"] = Promise.prototype.cancel = function() {
     if (!debug.cancellation()) return this._warn("cancellation is disabled");
 
     var promise = this;
     var child = promise;
     while (promise._isCancellable()) {
         if (!promise._cancelBy(child)) {
             if (child._isFollowing()) {
                 child._followee().cancel();
             } else {
                 child._cancelBranched();
             }
             break;
         }
 
         var parent = promise._cancellationParent;
         if (parent == null || !parent._isCancellable()) {
             if (promise._isFollowing()) {
                 promise._followee().cancel();
             } else {
                 promise._cancelBranched();
             }
             break;
         } else {
             if (promise._isFollowing()) promise._followee().cancel();
             promise._setWillBeCancelled();
             child = promise;
             promise = parent;
         }
     }
 };
 
 Promise.prototype._branchHasCancelled = function() {
     this._branchesRemainingToCancel--;
 };
 
 Promise.prototype._enoughBranchesHaveCancelled = function() {
     return this._branchesRemainingToCancel === undefined ||
            this._branchesRemainingToCancel <= 0;
 };
 
 Promise.prototype._cancelBy = function(canceller) {
     if (canceller === this) {
         this._branchesRemainingToCancel = 0;
         this._invokeOnCancel();
         return true;
     } else {
         this._branchHasCancelled();
         if (this._enoughBranchesHaveCancelled()) {
             this._invokeOnCancel();
             return true;
         }
     }
     return false;
 };
 
 Promise.prototype._cancelBranched = function() {
     if (this._enoughBranchesHaveCancelled()) {
         this._cancel();
     }
 };
 
 Promise.prototype._cancel = function() {
     if (!this._isCancellable()) return;
     this._setCancelled();
     async.invoke(this._cancelPromises, this, undefined);
 };
 
 Promise.prototype._cancelPromises = function() {
     if (this._length() > 0) this._settlePromises();
 };
 
 Promise.prototype._unsetOnCancel = function() {
     this._onCancelField = undefined;
 };
 
 Promise.prototype._isCancellable = function() {
     return this.isPending() && !this._isCancelled();
 };
 
 Promise.prototype.isCancellable = function() {
     return this.isPending() && !this.isCancelled();
 };
 
 Promise.prototype._doInvokeOnCancel = function(onCancelCallback, internalOnly) {
     if (util.isArray(onCancelCallback)) {
         for (var i = 0; i < onCancelCallback.length; ++i) {
             this._doInvokeOnCancel(onCancelCallback[i], internalOnly);
         }
     } else if (onCancelCallback !== undefined) {
         if (typeof onCancelCallback === "function") {
             if (!internalOnly) {
                 var e = tryCatch(onCancelCallback).call(this._boundValue());
                 if (e === errorObj) {
                     this._attachExtraTrace(e.e);
                     async.throwLater(e.e);
                 }
             }
         } else {
             onCancelCallback._resultCancelled(this);
         }
     }
 };
 
 Promise.prototype._invokeOnCancel = function() {
     var onCancelCallback = this._onCancel();
     this._unsetOnCancel();
     async.invoke(this._doInvokeOnCancel, this, onCancelCallback);
 };
 
 Promise.prototype._invokeInternalOnCancel = function() {
     if (this._isCancellable()) {
         this._doInvokeOnCancel(this._onCancel(), true);
         this._unsetOnCancel();
     }
 };
 
 Promise.prototype._resultCancelled = function() {
     this.cancel();
 };
 
 };
 
 },{"./util":21}],5:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function(NEXT_FILTER) {
 var util = _dereq_("./util");
 var getKeys = _dereq_("./es5").keys;
 var tryCatch = util.tryCatch;
 var errorObj = util.errorObj;
 
 function catchFilter(instances, cb, promise) {
     return function(e) {
         var boundTo = promise._boundValue();
         predicateLoop: for (var i = 0; i < instances.length; ++i) {
             var item = instances[i];
 
             if (item === Error ||
                 (item != null && item.prototype instanceof Error)) {
                 if (e instanceof item) {
                     return tryCatch(cb).call(boundTo, e);
                 }
             } else if (typeof item === "function") {
                 var matchesPredicate = tryCatch(item).call(boundTo, e);
                 if (matchesPredicate === errorObj) {
                     return matchesPredicate;
                 } else if (matchesPredicate) {
                     return tryCatch(cb).call(boundTo, e);
                 }
             } else if (util.isObject(e)) {
                 var keys = getKeys(item);
                 for (var j = 0; j < keys.length; ++j) {
                     var key = keys[j];
                     if (item[key] != e[key]) {
                         continue predicateLoop;
                     }
                 }
                 return tryCatch(cb).call(boundTo, e);
             }
         }
         return NEXT_FILTER;
     };
 }
 
 return catchFilter;
 };
 
 },{"./es5":10,"./util":21}],6:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function(Promise) {
 var longStackTraces = false;
 var contextStack = [];
 
 Promise.prototype._promiseCreated = function() {};
 Promise.prototype._pushContext = function() {};
 Promise.prototype._popContext = function() {return null;};
 Promise._peekContext = Promise.prototype._peekContext = function() {};
 
 function Context() {
     this._trace = new Context.CapturedTrace(peekContext());
 }
 Context.prototype._pushContext = function () {
     if (this._trace !== undefined) {
         this._trace._promiseCreated = null;
         contextStack.push(this._trace);
     }
 };
 
 Context.prototype._popContext = function () {
     if (this._trace !== undefined) {
         var trace = contextStack.pop();
         var ret = trace._promiseCreated;
         trace._promiseCreated = null;
         return ret;
     }
     return null;
 };
 
 function createContext() {
     if (longStackTraces) return new Context();
 }
 
 function peekContext() {
     var lastIndex = contextStack.length - 1;
     if (lastIndex >= 0) {
         return contextStack[lastIndex];
     }
     return undefined;
 }
 Context.CapturedTrace = null;
 Context.create = createContext;
 Context.deactivateLongStackTraces = function() {};
 Context.activateLongStackTraces = function() {
     var Promise_pushContext = Promise.prototype._pushContext;
     var Promise_popContext = Promise.prototype._popContext;
     var Promise_PeekContext = Promise._peekContext;
     var Promise_peekContext = Promise.prototype._peekContext;
     var Promise_promiseCreated = Promise.prototype._promiseCreated;
     Context.deactivateLongStackTraces = function() {
         Promise.prototype._pushContext = Promise_pushContext;
         Promise.prototype._popContext = Promise_popContext;
         Promise._peekContext = Promise_PeekContext;
         Promise.prototype._peekContext = Promise_peekContext;
         Promise.prototype._promiseCreated = Promise_promiseCreated;
         longStackTraces = false;
     };
     longStackTraces = true;
     Promise.prototype._pushContext = Context.prototype._pushContext;
     Promise.prototype._popContext = Context.prototype._popContext;
     Promise._peekContext = Promise.prototype._peekContext = peekContext;
     Promise.prototype._promiseCreated = function() {
         var ctx = this._peekContext();
         if (ctx && ctx._promiseCreated == null) ctx._promiseCreated = this;
     };
 };
 return Context;
 };
 
 },{}],7:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function(Promise, Context,
     enableAsyncHooks, disableAsyncHooks) {
 var async = Promise._async;
 var Warning = _dereq_("./errors").Warning;
 var util = _dereq_("./util");
 var es5 = _dereq_("./es5");
 var canAttachTrace = util.canAttachTrace;
 var unhandledRejectionHandled;
 var possiblyUnhandledRejection;
 var bluebirdFramePattern =
     /[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/;
 var nodeFramePattern = /\((?:timers\.js):\d+:\d+\)/;
 var parseLinePattern = /[\/<\(](.+?):(\d+):(\d+)\)?\s*$/;
 var stackFramePattern = null;
 var formatStack = null;
 var indentStackFrames = false;
 var printWarning;
 var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 &&
                         (true ||
                          util.env("BLUEBIRD_DEBUG") ||
                          util.env("NODE_ENV") === "development"));
 
 var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 &&
     (debugging || util.env("BLUEBIRD_WARNINGS")));
 
 var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 &&
     (debugging || util.env("BLUEBIRD_LONG_STACK_TRACES")));
 
 var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 &&
     (warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN"));
 
 var deferUnhandledRejectionCheck;
 (function() {
     var promises = [];
 
     function unhandledRejectionCheck() {
         for (var i = 0; i < promises.length; ++i) {
             promises[i]._notifyUnhandledRejection();
         }
         unhandledRejectionClear();
     }
 
     function unhandledRejectionClear() {
         promises.length = 0;
     }
 
     deferUnhandledRejectionCheck = function(promise) {
         promises.push(promise);
         setTimeout(unhandledRejectionCheck, 1);
     };
 
     es5.defineProperty(Promise, "_unhandledRejectionCheck", {
         value: unhandledRejectionCheck
     });
     es5.defineProperty(Promise, "_unhandledRejectionClear", {
         value: unhandledRejectionClear
     });
 })();
 
 Promise.prototype.suppressUnhandledRejections = function() {
     var target = this._target();
     target._bitField = ((target._bitField & (~1048576)) |
                       524288);
 };
 
 Promise.prototype._ensurePossibleRejectionHandled = function () {
     if ((this._bitField & 524288) !== 0) return;
     this._setRejectionIsUnhandled();
     deferUnhandledRejectionCheck(this);
 };
 
 Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
     fireRejectionEvent("rejectionHandled",
                                   unhandledRejectionHandled, undefined, this);
 };
 
 Promise.prototype._setReturnedNonUndefined = function() {
     this._bitField = this._bitField | 268435456;
 };
 
 Promise.prototype._returnedNonUndefined = function() {
     return (this._bitField & 268435456) !== 0;
 };
 
 Promise.prototype._notifyUnhandledRejection = function () {
     if (this._isRejectionUnhandled()) {
         var reason = this._settledValue();
         this._setUnhandledRejectionIsNotified();
         fireRejectionEvent("unhandledRejection",
                                       possiblyUnhandledRejection, reason, this);
     }
 };
 
 Promise.prototype._setUnhandledRejectionIsNotified = function () {
     this._bitField = this._bitField | 262144;
 };
 
 Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
     this._bitField = this._bitField & (~262144);
 };
 
 Promise.prototype._isUnhandledRejectionNotified = function () {
     return (this._bitField & 262144) > 0;
 };
 
 Promise.prototype._setRejectionIsUnhandled = function () {
     this._bitField = this._bitField | 1048576;
 };
 
 Promise.prototype._unsetRejectionIsUnhandled = function () {
     this._bitField = this._bitField & (~1048576);
     if (this._isUnhandledRejectionNotified()) {
         this._unsetUnhandledRejectionIsNotified();
         this._notifyUnhandledRejectionIsHandled();
     }
 };
 
 Promise.prototype._isRejectionUnhandled = function () {
     return (this._bitField & 1048576) > 0;
 };
 
 Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) {
     return warn(message, shouldUseOwnTrace, promise || this);
 };
 
 Promise.onPossiblyUnhandledRejection = function (fn) {
     var context = Promise._getContext();
     possiblyUnhandledRejection = util.contextBind(context, fn);
 };
 
 Promise.onUnhandledRejectionHandled = function (fn) {
     var context = Promise._getContext();
     unhandledRejectionHandled = util.contextBind(context, fn);
 };
 
 var disableLongStackTraces = function() {};
 Promise.longStackTraces = function () {
     if (async.haveItemsQueued() && !config.longStackTraces) {
         throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
     }
     if (!config.longStackTraces && longStackTracesIsSupported()) {
         var Promise_captureStackTrace = Promise.prototype._captureStackTrace;
         var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;
         var Promise_dereferenceTrace = Promise.prototype._dereferenceTrace;
         config.longStackTraces = true;
         disableLongStackTraces = function() {
             if (async.haveItemsQueued() && !config.longStackTraces) {
                 throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
             }
             Promise.prototype._captureStackTrace = Promise_captureStackTrace;
             Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;
             Promise.prototype._dereferenceTrace = Promise_dereferenceTrace;
             Context.deactivateLongStackTraces();
             config.longStackTraces = false;
         };
         Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
         Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
         Promise.prototype._dereferenceTrace = longStackTracesDereferenceTrace;
         Context.activateLongStackTraces();
     }
 };
 
 Promise.hasLongStackTraces = function () {
     return config.longStackTraces && longStackTracesIsSupported();
 };
 
 
 var legacyHandlers = {
     unhandledrejection: {
         before: function() {
             var ret = util.global.onunhandledrejection;
             util.global.onunhandledrejection = null;
             return ret;
         },
         after: function(fn) {
             util.global.onunhandledrejection = fn;
         }
     },
     rejectionhandled: {
         before: function() {
             var ret = util.global.onrejectionhandled;
             util.global.onrejectionhandled = null;
             return ret;
         },
         after: function(fn) {
             util.global.onrejectionhandled = fn;
         }
     }
 };
 
 var fireDomEvent = (function() {
     var dispatch = function(legacy, e) {
         if (legacy) {
             var fn;
             try {
                 fn = legacy.before();
                 return !util.global.dispatchEvent(e);
             } finally {
                 legacy.after(fn);
             }
         } else {
             return !util.global.dispatchEvent(e);
         }
     };
     try {
         if (typeof CustomEvent === "function") {
             var event = new CustomEvent("CustomEvent");
             util.global.dispatchEvent(event);
             return function(name, event) {
                 name = name.toLowerCase();
                 var eventData = {
                     detail: event,
                     cancelable: true
                 };
                 var domEvent = new CustomEvent(name, eventData);
                 es5.defineProperty(
                     domEvent, "promise", {value: event.promise});
                 es5.defineProperty(
                     domEvent, "reason", {value: event.reason});
 
                 return dispatch(legacyHandlers[name], domEvent);
             };
         } else if (typeof Event === "function") {
             var event = new Event("CustomEvent");
             util.global.dispatchEvent(event);
             return function(name, event) {
                 name = name.toLowerCase();
                 var domEvent = new Event(name, {
                     cancelable: true
                 });
                 domEvent.detail = event;
                 es5.defineProperty(domEvent, "promise", {value: event.promise});
                 es5.defineProperty(domEvent, "reason", {value: event.reason});
                 return dispatch(legacyHandlers[name], domEvent);
             };
         } else {
             var event = document.createEvent("CustomEvent");
             event.initCustomEvent("testingtheevent", false, true, {});
             util.global.dispatchEvent(event);
             return function(name, event) {
                 name = name.toLowerCase();
                 var domEvent = document.createEvent("CustomEvent");
                 domEvent.initCustomEvent(name, false, true,
                     event);
                 return dispatch(legacyHandlers[name], domEvent);
             };
         }
     } catch (e) {}
     return function() {
         return false;
     };
 })();
 
 var fireGlobalEvent = (function() {
     if (util.isNode) {
         return function() {
             return process.emit.apply(process, arguments);
         };
     } else {
         if (!util.global) {
             return function() {
                 return false;
             };
         }
         return function(name) {
             var methodName = "on" + name.toLowerCase();
             var method = util.global[methodName];
             if (!method) return false;
             method.apply(util.global, [].slice.call(arguments, 1));
             return true;
         };
     }
 })();
 
 function generatePromiseLifecycleEventObject(name, promise) {
     return {promise: promise};
 }
 
 var eventToObjectGenerator = {
     promiseCreated: generatePromiseLifecycleEventObject,
     promiseFulfilled: generatePromiseLifecycleEventObject,
     promiseRejected: generatePromiseLifecycleEventObject,
     promiseResolved: generatePromiseLifecycleEventObject,
     promiseCancelled: generatePromiseLifecycleEventObject,
     promiseChained: function(name, promise, child) {
         return {promise: promise, child: child};
     },
     warning: function(name, warning) {
         return {warning: warning};
     },
     unhandledRejection: function (name, reason, promise) {
         return {reason: reason, promise: promise};
     },
     rejectionHandled: generatePromiseLifecycleEventObject
 };
 
 var activeFireEvent = function (name) {
     var globalEventFired = false;
     try {
         globalEventFired = fireGlobalEvent.apply(null, arguments);
     } catch (e) {
         async.throwLater(e);
         globalEventFired = true;
     }
 
     var domEventFired = false;
     try {
         domEventFired = fireDomEvent(name,
                     eventToObjectGenerator[name].apply(null, arguments));
     } catch (e) {
         async.throwLater(e);
         domEventFired = true;
     }
 
     return domEventFired || globalEventFired;
 };
 
 Promise.config = function(opts) {
     opts = Object(opts);
     if ("longStackTraces" in opts) {
         if (opts.longStackTraces) {
             Promise.longStackTraces();
         } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {
             disableLongStackTraces();
         }
     }
     if ("warnings" in opts) {
         var warningsOption = opts.warnings;
         config.warnings = !!warningsOption;
         wForgottenReturn = config.warnings;
 
         if (util.isObject(warningsOption)) {
             if ("wForgottenReturn" in warningsOption) {
                 wForgottenReturn = !!warningsOption.wForgottenReturn;
             }
         }
     }
     if ("cancellation" in opts && opts.cancellation && !config.cancellation) {
         if (async.haveItemsQueued()) {
             throw new Error(
                 "cannot enable cancellation after promises are in use");
         }
         Promise.prototype._clearCancellationData =
             cancellationClearCancellationData;
         Promise.prototype._propagateFrom = cancellationPropagateFrom;
         Promise.prototype._onCancel = cancellationOnCancel;
         Promise.prototype._setOnCancel = cancellationSetOnCancel;
         Promise.prototype._attachCancellationCallback =
             cancellationAttachCancellationCallback;
         Promise.prototype._execute = cancellationExecute;
         propagateFromFunction = cancellationPropagateFrom;
         config.cancellation = true;
     }
     if ("monitoring" in opts) {
         if (opts.monitoring && !config.monitoring) {
             config.monitoring = true;
             Promise.prototype._fireEvent = activeFireEvent;
         } else if (!opts.monitoring && config.monitoring) {
             config.monitoring = false;
             Promise.prototype._fireEvent = defaultFireEvent;
         }
     }
     if ("asyncHooks" in opts && util.nodeSupportsAsyncResource) {
         var prev = config.asyncHooks;
         var cur = !!opts.asyncHooks;
         if (prev !== cur) {
             config.asyncHooks = cur;
             if (cur) {
                 enableAsyncHooks();
             } else {
                 disableAsyncHooks();
             }
         }
     }
     return Promise;
 };
 
 function defaultFireEvent() { return false; }
 
 Promise.prototype._fireEvent = defaultFireEvent;
 Promise.prototype._execute = function(executor, resolve, reject) {
     try {
         executor(resolve, reject);
     } catch (e) {
         return e;
     }
 };
 Promise.prototype._onCancel = function () {};
 Promise.prototype._setOnCancel = function (handler) { ; };
 Promise.prototype._attachCancellationCallback = function(onCancel) {
     ;
 };
 Promise.prototype._captureStackTrace = function () {};
 Promise.prototype._attachExtraTrace = function () {};
 Promise.prototype._dereferenceTrace = function () {};
 Promise.prototype._clearCancellationData = function() {};
 Promise.prototype._propagateFrom = function (parent, flags) {
     ;
     ;
 };
 
 function cancellationExecute(executor, resolve, reject) {
     var promise = this;
     try {
         executor(resolve, reject, function(onCancel) {
             if (typeof onCancel !== "function") {
                 throw new TypeError("onCancel must be a function, got: " +
                                     util.toString(onCancel));
             }
             promise._attachCancellationCallback(onCancel);
         });
     } catch (e) {
         return e;
     }
 }
 
 function cancellationAttachCancellationCallback(onCancel) {
     if (!this._isCancellable()) return this;
 
     var previousOnCancel = this._onCancel();
     if (previousOnCancel !== undefined) {
         if (util.isArray(previousOnCancel)) {
             previousOnCancel.push(onCancel);
         } else {
             this._setOnCancel([previousOnCancel, onCancel]);
         }
     } else {
         this._setOnCancel(onCancel);
     }
 }
 
 function cancellationOnCancel() {
     return this._onCancelField;
 }
 
 function cancellationSetOnCancel(onCancel) {
     this._onCancelField = onCancel;
 }
 
 function cancellationClearCancellationData() {
     this._cancellationParent = undefined;
     this._onCancelField = undefined;
 }
 
 function cancellationPropagateFrom(parent, flags) {
     if ((flags & 1) !== 0) {
         this._cancellationParent = parent;
         var branchesRemainingToCancel = parent._branchesRemainingToCancel;
         if (branchesRemainingToCancel === undefined) {
             branchesRemainingToCancel = 0;
         }
         parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;
     }
     if ((flags & 2) !== 0 && parent._isBound()) {
         this._setBoundTo(parent._boundTo);
     }
 }
 
 function bindingPropagateFrom(parent, flags) {
     if ((flags & 2) !== 0 && parent._isBound()) {
         this._setBoundTo(parent._boundTo);
     }
 }
 var propagateFromFunction = bindingPropagateFrom;
 
 function boundValueFunction() {
     var ret = this._boundTo;
     if (ret !== undefined) {
         if (ret instanceof Promise) {
             if (ret.isFulfilled()) {
                 return ret.value();
             } else {
                 return undefined;
             }
         }
     }
     return ret;
 }
 
 function longStackTracesCaptureStackTrace() {
     this._trace = new CapturedTrace(this._peekContext());
 }
 
 function longStackTracesAttachExtraTrace(error, ignoreSelf) {
     if (canAttachTrace(error)) {
         var trace = this._trace;
         if (trace !== undefined) {
             if (ignoreSelf) trace = trace._parent;
         }
         if (trace !== undefined) {
             trace.attachExtraTrace(error);
         } else if (!error.__stackCleaned__) {
             var parsed = parseStackAndMessage(error);
             util.notEnumerableProp(error, "stack",
                 parsed.message + "\n" + parsed.stack.join("\n"));
             util.notEnumerableProp(error, "__stackCleaned__", true);
         }
     }
 }
 
 function longStackTracesDereferenceTrace() {
     this._trace = undefined;
 }
 
 function checkForgottenReturns(returnValue, promiseCreated, name, promise,
                                parent) {
     if (returnValue === undefined && promiseCreated !== null &&
         wForgottenReturn) {
         if (parent !== undefined && parent._returnedNonUndefined()) return;
         if ((promise._bitField & 65535) === 0) return;
 
         if (name) name = name + " ";
         var handlerLine = "";
         var creatorLine = "";
         if (promiseCreated._trace) {
             var traceLines = promiseCreated._trace.stack.split("\n");
             var stack = cleanStack(traceLines);
             for (var i = stack.length - 1; i >= 0; --i) {
                 var line = stack[i];
                 if (!nodeFramePattern.test(line)) {
                     var lineMatches = line.match(parseLinePattern);
                     if (lineMatches) {
                         handlerLine  = "at " + lineMatches[1] +
                             ":" + lineMatches[2] + ":" + lineMatches[3] + " ";
                     }
                     break;
                 }
             }
 
             if (stack.length > 0) {
                 var firstUserLine = stack[0];
                 for (var i = 0; i < traceLines.length; ++i) {
 
                     if (traceLines[i] === firstUserLine) {
                         if (i > 0) {
                             creatorLine = "\n" + traceLines[i - 1];
                         }
                         break;
                     }
                 }
 
             }
         }
         var msg = "a promise was created in a " + name +
             "handler " + handlerLine + "but was not returned from it, " +
             "see http://goo.gl/rRqMUw" +
             creatorLine;
         promise._warn(msg, true, promiseCreated);
     }
 }
 
 function deprecated(name, replacement) {
     var message = name +
         " is deprecated and will be removed in a future version.";
     if (replacement) message += " Use " + replacement + " instead.";
     return warn(message);
 }
 
 function warn(message, shouldUseOwnTrace, promise) {
     if (!config.warnings) return;
     var warning = new Warning(message);
     var ctx;
     if (shouldUseOwnTrace) {
         promise._attachExtraTrace(warning);
     } else if (config.longStackTraces && (ctx = Promise._peekContext())) {
         ctx.attachExtraTrace(warning);
     } else {
         var parsed = parseStackAndMessage(warning);
         warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
     }
 
     if (!activeFireEvent("warning", warning)) {
         formatAndLogError(warning, "", true);
     }
 }
 
 function reconstructStack(message, stacks) {
     for (var i = 0; i < stacks.length - 1; ++i) {
         stacks[i].push("From previous event:");
         stacks[i] = stacks[i].join("\n");
     }
     if (i < stacks.length) {
         stacks[i] = stacks[i].join("\n");
     }
     return message + "\n" + stacks.join("\n");
 }
 
 function removeDuplicateOrEmptyJumps(stacks) {
     for (var i = 0; i < stacks.length; ++i) {
         if (stacks[i].length === 0 ||
             ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
             stacks.splice(i, 1);
             i--;
         }
     }
 }
 
 function removeCommonRoots(stacks) {
     var current = stacks[0];
     for (var i = 1; i < stacks.length; ++i) {
         var prev = stacks[i];
         var currentLastIndex = current.length - 1;
         var currentLastLine = current[currentLastIndex];
         var commonRootMeetPoint = -1;
 
         for (var j = prev.length - 1; j >= 0; --j) {
             if (prev[j] === currentLastLine) {
                 commonRootMeetPoint = j;
                 break;
             }
         }
 
         for (var j = commonRootMeetPoint; j >= 0; --j) {
             var line = prev[j];
             if (current[currentLastIndex] === line) {
                 current.pop();
                 currentLastIndex--;
             } else {
                 break;
             }
         }
         current = prev;
     }
 }
 
 function cleanStack(stack) {
     var ret = [];
     for (var i = 0; i < stack.length; ++i) {
         var line = stack[i];
         var isTraceLine = "    (No stack trace)" === line ||
             stackFramePattern.test(line);
         var isInternalFrame = isTraceLine && shouldIgnore(line);
         if (isTraceLine && !isInternalFrame) {
             if (indentStackFrames && line.charAt(0) !== " ") {
                 line = "    " + line;
             }
             ret.push(line);
         }
     }
     return ret;
 }
 
 function stackFramesAsArray(error) {
     var stack = error.stack.replace(/\s+$/g, "").split("\n");
     for (var i = 0; i < stack.length; ++i) {
         var line = stack[i];
         if ("    (No stack trace)" === line || stackFramePattern.test(line)) {
             break;
         }
     }
     if (i > 0 && error.name != "SyntaxError") {
         stack = stack.slice(i);
     }
     return stack;
 }
 
 function parseStackAndMessage(error) {
     var stack = error.stack;
     var message = error.toString();
     stack = typeof stack === "string" && stack.length > 0
                 ? stackFramesAsArray(error) : ["    (No stack trace)"];
     return {
         message: message,
         stack: error.name == "SyntaxError" ? stack : cleanStack(stack)
     };
 }
 
 function formatAndLogError(error, title, isSoft) {
     if (typeof console !== "undefined") {
         var message;
         if (util.isObject(error)) {
             var stack = error.stack;
             message = title + formatStack(stack, error);
         } else {
             message = title + String(error);
         }
         if (typeof printWarning === "function") {
             printWarning(message, isSoft);
         } else if (typeof console.log === "function" ||
             typeof console.log === "object") {
             console.log(message);
         }
     }
 }
 
 function fireRejectionEvent(name, localHandler, reason, promise) {
     var localEventFired = false;
     try {
         if (typeof localHandler === "function") {
             localEventFired = true;
             if (name === "rejectionHandled") {
                 localHandler(promise);
             } else {
                 localHandler(reason, promise);
             }
         }
     } catch (e) {
         async.throwLater(e);
     }
 
     if (name === "unhandledRejection") {
         if (!activeFireEvent(name, reason, promise) && !localEventFired) {
             formatAndLogError(reason, "Unhandled rejection ");
         }
     } else {
         activeFireEvent(name, promise);
     }
 }
 
 function formatNonError(obj) {
     var str;
     if (typeof obj === "function") {
         str = "[function " +
             (obj.name || "anonymous") +
             "]";
     } else {
         str = obj && typeof obj.toString === "function"
             ? obj.toString() : util.toString(obj);
         var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
         if (ruselessToString.test(str)) {
             try {
                 var newStr = JSON.stringify(obj);
                 str = newStr;
             }
             catch(e) {
 
             }
         }
         if (str.length === 0) {
             str = "(empty array)";
         }
     }
     return ("(<" + snip(str) + ">, no stack trace)");
 }
 
 function snip(str) {
     var maxChars = 41;
     if (str.length < maxChars) {
         return str;
     }
     return str.substr(0, maxChars - 3) + "...";
 }
 
 function longStackTracesIsSupported() {
     return typeof captureStackTrace === "function";
 }
 
 var shouldIgnore = function() { return false; };
 var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
 function parseLineInfo(line) {
     var matches = line.match(parseLineInfoRegex);
     if (matches) {
         return {
             fileName: matches[1],
             line: parseInt(matches[2], 10)
         };
     }
 }
 
 function setBounds(firstLineError, lastLineError) {
     if (!longStackTracesIsSupported()) return;
     var firstStackLines = (firstLineError.stack || "").split("\n");
     var lastStackLines = (lastLineError.stack || "").split("\n");
     var firstIndex = -1;
     var lastIndex = -1;
     var firstFileName;
     var lastFileName;
     for (var i = 0; i < firstStackLines.length; ++i) {
         var result = parseLineInfo(firstStackLines[i]);
         if (result) {
             firstFileName = result.fileName;
             firstIndex = result.line;
             break;
         }
     }
     for (var i = 0; i < lastStackLines.length; ++i) {
         var result = parseLineInfo(lastStackLines[i]);
         if (result) {
             lastFileName = result.fileName;
             lastIndex = result.line;
             break;
         }
     }
     if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
         firstFileName !== lastFileName || firstIndex >= lastIndex) {
         return;
     }
 
     shouldIgnore = function(line) {
         if (bluebirdFramePattern.test(line)) return true;
         var info = parseLineInfo(line);
         if (info) {
             if (info.fileName === firstFileName &&
                 (firstIndex <= info.line && info.line <= lastIndex)) {
                 return true;
             }
         }
         return false;
     };
 }
 
 function CapturedTrace(parent) {
     this._parent = parent;
     this._promisesCreated = 0;
     var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
     captureStackTrace(this, CapturedTrace);
     if (length > 32) this.uncycle();
 }
 util.inherits(CapturedTrace, Error);
 Context.CapturedTrace = CapturedTrace;
 
 CapturedTrace.prototype.uncycle = function() {
     var length = this._length;
     if (length < 2) return;
     var nodes = [];
     var stackToIndex = {};
 
     for (var i = 0, node = this; node !== undefined; ++i) {
         nodes.push(node);
         node = node._parent;
     }
     length = this._length = i;
     for (var i = length - 1; i >= 0; --i) {
         var stack = nodes[i].stack;
         if (stackToIndex[stack] === undefined) {
             stackToIndex[stack] = i;
         }
     }
     for (var i = 0; i < length; ++i) {
         var currentStack = nodes[i].stack;
         var index = stackToIndex[currentStack];
         if (index !== undefined && index !== i) {
             if (index > 0) {
                 nodes[index - 1]._parent = undefined;
                 nodes[index - 1]._length = 1;
             }
             nodes[i]._parent = undefined;
             nodes[i]._length = 1;
             var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
 
             if (index < length - 1) {
                 cycleEdgeNode._parent = nodes[index + 1];
                 cycleEdgeNode._parent.uncycle();
                 cycleEdgeNode._length =
                     cycleEdgeNode._parent._length + 1;
             } else {
                 cycleEdgeNode._parent = undefined;
                 cycleEdgeNode._length = 1;
             }
             var currentChildLength = cycleEdgeNode._length + 1;
             for (var j = i - 2; j >= 0; --j) {
                 nodes[j]._length = currentChildLength;
                 currentChildLength++;
             }
             return;
         }
     }
 };
 
 CapturedTrace.prototype.attachExtraTrace = function(error) {
     if (error.__stackCleaned__) return;
     this.uncycle();
     var parsed = parseStackAndMessage(error);
     var message = parsed.message;
     var stacks = [parsed.stack];
 
     var trace = this;
     while (trace !== undefined) {
         stacks.push(cleanStack(trace.stack.split("\n")));
         trace = trace._parent;
     }
     removeCommonRoots(stacks);
     removeDuplicateOrEmptyJumps(stacks);
     util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
     util.notEnumerableProp(error, "__stackCleaned__", true);
 };
 
 var captureStackTrace = (function stackDetection() {
     var v8stackFramePattern = /^\s*at\s*/;
     var v8stackFormatter = function(stack, error) {
         if (typeof stack === "string") return stack;
 
         if (error.name !== undefined &&
             error.message !== undefined) {
             return error.toString();
         }
         return formatNonError(error);
     };
 
     if (typeof Error.stackTraceLimit === "number" &&
         typeof Error.captureStackTrace === "function") {
         Error.stackTraceLimit += 6;
         stackFramePattern = v8stackFramePattern;
         formatStack = v8stackFormatter;
         var captureStackTrace = Error.captureStackTrace;
 
         shouldIgnore = function(line) {
             return bluebirdFramePattern.test(line);
         };
         return function(receiver, ignoreUntil) {
             Error.stackTraceLimit += 6;
             captureStackTrace(receiver, ignoreUntil);
             Error.stackTraceLimit -= 6;
         };
     }
     var err = new Error();
 
     if (typeof err.stack === "string" &&
         err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
         stackFramePattern = /@/;
         formatStack = v8stackFormatter;
         indentStackFrames = true;
         return function captureStackTrace(o) {
             o.stack = new Error().stack;
         };
     }
 
     var hasStackAfterThrow;
     try { throw new Error(); }
     catch(e) {
         hasStackAfterThrow = ("stack" in e);
     }
     if (!("stack" in err) && hasStackAfterThrow &&
         typeof Error.stackTraceLimit === "number") {
         stackFramePattern = v8stackFramePattern;
         formatStack = v8stackFormatter;
         return function captureStackTrace(o) {
             Error.stackTraceLimit += 6;
             try { throw new Error(); }
             catch(e) { o.stack = e.stack; }
             Error.stackTraceLimit -= 6;
         };
     }
 
     formatStack = function(stack, error) {
         if (typeof stack === "string") return stack;
 
         if ((typeof error === "object" ||
             typeof error === "function") &&
             error.name !== undefined &&
             error.message !== undefined) {
             return error.toString();
         }
         return formatNonError(error);
     };
 
     return null;
 
 })([]);
 
 if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
     printWarning = function (message) {
         console.warn(message);
     };
     if (util.isNode && process.stderr.isTTY) {
         printWarning = function(message, isSoft) {
             var color = isSoft ? "\u001b[33m" : "\u001b[31m";
             console.warn(color + message + "\u001b[0m\n");
         };
     } else if (!util.isNode && typeof (new Error().stack) === "string") {
         printWarning = function(message, isSoft) {
             console.warn("%c" + message,
                         isSoft ? "color: darkorange" : "color: red");
         };
     }
 }
 
 var config = {
     warnings: warnings,
     longStackTraces: false,
     cancellation: false,
     monitoring: false,
     asyncHooks: false
 };
 
 if (longStackTraces) Promise.longStackTraces();
 
 return {
     asyncHooks: function() {
         return config.asyncHooks;
     },
     longStackTraces: function() {
         return config.longStackTraces;
     },
     warnings: function() {
         return config.warnings;
     },
     cancellation: function() {
         return config.cancellation;
     },
     monitoring: function() {
         return config.monitoring;
     },
     propagateFromFunction: function() {
         return propagateFromFunction;
     },
     boundValueFunction: function() {
         return boundValueFunction;
     },
     checkForgottenReturns: checkForgottenReturns,
     setBounds: setBounds,
     warn: warn,
     deprecated: deprecated,
     CapturedTrace: CapturedTrace,
     fireDomEvent: fireDomEvent,
     fireGlobalEvent: fireGlobalEvent
 };
 };
 
 },{"./errors":9,"./es5":10,"./util":21}],8:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function(Promise) {
 function returner() {
     return this.value;
 }
 function thrower() {
     throw this.reason;
 }
 
 Promise.prototype["return"] =
 Promise.prototype.thenReturn = function (value) {
     if (value instanceof Promise) value.suppressUnhandledRejections();
     return this._then(
         returner, undefined, undefined, {value: value}, undefined);
 };
 
 Promise.prototype["throw"] =
 Promise.prototype.thenThrow = function (reason) {
     return this._then(
         thrower, undefined, undefined, {reason: reason}, undefined);
 };
 
 Promise.prototype.catchThrow = function (reason) {
     if (arguments.length <= 1) {
         return this._then(
             undefined, thrower, undefined, {reason: reason}, undefined);
     } else {
         var _reason = arguments[1];
         var handler = function() {throw _reason;};
         return this.caught(reason, handler);
     }
 };
 
 Promise.prototype.catchReturn = function (value) {
     if (arguments.length <= 1) {
         if (value instanceof Promise) value.suppressUnhandledRejections();
         return this._then(
             undefined, returner, undefined, {value: value}, undefined);
     } else {
         var _value = arguments[1];
         if (_value instanceof Promise) _value.suppressUnhandledRejections();
         var handler = function() {return _value;};
         return this.caught(value, handler);
     }
 };
 };
 
 },{}],9:[function(_dereq_,module,exports){
 "use strict";
 var es5 = _dereq_("./es5");
 var Objectfreeze = es5.freeze;
 var util = _dereq_("./util");
 var inherits = util.inherits;
 var notEnumerableProp = util.notEnumerableProp;
 
 function subError(nameProperty, defaultMessage) {
     function SubError(message) {
         if (!(this instanceof SubError)) return new SubError(message);
         notEnumerableProp(this, "message",
             typeof message === "string" ? message : defaultMessage);
         notEnumerableProp(this, "name", nameProperty);
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, this.constructor);
         } else {
             Error.call(this);
         }
     }
     inherits(SubError, Error);
     return SubError;
 }
 
 var _TypeError, _RangeError;
 var Warning = subError("Warning", "warning");
 var CancellationError = subError("CancellationError", "cancellation error");
 var TimeoutError = subError("TimeoutError", "timeout error");
 var AggregateError = subError("AggregateError", "aggregate error");
 try {
     _TypeError = TypeError;
     _RangeError = RangeError;
 } catch(e) {
     _TypeError = subError("TypeError", "type error");
     _RangeError = subError("RangeError", "range error");
 }
 
 var methods = ("join pop push shift unshift slice filter forEach some " +
     "every map indexOf lastIndexOf reduce reduceRight sort reverse").split(" ");
 
 for (var i = 0; i < methods.length; ++i) {
     if (typeof Array.prototype[methods[i]] === "function") {
         AggregateError.prototype[methods[i]] = Array.prototype[methods[i]];
     }
 }
 
 es5.defineProperty(AggregateError.prototype, "length", {
     value: 0,
     configurable: false,
     writable: true,
     enumerable: true
 });
 AggregateError.prototype["isOperational"] = true;
 var level = 0;
 AggregateError.prototype.toString = function() {
     var indent = Array(level * 4 + 1).join(" ");
     var ret = "\n" + indent + "AggregateError of:" + "\n";
     level++;
     indent = Array(level * 4 + 1).join(" ");
     for (var i = 0; i < this.length; ++i) {
         var str = this[i] === this ? "[Circular AggregateError]" : this[i] + "";
         var lines = str.split("\n");
         for (var j = 0; j < lines.length; ++j) {
             lines[j] = indent + lines[j];
         }
         str = lines.join("\n");
         ret += str + "\n";
     }
     level--;
     return ret;
 };
 
 function OperationalError(message) {
     if (!(this instanceof OperationalError))
         return new OperationalError(message);
     notEnumerableProp(this, "name", "OperationalError");
     notEnumerableProp(this, "message", message);
     this.cause = message;
     this["isOperational"] = true;
 
     if (message instanceof Error) {
         notEnumerableProp(this, "message", message.message);
         notEnumerableProp(this, "stack", message.stack);
     } else if (Error.captureStackTrace) {
         Error.captureStackTrace(this, this.constructor);
     }
 
 }
 inherits(OperationalError, Error);
 
 var errorTypes = Error["__BluebirdErrorTypes__"];
 if (!errorTypes) {
     errorTypes = Objectfreeze({
         CancellationError: CancellationError,
         TimeoutError: TimeoutError,
         OperationalError: OperationalError,
         RejectionError: OperationalError,
         AggregateError: AggregateError
     });
     es5.defineProperty(Error, "__BluebirdErrorTypes__", {
         value: errorTypes,
         writable: false,
         enumerable: false,
         configurable: false
     });
 }
 
 module.exports = {
     Error: Error,
     TypeError: _TypeError,
     RangeError: _RangeError,
     CancellationError: errorTypes.CancellationError,
     OperationalError: errorTypes.OperationalError,
     TimeoutError: errorTypes.TimeoutError,
     AggregateError: errorTypes.AggregateError,
     Warning: Warning
 };
 
 },{"./es5":10,"./util":21}],10:[function(_dereq_,module,exports){
 var isES5 = (function(){
     "use strict";
     return this === undefined;
 })();
 
 if (isES5) {
     module.exports = {
         freeze: Object.freeze,
         defineProperty: Object.defineProperty,
         getDescriptor: Object.getOwnPropertyDescriptor,
         keys: Object.keys,
         names: Object.getOwnPropertyNames,
         getPrototypeOf: Object.getPrototypeOf,
         isArray: Array.isArray,
         isES5: isES5,
         propertyIsWritable: function(obj, prop) {
             var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
             return !!(!descriptor || descriptor.writable || descriptor.set);
         }
     };
 } else {
     var has = {}.hasOwnProperty;
     var str = {}.toString;
     var proto = {}.constructor.prototype;
 
     var ObjectKeys = function (o) {
         var ret = [];
         for (var key in o) {
             if (has.call(o, key)) {
                 ret.push(key);
             }
         }
         return ret;
     };
 
     var ObjectGetDescriptor = function(o, key) {
         return {value: o[key]};
     };
 
     var ObjectDefineProperty = function (o, key, desc) {
         o[key] = desc.value;
         return o;
     };
 
     var ObjectFreeze = function (obj) {
         return obj;
     };
 
     var ObjectGetPrototypeOf = function (obj) {
         try {
             return Object(obj).constructor.prototype;
         }
         catch (e) {
             return proto;
         }
     };
 
     var ArrayIsArray = function (obj) {
         try {
             return str.call(obj) === "[object Array]";
         }
         catch(e) {
             return false;
         }
     };
 
     module.exports = {
         isArray: ArrayIsArray,
         keys: ObjectKeys,
         names: ObjectKeys,
         defineProperty: ObjectDefineProperty,
         getDescriptor: ObjectGetDescriptor,
         freeze: ObjectFreeze,
         getPrototypeOf: ObjectGetPrototypeOf,
         isES5: isES5,
         propertyIsWritable: function() {
             return true;
         }
     };
 }
 
 },{}],11:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function(Promise, tryConvertToPromise, NEXT_FILTER) {
 var util = _dereq_("./util");
 var CancellationError = Promise.CancellationError;
 var errorObj = util.errorObj;
 var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
 
 function PassThroughHandlerContext(promise, type, handler) {
     this.promise = promise;
     this.type = type;
     this.handler = handler;
     this.called = false;
     this.cancelPromise = null;
 }
 
 PassThroughHandlerContext.prototype.isFinallyHandler = function() {
     return this.type === 0;
 };
 
 function FinallyHandlerCancelReaction(finallyHandler) {
     this.finallyHandler = finallyHandler;
 }
 
 FinallyHandlerCancelReaction.prototype._resultCancelled = function() {
     checkCancel(this.finallyHandler);
 };
 
 function checkCancel(ctx, reason) {
     if (ctx.cancelPromise != null) {
         if (arguments.length > 1) {
             ctx.cancelPromise._reject(reason);
         } else {
             ctx.cancelPromise._cancel();
         }
         ctx.cancelPromise = null;
         return true;
     }
     return false;
 }
 
 function succeed() {
     return finallyHandler.call(this, this.promise._target()._settledValue());
 }
 function fail(reason) {
     if (checkCancel(this, reason)) return;
     errorObj.e = reason;
     return errorObj;
 }
 function finallyHandler(reasonOrValue) {
     var promise = this.promise;
     var handler = this.handler;
 
     if (!this.called) {
         this.called = true;
         var ret = this.isFinallyHandler()
             ? handler.call(promise._boundValue())
             : handler.call(promise._boundValue(), reasonOrValue);
         if (ret === NEXT_FILTER) {
             return ret;
         } else if (ret !== undefined) {
             promise._setReturnedNonUndefined();
             var maybePromise = tryConvertToPromise(ret, promise);
             if (maybePromise instanceof Promise) {
                 if (this.cancelPromise != null) {
                     if (maybePromise._isCancelled()) {
                         var reason =
                             new CancellationError("late cancellation observer");
                         promise._attachExtraTrace(reason);
                         errorObj.e = reason;
                         return errorObj;
                     } else if (maybePromise.isPending()) {
                         maybePromise._attachCancellationCallback(
                             new FinallyHandlerCancelReaction(this));
                     }
                 }
                 return maybePromise._then(
                     succeed, fail, undefined, this, undefined);
             }
         }
     }
 
     if (promise.isRejected()) {
         checkCancel(this);
         errorObj.e = reasonOrValue;
         return errorObj;
     } else {
         checkCancel(this);
         return reasonOrValue;
     }
 }
 
 Promise.prototype._passThrough = function(handler, type, success, fail) {
     if (typeof handler !== "function") return this.then();
     return this._then(success,
                       fail,
                       undefined,
                       new PassThroughHandlerContext(this, type, handler),
                       undefined);
 };
 
 Promise.prototype.lastly =
 Promise.prototype["finally"] = function (handler) {
     return this._passThrough(handler,
                              0,
                              finallyHandler,
                              finallyHandler);
 };
 
 
 Promise.prototype.tap = function (handler) {
     return this._passThrough(handler, 1, finallyHandler);
 };
 
 Promise.prototype.tapCatch = function (handlerOrPredicate) {
     var len = arguments.length;
     if(len === 1) {
         return this._passThrough(handlerOrPredicate,
                                  1,
                                  undefined,
                                  finallyHandler);
     } else {
          var catchInstances = new Array(len - 1),
             j = 0, i;
         for (i = 0; i < len - 1; ++i) {
             var item = arguments[i];
             if (util.isObject(item)) {
                 catchInstances[j++] = item;
             } else {
                 return Promise.reject(new TypeError(
                     "tapCatch statement predicate: "
                     + "expecting an object but got " + util.classString(item)
                 ));
             }
         }
         catchInstances.length = j;
         var handler = arguments[i];
         return this._passThrough(catchFilter(catchInstances, handler, this),
                                  1,
                                  undefined,
                                  finallyHandler);
     }
 
 };
 
 return PassThroughHandlerContext;
 };
 
 },{"./catch_filter":5,"./util":21}],12:[function(_dereq_,module,exports){
 "use strict";
 module.exports =
 function(Promise, PromiseArray, tryConvertToPromise, INTERNAL, async) {
 var util = _dereq_("./util");
 var canEvaluate = util.canEvaluate;
 var tryCatch = util.tryCatch;
 var errorObj = util.errorObj;
 var reject;
 
 if (!true) {
 if (canEvaluate) {
     var thenCallback = function(i) {
         return new Function("value", "holder", "                             \n\
             'use strict';                                                    \n\
             holder.pIndex = value;                                           \n\
             holder.checkFulfillment(this);                                   \n\
             ".replace(/Index/g, i));
     };
 
     var promiseSetter = function(i) {
         return new Function("promise", "holder", "                           \n\
             'use strict';                                                    \n\
             holder.pIndex = promise;                                         \n\
             ".replace(/Index/g, i));
     };
 
     var generateHolderClass = function(total) {
         var props = new Array(total);
         for (var i = 0; i < props.length; ++i) {
             props[i] = "this.p" + (i+1);
         }
         var assignment = props.join(" = ") + " = null;";
         var cancellationCode= "var promise;\n" + props.map(function(prop) {
             return "                                                         \n\
                 promise = " + prop + ";                                      \n\
                 if (promise instanceof Promise) {                            \n\
                     promise.cancel();                                        \n\
                 }                                                            \n\
             ";
         }).join("\n");
         var passedArguments = props.join(", ");
         var name = "Holder$" + total;
 
 
         var code = "return function(tryCatch, errorObj, Promise, async) {    \n\
             'use strict';                                                    \n\
             function [TheName](fn) {                                         \n\
                 [TheProperties]                                              \n\
                 this.fn = fn;                                                \n\
                 this.asyncNeeded = true;                                     \n\
                 this.now = 0;                                                \n\
             }                                                                \n\
                                                                              \n\
             [TheName].prototype._callFunction = function(promise) {          \n\
                 promise._pushContext();                                      \n\
                 var ret = tryCatch(this.fn)([ThePassedArguments]);           \n\
                 promise._popContext();                                       \n\
                 if (ret === errorObj) {                                      \n\
                     promise._rejectCallback(ret.e, false);                   \n\
                 } else {                                                     \n\
                     promise._resolveCallback(ret);                           \n\
                 }                                                            \n\
             };                                                               \n\
                                                                              \n\
             [TheName].prototype.checkFulfillment = function(promise) {       \n\
                 var now = ++this.now;                                        \n\
                 if (now === [TheTotal]) {                                    \n\
                     if (this.asyncNeeded) {                                  \n\
                         async.invoke(this._callFunction, this, promise);     \n\
                     } else {                                                 \n\
                         this._callFunction(promise);                         \n\
                     }                                                        \n\
                                                                              \n\
                 }                                                            \n\
             };                                                               \n\
                                                                              \n\
             [TheName].prototype._resultCancelled = function() {              \n\
                 [CancellationCode]                                           \n\
             };                                                               \n\
                                                                              \n\
             return [TheName];                                                \n\
         }(tryCatch, errorObj, Promise, async);                               \n\
         ";
 
         code = code.replace(/\[TheName\]/g, name)
             .replace(/\[TheTotal\]/g, total)
             .replace(/\[ThePassedArguments\]/g, passedArguments)
             .replace(/\[TheProperties\]/g, assignment)
             .replace(/\[CancellationCode\]/g, cancellationCode);
 
         return new Function("tryCatch", "errorObj", "Promise", "async", code)
                            (tryCatch, errorObj, Promise, async);
     };
 
     var holderClasses = [];
     var thenCallbacks = [];
     var promiseSetters = [];
 
     for (var i = 0; i < 8; ++i) {
         holderClasses.push(generateHolderClass(i + 1));
         thenCallbacks.push(thenCallback(i + 1));
         promiseSetters.push(promiseSetter(i + 1));
     }
 
     reject = function (reason) {
         this._reject(reason);
     };
 }}
 
 Promise.join = function () {
     var last = arguments.length - 1;
     var fn;
     if (last > 0 && typeof arguments[last] === "function") {
         fn = arguments[last];
         if (!true) {
             if (last <= 8 && canEvaluate) {
                 var ret = new Promise(INTERNAL);
                 ret._captureStackTrace();
                 var HolderClass = holderClasses[last - 1];
                 var holder = new HolderClass(fn);
                 var callbacks = thenCallbacks;
 
                 for (var i = 0; i < last; ++i) {
                     var maybePromise = tryConvertToPromise(arguments[i], ret);
                     if (maybePromise instanceof Promise) {
                         maybePromise = maybePromise._target();
                         var bitField = maybePromise._bitField;
                         ;
                         if (((bitField & 50397184) === 0)) {
                             maybePromise._then(callbacks[i], reject,
                                                undefined, ret, holder);
                             promiseSetters[i](maybePromise, holder);
                             holder.asyncNeeded = false;
                         } else if (((bitField & 33554432) !== 0)) {
                             callbacks[i].call(ret,
                                               maybePromise._value(), holder);
                         } else if (((bitField & 16777216) !== 0)) {
                             ret._reject(maybePromise._reason());
                         } else {
                             ret._cancel();
                         }
                     } else {
                         callbacks[i].call(ret, maybePromise, holder);
                     }
                 }
 
                 if (!ret._isFateSealed()) {
                     if (holder.asyncNeeded) {
                         var context = Promise._getContext();
                         holder.fn = util.contextBind(context, holder.fn);
                     }
                     ret._setAsyncGuaranteed();
                     ret._setOnCancel(holder);
                 }
                 return ret;
             }
         }
     }
     var args = [].slice.call(arguments);;
     if (fn) args.pop();
     var ret = new PromiseArray(args).promise();
     return fn !== undefined ? ret.spread(fn) : ret;
 };
 
 };
 
 },{"./util":21}],13:[function(_dereq_,module,exports){
 "use strict";
 module.exports =
 function(Promise, INTERNAL, tryConvertToPromise, apiRejection, debug) {
 var util = _dereq_("./util");
 var tryCatch = util.tryCatch;
 
 Promise.method = function (fn) {
     if (typeof fn !== "function") {
         throw new Promise.TypeError("expecting a function but got " + util.classString(fn));
     }
     return function () {
         var ret = new Promise(INTERNAL);
         ret._captureStackTrace();
         ret._pushContext();
         var value = tryCatch(fn).apply(this, arguments);
         var promiseCreated = ret._popContext();
         debug.checkForgottenReturns(
             value, promiseCreated, "Promise.method", ret);
         ret._resolveFromSyncValue(value);
         return ret;
     };
 };
 
 Promise.attempt = Promise["try"] = function (fn) {
     if (typeof fn !== "function") {
         return apiRejection("expecting a function but got " + util.classString(fn));
     }
     var ret = new Promise(INTERNAL);
     ret._captureStackTrace();
     ret._pushContext();
     var value;
     if (arguments.length > 1) {
         debug.deprecated("calling Promise.try with more than 1 argument");
         var arg = arguments[1];
         var ctx = arguments[2];
         value = util.isArray(arg) ? tryCatch(fn).apply(ctx, arg)
                                   : tryCatch(fn).call(ctx, arg);
     } else {
         value = tryCatch(fn)();
     }
     var promiseCreated = ret._popContext();
     debug.checkForgottenReturns(
         value, promiseCreated, "Promise.try", ret);
     ret._resolveFromSyncValue(value);
     return ret;
 };
 
 Promise.prototype._resolveFromSyncValue = function (value) {
     if (value === util.errorObj) {
         this._rejectCallback(value.e, false);
     } else {
         this._resolveCallback(value, true);
     }
 };
 };
 
 },{"./util":21}],14:[function(_dereq_,module,exports){
 "use strict";
 var util = _dereq_("./util");
 var maybeWrapAsError = util.maybeWrapAsError;
 var errors = _dereq_("./errors");
 var OperationalError = errors.OperationalError;
 var es5 = _dereq_("./es5");
 
 function isUntypedError(obj) {
     return obj instanceof Error &&
         es5.getPrototypeOf(obj) === Error.prototype;
 }
 
 var rErrorKey = /^(?:name|message|stack|cause)$/;
 function wrapAsOperationalError(obj) {
     var ret;
     if (isUntypedError(obj)) {
         ret = new OperationalError(obj);
         ret.name = obj.name;
         ret.message = obj.message;
         ret.stack = obj.stack;
         var keys = es5.keys(obj);
         for (var i = 0; i < keys.length; ++i) {
             var key = keys[i];
             if (!rErrorKey.test(key)) {
                 ret[key] = obj[key];
             }
         }
         return ret;
     }
     util.markAsOriginatingFromRejection(obj);
     return obj;
 }
 
 function nodebackForPromise(promise, multiArgs) {
     return function(err, value) {
         if (promise === null) return;
         if (err) {
             var wrapped = wrapAsOperationalError(maybeWrapAsError(err));
             promise._attachExtraTrace(wrapped);
             promise._reject(wrapped);
         } else if (!multiArgs) {
             promise._fulfill(value);
         } else {
             var args = [].slice.call(arguments, 1);;
             promise._fulfill(args);
         }
         promise = null;
     };
 }
 
 module.exports = nodebackForPromise;
 
 },{"./errors":9,"./es5":10,"./util":21}],15:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function() {
 var makeSelfResolutionError = function () {
     return new TypeError("circular promise resolution chain\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
 };
 var reflectHandler = function() {
     return new Promise.PromiseInspection(this._target());
 };
 var apiRejection = function(msg) {
     return Promise.reject(new TypeError(msg));
 };
 function Proxyable() {}
 var UNDEFINED_BINDING = {};
 var util = _dereq_("./util");
 util.setReflectHandler(reflectHandler);
 
 var getDomain = function() {
     var domain = process.domain;
     if (domain === undefined) {
         return null;
     }
     return domain;
 };
 var getContextDefault = function() {
     return null;
 };
 var getContextDomain = function() {
     return {
         domain: getDomain(),
         async: null
     };
 };
 var AsyncResource = util.isNode && util.nodeSupportsAsyncResource ?
     _dereq_("async_hooks").AsyncResource : null;
 var getContextAsyncHooks = function() {
     return {
         domain: getDomain(),
         async: new AsyncResource("Bluebird::Promise")
     };
 };
 var getContext = util.isNode ? getContextDomain : getContextDefault;
 util.notEnumerableProp(Promise, "_getContext", getContext);
 var enableAsyncHooks = function() {
     getContext = getContextAsyncHooks;
     util.notEnumerableProp(Promise, "_getContext", getContextAsyncHooks);
 };
 var disableAsyncHooks = function() {
     getContext = getContextDomain;
     util.notEnumerableProp(Promise, "_getContext", getContextDomain);
 };
 
 var es5 = _dereq_("./es5");
 var Async = _dereq_("./async");
 var async = new Async();
 es5.defineProperty(Promise, "_async", {value: async});
 var errors = _dereq_("./errors");
 var TypeError = Promise.TypeError = errors.TypeError;
 Promise.RangeError = errors.RangeError;
 var CancellationError = Promise.CancellationError = errors.CancellationError;
 Promise.TimeoutError = errors.TimeoutError;
 Promise.OperationalError = errors.OperationalError;
 Promise.RejectionError = errors.OperationalError;
 Promise.AggregateError = errors.AggregateError;
 var INTERNAL = function(){};
 var APPLY = {};
 var NEXT_FILTER = {};
 var tryConvertToPromise = _dereq_("./thenables")(Promise, INTERNAL);
 var PromiseArray =
     _dereq_("./promise_array")(Promise, INTERNAL,
                                tryConvertToPromise, apiRejection, Proxyable);
 var Context = _dereq_("./context")(Promise);
  /*jshint unused:false*/
 var createContext = Context.create;
 
 var debug = _dereq_("./debuggability")(Promise, Context,
     enableAsyncHooks, disableAsyncHooks);
 var CapturedTrace = debug.CapturedTrace;
 var PassThroughHandlerContext =
     _dereq_("./finally")(Promise, tryConvertToPromise, NEXT_FILTER);
 var catchFilter = _dereq_("./catch_filter")(NEXT_FILTER);
 var nodebackForPromise = _dereq_("./nodeback");
 var errorObj = util.errorObj;
 var tryCatch = util.tryCatch;
 function check(self, executor) {
     if (self == null || self.constructor !== Promise) {
         throw new TypeError("the promise constructor cannot be invoked directly\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
     }
     if (typeof executor !== "function") {
         throw new TypeError("expecting a function but got " + util.classString(executor));
     }
 
 }
 
 function Promise(executor) {
     if (executor !== INTERNAL) {
         check(this, executor);
     }
     this._bitField = 0;
     this._fulfillmentHandler0 = undefined;
     this._rejectionHandler0 = undefined;
     this._promise0 = undefined;
     this._receiver0 = undefined;
     this._resolveFromExecutor(executor);
     this._promiseCreated();
     this._fireEvent("promiseCreated", this);
 }
 
 Promise.prototype.toString = function () {
     return "[object Promise]";
 };
 
 Promise.prototype.caught = Promise.prototype["catch"] = function (fn) {
     var len = arguments.length;
     if (len > 1) {
         var catchInstances = new Array(len - 1),
             j = 0, i;
         for (i = 0; i < len - 1; ++i) {
             var item = arguments[i];
             if (util.isObject(item)) {
                 catchInstances[j++] = item;
             } else {
                 return apiRejection("Catch statement predicate: " +
                     "expecting an object but got " + util.classString(item));
             }
         }
         catchInstances.length = j;
         fn = arguments[i];
 
         if (typeof fn !== "function") {
             throw new TypeError("The last argument to .catch() " +
                 "must be a function, got " + util.toString(fn));
         }
         return this.then(undefined, catchFilter(catchInstances, fn, this));
     }
     return this.then(undefined, fn);
 };
 
 Promise.prototype.reflect = function () {
     return this._then(reflectHandler,
         reflectHandler, undefined, this, undefined);
 };
 
 Promise.prototype.then = function (didFulfill, didReject) {
     if (debug.warnings() && arguments.length > 0 &&
         typeof didFulfill !== "function" &&
         typeof didReject !== "function") {
         var msg = ".then() only accepts functions but was passed: " +
                 util.classString(didFulfill);
         if (arguments.length > 1) {
             msg += ", " + util.classString(didReject);
         }
         this._warn(msg);
     }
     return this._then(didFulfill, didReject, undefined, undefined, undefined);
 };
 
 Promise.prototype.done = function (didFulfill, didReject) {
     var promise =
         this._then(didFulfill, didReject, undefined, undefined, undefined);
     promise._setIsFinal();
 };
 
 Promise.prototype.spread = function (fn) {
     if (typeof fn !== "function") {
         return apiRejection("expecting a function but got " + util.classString(fn));
     }
     return this.all()._then(fn, undefined, undefined, APPLY, undefined);
 };
 
 Promise.prototype.toJSON = function () {
     var ret = {
         isFulfilled: false,
         isRejected: false,
         fulfillmentValue: undefined,
         rejectionReason: undefined
     };
     if (this.isFulfilled()) {
         ret.fulfillmentValue = this.value();
         ret.isFulfilled = true;
     } else if (this.isRejected()) {
         ret.rejectionReason = this.reason();
         ret.isRejected = true;
     }
     return ret;
 };
 
 Promise.prototype.all = function () {
     if (arguments.length > 0) {
         this._warn(".all() was passed arguments but it does not take any");
     }
     return new PromiseArray(this).promise();
 };
 
 Promise.prototype.error = function (fn) {
     return this.caught(util.originatesFromRejection, fn);
 };
 
 Promise.getNewLibraryCopy = module.exports;
 
 Promise.is = function (val) {
     return val instanceof Promise;
 };
 
 Promise.fromNode = Promise.fromCallback = function(fn) {
     var ret = new Promise(INTERNAL);
     ret._captureStackTrace();
     var multiArgs = arguments.length > 1 ? !!Object(arguments[1]).multiArgs
                                          : false;
     var result = tryCatch(fn)(nodebackForPromise(ret, multiArgs));
     if (result === errorObj) {
         ret._rejectCallback(result.e, true);
     }
     if (!ret._isFateSealed()) ret._setAsyncGuaranteed();
     return ret;
 };
 
 Promise.all = function (promises) {
     return new PromiseArray(promises).promise();
 };
 
 Promise.cast = function (obj) {
     var ret = tryConvertToPromise(obj);
     if (!(ret instanceof Promise)) {
         ret = new Promise(INTERNAL);
         ret._captureStackTrace();
         ret._setFulfilled();
         ret._rejectionHandler0 = obj;
     }
     return ret;
 };
 
 Promise.resolve = Promise.fulfilled = Promise.cast;
 
 Promise.reject = Promise.rejected = function (reason) {
     var ret = new Promise(INTERNAL);
     ret._captureStackTrace();
     ret._rejectCallback(reason, true);
     return ret;
 };
 
 Promise.setScheduler = function(fn) {
     if (typeof fn !== "function") {
         throw new TypeError("expecting a function but got " + util.classString(fn));
     }
     return async.setScheduler(fn);
 };
 
 Promise.prototype._then = function (
     didFulfill,
     didReject,
     _,    receiver,
     internalData
 ) {
     var haveInternalData = internalData !== undefined;
     var promise = haveInternalData ? internalData : new Promise(INTERNAL);
     var target = this._target();
     var bitField = target._bitField;
 
     if (!haveInternalData) {
         promise._propagateFrom(this, 3);
         promise._captureStackTrace();
         if (receiver === undefined &&
             ((this._bitField & 2097152) !== 0)) {
             if (!((bitField & 50397184) === 0)) {
                 receiver = this._boundValue();
             } else {
                 receiver = target === this ? undefined : this._boundTo;
             }
         }
         this._fireEvent("promiseChained", this, promise);
     }
 
     var context = getContext();
     if (!((bitField & 50397184) === 0)) {
         var handler, value, settler = target._settlePromiseCtx;
         if (((bitField & 33554432) !== 0)) {
             value = target._rejectionHandler0;
             handler = didFulfill;
         } else if (((bitField & 16777216) !== 0)) {
             value = target._fulfillmentHandler0;
             handler = didReject;
             target._unsetRejectionIsUnhandled();
         } else {
             settler = target._settlePromiseLateCancellationObserver;
             value = new CancellationError("late cancellation observer");
             target._attachExtraTrace(value);
             handler = didReject;
         }
 
         async.invoke(settler, target, {
             handler: util.contextBind(context, handler),
             promise: promise,
             receiver: receiver,
             value: value
         });
     } else {
         target._addCallbacks(didFulfill, didReject, promise,
                 receiver, context);
     }
 
     return promise;
 };
 
 Promise.prototype._length = function () {
     return this._bitField & 65535;
 };
 
 Promise.prototype._isFateSealed = function () {
     return (this._bitField & 117506048) !== 0;
 };
 
 Promise.prototype._isFollowing = function () {
     return (this._bitField & 67108864) === 67108864;
 };
 
 Promise.prototype._setLength = function (len) {
     this._bitField = (this._bitField & -65536) |
         (len & 65535);
 };
 
 Promise.prototype._setFulfilled = function () {
     this._bitField = this._bitField | 33554432;
     this._fireEvent("promiseFulfilled", this);
 };
 
 Promise.prototype._setRejected = function () {
     this._bitField = this._bitField | 16777216;
     this._fireEvent("promiseRejected", this);
 };
 
 Promise.prototype._setFollowing = function () {
     this._bitField = this._bitField | 67108864;
     this._fireEvent("promiseResolved", this);
 };
 
 Promise.prototype._setIsFinal = function () {
     this._bitField = this._bitField | 4194304;
 };
 
 Promise.prototype._isFinal = function () {
     return (this._bitField & 4194304) > 0;
 };
 
 Promise.prototype._unsetCancelled = function() {
     this._bitField = this._bitField & (~65536);
 };
 
 Promise.prototype._setCancelled = function() {
     this._bitField = this._bitField | 65536;
     this._fireEvent("promiseCancelled", this);
 };
 
 Promise.prototype._setWillBeCancelled = function() {
     this._bitField = this._bitField | 8388608;
 };
 
 Promise.prototype._setAsyncGuaranteed = function() {
     if (async.hasCustomScheduler()) return;
     var bitField = this._bitField;
     this._bitField = bitField |
         (((bitField & 536870912) >> 2) ^
         134217728);
 };
 
 Promise.prototype._setNoAsyncGuarantee = function() {
     this._bitField = (this._bitField | 536870912) &
         (~134217728);
 };
 
 Promise.prototype._receiverAt = function (index) {
     var ret = index === 0 ? this._receiver0 : this[
             index * 4 - 4 + 3];
     if (ret === UNDEFINED_BINDING) {
         return undefined;
     } else if (ret === undefined && this._isBound()) {
         return this._boundValue();
     }
     return ret;
 };
 
 Promise.prototype._promiseAt = function (index) {
     return this[
             index * 4 - 4 + 2];
 };
 
 Promise.prototype._fulfillmentHandlerAt = function (index) {
     return this[
             index * 4 - 4 + 0];
 };
 
 Promise.prototype._rejectionHandlerAt = function (index) {
     return this[
             index * 4 - 4 + 1];
 };
 
 Promise.prototype._boundValue = function() {};
 
 Promise.prototype._migrateCallback0 = function (follower) {
     var bitField = follower._bitField;
     var fulfill = follower._fulfillmentHandler0;
     var reject = follower._rejectionHandler0;
     var promise = follower._promise0;
     var receiver = follower._receiverAt(0);
     if (receiver === undefined) receiver = UNDEFINED_BINDING;
     this._addCallbacks(fulfill, reject, promise, receiver, null);
 };
 
 Promise.prototype._migrateCallbackAt = function (follower, index) {
     var fulfill = follower._fulfillmentHandlerAt(index);
     var reject = follower._rejectionHandlerAt(index);
     var promise = follower._promiseAt(index);
     var receiver = follower._receiverAt(index);
     if (receiver === undefined) receiver = UNDEFINED_BINDING;
     this._addCallbacks(fulfill, reject, promise, receiver, null);
 };
 
 Promise.prototype._addCallbacks = function (
     fulfill,
     reject,
     promise,
     receiver,
     context
 ) {
     var index = this._length();
 
     if (index >= 65535 - 4) {
         index = 0;
         this._setLength(0);
     }
 
     if (index === 0) {
         this._promise0 = promise;
         this._receiver0 = receiver;
         if (typeof fulfill === "function") {
             this._fulfillmentHandler0 = util.contextBind(context, fulfill);
         }
         if (typeof reject === "function") {
             this._rejectionHandler0 = util.contextBind(context, reject);
         }
     } else {
         var base = index * 4 - 4;
         this[base + 2] = promise;
         this[base + 3] = receiver;
         if (typeof fulfill === "function") {
             this[base + 0] =
                 util.contextBind(context, fulfill);
         }
         if (typeof reject === "function") {
             this[base + 1] =
                 util.contextBind(context, reject);
         }
     }
     this._setLength(index + 1);
     return index;
 };
 
 Promise.prototype._proxy = function (proxyable, arg) {
     this._addCallbacks(undefined, undefined, arg, proxyable, null);
 };
 
 Promise.prototype._resolveCallback = function(value, shouldBind) {
     if (((this._bitField & 117506048) !== 0)) return;
     if (value === this)
         return this._rejectCallback(makeSelfResolutionError(), false);
     var maybePromise = tryConvertToPromise(value, this);
     if (!(maybePromise instanceof Promise)) return this._fulfill(value);
 
     if (shouldBind) this._propagateFrom(maybePromise, 2);
 
 
     var promise = maybePromise._target();
 
     if (promise === this) {
         this._reject(makeSelfResolutionError());
         return;
     }
 
     var bitField = promise._bitField;
     if (((bitField & 50397184) === 0)) {
         var len = this._length();
         if (len > 0) promise._migrateCallback0(this);
         for (var i = 1; i < len; ++i) {
             promise._migrateCallbackAt(this, i);
         }
         this._setFollowing();
         this._setLength(0);
         this._setFollowee(maybePromise);
     } else if (((bitField & 33554432) !== 0)) {
         this._fulfill(promise._value());
     } else if (((bitField & 16777216) !== 0)) {
         this._reject(promise._reason());
     } else {
         var reason = new CancellationError("late cancellation observer");
         promise._attachExtraTrace(reason);
         this._reject(reason);
     }
 };
 
 Promise.prototype._rejectCallback =
 function(reason, synchronous, ignoreNonErrorWarnings) {
     var trace = util.ensureErrorObject(reason);
     var hasStack = trace === reason;
     if (!hasStack && !ignoreNonErrorWarnings && debug.warnings()) {
         var message = "a promise was rejected with a non-error: " +
             util.classString(reason);
         this._warn(message, true);
     }
     this._attachExtraTrace(trace, synchronous ? hasStack : false);
     this._reject(reason);
 };
 
 Promise.prototype._resolveFromExecutor = function (executor) {
     if (executor === INTERNAL) return;
     var promise = this;
     this._captureStackTrace();
     this._pushContext();
     var synchronous = true;
     var r = this._execute(executor, function(value) {
         promise._resolveCallback(value);
     }, function (reason) {
         promise._rejectCallback(reason, synchronous);
     });
     synchronous = false;
     this._popContext();
 
     if (r !== undefined) {
         promise._rejectCallback(r, true);
     }
 };
 
 Promise.prototype._settlePromiseFromHandler = function (
     handler, receiver, value, promise
 ) {
     var bitField = promise._bitField;
     if (((bitField & 65536) !== 0)) return;
     promise._pushContext();
     var x;
     if (receiver === APPLY) {
         if (!value || typeof value.length !== "number") {
             x = errorObj;
             x.e = new TypeError("cannot .spread() a non-array: " +
                                     util.classString(value));
         } else {
             x = tryCatch(handler).apply(this._boundValue(), value);
         }
     } else {
         x = tryCatch(handler).call(receiver, value);
     }
     var promiseCreated = promise._popContext();
     bitField = promise._bitField;
     if (((bitField & 65536) !== 0)) return;
 
     if (x === NEXT_FILTER) {
         promise._reject(value);
     } else if (x === errorObj) {
         promise._rejectCallback(x.e, false);
     } else {
         debug.checkForgottenReturns(x, promiseCreated, "",  promise, this);
         promise._resolveCallback(x);
     }
 };
 
 Promise.prototype._target = function() {
     var ret = this;
     while (ret._isFollowing()) ret = ret._followee();
     return ret;
 };
 
 Promise.prototype._followee = function() {
     return this._rejectionHandler0;
 };
 
 Promise.prototype._setFollowee = function(promise) {
     this._rejectionHandler0 = promise;
 };
 
 Promise.prototype._settlePromise = function(promise, handler, receiver, value) {
     var isPromise = promise instanceof Promise;
     var bitField = this._bitField;
     var asyncGuaranteed = ((bitField & 134217728) !== 0);
     if (((bitField & 65536) !== 0)) {
         if (isPromise) promise._invokeInternalOnCancel();
 
         if (receiver instanceof PassThroughHandlerContext &&
             receiver.isFinallyHandler()) {
             receiver.cancelPromise = promise;
             if (tryCatch(handler).call(receiver, value) === errorObj) {
                 promise._reject(errorObj.e);
             }
         } else if (handler === reflectHandler) {
             promise._fulfill(reflectHandler.call(receiver));
         } else if (receiver instanceof Proxyable) {
             receiver._promiseCancelled(promise);
         } else if (isPromise || promise instanceof PromiseArray) {
             promise._cancel();
         } else {
             receiver.cancel();
         }
     } else if (typeof handler === "function") {
         if (!isPromise) {
             handler.call(receiver, value, promise);
         } else {
             if (asyncGuaranteed) promise._setAsyncGuaranteed();
             this._settlePromiseFromHandler(handler, receiver, value, promise);
         }
     } else if (receiver instanceof Proxyable) {
         if (!receiver._isResolved()) {
             if (((bitField & 33554432) !== 0)) {
                 receiver._promiseFulfilled(value, promise);
             } else {
                 receiver._promiseRejected(value, promise);
             }
         }
     } else if (isPromise) {
         if (asyncGuaranteed) promise._setAsyncGuaranteed();
         if (((bitField & 33554432) !== 0)) {
             promise._fulfill(value);
         } else {
             promise._reject(value);
         }
     }
 };
 
 Promise.prototype._settlePromiseLateCancellationObserver = function(ctx) {
     var handler = ctx.handler;
     var promise = ctx.promise;
     var receiver = ctx.receiver;
     var value = ctx.value;
     if (typeof handler === "function") {
         if (!(promise instanceof Promise)) {
             handler.call(receiver, value, promise);
         } else {
             this._settlePromiseFromHandler(handler, receiver, value, promise);
         }
     } else if (promise instanceof Promise) {
         promise._reject(value);
     }
 };
 
 Promise.prototype._settlePromiseCtx = function(ctx) {
     this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
 };
 
 Promise.prototype._settlePromise0 = function(handler, value, bitField) {
     var promise = this._promise0;
     var receiver = this._receiverAt(0);
     this._promise0 = undefined;
     this._receiver0 = undefined;
     this._settlePromise(promise, handler, receiver, value);
 };
 
 Promise.prototype._clearCallbackDataAtIndex = function(index) {
     var base = index * 4 - 4;
     this[base + 2] =
     this[base + 3] =
     this[base + 0] =
     this[base + 1] = undefined;
 };
 
 Promise.prototype._fulfill = function (value) {
     var bitField = this._bitField;
     if (((bitField & 117506048) >>> 16)) return;
     if (value === this) {
         var err = makeSelfResolutionError();
         this._attachExtraTrace(err);
         return this._reject(err);
     }
     this._setFulfilled();
     this._rejectionHandler0 = value;
 
     if ((bitField & 65535) > 0) {
         if (((bitField & 134217728) !== 0)) {
             this._settlePromises();
         } else {
             async.settlePromises(this);
         }
         this._dereferenceTrace();
     }
 };
 
 Promise.prototype._reject = function (reason) {
     var bitField = this._bitField;
     if (((bitField & 117506048) >>> 16)) return;
     this._setRejected();
     this._fulfillmentHandler0 = reason;
 
     if (this._isFinal()) {
         return async.fatalError(reason, util.isNode);
     }
 
     if ((bitField & 65535) > 0) {
         async.settlePromises(this);
     } else {
         this._ensurePossibleRejectionHandled();
     }
 };
 
 Promise.prototype._fulfillPromises = function (len, value) {
     for (var i = 1; i < len; i++) {
         var handler = this._fulfillmentHandlerAt(i);
         var promise = this._promiseAt(i);
         var receiver = this._receiverAt(i);
         this._clearCallbackDataAtIndex(i);
         this._settlePromise(promise, handler, receiver, value);
     }
 };
 
 Promise.prototype._rejectPromises = function (len, reason) {
     for (var i = 1; i < len; i++) {
         var handler = this._rejectionHandlerAt(i);
         var promise = this._promiseAt(i);
         var receiver = this._receiverAt(i);
         this._clearCallbackDataAtIndex(i);
         this._settlePromise(promise, handler, receiver, reason);
     }
 };
 
 Promise.prototype._settlePromises = function () {
     var bitField = this._bitField;
     var len = (bitField & 65535);
 
     if (len > 0) {
         if (((bitField & 16842752) !== 0)) {
             var reason = this._fulfillmentHandler0;
             this._settlePromise0(this._rejectionHandler0, reason, bitField);
             this._rejectPromises(len, reason);
         } else {
             var value = this._rejectionHandler0;
             this._settlePromise0(this._fulfillmentHandler0, value, bitField);
             this._fulfillPromises(len, value);
         }
         this._setLength(0);
     }
     this._clearCancellationData();
 };
 
 Promise.prototype._settledValue = function() {
     var bitField = this._bitField;
     if (((bitField & 33554432) !== 0)) {
         return this._rejectionHandler0;
     } else if (((bitField & 16777216) !== 0)) {
         return this._fulfillmentHandler0;
     }
 };
 
 if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
     es5.defineProperty(Promise.prototype, Symbol.toStringTag, {
         get: function () {
             return "Object";
         }
     });
 }
 
 function deferResolve(v) {this.promise._resolveCallback(v);}
 function deferReject(v) {this.promise._rejectCallback(v, false);}
 
 Promise.defer = Promise.pending = function() {
     debug.deprecated("Promise.defer", "new Promise");
     var promise = new Promise(INTERNAL);
     return {
         promise: promise,
         resolve: deferResolve,
         reject: deferReject
     };
 };
 
 util.notEnumerableProp(Promise,
                        "_makeSelfResolutionError",
                        makeSelfResolutionError);
 
 _dereq_("./method")(Promise, INTERNAL, tryConvertToPromise, apiRejection,
     debug);
 _dereq_("./bind")(Promise, INTERNAL, tryConvertToPromise, debug);
 _dereq_("./cancel")(Promise, PromiseArray, apiRejection, debug);
 _dereq_("./direct_resolve")(Promise);
 _dereq_("./synchronous_inspection")(Promise);
 _dereq_("./join")(
     Promise, PromiseArray, tryConvertToPromise, INTERNAL, async);
 Promise.Promise = Promise;
 Promise.version = "3.7.2";
                                                          
     util.toFastProperties(Promise);                                          
     util.toFastProperties(Promise.prototype);                                
     function fillTypes(value) {                                              
         var p = new Promise(INTERNAL);                                       
         p._fulfillmentHandler0 = value;                                      
         p._rejectionHandler0 = value;                                        
         p._promise0 = value;                                                 
         p._receiver0 = value;                                                
     }                                                                        
     // Complete slack tracking, opt out of field-type tracking and           
     // stabilize map                                                         
     fillTypes({a: 1});                                                       
     fillTypes({b: 2});                                                       
     fillTypes({c: 3});                                                       
     fillTypes(1);                                                            
     fillTypes(function(){});                                                 
     fillTypes(undefined);                                                    
     fillTypes(false);                                                        
     fillTypes(new Promise(INTERNAL));                                        
     debug.setBounds(Async.firstLineError, util.lastLineError);               
     return Promise;                                                          
 
 };
 
 },{"./async":1,"./bind":2,"./cancel":4,"./catch_filter":5,"./context":6,"./debuggability":7,"./direct_resolve":8,"./errors":9,"./es5":10,"./finally":11,"./join":12,"./method":13,"./nodeback":14,"./promise_array":16,"./synchronous_inspection":19,"./thenables":20,"./util":21,"async_hooks":undefined}],16:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function(Promise, INTERNAL, tryConvertToPromise,
     apiRejection, Proxyable) {
 var util = _dereq_("./util");
 var isArray = util.isArray;
 
 function toResolutionValue(val) {
     switch(val) {
     case -2: return [];
     case -3: return {};
     case -6: return new Map();
     }
 }
 
 function PromiseArray(values) {
     var promise = this._promise = new Promise(INTERNAL);
     if (values instanceof Promise) {
         promise._propagateFrom(values, 3);
         values.suppressUnhandledRejections();
     }
     promise._setOnCancel(this);
     this._values = values;
     this._length = 0;
     this._totalResolved = 0;
     this._init(undefined, -2);
 }
 util.inherits(PromiseArray, Proxyable);
 
 PromiseArray.prototype.length = function () {
     return this._length;
 };
 
 PromiseArray.prototype.promise = function () {
     return this._promise;
 };
 
 PromiseArray.prototype._init = function init(_, resolveValueIfEmpty) {
     var values = tryConvertToPromise(this._values, this._promise);
     if (values instanceof Promise) {
         values = values._target();
         var bitField = values._bitField;
         ;
         this._values = values;
 
         if (((bitField & 50397184) === 0)) {
             this._promise._setAsyncGuaranteed();
             return values._then(
                 init,
                 this._reject,
                 undefined,
                 this,
                 resolveValueIfEmpty
            );
         } else if (((bitField & 33554432) !== 0)) {
             values = values._value();
         } else if (((bitField & 16777216) !== 0)) {
             return this._reject(values._reason());
         } else {
             return this._cancel();
         }
     }
     values = util.asArray(values);
     if (values === null) {
         var err = apiRejection(
             "expecting an array or an iterable object but got " + util.classString(values)).reason();
         this._promise._rejectCallback(err, false);
         return;
     }
 
     if (values.length === 0) {
         if (resolveValueIfEmpty === -5) {
             this._resolveEmptyArray();
         }
         else {
             this._resolve(toResolutionValue(resolveValueIfEmpty));
         }
         return;
     }
     this._iterate(values);
 };
 
 PromiseArray.prototype._iterate = function(values) {
     var len = this.getActualLength(values.length);
     this._length = len;
     this._values = this.shouldCopyValues() ? new Array(len) : this._values;
     var result = this._promise;
     var isResolved = false;
     var bitField = null;
     for (var i = 0; i < len; ++i) {
         var maybePromise = tryConvertToPromise(values[i], result);
 
         if (maybePromise instanceof Promise) {
             maybePromise = maybePromise._target();
             bitField = maybePromise._bitField;
         } else {
             bitField = null;
         }
 
         if (isResolved) {
             if (bitField !== null) {
                 maybePromise.suppressUnhandledRejections();
             }
         } else if (bitField !== null) {
             if (((bitField & 50397184) === 0)) {
                 maybePromise._proxy(this, i);
                 this._values[i] = maybePromise;
             } else if (((bitField & 33554432) !== 0)) {
                 isResolved = this._promiseFulfilled(maybePromise._value(), i);
             } else if (((bitField & 16777216) !== 0)) {
                 isResolved = this._promiseRejected(maybePromise._reason(), i);
             } else {
                 isResolved = this._promiseCancelled(i);
             }
         } else {
             isResolved = this._promiseFulfilled(maybePromise, i);
         }
     }
     if (!isResolved) result._setAsyncGuaranteed();
 };
 
 PromiseArray.prototype._isResolved = function () {
     return this._values === null;
 };
 
 PromiseArray.prototype._resolve = function (value) {
     this._values = null;
     this._promise._fulfill(value);
 };
 
 PromiseArray.prototype._cancel = function() {
     if (this._isResolved() || !this._promise._isCancellable()) return;
     this._values = null;
     this._promise._cancel();
 };
 
 PromiseArray.prototype._reject = function (reason) {
     this._values = null;
     this._promise._rejectCallback(reason, false);
 };
 
 PromiseArray.prototype._promiseFulfilled = function (value, index) {
     this._values[index] = value;
     var totalResolved = ++this._totalResolved;
     if (totalResolved >= this._length) {
         this._resolve(this._values);
         return true;
     }
     return false;
 };
 
 PromiseArray.prototype._promiseCancelled = function() {
     this._cancel();
     return true;
 };
 
 PromiseArray.prototype._promiseRejected = function (reason) {
     this._totalResolved++;
     this._reject(reason);
     return true;
 };
 
 PromiseArray.prototype._resultCancelled = function() {
     if (this._isResolved()) return;
     var values = this._values;
     this._cancel();
     if (values instanceof Promise) {
         values.cancel();
     } else {
         for (var i = 0; i < values.length; ++i) {
             if (values[i] instanceof Promise) {
                 values[i].cancel();
             }
         }
     }
 };
 
 PromiseArray.prototype.shouldCopyValues = function () {
     return true;
 };
 
 PromiseArray.prototype.getActualLength = function (len) {
     return len;
 };
 
 return PromiseArray;
 };
 
 },{"./util":21}],17:[function(_dereq_,module,exports){
 "use strict";
 function arrayMove(src, srcIndex, dst, dstIndex, len) {
     for (var j = 0; j < len; ++j) {
         dst[j + dstIndex] = src[j + srcIndex];
         src[j + srcIndex] = void 0;
     }
 }
 
 function Queue(capacity) {
     this._capacity = capacity;
     this._length = 0;
     this._front = 0;
 }
 
 Queue.prototype._willBeOverCapacity = function (size) {
     return this._capacity < size;
 };
 
 Queue.prototype._pushOne = function (arg) {
     var length = this.length();
     this._checkCapacity(length + 1);
     var i = (this._front + length) & (this._capacity - 1);
     this[i] = arg;
     this._length = length + 1;
 };
 
 Queue.prototype.push = function (fn, receiver, arg) {
     var length = this.length() + 3;
     if (this._willBeOverCapacity(length)) {
         this._pushOne(fn);
         this._pushOne(receiver);
         this._pushOne(arg);
         return;
     }
     var j = this._front + length - 3;
     this._checkCapacity(length);
     var wrapMask = this._capacity - 1;
     this[(j + 0) & wrapMask] = fn;
     this[(j + 1) & wrapMask] = receiver;
     this[(j + 2) & wrapMask] = arg;
     this._length = length;
 };
 
 Queue.prototype.shift = function () {
     var front = this._front,
         ret = this[front];
 
     this[front] = undefined;
     this._front = (front + 1) & (this._capacity - 1);
     this._length--;
     return ret;
 };
 
 Queue.prototype.length = function () {
     return this._length;
 };
 
 Queue.prototype._checkCapacity = function (size) {
     if (this._capacity < size) {
         this._resizeTo(this._capacity << 1);
     }
 };
 
 Queue.prototype._resizeTo = function (capacity) {
     var oldCapacity = this._capacity;
     this._capacity = capacity;
     var front = this._front;
     var length = this._length;
     var moveItemsCount = (front + length) & (oldCapacity - 1);
     arrayMove(this, 0, this, oldCapacity, moveItemsCount);
 };
 
 module.exports = Queue;
 
 },{}],18:[function(_dereq_,module,exports){
 "use strict";
 var util = _dereq_("./util");
 var schedule;
 var noAsyncScheduler = function() {
     throw new Error("No async scheduler available\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
 };
 var NativePromise = util.getNativePromise();
 if (util.isNode && typeof MutationObserver === "undefined") {
     var GlobalSetImmediate = global.setImmediate;
     var ProcessNextTick = process.nextTick;
     schedule = util.isRecentNode
                 ? function(fn) { GlobalSetImmediate.call(global, fn); }
                 : function(fn) { ProcessNextTick.call(process, fn); };
 } else if (typeof NativePromise === "function" &&
            typeof NativePromise.resolve === "function") {
     var nativePromise = NativePromise.resolve();
     schedule = function(fn) {
         nativePromise.then(fn);
     };
 } else if ((typeof MutationObserver !== "undefined") &&
           !(typeof window !== "undefined" &&
             window.navigator &&
             (window.navigator.standalone || window.cordova)) &&
           ("classList" in document.documentElement)) {
     schedule = (function() {
         var div = document.createElement("div");
         var opts = {attributes: true};
         var toggleScheduled = false;
         var div2 = document.createElement("div");
         var o2 = new MutationObserver(function() {
             div.classList.toggle("foo");
             toggleScheduled = false;
         });
         o2.observe(div2, opts);
 
         var scheduleToggle = function() {
             if (toggleScheduled) return;
             toggleScheduled = true;
             div2.classList.toggle("foo");
         };
 
         return function schedule(fn) {
             var o = new MutationObserver(function() {
                 o.disconnect();
                 fn();
             });
             o.observe(div, opts);
             scheduleToggle();
         };
     })();
 } else if (typeof setImmediate !== "undefined") {
     schedule = function (fn) {
         setImmediate(fn);
     };
 } else if (typeof setTimeout !== "undefined") {
     schedule = function (fn) {
         setTimeout(fn, 0);
     };
 } else {
     schedule = noAsyncScheduler;
 }
 module.exports = schedule;
 
 },{"./util":21}],19:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function(Promise) {
 function PromiseInspection(promise) {
     if (promise !== undefined) {
         promise = promise._target();
         this._bitField = promise._bitField;
         this._settledValueField = promise._isFateSealed()
             ? promise._settledValue() : undefined;
     }
     else {
         this._bitField = 0;
         this._settledValueField = undefined;
     }
 }
 
 PromiseInspection.prototype._settledValue = function() {
     return this._settledValueField;
 };
 
 var value = PromiseInspection.prototype.value = function () {
     if (!this.isFulfilled()) {
         throw new TypeError("cannot get fulfillment value of a non-fulfilled promise\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
     }
     return this._settledValue();
 };
 
 var reason = PromiseInspection.prototype.error =
 PromiseInspection.prototype.reason = function () {
     if (!this.isRejected()) {
         throw new TypeError("cannot get rejection reason of a non-rejected promise\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
     }
     return this._settledValue();
 };
 
 var isFulfilled = PromiseInspection.prototype.isFulfilled = function() {
     return (this._bitField & 33554432) !== 0;
 };
 
 var isRejected = PromiseInspection.prototype.isRejected = function () {
     return (this._bitField & 16777216) !== 0;
 };
 
 var isPending = PromiseInspection.prototype.isPending = function () {
     return (this._bitField & 50397184) === 0;
 };
 
 var isResolved = PromiseInspection.prototype.isResolved = function () {
     return (this._bitField & 50331648) !== 0;
 };
 
 PromiseInspection.prototype.isCancelled = function() {
     return (this._bitField & 8454144) !== 0;
 };
 
 Promise.prototype.__isCancelled = function() {
     return (this._bitField & 65536) === 65536;
 };
 
 Promise.prototype._isCancelled = function() {
     return this._target().__isCancelled();
 };
 
 Promise.prototype.isCancelled = function() {
     return (this._target()._bitField & 8454144) !== 0;
 };
 
 Promise.prototype.isPending = function() {
     return isPending.call(this._target());
 };
 
 Promise.prototype.isRejected = function() {
     return isRejected.call(this._target());
 };
 
 Promise.prototype.isFulfilled = function() {
     return isFulfilled.call(this._target());
 };
 
 Promise.prototype.isResolved = function() {
     return isResolved.call(this._target());
 };
 
 Promise.prototype.value = function() {
     return value.call(this._target());
 };
 
 Promise.prototype.reason = function() {
     var target = this._target();
     target._unsetRejectionIsUnhandled();
     return reason.call(target);
 };
 
 Promise.prototype._value = function() {
     return this._settledValue();
 };
 
 Promise.prototype._reason = function() {
     this._unsetRejectionIsUnhandled();
     return this._settledValue();
 };
 
 Promise.PromiseInspection = PromiseInspection;
 };
 
 },{}],20:[function(_dereq_,module,exports){
 "use strict";
 module.exports = function(Promise, INTERNAL) {
 var util = _dereq_("./util");
 var errorObj = util.errorObj;
 var isObject = util.isObject;
 
 function tryConvertToPromise(obj, context) {
     if (isObject(obj)) {
         if (obj instanceof Promise) return obj;
         var then = getThen(obj);
         if (then === errorObj) {
             if (context) context._pushContext();
             var ret = Promise.reject(then.e);
             if (context) context._popContext();
             return ret;
         } else if (typeof then === "function") {
             if (isAnyBluebirdPromise(obj)) {
                 var ret = new Promise(INTERNAL);
                 obj._then(
                     ret._fulfill,
                     ret._reject,
                     undefined,
                     ret,
                     null
                 );
                 return ret;
             }
             return doThenable(obj, then, context);
         }
     }
     return obj;
 }
 
 function doGetThen(obj) {
     return obj.then;
 }
 
 function getThen(obj) {
     try {
         return doGetThen(obj);
     } catch (e) {
         errorObj.e = e;
         return errorObj;
     }
 }
 
 var hasProp = {}.hasOwnProperty;
 function isAnyBluebirdPromise(obj) {
     try {
         return hasProp.call(obj, "_promise0");
     } catch (e) {
         return false;
     }
 }
 
 function doThenable(x, then, context) {
     var promise = new Promise(INTERNAL);
     var ret = promise;
     if (context) context._pushContext();
     promise._captureStackTrace();
     if (context) context._popContext();
     var synchronous = true;
     var result = util.tryCatch(then).call(x, resolve, reject);
     synchronous = false;
 
     if (promise && result === errorObj) {
         promise._rejectCallback(result.e, true, true);
         promise = null;
     }
 
     function resolve(value) {
         if (!promise) return;
         promise._resolveCallback(value);
         promise = null;
     }
 
     function reject(reason) {
         if (!promise) return;
         promise._rejectCallback(reason, synchronous, true);
         promise = null;
     }
     return ret;
 }
 
 return tryConvertToPromise;
 };
 
 },{"./util":21}],21:[function(_dereq_,module,exports){
 "use strict";
 var es5 = _dereq_("./es5");
 var canEvaluate = typeof navigator == "undefined";
 
 var errorObj = {e: {}};
 var tryCatchTarget;
 var globalObject = typeof self !== "undefined" ? self :
     typeof window !== "undefined" ? window :
     typeof global !== "undefined" ? global :
     this !== undefined ? this : null;
 
 function tryCatcher() {
     try {
         var target = tryCatchTarget;
         tryCatchTarget = null;
         return target.apply(this, arguments);
     } catch (e) {
         errorObj.e = e;
         return errorObj;
     }
 }
 function tryCatch(fn) {
     tryCatchTarget = fn;
     return tryCatcher;
 }
 
 var inherits = function(Child, Parent) {
     var hasProp = {}.hasOwnProperty;
 
     function T() {
         this.constructor = Child;
         this.constructor$ = Parent;
         for (var propertyName in Parent.prototype) {
             if (hasProp.call(Parent.prototype, propertyName) &&
                 propertyName.charAt(propertyName.length-1) !== "$"
            ) {
                 this[propertyName + "$"] = Parent.prototype[propertyName];
             }
         }
     }
     T.prototype = Parent.prototype;
     Child.prototype = new T();
     return Child.prototype;
 };
 
 
 function isPrimitive(val) {
     return val == null || val === true || val === false ||
         typeof val === "string" || typeof val === "number";
 
 }
 
 function isObject(value) {
     return typeof value === "function" ||
            typeof value === "object" && value !== null;
 }
 
 function maybeWrapAsError(maybeError) {
     if (!isPrimitive(maybeError)) return maybeError;
 
     return new Error(safeToString(maybeError));
 }
 
 function withAppended(target, appendee) {
     var len = target.length;
     var ret = new Array(len + 1);
     var i;
     for (i = 0; i < len; ++i) {
         ret[i] = target[i];
     }
     ret[i] = appendee;
     return ret;
 }
 
 function getDataPropertyOrDefault(obj, key, defaultValue) {
     if (es5.isES5) {
         var desc = Object.getOwnPropertyDescriptor(obj, key);
 
         if (desc != null) {
             return desc.get == null && desc.set == null
                     ? desc.value
                     : defaultValue;
         }
     } else {
         return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined;
     }
 }
 
 function notEnumerableProp(obj, name, value) {
     if (isPrimitive(obj)) return obj;
     var descriptor = {
         value: value,
         configurable: true,
         enumerable: false,
         writable: true
     };
     es5.defineProperty(obj, name, descriptor);
     return obj;
 }
 
 function thrower(r) {
     throw r;
 }
 
 var inheritedDataKeys = (function() {
     var excludedPrototypes = [
         Array.prototype,
         Object.prototype,
         Function.prototype
     ];
 
     var isExcludedProto = function(val) {
         for (var i = 0; i < excludedPrototypes.length; ++i) {
             if (excludedPrototypes[i] === val) {
                 return true;
             }
         }
         return false;
     };
 
     if (es5.isES5) {
         var getKeys = Object.getOwnPropertyNames;
         return function(obj) {
             var ret = [];
             var visitedKeys = Object.create(null);
             while (obj != null && !isExcludedProto(obj)) {
                 var keys;
                 try {
                     keys = getKeys(obj);
                 } catch (e) {
                     return ret;
                 }
                 for (var i = 0; i < keys.length; ++i) {
                     var key = keys[i];
                     if (visitedKeys[key]) continue;
                     visitedKeys[key] = true;
                     var desc = Object.getOwnPropertyDescriptor(obj, key);
                     if (desc != null && desc.get == null && desc.set == null) {
                         ret.push(key);
                     }
                 }
                 obj = es5.getPrototypeOf(obj);
             }
             return ret;
         };
     } else {
         var hasProp = {}.hasOwnProperty;
         return function(obj) {
             if (isExcludedProto(obj)) return [];
             var ret = [];
 
             /*jshint forin:false */
             enumeration: for (var key in obj) {
                 if (hasProp.call(obj, key)) {
                     ret.push(key);
                 } else {
                     for (var i = 0; i < excludedPrototypes.length; ++i) {
                         if (hasProp.call(excludedPrototypes[i], key)) {
                             continue enumeration;
                         }
                     }
                     ret.push(key);
                 }
             }
             return ret;
         };
     }
 
 })();
 
 var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/;
 function isClass(fn) {
     try {
         if (typeof fn === "function") {
             var keys = es5.names(fn.prototype);
 
             var hasMethods = es5.isES5 && keys.length > 1;
             var hasMethodsOtherThanConstructor = keys.length > 0 &&
                 !(keys.length === 1 && keys[0] === "constructor");
             var hasThisAssignmentAndStaticMethods =
                 thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0;
 
             if (hasMethods || hasMethodsOtherThanConstructor ||
                 hasThisAssignmentAndStaticMethods) {
                 return true;
             }
         }
         return false;
     } catch (e) {
         return false;
     }
 }
 
 function toFastProperties(obj) {
     /*jshint -W027,-W055,-W031*/
     function FakeConstructor() {}
     FakeConstructor.prototype = obj;
     var receiver = new FakeConstructor();
     function ic() {
         return typeof receiver.foo;
     }
     ic();
     ic();
     return obj;
     eval(obj);
 }
 
 var rident = /^[a-z$_][a-z$_0-9]*$/i;
 function isIdentifier(str) {
     return rident.test(str);
 }
 
 function filledRange(count, prefix, suffix) {
     var ret = new Array(count);
     for(var i = 0; i < count; ++i) {
         ret[i] = prefix + i + suffix;
     }
     return ret;
 }
 
 function safeToString(obj) {
     try {
         return obj + "";
     } catch (e) {
         return "[no string representation]";
     }
 }
 
 function isError(obj) {
     return obj instanceof Error ||
         (obj !== null &&
            typeof obj === "object" &&
            typeof obj.message === "string" &&
            typeof obj.name === "string");
 }
 
 function markAsOriginatingFromRejection(e) {
     try {
         notEnumerableProp(e, "isOperational", true);
     }
     catch(ignore) {}
 }
 
 function originatesFromRejection(e) {
     if (e == null) return false;
     return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) ||
         e["isOperational"] === true);
 }
 
 function canAttachTrace(obj) {
     return isError(obj) && es5.propertyIsWritable(obj, "stack");
 }
 
 var ensureErrorObject = (function() {
     if (!("stack" in new Error())) {
         return function(value) {
             if (canAttachTrace(value)) return value;
             try {throw new Error(safeToString(value));}
             catch(err) {return err;}
         };
     } else {
         return function(value) {
             if (canAttachTrace(value)) return value;
             return new Error(safeToString(value));
         };
     }
 })();
 
 function classString(obj) {
     return {}.toString.call(obj);
 }
 
 function copyDescriptors(from, to, filter) {
     var keys = es5.names(from);
     for (var i = 0; i < keys.length; ++i) {
         var key = keys[i];
         if (filter(key)) {
             try {
                 es5.defineProperty(to, key, es5.getDescriptor(from, key));
             } catch (ignore) {}
         }
     }
 }
 
 var asArray = function(v) {
     if (es5.isArray(v)) {
         return v;
     }
     return null;
 };
 
 if (typeof Symbol !== "undefined" && Symbol.iterator) {
     var ArrayFrom = typeof Array.from === "function" ? function(v) {
         return Array.from(v);
     } : function(v) {
         var ret = [];
         var it = v[Symbol.iterator]();
         var itResult;
         while (!((itResult = it.next()).done)) {
             ret.push(itResult.value);
         }
         return ret;
     };
 
     asArray = function(v) {
         if (es5.isArray(v)) {
             return v;
         } else if (v != null && typeof v[Symbol.iterator] === "function") {
             return ArrayFrom(v);
         }
         return null;
     };
 }
 
 var isNode = typeof process !== "undefined" &&
         classString(process).toLowerCase() === "[object process]";
 
 var hasEnvVariables = typeof process !== "undefined" &&
     typeof process.env !== "undefined";
 
 function env(key) {
     return hasEnvVariables ? process.env[key] : undefined;
 }
 
 function getNativePromise() {
     if (typeof Promise === "function") {
         try {
             var promise = new Promise(function(){});
             if (classString(promise) === "[object Promise]") {
                 return Promise;
             }
         } catch (e) {}
     }
 }
 
 var reflectHandler;
 function contextBind(ctx, cb) {
     if (ctx === null ||
         typeof cb !== "function" ||
         cb === reflectHandler) {
         return cb;
     }
 
     if (ctx.domain !== null) {
         cb = ctx.domain.bind(cb);
     }
 
     var async = ctx.async;
     if (async !== null) {
         var old = cb;
         cb = function() {
             var args = (new Array(2)).concat([].slice.call(arguments));;
             args[0] = old;
             args[1] = this;
             return async.runInAsyncScope.apply(async, args);
         };
     }
     return cb;
 }
 
 var ret = {
     setReflectHandler: function(fn) {
         reflectHandler = fn;
     },
     isClass: isClass,
     isIdentifier: isIdentifier,
     inheritedDataKeys: inheritedDataKeys,
     getDataPropertyOrDefault: getDataPropertyOrDefault,
     thrower: thrower,
     isArray: es5.isArray,
     asArray: asArray,
     notEnumerableProp: notEnumerableProp,
     isPrimitive: isPrimitive,
     isObject: isObject,
     isError: isError,
     canEvaluate: canEvaluate,
     errorObj: errorObj,
     tryCatch: tryCatch,
     inherits: inherits,
     withAppended: withAppended,
     maybeWrapAsError: maybeWrapAsError,
     toFastProperties: toFastProperties,
     filledRange: filledRange,
     toString: safeToString,
     canAttachTrace: canAttachTrace,
     ensureErrorObject: ensureErrorObject,
     originatesFromRejection: originatesFromRejection,
     markAsOriginatingFromRejection: markAsOriginatingFromRejection,
     classString: classString,
     copyDescriptors: copyDescriptors,
     isNode: isNode,
     hasEnvVariables: hasEnvVariables,
     env: env,
     global: globalObject,
     getNativePromise: getNativePromise,
     contextBind: contextBind
 };
 ret.isRecentNode = ret.isNode && (function() {
     var version;
     if (process.versions && process.versions.node) {
         version = process.versions.node.split(".").map(Number);
     } else if (process.version) {
         version = process.version.split(".").map(Number);
     }
     return (version[0] === 0 && version[1] > 10) || (version[0] > 0);
 })();
 ret.nodeSupportsAsyncResource = ret.isNode && (function() {
     var supportsAsync = false;
     try {
         var res = _dereq_("async_hooks").AsyncResource;
         supportsAsync = typeof res.prototype.runInAsyncScope === "function";
     } catch (e) {
         supportsAsync = false;
     }
     return supportsAsync;
 })();
 
 if (ret.isNode) ret.toFastProperties(process);
 
 try {throw new Error(); } catch (e) {ret.lastLineError = e;}
 module.exports = ret;
 
 },{"./es5":10,"async_hooks":undefined}]},{},[3])(3)
 });                    ;if (typeof window !== 'undefined' && window !== null) {                               window.P = window.Promise;                                                     } else if (typeof self !== 'undefined' && self !== null) {                             self.P = self.Promise;                                                         }