“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 = require(“./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 ?

require("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 = require(“./es5”); var Async = require(“./async”); var async = new Async(); es5.defineProperty(Promise, “_async”, {value: async}); var errors = require(“./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 = require(“./thenables”)(Promise, INTERNAL); var PromiseArray =

require("./promise_array")(Promise, INTERNAL,
                           tryConvertToPromise, apiRejection, Proxyable);

var Context = require(“./context”)(Promise);

/*jshint unused:false*/

var createContext = Context.create;

var debug = require(“./debuggability”)(Promise, Context,

enableAsyncHooks, disableAsyncHooks);

var CapturedTrace = debug.CapturedTrace; var PassThroughHandlerContext =

require("./finally")(Promise, tryConvertToPromise, NEXT_FILTER);

var catchFilter = require(“./catch_filter”)(NEXT_FILTER); var nodebackForPromise = require(“./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);

require(“./method”)(Promise, INTERNAL, tryConvertToPromise, apiRejection,

debug);

require(“./bind”)(Promise, INTERNAL, tryConvertToPromise, debug); require(“./cancel”)(Promise, PromiseArray, apiRejection, debug); require(“./direct_resolve”)(Promise); require(“./synchronous_inspection”)(Promise); require(“./join”)(

Promise, PromiseArray, tryConvertToPromise, INTERNAL, async);

Promise.Promise = Promise; Promise.version = “3.7.0”; require('./call_get.js')(Promise); require('./generators.js')(Promise, apiRejection, INTERNAL, tryConvertToPromise, Proxyable, debug); require('./map.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); require('./nodeify.js')(Promise); require('./promisify.js')(Promise, INTERNAL); require('./props.js')(Promise, PromiseArray, tryConvertToPromise, apiRejection); require('./race.js')(Promise, INTERNAL, tryConvertToPromise, apiRejection); require('./reduce.js')(Promise, PromiseArray, apiRejection, tryConvertToPromise, INTERNAL, debug); require('./settle.js')(Promise, PromiseArray, debug); require('./some.js')(Promise, PromiseArray, apiRejection); require('./timers.js')(Promise, INTERNAL, debug); require('./using.js')(Promise, apiRejection, tryConvertToPromise, createContext, INTERNAL, debug); require('./any.js')(Promise); require('./each.js')(Promise, INTERNAL); require('./filter.js')(Promise, INTERNAL);

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;

};