“use strict”; module.exports = function(Promise, CapturedTrace) { var getDomain = Promise._getDomain; var async = require(“./async.js”); var Warning = require(“./errors.js”).Warning; var util = require(“./util.js”); var canAttachTrace = util.canAttachTrace; var unhandledRejectionHandled; var possiblyUnhandledRejection; var debugging = false || (util.isNode &&

(!!process.env["BLUEBIRD_DEBUG"] ||
 process.env["NODE_ENV"] === "development"));

if (util.isNode && process.env == 0) debugging = false;

if (debugging) {

async.disableTrampolineIfNecessary();

}

Promise.prototype._ignoreRejections = function() {

this._unsetRejectionIsUnhandled();
this._bitField = this._bitField | 16777216;

};

Promise.prototype._ensurePossibleRejectionHandled = function () {

if ((this._bitField & 16777216) !== 0) return;
this._setRejectionIsUnhandled();
async.invokeLater(this._notifyUnhandledRejection, this, undefined);

};

Promise.prototype._notifyUnhandledRejectionIsHandled = function () {

CapturedTrace.fireRejectionEvent("rejectionHandled",
                              unhandledRejectionHandled, undefined, this);

};

Promise.prototype._notifyUnhandledRejection = function () {

if (this._isRejectionUnhandled()) {
    var reason = this._getCarriedStackTrace() || this._settledValue;
    this._setUnhandledRejectionIsNotified();
    CapturedTrace.fireRejectionEvent("unhandledRejection",
                                  possiblyUnhandledRejection, reason, this);
}

};

Promise.prototype._setUnhandledRejectionIsNotified = function () {

this._bitField = this._bitField | 524288;

};

Promise.prototype._unsetUnhandledRejectionIsNotified = function () {

this._bitField = this._bitField & (~524288);

};

Promise.prototype._isUnhandledRejectionNotified = function () {

return (this._bitField & 524288) > 0;

};

Promise.prototype._setRejectionIsUnhandled = function () {

this._bitField = this._bitField | 2097152;

};

Promise.prototype._unsetRejectionIsUnhandled = function () {

this._bitField = this._bitField & (~2097152);
if (this._isUnhandledRejectionNotified()) {
    this._unsetUnhandledRejectionIsNotified();
    this._notifyUnhandledRejectionIsHandled();
}

};

Promise.prototype._isRejectionUnhandled = function () {

return (this._bitField & 2097152) > 0;

};

Promise.prototype._setCarriedStackTrace = function (capturedTrace) {

this._bitField = this._bitField | 1048576;
this._fulfillmentHandler0 = capturedTrace;

};

Promise.prototype._isCarryingStackTrace = function () {

return (this._bitField & 1048576) > 0;

};

Promise.prototype._getCarriedStackTrace = function () {

return this._isCarryingStackTrace()
    ? this._fulfillmentHandler0
    : undefined;

};

Promise.prototype._captureStackTrace = function () {

if (debugging) {
    this._trace = new CapturedTrace(this._peekContext());
}
return this;

};

Promise.prototype._attachExtraTrace = function (error, ignoreSelf) {

if (debugging && 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 = CapturedTrace.parseStackAndMessage(error);
        util.notEnumerableProp(error, "stack",
            parsed.message + "\n" + parsed.stack.join("\n"));
        util.notEnumerableProp(error, "__stackCleaned__", true);
    }
}

};

Promise.prototype._warn = function(message) {

var warning = new Warning(message);
var ctx = this._peekContext();
if (ctx) {
    ctx.attachExtraTrace(warning);
} else {
    var parsed = CapturedTrace.parseStackAndMessage(warning);
    warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
}
CapturedTrace.formatAndLogError(warning, "");

};

Promise.onPossiblyUnhandledRejection = function (fn) {

var domain = getDomain();
possiblyUnhandledRejection =
    typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
                             : undefined;

};

Promise.onUnhandledRejectionHandled = function (fn) {

var domain = getDomain();
unhandledRejectionHandled =
    typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
                             : undefined;

};

Promise.longStackTraces = function () {

 if (async.haveItemsQueued() &&
     debugging === false
) {
     throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/DT1qyG\u000a");
 }
 debugging = CapturedTrace.isSupported();
 if (debugging) {
     async.disableTrampolineIfNecessary();
 }

};

Promise.hasLongStackTraces = function () {

return debugging && CapturedTrace.isSupported();

};

if (!CapturedTrace.isSupported()) {

Promise.longStackTraces = function(){};
debugging = false;

}

return function() {

return debugging;

}; };