/* @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.0
* 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){if(!t){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={exports:{}};t[0].call(l.exports,function(e){var n=t[1];return s(n?n:e)},l,l.exports,e,t,n,r)}return n.exports}var i=typeof dereq==“function”&&dereq;for(var o=0;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 = 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;
}

if (util.isNode) {
    deferUnhandledRejectionCheck = (function() {
        var timers = _dereq_("timers");
        var timerSetTimeout = timers.setTimeout;
        var timer = timerSetTimeout(unhandledRejectionCheck, 1);
        timer.unref();

        return function(promise) {
            promises.push(promise);
            if (typeof timer.refresh === "function") {
                timer.refresh();
            } else {
                timerSetTimeout(unhandledRejectionCheck, 1).unref();
            }
        };
    })();
} else if (typeof document === "object" && document.createElement) {
    deferUnhandledRejectionCheck = (function() {
        var iframeSetTimeout;

        function checkIframe() {
            if (document.body) {
                var iframe = document.createElement("iframe");
                document.body.appendChild(iframe);
                if (iframe.contentWindow &&
                    iframe.contentWindow.setTimeout) {
                    iframeSetTimeout = iframe.contentWindow.setTimeout;
                }
                document.body.removeChild(iframe);
            }
        }
        checkIframe();
        return function(promise) {
            promises.push(promise);
            if (iframeSetTimeout) {
                iframeSetTimeout(unhandledRejectionCheck, 1);
            } else {
                checkIframe();
            }
        };
    })();
} else {
    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,“timers”:undefined}],8:[function(dereq,module,exports){ “use strict”; module.exports = function(Promise) { function returner() {

return this.value;

} function thrower() {

throw this.reason;

}

Promise.prototype = Promise.prototype.thenReturn = function (value) {

if (value instanceof Promise) value.suppressUnhandledRejections();
return this._then(
    returner, undefined, undefined, {value: value}, undefined);

};

Promise.prototype = 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 = 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; 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 = 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 = 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 = 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.0”;

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® {

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 = /thiss*.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$_]*$/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; }