text: "use strict";
  module.exports = function(Promise, CapturedTrace) {
  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 (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) {
      possiblyUnhandledRejection = typeof fn === "function" ? fn : undefined;
  };
  
  Promise.onUnhandledRejectionHandled = function (fn) {
      unhandledRejectionHandled = typeof fn === "function" ? 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;
  };
  };
  